Added GPLv3.0 license

J2ghz/palette

.gitignore

@@ -25,4 +25,3 @@ _testmain.go
 
 /gopow
 /build
-resources.go

Godeps/Godeps.json

@@ -1,48 +0,0 @@
-{
-	"ImportPath": "github.com/dhogborg/rtl-gopow",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v66",
-	"Deps": [
-		{
-			"ImportPath": "github.com/Sirupsen/logrus",
-			"Comment": "v0.6.4-6-g539d4dc",
-			"Rev": "539d4dc034c079a7188b5d4ca9650632d73c66e8"
-		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-64-ge1712f3",
-			"Rev": "e1712f381785e32046927f64a7c86fe569203196"
-		},
-		{
-			"ImportPath": "github.com/dustin/go-humanize",
-			"Rev": "8929fe90cee4b2cb9deb468b51fb34eba64d1bf0"
-		},
-		{
-			"ImportPath": "github.com/golang/freetype",
-			"Comment": "release-129-gc67e4d9",
-			"Rev": "c67e4d98d212356ec0d9436a1edcbb6eb799f847"
-		},
-		{
-			"ImportPath": "github.com/golang/freetype/raster",
-			"Comment": "release-129-gc67e4d9",
-			"Rev": "c67e4d98d212356ec0d9436a1edcbb6eb799f847"
-		},
-		{
-			"ImportPath": "github.com/golang/freetype/truetype",
-			"Comment": "release-129-gc67e4d9",
-			"Rev": "c67e4d98d212356ec0d9436a1edcbb6eb799f847"
-		},
-		{
-			"ImportPath": "github.com/lucasb-eyer/go-colorful",
-			"Rev": "e524a63fc3d334b573e6c1060c9b5866cf236626"
-		},
-		{
-			"ImportPath": "golang.org/x/image/font",
-			"Rev": "f551d3a6b7fc11df315ad9e18b404280680f8bec"
-		},
-		{
-			"ImportPath": "golang.org/x/image/math/fixed",
-			"Rev": "f551d3a6b7fc11df315ad9e18b404280680f8bec"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

LICENSE

@@ -0,0 +1,674 @@
+                     GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

@@ -1,49 +1,62 @@
 
-.PHONY: setup build resources lint clean
-
 VERSION = $(shell git describe --always --dirty)
 TIMESTAMP = $(shell git show -s --format=%ct)
 
-default: build_darwin
+default: build
 
+.PHONY: setup
 setup: 
 	go get -u github.com/jteeuwen/go-bindata/...
-	go get github.com/tools/godep
 
+.PHONY: resources
 resources:
 	go-bindata -pkg resources -o internal/resources/resources.go resources/...
 
-build_darwin: resources
-	GOOS=darwin GOARCH=amd64 godep go build -a -o ./build/gopow *.go
-	zip ./build/gopow_darwin64.zip ./build/gopow
+.PHONY: build
+build:
+	go build -o ./build/gopow *.go
 
-build_linux: resources
-	GOOS=linux GOARCH=amd64 godep go build -a -o ./build/gopow *.go
-	zip ./build/gopow_linux64.zip ./build/gopow
-
-build_arm5: resources
-	GOOS=linux GOARM=5 GOARCH=arm godep go build -a -o ./build/gopow *.go
-	zip ./build/gopow_linux_arm5.zip ./build/gopow
-
-build_arm7: resources
-	GOOS=linux GOARM=7 GOARCH=arm godep go build -a -o ./build/gopow *.go
-	zip ./build/gopow_linux_arm7.zip ./build/gopow
-
-build_win64: resources
-	GOOS=windows GOARCH=amd64 godep go build -a -o ./build/gopow.exe *.go
-	zip ./build/gopow_win64.zip ./build/gopow.exe
-
-build_win32: resources
-	GOOS=windows GOARCH=386 godep go build -a -o ./build/gopow.exe *.go
-	zip ./build/gopow_win32.zip ./build/gopow.exe
-
-all: build_darwin build_linux build_arm5 build_arm7 build_win64 build_win32
+.PHONY: all
+all: build_darwin_x86 build_darwin_arm64 build_linux build_arm5 build_arm7 build_win64 build_win32
 	rm ./build/gopow
 	rm ./build/gopow.exe
 
-lint:
-	golint .
+.PHONY: build_darwin_x86
+build_darwin_x86:
+	GOOS=darwin GOARCH=amd64 go build -a -o ./build/gopow *.go
+	zip ./build/gopow_darwin_amd64.zip ./build/gopow
 
+.PHONY: build_darwin_arm64
+build_darwin_arm64:
+	GOOS=darwin GOARCH=arm64 go build -a -o ./build/gopow *.go
+	zip ./build/gopow_darwin_arm64.zip ./build/gopow
+
+.PHONY: build_linux
+build_linux:
+	GOOS=linux GOARCH=amd64 go build -a -o ./build/gopow *.go
+	zip ./build/gopow_linux_amd64.zip ./build/gopow
+
+.PHONY: build_arm5
+build_arm5:
+	GOOS=linux GOARM=5 GOARCH=arm go build -a -o ./build/gopow *.go
+	zip ./build/gopow_linux_arm5.zip ./build/gopow
+
+.PHONY: build_arm7
+build_arm7:
+	GOOS=linux GOARM=7 GOARCH=arm go build -a -o ./build/gopow *.go
+	zip ./build/gopow_linux_arm7.zip ./build/gopow
+
+.PHONY: build_win64
+build_win64:
+	GOOS=windows GOARCH=amd64 go build -a -o ./build/gopow.exe *.go
+	zip ./build/gopow_win64.zip ./build/gopow.exe
+
+.PHONY: build_win32
+build_win32:
+	GOOS=windows GOARCH=386 go build -a -o ./build/gopow.exe *.go
+	zip ./build/gopow_win32.zip ./build/gopow.exe
+
+.PHONY: clean
 clean:
 	- rm -r build
 	- rm -rf internal/resources

go.mod

@@ -0,0 +1,18 @@
+module github.com/dhogborg/rtl-gopow
+
+require (
+	github.com/codegangsta/cli v1.4.2-0.20150128051617-e1712f381785
+	github.com/dustin/go-humanize v0.0.0-20151125214831-8929fe90cee4
+	github.com/golang/freetype v0.0.0-20160410050536-c67e4d98d212
+	github.com/lucasb-eyer/go-colorful v0.0.0-20150907065137-e524a63fc3d3
+	github.com/sirupsen/logrus v1.6.0
+	golang.org/x/image v0.0.0-20160423080830-f551d3a6b7fc
+)
+
+require (
+	github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
+	github.com/stretchr/testify v1.6.1 // indirect
+	golang.org/x/sys v0.3.0 // indirect
+)
+
+go 1.19

go.sum

@@ -0,0 +1,30 @@
+github.com/codegangsta/cli v1.4.2-0.20150128051617-e1712f381785 h1:dd7vSznOk2xIT8gJyFqbcrshRrTIWtPG7f41LLfTtMY=
+github.com/codegangsta/cli v1.4.2-0.20150128051617-e1712f381785/go.mod h1:/qJNoX69yVSKu5o4jLyXAENLRyk1uhi7zkbQ3slBdOA=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v0.0.0-20151125214831-8929fe90cee4 h1:WX/DKY159S5AHCpmUWGsVKoCXqLSpKd0R1150CWscw8=
+github.com/dustin/go-humanize v0.0.0-20151125214831-8929fe90cee4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/golang/freetype v0.0.0-20160410050536-c67e4d98d212 h1:erqso4t6p/N1EjjNntiZUXlhmdTEIDSmM8lzICeaY/c=
+github.com/golang/freetype v0.0.0-20160410050536-c67e4d98d212/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/lucasb-eyer/go-colorful v0.0.0-20150907065137-e524a63fc3d3 h1:HKvdgi34B5ivKjlR94L4WMyiC37Kzvmti867/EdbGRk=
+github.com/lucasb-eyer/go-colorful v0.0.0-20150907065137-e524a63fc3d3/go.mod h1:NXg0ArsFk0Y01623LgUqoqcouGDB+PwCCQlrwrG6xJ4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/image v0.0.0-20160423080830-f551d3a6b7fc h1:2xx8haaLdeT9SyZMv+NzYjaPJbm5ZU4CzTiF9icqXQg=
+golang.org/x/image v0.0.0-20160423080830-f551d3a6b7fc/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

gopow.go

@@ -3,14 +3,13 @@ package main
 import (
 	"os"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/codegangsta/cli"
+	log "github.com/sirupsen/logrus"
 
 	"github.com/dhogborg/rtl-gopow/internal/gopow"
 )
 
 func main() {
-
 	app := cli.NewApp()
 	app.Name = "RTL GoPow"
 	app.Usage = "Render a rtl_power CSV output as waterfall image"
@@ -19,8 +18,7 @@ func main() {
 	app.Email = "d@hogborg.se"
 
 	app.Action = func(c *cli.Context) {
-
-		if c.Bool("verbose") == true {
+		if c.Bool("verbose") {
 			log.SetLevel(log.DebugLevel)
 		} else {
 			log.SetLevel(log.InfoLevel)
@@ -49,7 +47,6 @@ func main() {
 			}).Fatal("write failed")
 			return
 		}
-
 	}
 
 	app.Flags = []cli.Flag{
@@ -86,6 +83,11 @@ func main() {
 			Name:  "no-annotations",
 			Usage: "Disabled annotations such as time and frequency scales",
 		},
+		cli.StringFlag{
+			Name:  "palette",
+			Usage: "Select the palette for output image. [spectrum,yellow]",
+			Value: "spectrum",
+		},
 	}
 
 	app.Run(os.Args)

internal/gopow/annotater.go

@@ -6,9 +6,9 @@ import (
 	"math"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/dustin/go-humanize"
 	"github.com/golang/freetype"
+	log "github.com/sirupsen/logrus"
 	"golang.org/x/image/font"
 
 	"github.com/dhogborg/rtl-gopow/internal/resources"

internal/gopow/gopow.go

@@ -8,9 +8,9 @@ import (
 	"os"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/codegangsta/cli"
 	"github.com/dustin/go-humanize"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -24,6 +24,7 @@ type RunConfig struct {
 	Annotations bool
 	MaxPower    float64
 	MinPower    float64
+	Palette     string
 }
 
 type GoPow struct {
@@ -33,7 +34,6 @@ type GoPow struct {
 }
 
 func NewGoPow(c *cli.Context) (*GoPow, error) {
-
 	config := &RunConfig{
 		InputFile:   c.String("input"),
 		OutputFile:  c.String("output"),
@@ -41,6 +41,7 @@ func NewGoPow(c *cli.Context) (*GoPow, error) {
 		Annotations: !c.Bool("no-annotations"),
 		MaxPower:    c.Float64("max-power"),
 		MinPower:    c.Float64("min-power"),
+		Palette:     c.String("palette"),
 	}
 
 	if !c.IsSet("max-power") {
@@ -80,7 +81,6 @@ func NewGoPow(c *cli.Context) (*GoPow, error) {
 }
 
 func (g *GoPow) Render() error {
-
 	conf := &RenderConfig{}
 
 	if g.config.MaxPower != PowerConfigAuto {
@@ -91,6 +91,14 @@ func (g *GoPow) Render() error {
 		conf.MinPower = &g.config.MinPower
 	}
 
+	var palette Palette
+	switch g.config.Palette {
+	case "yellow":
+		palette = &YellowPalette{}
+	default:
+		palette = &SpectrumPalette{}
+	}
+
 	log.Debug("staring render")
 	g.timestamp = time.Now()
 
@@ -103,12 +111,11 @@ func (g *GoPow) Render() error {
 
 	for y, row := range table.Rows {
 		for x := range row.Samples {
-			g.image.Set(x, y, table.ColorAt(x, y))
+			g.image.Set(x, y, palette.ColorAt(table, x, y))
 		}
 	}
 
 	if g.config.Annotations {
-
 		annotator, err := NewAnnotator(g.image, table)
 		if err != nil {
 			return err
@@ -124,7 +131,6 @@ func (g *GoPow) Render() error {
 }
 
 func (g *GoPow) Write() error {
-
 	log.WithFields(log.Fields{
 		"file": g.config.OutputFile,
 	}).Debug("staring output write")

internal/gopow/line.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
 type LineComplex struct {

internal/gopow/palette.go

@@ -0,0 +1,61 @@
+package gopow
+
+import (
+	"image/color"
+
+	"github.com/lucasb-eyer/go-colorful"
+)
+
+type Palette interface {
+	ColorAt(table *TableComplex, x, y int) color.Color
+}
+
+type YellowPalette struct {
+}
+
+func (p *YellowPalette) ColorAt(table *TableComplex, x, y int) color.Color {
+	cell := table.Rows[y].Sample(x)
+
+	hueStart := 0.0
+	hueEnd := 1.0
+
+	span := (*table.Config.MinPower - *table.Config.MaxPower) * -1
+	hPerDeg := (hueStart - hueEnd) / span
+	powNormalized := cell - *table.Config.MinPower
+	powDegrees := powNormalized * hPerDeg
+	hue := hueStart - powDegrees
+
+	if hue < hueStart {
+		hue = hueStart
+	}
+	if hue > hueEnd {
+		hue = hueEnd
+	}
+
+	return colorful.Color{hue, hue, 0}
+}
+
+type SpectrumPalette struct {
+}
+
+func (p *SpectrumPalette) ColorAt(table *TableComplex, x, y int) color.Color {
+	cell := table.Rows[y].Sample(x)
+
+	hueStart := 236.0
+	hueEnd := 0.0
+
+	span := (*table.Config.MinPower - *table.Config.MaxPower) * -1
+	hPerDeg := (hueStart - hueEnd) / span
+	powNormalized := cell - *table.Config.MinPower
+	powDegrees := powNormalized * hPerDeg
+	hue := hueStart - powDegrees
+
+	if hue > hueStart {
+		hue = hueStart
+	}
+	if hue < hueEnd {
+		hue = hueEnd
+	}
+
+	return colorful.Hsv(hue, 1, 0.90)
+}

internal/gopow/table.go

@@ -3,16 +3,14 @@ package gopow
 import (
 	"bytes"
 	"image"
-	"image/color"
 	"io/ioutil"
 	"math"
 	"sort"
 	"strings"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/dustin/go-humanize"
-	"github.com/lucasb-eyer/go-colorful"
+	log "github.com/sirupsen/logrus"
 )
 
 type TableComplex struct {
@@ -38,7 +36,6 @@ type RenderConfig struct {
 }
 
 func NewTable(file string, conf *RenderConfig) (*TableComplex, error) {
-
 	log.Debug("creating table")
 
 	t := &TableComplex{
@@ -54,7 +51,6 @@ func NewTable(file string, conf *RenderConfig) (*TableComplex, error) {
 }
 
 func (t *TableComplex) Load(file string) error {
-
 	log.Debug("loading table")
 
 	t.File = file
@@ -75,7 +71,6 @@ func (t *TableComplex) Load(file string) error {
 }
 
 func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
-
 	var max = float64(math.MaxFloat64 * -1)
 	var min = float64(math.MaxFloat64)
 
@@ -84,7 +79,6 @@ func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
 	table := map[string][]*LineComplex{}
 
 	for _, l := range lines {
-
 		cells := strings.Split(string(l), ",")
 		line := NewLineComplex(cells)
 
@@ -99,11 +93,8 @@ func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
 
 	// loop over hash keys with lines
 	for _, lines := range table {
-
 		row := t.IntegrateLines(lines)
-
 		if row != nil {
-
 			rows = append(rows, row)
 
 			if min > row.LowSample() {
@@ -117,7 +108,6 @@ func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
 			t.HzHigh = row.HzHigh
 
 			if row.Time != nil {
-
 				if t.TimeStart == nil {
 					t.TimeStart = row.Time
 				}
@@ -134,7 +124,6 @@ func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
 					t.TimeEnd = row.Time
 				}
 			}
-
 		}
 	}
 
@@ -170,7 +159,6 @@ func (t *TableComplex) parseBuffer(filebuffer []byte) []*LineComplex {
 }
 
 func (t *TableComplex) Image() *image.RGBA {
-
 	log.WithFields(log.Fields{
 		"width":  t.Bins,
 		"height": t.Integrations,
@@ -180,7 +168,6 @@ func (t *TableComplex) Image() *image.RGBA {
 }
 
 func (t *TableComplex) IntegrateLines(lines []*LineComplex) *LineComplex {
-
 	if len(lines) == 0 {
 		return nil
 	}
@@ -194,27 +181,3 @@ func (t *TableComplex) IntegrateLines(lines []*LineComplex) *LineComplex {
 
 	return masterline
 }
-
-func (t *TableComplex) ColorAt(x, y int) color.Color {
-
-	cell := t.Rows[y].Sample(x)
-
-	hueStart := 236.0
-	hueEnd := 0.0
-
-	span := (*t.Config.MinPower - *t.Config.MaxPower) * -1
-	hPerDeg := (hueStart - hueEnd) / span
-	powNormalized := cell - *t.Config.MinPower
-	powDegrees := powNormalized * hPerDeg
-	hue := hueStart - powDegrees
-
-	if hue > hueStart {
-		hue = hueStart
-	}
-	if hue < hueEnd {
-		hue = hueEnd
-	}
-
-	return colorful.Hsv(hue, 1, 0.90)
-
-}

vendor/github.com/Sirupsen/logrus/.gitignore

@@ -1 +0,0 @@
-logrus

vendor/github.com/Sirupsen/logrus/.travis.yml

@@ -1,8 +0,0 @@
-language: go
-go:
-  - 1.2
-  - 1.3
-  - 1.4
-  - tip
-install:
-  - go get -t ./...

vendor/github.com/Sirupsen/logrus/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Simon Eskildsen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

vendor/github.com/Sirupsen/logrus/README.md

@@ -1,355 +0,0 @@
-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![godoc reference](https://godoc.org/github.com/Sirupsen/logrus?status.png)][godoc]
-
-Logrus is a structured logger for Go (golang), completely API compatible with
-the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
-yet stable (pre 1.0), the core API is unlikely to change much but please version
-control your Logrus to make sure you aren't fetching latest `master` on every
-build.**
-
-Nicely color-coded in development (when a TTY is attached, otherwise just
-plain text):
-
-![Colored](http://i.imgur.com/PY7qMwd.png)
-
-With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
-or Splunk:
-
-```json
-{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
-ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
-
-{"level":"warning","msg":"The group's number increased tremendously!",
-"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
-"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
-"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
-
-{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
-"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
-```
-
-With the default `log.Formatter = new(logrus.TextFormatter)` when a TTY is not
-attached, the output is compatible with the
-[logfmt](http://godoc.org/github.com/kr/logfmt) format:
-
-```text
-time="2014-04-20 15:36:23.830442383 -0400 EDT" level="info" msg="A group of walrus emerges from the ocean" animal="walrus" size=10
-time="2014-04-20 15:36:23.830584199 -0400 EDT" level="warning" msg="The group's number increased tremendously!" omg=true number=122
-time="2014-04-20 15:36:23.830596521 -0400 EDT" level="info" msg="A giant walrus appears!" animal="walrus" size=10
-time="2014-04-20 15:36:23.830611837 -0400 EDT" level="info" msg="Tremendously sized cow enters the ocean." animal="walrus" size=9
-time="2014-04-20 15:36:23.830626464 -0400 EDT" level="fatal" msg="The ice breaks!" omg=true number=100
-```
-
-#### Example
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-```go
-package main
-
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-  }).Info("A walrus appears")
-}
-```
-
-Note that it's completely api-compatible with the stdlib logger, so you can
-replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
-and you'll now have the flexibility of Logrus. You can customize it all you
-want:
-
-```go
-package main
-
-import (
-  "os"
-  log "github.com/Sirupsen/logrus"
-  "github.com/Sirupsen/logrus/hooks/airbrake"
-)
-
-func init() {
-  // Log as JSON instead of the default ASCII formatter.
-  log.SetFormatter(&log.JSONFormatter{})
-
-  // Use the Airbrake hook to report errors that have Error severity or above to
-  // an exception tracker. You can create custom hooks, see the Hooks section.
-  log.AddHook(&logrus_airbrake.AirbrakeHook{})
-
-  // Output to stderr instead of stdout, could also be a file.
-  log.SetOutput(os.Stderr)
-
-  // Only log the warning severity or above.
-  log.SetLevel(log.WarnLevel)
-}
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 122,
-  }).Warn("The group's number increased tremendously!")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 100,
-  }).Fatal("The ice breaks!")
-}
-```
-
-For more advanced usage such as logging to multiple locations from the same
-application, you can also create an instance of the `logrus` Logger:
-
-```go
-package main
-
-import (
-  "github.com/Sirupsen/logrus"
-)
-
-// Create a new instance of the logger. You can have any number of instances.
-var log = logrus.New()
-
-func main() {
-  // The API for setting attributes is a little different than the package level
-  // exported logger. See Godoc.
-  log.Out = os.Stderr
-
-  log.WithFields(logrus.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-}
-```
-
-#### Fields
-
-Logrus encourages careful, structured logging though logging fields instead of
-long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
-to send event %s to topic %s with key %d")`, you should log the much more
-discoverable:
-
-```go
-log.WithFields(log.Fields{
-  "event": event,
-  "topic": topic,
-  "key": key,
-}).Fatal("Failed to send event")
-```
-
-We've found this API forces you to think about logging in a way that produces
-much more useful logging messages. We've been in countless situations where just
-a single added field to a log statement that was already there would've saved us
-hours. The `WithFields` call is optional.
-
-In general, with Logrus using any of the `printf`-family functions should be
-seen as a hint you should add a field, however, you can still use the
-`printf`-family functions with Logrus.
-
-#### Hooks
-
-You can add hooks for logging levels. For example to send errors to an exception
-tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
-multiple places simultaneously, e.g. syslog.
-
-```go
-// Not the real implementation of the Airbrake hook. Just a simple sample.
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-func init() {
-  log.AddHook(new(AirbrakeHook))
-}
-
-type AirbrakeHook struct{}
-
-// `Fire()` takes the entry that the hook is fired for. `entry.Data[]` contains
-// the fields for the entry. See the Fields section of the README.
-func (hook *AirbrakeHook) Fire(entry *logrus.Entry) error {
-  err := airbrake.Notify(entry.Data["error"].(error))
-  if err != nil {
-    log.WithFields(log.Fields{
-      "source":   "airbrake",
-      "endpoint": airbrake.Endpoint,
-    }).Info("Failed to send error to Airbrake")
-  }
-
-  return nil
-}
-
-// `Levels()` returns a slice of `Levels` the hook is fired for.
-func (hook *AirbrakeHook) Levels() []log.Level {
-  return []log.Level{
-    log.ErrorLevel,
-    log.FatalLevel,
-    log.PanicLevel,
-  }
-}
-```
-
-Logrus comes with built-in hooks. Add those, or your custom hook, in `init`:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-  "github.com/Sirupsen/logrus/hooks/airbrake"
-  "github.com/Sirupsen/logrus/hooks/syslog"
-  "log/syslog"
-)
-
-func init() {
-  log.AddHook(new(logrus_airbrake.AirbrakeHook))
-
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-  if err != nil {
-    log.Error("Unable to connect to local syslog daemon")
-  } else {
-    log.AddHook(hook)
-  }
-}
-```
-
-* [`github.com/Sirupsen/logrus/hooks/airbrake`](https://github.com/Sirupsen/logrus/blob/master/hooks/airbrake/airbrake.go)
-  Send errors to an exception tracking service compatible with the Airbrake API.
-  Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes.
-
-* [`github.com/Sirupsen/logrus/hooks/papertrail`](https://github.com/Sirupsen/logrus/blob/master/hooks/papertrail/papertrail.go)
-  Send errors to the Papertrail hosted logging service via UDP.
-
-* [`github.com/Sirupsen/logrus/hooks/syslog`](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go)
-  Send errors to remote syslog server.
-  Uses standard library `log/syslog` behind the scenes.
-
-* [`github.com/nubo/hiprus`](https://github.com/nubo/hiprus)
-  Send errors to a channel in hipchat.
-
-* [`github.com/sebest/logrusly`](https://github.com/sebest/logrusly)
-  Send logs to Loggly (https://www.loggly.com/)
-
-* [`github.com/johntdyer/slackrus`](https://github.com/johntdyer/slackrus)
-  Hook for Slack chat.
-
-#### Level logging
-
-Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
-
-```go
-log.Debug("Useful debugging information.")
-log.Info("Something noteworthy happened!")
-log.Warn("You should probably take a look at this.")
-log.Error("Something failed but I'm not quitting.")
-// Calls os.Exit(1) after logging
-log.Fatal("Bye.")
-// Calls panic() after logging
-log.Panic("I'm bailing.")
-```
-
-You can set the logging level on a `Logger`, then it will only log entries with
-that severity or anything above it:
-
-```go
-// Will log anything that is info or above (warn, error, fatal, panic). Default.
-log.SetLevel(log.InfoLevel)
-```
-
-It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
-environment if your application has that.
-
-#### Entries
-
-Besides the fields added with `WithField` or `WithFields` some fields are
-automatically added to all logging events:
-
-1. `time`. The timestamp when the entry was created.
-2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
-   the `AddFields` call. E.g. `Failed to send event.`
-3. `level`. The logging level. E.g. `info`.
-
-#### Environments
-
-Logrus has no notion of environment.
-
-If you wish for hooks and formatters to only be used in specific environments,
-you should handle that yourself. For example, if your application has a global
-variable `Environment`, which is a string representation of the environment you
-could do:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-init() {
-  // do something here to set environment depending on an environment variable
-  // or command-line flag
-  if Environment == "production" {
-    log.SetFormatter(logrus.JSONFormatter)
-  } else {
-    // The TextFormatter is default, you don't actually have to do this.
-    log.SetFormatter(logrus.TextFormatter)
-  }
-}
-```
-
-This configuration is how `logrus` was intended to be used, but JSON in
-production is mostly only useful if you do log aggregation with tools like
-Splunk or Logstash.
-
-#### Formatters
-
-The built-in logging formatters are:
-
-* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
-  without colors.
-  * *Note:* to force colored output when there is no TTY, set the `ForceColors`
-    field to `true`.  To force no colored output even if there is a TTY  set the
-    `DisableColors` field to `true`
-* `logrus.JSONFormatter`. Logs fields as JSON.
-
-Third party logging formatters:
-
-* [`zalgo`](https://github.com/aybabtme/logzalgo): invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
-
-You can define your formatter by implementing the `Formatter` interface,
-requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
-`Fields` type (`map[string]interface{}`) with all your fields as well as the
-default ones (see Entries section above):
-
-```go
-type MyJSONFormatter struct {
-}
-
-log.SetFormatter(new(MyJSONFormatter))
-
-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
-  // Note this doesn't include Time, Level and Message which are available on
-  // the Entry. Consult `godoc` on information about those fields or read the
-  // source of the official loggers.
-  serialized, err := json.Marshal(entry.Data)
-    if err != nil {
-      return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-    }
-  return append(serialized, '\n'), nil
-}
-```
-
-#### Rotation
-
-Log rotation is not provided with Logrus. Log rotation should be done by an
-external program (like `logrotated(8)`) that can compress and delete old log
-entries. It should not be a feature of the application-level logger.
-
-
-[godoc]: https://godoc.org/github.com/Sirupsen/logrus

vendor/github.com/Sirupsen/logrus/entry.go

@@ -1,252 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-// An entry is the final or intermediate Logrus logging entry. It contains all
-// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
-// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
-// passed around as much as you wish to avoid field duplication.
-type Entry struct {
-	Logger *Logger
-
-	// Contains all the fields set by the user.
-	Data Fields
-
-	// Time at which the log entry was created
-	Time time.Time
-
-	// Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
-	Level Level
-
-	// Message passed to Debug, Info, Warn, Error, Fatal or Panic
-	Message string
-}
-
-func NewEntry(logger *Logger) *Entry {
-	return &Entry{
-		Logger: logger,
-		// Default is three fields, give a little extra room
-		Data: make(Fields, 5),
-	}
-}
-
-// Returns a reader for the entry, which is a proxy to the formatter.
-func (entry *Entry) Reader() (*bytes.Buffer, error) {
-	serialized, err := entry.Logger.Formatter.Format(entry)
-	return bytes.NewBuffer(serialized), err
-}
-
-// Returns the string representation from the reader and ultimately the
-// formatter.
-func (entry *Entry) String() (string, error) {
-	reader, err := entry.Reader()
-	if err != nil {
-		return "", err
-	}
-
-	return reader.String(), err
-}
-
-// Add a single field to the Entry.
-func (entry *Entry) WithField(key string, value interface{}) *Entry {
-	return entry.WithFields(Fields{key: value})
-}
-
-// Add a map of fields to the Entry.
-func (entry *Entry) WithFields(fields Fields) *Entry {
-	data := Fields{}
-	for k, v := range entry.Data {
-		data[k] = v
-	}
-	for k, v := range fields {
-		data[k] = v
-	}
-	return &Entry{Logger: entry.Logger, Data: data}
-}
-
-func (entry *Entry) log(level Level, msg string) {
-	entry.Time = time.Now()
-	entry.Level = level
-	entry.Message = msg
-
-	if err := entry.Logger.Hooks.Fire(level, entry); err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
-		entry.Logger.mu.Unlock()
-	}
-
-	reader, err := entry.Reader()
-	if err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
-		entry.Logger.mu.Unlock()
-	}
-
-	entry.Logger.mu.Lock()
-	defer entry.Logger.mu.Unlock()
-
-	_, err = io.Copy(entry.Logger.Out, reader)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
-	}
-
-	// To avoid Entry#log() returning a value that only would make sense for
-	// panic() to use in Entry#Panic(), we avoid the allocation by checking
-	// directly here.
-	if level <= PanicLevel {
-		panic(entry)
-	}
-}
-
-func (entry *Entry) Debug(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.log(DebugLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Print(args ...interface{}) {
-	entry.Info(args...)
-}
-
-func (entry *Entry) Info(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.log(InfoLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warn(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.log(WarnLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warning(args ...interface{}) {
-	entry.Warn(args...)
-}
-
-func (entry *Entry) Error(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.log(ErrorLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Fatal(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.log(FatalLevel, fmt.Sprint(args...))
-	}
-	os.Exit(1)
-}
-
-func (entry *Entry) Panic(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.log(PanicLevel, fmt.Sprint(args...))
-	}
-	panic(fmt.Sprint(args...))
-}
-
-// Entry Printf family functions
-
-func (entry *Entry) Debugf(format string, args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Infof(format string, args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Printf(format string, args ...interface{}) {
-	entry.Infof(format, args...)
-}
-
-func (entry *Entry) Warnf(format string, args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Warningf(format string, args ...interface{}) {
-	entry.Warnf(format, args...)
-}
-
-func (entry *Entry) Errorf(format string, args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Fatalf(format string, args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Panicf(format string, args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(fmt.Sprintf(format, args...))
-	}
-}
-
-// Entry Println family functions
-
-func (entry *Entry) Debugln(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Infoln(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Println(args ...interface{}) {
-	entry.Infoln(args...)
-}
-
-func (entry *Entry) Warnln(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Warningln(args ...interface{}) {
-	entry.Warnln(args...)
-}
-
-func (entry *Entry) Errorln(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Fatalln(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Panicln(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(entry.sprintlnn(args...))
-	}
-}
-
-// Sprintlnn => Sprint no newline. This is to get the behavior of how
-// fmt.Sprintln where spaces are always added between operands, regardless of
-// their type. Instead of vendoring the Sprintln implementation to spare a
-// string allocation, we do the simplest thing.
-func (entry *Entry) sprintlnn(args ...interface{}) string {
-	msg := fmt.Sprintln(args...)
-	return msg[:len(msg)-1]
-}

vendor/github.com/Sirupsen/logrus/exported.go

@@ -1,182 +0,0 @@
-package logrus
-
-import (
-	"io"
-)
-
-var (
-	// std is the name of the standard logger in stdlib `log`
-	std = New()
-)
-
-// SetOutput sets the standard logger output.
-func SetOutput(out io.Writer) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Out = out
-}
-
-// SetFormatter sets the standard logger formatter.
-func SetFormatter(formatter Formatter) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Formatter = formatter
-}
-
-// SetLevel sets the standard logger level.
-func SetLevel(level Level) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Level = level
-}
-
-// GetLevel returns the standard logger level.
-func GetLevel() Level {
-	return std.Level
-}
-
-// AddHook adds a hook to the standard logger hooks.
-func AddHook(hook Hook) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Hooks.Add(hook)
-}
-
-// WithField creates an entry from the standard logger and adds a field to
-// it. If you want multiple fields, use `WithFields`.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithField(key string, value interface{}) *Entry {
-	return std.WithField(key, value)
-}
-
-// WithFields creates an entry from the standard logger and adds multiple
-// fields to it. This is simply a helper for `WithField`, invoking it
-// once for each field.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithFields(fields Fields) *Entry {
-	return std.WithFields(fields)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func Debug(args ...interface{}) {
-	std.Debug(args...)
-}
-
-// Print logs a message at level Info on the standard logger.
-func Print(args ...interface{}) {
-	std.Print(args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func Info(args ...interface{}) {
-	std.Info(args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func Warn(args ...interface{}) {
-	std.Warn(args...)
-}
-
-// Warning logs a message at level Warn on the standard logger.
-func Warning(args ...interface{}) {
-	std.Warning(args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func Error(args ...interface{}) {
-	std.Error(args...)
-}
-
-// Panic logs a message at level Panic on the standard logger.
-func Panic(args ...interface{}) {
-	std.Panic(args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func Fatal(args ...interface{}) {
-	std.Fatal(args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func Debugf(format string, args ...interface{}) {
-	std.Debugf(format, args...)
-}
-
-// Printf logs a message at level Info on the standard logger.
-func Printf(format string, args ...interface{}) {
-	std.Printf(format, args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func Infof(format string, args ...interface{}) {
-	std.Infof(format, args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func Warnf(format string, args ...interface{}) {
-	std.Warnf(format, args...)
-}
-
-// Warningf logs a message at level Warn on the standard logger.
-func Warningf(format string, args ...interface{}) {
-	std.Warningf(format, args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func Errorf(format string, args ...interface{}) {
-	std.Errorf(format, args...)
-}
-
-// Panicf logs a message at level Panic on the standard logger.
-func Panicf(format string, args ...interface{}) {
-	std.Panicf(format, args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger.
-func Fatalf(format string, args ...interface{}) {
-	std.Fatalf(format, args...)
-}
-
-// Debugln logs a message at level Debug on the standard logger.
-func Debugln(args ...interface{}) {
-	std.Debugln(args...)
-}
-
-// Println logs a message at level Info on the standard logger.
-func Println(args ...interface{}) {
-	std.Println(args...)
-}
-
-// Infoln logs a message at level Info on the standard logger.
-func Infoln(args ...interface{}) {
-	std.Infoln(args...)
-}
-
-// Warnln logs a message at level Warn on the standard logger.
-func Warnln(args ...interface{}) {
-	std.Warnln(args...)
-}
-
-// Warningln logs a message at level Warn on the standard logger.
-func Warningln(args ...interface{}) {
-	std.Warningln(args...)
-}
-
-// Errorln logs a message at level Error on the standard logger.
-func Errorln(args ...interface{}) {
-	std.Errorln(args...)
-}
-
-// Panicln logs a message at level Panic on the standard logger.
-func Panicln(args ...interface{}) {
-	std.Panicln(args...)
-}
-
-// Fatalln logs a message at level Fatal on the standard logger.
-func Fatalln(args ...interface{}) {
-	std.Fatalln(args...)
-}

vendor/github.com/Sirupsen/logrus/formatter.go

@@ -1,44 +0,0 @@
-package logrus
-
-// The Formatter interface is used to implement a custom Formatter. It takes an
-// `Entry`. It exposes all the fields, including the default ones:
-//
-// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
-// * `entry.Data["time"]`. The timestamp.
-// * `entry.Data["level"]. The level the entry was logged at.
-//
-// Any additional fields added with `WithField` or `WithFields` are also in
-// `entry.Data`. Format is expected to return an array of bytes which are then
-// logged to `logger.Out`.
-type Formatter interface {
-	Format(*Entry) ([]byte, error)
-}
-
-// This is to not silently overwrite `time`, `msg` and `level` fields when
-// dumping it. If this code wasn't there doing:
-//
-//  logrus.WithField("level", 1).Info("hello")
-//
-// Would just silently drop the user provided level. Instead with this code
-// it'll logged as:
-//
-//  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
-//
-// It's not exported because it's still using Data in an opinionated way. It's to
-// avoid code duplication between the two default formatters.
-func prefixFieldClashes(data Fields) {
-	_, ok := data["time"]
-	if ok {
-		data["fields.time"] = data["time"]
-	}
-
-	_, ok = data["msg"]
-	if ok {
-		data["fields.msg"] = data["msg"]
-	}
-
-	_, ok = data["level"]
-	if ok {
-		data["fields.level"] = data["level"]
-	}
-}

vendor/github.com/Sirupsen/logrus/hooks.go

@@ -1,34 +0,0 @@
-package logrus
-
-// A hook to be fired when logging on the logging levels returned from
-// `Levels()` on your implementation of the interface. Note that this is not
-// fired in a goroutine or a channel with workers, you should handle such
-// functionality yourself if your call is non-blocking and you don't wish for
-// the logging calls for levels returned from `Levels()` to block.
-type Hook interface {
-	Levels() []Level
-	Fire(*Entry) error
-}
-
-// Internal type for storing the hooks on a logger instance.
-type levelHooks map[Level][]Hook
-
-// Add a hook to an instance of logger. This is called with
-// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
-func (hooks levelHooks) Add(hook Hook) {
-	for _, level := range hook.Levels() {
-		hooks[level] = append(hooks[level], hook)
-	}
-}
-
-// Fire all the hooks for the passed level. Used by `entry.log` to fire
-// appropriate hooks for a log entry.
-func (hooks levelHooks) Fire(level Level, entry *Entry) error {
-	for _, hook := range hooks[level] {
-		if err := hook.Fire(entry); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

vendor/github.com/Sirupsen/logrus/json_formatter.go

@@ -1,26 +0,0 @@
-package logrus
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-)
-
-type JSONFormatter struct{}
-
-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
-	data := make(Fields, len(entry.Data)+3)
-	for k, v := range entry.Data {
-		data[k] = v
-	}
-	prefixFieldClashes(data)
-	data["time"] = entry.Time.Format(time.RFC3339)
-	data["msg"] = entry.Message
-	data["level"] = entry.Level.String()
-
-	serialized, err := json.Marshal(data)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-	}
-	return append(serialized, '\n'), nil
-}

vendor/github.com/Sirupsen/logrus/logger.go

@@ -1,161 +0,0 @@
-package logrus
-
-import (
-	"io"
-	"os"
-	"sync"
-)
-
-type Logger struct {
-	// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
-	// file, or leave it default which is `os.Stdout`. You can also set this to
-	// something more adventorous, such as logging to Kafka.
-	Out io.Writer
-	// Hooks for the logger instance. These allow firing events based on logging
-	// levels and log entries. For example, to send errors to an error tracking
-	// service, log to StatsD or dump the core on fatal errors.
-	Hooks levelHooks
-	// All log entries pass through the formatter before logged to Out. The
-	// included formatters are `TextFormatter` and `JSONFormatter` for which
-	// TextFormatter is the default. In development (when a TTY is attached) it
-	// logs with colors, but to a file it wouldn't. You can easily implement your
-	// own that implements the `Formatter` interface, see the `README` or included
-	// formatters for examples.
-	Formatter Formatter
-	// The logging level the logger should log at. This is typically (and defaults
-	// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
-	// logged. `logrus.Debug` is useful in
-	Level Level
-	// Used to sync writing to the log.
-	mu sync.Mutex
-}
-
-// Creates a new logger. Configuration should be set by changing `Formatter`,
-// `Out` and `Hooks` directly on the default logger instance. You can also just
-// instantiate your own:
-//
-//    var log = &Logger{
-//      Out: os.Stderr,
-//      Formatter: new(JSONFormatter),
-//      Hooks: make(levelHooks),
-//      Level: logrus.DebugLevel,
-//    }
-//
-// It's recommended to make this a global instance called `log`.
-func New() *Logger {
-	return &Logger{
-		Out:       os.Stdout,
-		Formatter: new(TextFormatter),
-		Hooks:     make(levelHooks),
-		Level:     InfoLevel,
-	}
-}
-
-// Adds a field to the log entry, note that you it doesn't log until you call
-// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
-// Ff you want multiple fields, use `WithFields`.
-func (logger *Logger) WithField(key string, value interface{}) *Entry {
-	return NewEntry(logger).WithField(key, value)
-}
-
-// Adds a struct of fields to the log entry. All it does is call `WithField` for
-// each `Field`.
-func (logger *Logger) WithFields(fields Fields) *Entry {
-	return NewEntry(logger).WithFields(fields)
-}
-
-func (logger *Logger) Debugf(format string, args ...interface{}) {
-	NewEntry(logger).Debugf(format, args...)
-}
-
-func (logger *Logger) Infof(format string, args ...interface{}) {
-	NewEntry(logger).Infof(format, args...)
-}
-
-func (logger *Logger) Printf(format string, args ...interface{}) {
-	NewEntry(logger).Printf(format, args...)
-}
-
-func (logger *Logger) Warnf(format string, args ...interface{}) {
-	NewEntry(logger).Warnf(format, args...)
-}
-
-func (logger *Logger) Warningf(format string, args ...interface{}) {
-	NewEntry(logger).Warnf(format, args...)
-}
-
-func (logger *Logger) Errorf(format string, args ...interface{}) {
-	NewEntry(logger).Errorf(format, args...)
-}
-
-func (logger *Logger) Fatalf(format string, args ...interface{}) {
-	NewEntry(logger).Fatalf(format, args...)
-}
-
-func (logger *Logger) Panicf(format string, args ...interface{}) {
-	NewEntry(logger).Panicf(format, args...)
-}
-
-func (logger *Logger) Debug(args ...interface{}) {
-	NewEntry(logger).Debug(args...)
-}
-
-func (logger *Logger) Info(args ...interface{}) {
-	NewEntry(logger).Info(args...)
-}
-
-func (logger *Logger) Print(args ...interface{}) {
-	NewEntry(logger).Info(args...)
-}
-
-func (logger *Logger) Warn(args ...interface{}) {
-	NewEntry(logger).Warn(args...)
-}
-
-func (logger *Logger) Warning(args ...interface{}) {
-	NewEntry(logger).Warn(args...)
-}
-
-func (logger *Logger) Error(args ...interface{}) {
-	NewEntry(logger).Error(args...)
-}
-
-func (logger *Logger) Fatal(args ...interface{}) {
-	NewEntry(logger).Fatal(args...)
-}
-
-func (logger *Logger) Panic(args ...interface{}) {
-	NewEntry(logger).Panic(args...)
-}
-
-func (logger *Logger) Debugln(args ...interface{}) {
-	NewEntry(logger).Debugln(args...)
-}
-
-func (logger *Logger) Infoln(args ...interface{}) {
-	NewEntry(logger).Infoln(args...)
-}
-
-func (logger *Logger) Println(args ...interface{}) {
-	NewEntry(logger).Println(args...)
-}
-
-func (logger *Logger) Warnln(args ...interface{}) {
-	NewEntry(logger).Warnln(args...)
-}
-
-func (logger *Logger) Warningln(args ...interface{}) {
-	NewEntry(logger).Warnln(args...)
-}
-
-func (logger *Logger) Errorln(args ...interface{}) {
-	NewEntry(logger).Errorln(args...)
-}
-
-func (logger *Logger) Fatalln(args ...interface{}) {
-	NewEntry(logger).Fatalln(args...)
-}
-
-func (logger *Logger) Panicln(args ...interface{}) {
-	NewEntry(logger).Panicln(args...)
-}

vendor/github.com/Sirupsen/logrus/logrus.go

@@ -1,94 +0,0 @@
-package logrus
-
-import (
-	"fmt"
-	"log"
-)
-
-// Fields type, used to pass to `WithFields`.
-type Fields map[string]interface{}
-
-// Level type
-type Level uint8
-
-// Convert the Level to a string. E.g. PanicLevel becomes "panic".
-func (level Level) String() string {
-	switch level {
-	case DebugLevel:
-		return "debug"
-	case InfoLevel:
-		return "info"
-	case WarnLevel:
-		return "warning"
-	case ErrorLevel:
-		return "error"
-	case FatalLevel:
-		return "fatal"
-	case PanicLevel:
-		return "panic"
-	}
-
-	return "unknown"
-}
-
-// ParseLevel takes a string level and returns the Logrus log level constant.
-func ParseLevel(lvl string) (Level, error) {
-	switch lvl {
-	case "panic":
-		return PanicLevel, nil
-	case "fatal":
-		return FatalLevel, nil
-	case "error":
-		return ErrorLevel, nil
-	case "warn", "warning":
-		return WarnLevel, nil
-	case "info":
-		return InfoLevel, nil
-	case "debug":
-		return DebugLevel, nil
-	}
-
-	var l Level
-	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
-}
-
-// These are the different logging levels. You can set the logging level to log
-// on your instance of logger, obtained with `logrus.New()`.
-const (
-	// PanicLevel level, highest level of severity. Logs and then calls panic with the
-	// message passed to Debug, Info, ...
-	PanicLevel Level = iota
-	// FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
-	// logging level is set to Panic.
-	FatalLevel
-	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
-	// Commonly used for hooks to send errors to an error tracking service.
-	ErrorLevel
-	// WarnLevel level. Non-critical entries that deserve eyes.
-	WarnLevel
-	// InfoLevel level. General operational entries about what's going on inside the
-	// application.
-	InfoLevel
-	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
-	DebugLevel
-)
-
-// Won't compile if StdLogger can't be realized by a log.Logger
-var _ StdLogger = &log.Logger{}
-
-// StdLogger is what your logrus-enabled library should take, that way
-// it'll accept a stdlib logger and a logrus logger. There's no standard
-// interface, this is the closest we get, unfortunately.
-type StdLogger interface {
-	Print(...interface{})
-	Printf(string, ...interface{})
-	Println(...interface{})
-
-	Fatal(...interface{})
-	Fatalf(string, ...interface{})
-	Fatalln(...interface{})
-
-	Panic(...interface{})
-	Panicf(string, ...interface{})
-	Panicln(...interface{})
-}

vendor/github.com/Sirupsen/logrus/terminal_darwin.go

@@ -1,12 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-type Termios syscall.Termios

vendor/github.com/Sirupsen/logrus/terminal_freebsd.go

@@ -1,20 +0,0 @@
-/*
-  Go 1.2 doesn't include Termios for FreeBSD. This should be added in 1.3 and this could be merged with terminal_darwin.
-*/
-package logrus
-
-import (
-	"syscall"
-)
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-type Termios struct {
-	Iflag  uint32
-	Oflag  uint32
-	Cflag  uint32
-	Lflag  uint32
-	Cc     [20]uint8
-	Ispeed uint32
-	Ospeed uint32
-}

vendor/github.com/Sirupsen/logrus/terminal_linux.go

@@ -1,12 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TCGETS
-
-type Termios syscall.Termios

vendor/github.com/Sirupsen/logrus/terminal_notwindows.go

@@ -1,21 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux,!appengine darwin freebsd openbsd
-
-package logrus
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-func IsTerminal() bool {
-	fd := syscall.Stdout
-	var termios Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

vendor/github.com/Sirupsen/logrus/terminal_openbsd.go

@@ -1,8 +0,0 @@
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-type Termios syscall.Termios

vendor/github.com/Sirupsen/logrus/terminal_windows.go

@@ -1,27 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-package logrus
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var kernel32 = syscall.NewLazyDLL("kernel32.dll")
-
-var (
-	procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-func IsTerminal() bool {
-	fd := syscall.Stdout
-	var st uint32
-	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
-	return r != 0 && e == 0
-}

vendor/github.com/Sirupsen/logrus/text_formatter.go

@@ -1,124 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-)
-
-const (
-	nocolor = 0
-	red     = 31
-	green   = 32
-	yellow  = 33
-	blue    = 34
-)
-
-var (
-	baseTimestamp time.Time
-	isTerminal    bool
-	noQuoteNeeded *regexp.Regexp
-)
-
-func init() {
-	baseTimestamp = time.Now()
-	isTerminal = IsTerminal()
-}
-
-func miniTS() int {
-	return int(time.Since(baseTimestamp) / time.Second)
-}
-
-type TextFormatter struct {
-	// Set to true to bypass checking for a TTY before outputting colors.
-	ForceColors   bool
-	DisableColors bool
-	// Set to true to disable timestamp logging (useful when the output
-	// is redirected to a logging system already adding a timestamp)
-	DisableTimestamp bool
-}
-
-func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
-
-	var keys []string
-	for k := range entry.Data {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	b := &bytes.Buffer{}
-
-	prefixFieldClashes(entry.Data)
-
-	isColored := (f.ForceColors || isTerminal) && !f.DisableColors
-
-	if isColored {
-		printColored(b, entry, keys)
-	} else {
-		if !f.DisableTimestamp {
-			f.appendKeyValue(b, "time", entry.Time.Format(time.RFC3339))
-		}
-		f.appendKeyValue(b, "level", entry.Level.String())
-		f.appendKeyValue(b, "msg", entry.Message)
-		for _, key := range keys {
-			f.appendKeyValue(b, key, entry.Data[key])
-		}
-	}
-
-	b.WriteByte('\n')
-	return b.Bytes(), nil
-}
-
-func printColored(b *bytes.Buffer, entry *Entry, keys []string) {
-	var levelColor int
-	switch entry.Level {
-	case WarnLevel:
-		levelColor = yellow
-	case ErrorLevel, FatalLevel, PanicLevel:
-		levelColor = red
-	default:
-		levelColor = blue
-	}
-
-	levelText := strings.ToUpper(entry.Level.String())[0:4]
-
-	fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)
-	for _, k := range keys {
-		v := entry.Data[k]
-		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%v", levelColor, k, v)
-	}
-}
-
-func needsQuoting(text string) bool {
-	for _, ch := range text {
-		if !((ch >= 'a' && ch <= 'z') ||
-			(ch >= 'A' && ch <= 'Z') ||
-			(ch >= '0' && ch < '9') ||
-			ch == '-' || ch == '.') {
-			return false
-		}
-	}
-	return true
-}
-
-func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key, value interface{}) {
-	switch value.(type) {
-	case string:
-		if needsQuoting(value.(string)) {
-			fmt.Fprintf(b, "%v=%s ", key, value)
-		} else {
-			fmt.Fprintf(b, "%v=%q ", key, value)
-		}
-	case error:
-		if needsQuoting(value.(error).Error()) {
-			fmt.Fprintf(b, "%v=%s ", key, value)
-		} else {
-			fmt.Fprintf(b, "%v=%q ", key, value)
-		}
-	default:
-		fmt.Fprintf(b, "%v=%v ", key, value)
-	}
-}

vendor/github.com/codegangsta/cli/.travis.yml

@@ -1,6 +0,0 @@
-language: go
-go: 1.1
-
-script:
-- go vet ./...
-- go test -v ./...

vendor/github.com/codegangsta/cli/LICENSE

@@ -1,21 +0,0 @@
-Copyright (C) 2013 Jeremy Saenz
-All Rights Reserved.
-
-MIT LICENSE
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/codegangsta/cli/README.md

@@ -1,298 +0,0 @@
-[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
-
-# cli.go
-cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
-
-You can view the API docs here:
-http://godoc.org/github.com/codegangsta/cli
-
-## Overview
-Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
-
-**This is where cli.go comes into play.** cli.go makes command line programming fun, organized, and expressive!
-
-## Installation
-Make sure you have a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
-
-To install `cli.go`, simply run:
-```
-$ go get github.com/codegangsta/cli
-```
-
-Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
-```
-export PATH=$PATH:$GOPATH/bin
-```
-
-## Getting Started
-One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`. 
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  cli.NewApp().Run(os.Args)
-}
-```
-
-This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "boom"
-  app.Usage = "make an explosive entrance"
-  app.Action = func(c *cli.Context) {
-    println("boom! I say!")
-  }
-  
-  app.Run(os.Args)
-}
-```
-
-Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
-
-## Example
-
-Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
-
-Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "greet"
-  app.Usage = "fight the loneliness!"
-  app.Action = func(c *cli.Context) {
-    println("Hello friend!")
-  }
-
-  app.Run(os.Args)
-}
-```
-
-Install our command to the `$GOPATH/bin` directory:
-
-```
-$ go install
-```
-
-Finally run our new command:
-
-```
-$ greet
-Hello friend!
-```
-
-cli.go also generates some bitchass help text:
-```
-$ greet help
-NAME:
-    greet - fight the loneliness!
-
-USAGE:
-    greet [global options] command [command options] [arguments...]
-
-VERSION:
-    0.0.0
-
-COMMANDS:
-    help, h  Shows a list of commands or help for one command
-
-GLOBAL OPTIONS
-    --version	Shows version information
-```
-
-### Arguments
-You can lookup arguments by calling the `Args` function on `cli.Context`.
-
-``` go
-...
-app.Action = func(c *cli.Context) {
-  println("Hello", c.Args()[0])
-}
-...
-```
-
-### Flags
-Setting and querying flags is simple.
-``` go
-...
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-app.Action = func(c *cli.Context) {
-  name := "someone"
-  if len(c.Args()) > 0 {
-    name = c.Args()[0]
-  }
-  if c.String("lang") == "spanish" {
-    println("Hola", name)
-  } else {
-    println("Hello", name)
-  }
-}
-...
-```
-
-#### Alternate Names
-
-You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-```
-
-That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
-
-#### Values from the Environment
-
-You can also have the default value set from the environment via `EnvVar`.  e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "APP_LANG",
-  },
-}
-```
-
-The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
-  },
-}
-```
-
-### Subcommands
-
-Subcommands can be defined for a more git-like command line app.
-```go
-...
-app.Commands = []cli.Command{
-  {
-    Name:      "add",
-    ShortName: "a",
-    Usage:     "add a task to the list",
-    Action: func(c *cli.Context) {
-      println("added task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "complete",
-    ShortName: "c",
-    Usage:     "complete a task on the list",
-    Action: func(c *cli.Context) {
-      println("completed task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "template",
-    ShortName: "r",
-    Usage:     "options for task templates",
-    Subcommands: []cli.Command{
-      {
-        Name:  "add",
-        Usage: "add a new template",
-        Action: func(c *cli.Context) {
-            println("new task template: ", c.Args().First())
-        },
-      },
-      {
-        Name:  "remove",
-        Usage: "remove an existing template",
-        Action: func(c *cli.Context) {
-          println("removed task template: ", c.Args().First())
-        },
-      },
-    },
-  },     
-}
-...
-```
-
-### Bash Completion
-
-You can enable completion commands by setting the `EnableBashCompletion`
-flag on the `App` object.  By default, this setting will only auto-complete to
-show an app's subcommands, but you can write your own completion methods for
-the App or its subcommands.
-```go
-...
-var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
-app := cli.NewApp()
-app.EnableBashCompletion = true
-app.Commands = []cli.Command{
-  {
-    Name: "complete",
-    ShortName: "c",
-    Usage: "complete a task on the list",
-    Action: func(c *cli.Context) {
-       println("completed task: ", c.Args().First())
-    },
-    BashComplete: func(c *cli.Context) {
-      // This will complete if no args are passed
-      if len(c.Args()) > 0 {
-        return
-      }
-      for _, t := range tasks {
-        fmt.Println(t)
-      }
-    },
-  }
-}
-...
-```
-
-#### To Enable
-
-Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
-setting the `PROG` variable to the name of your program:
-
-`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
-
-
-## Contribution Guidelines
-Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
-
-If you are have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
-
-If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.

vendor/github.com/codegangsta/cli/app.go

@@ -1,275 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"text/tabwriter"
-	"text/template"
-	"time"
-)
-
-// App is the main structure of a cli application. It is recomended that
-// and app be created with the cli.NewApp() function
-type App struct {
-	// The name of the program. Defaults to os.Args[0]
-	Name string
-	// Description of the program.
-	Usage string
-	// Version of the program
-	Version string
-	// List of commands to execute
-	Commands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Boolean to enable bash completion commands
-	EnableBashCompletion bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-	// Boolean to hide built-in version flag
-	HideVersion bool
-	// An action to execute when the bash-completion flag is set
-	BashComplete func(context *Context)
-	// An action to execute before any subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no subcommands are run
-	Before func(context *Context) error
-	// The action to execute when no subcommands are specified
-	Action func(context *Context)
-	// Execute this function if the proper command cannot be found
-	CommandNotFound func(context *Context, command string)
-	// Compilation date
-	Compiled time.Time
-	// Author
-	Author string
-	// Author e-mail
-	Email string
-	// Writer writer to write output to
-	Writer io.Writer
-}
-
-// Tries to find out when this binary was compiled.
-// Returns the current time if it fails to find it.
-func compileTime() time.Time {
-	info, err := os.Stat(os.Args[0])
-	if err != nil {
-		return time.Now()
-	}
-	return info.ModTime()
-}
-
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
-func NewApp() *App {
-	return &App{
-		Name:         os.Args[0],
-		Usage:        "A new cli application",
-		Version:      "0.0.0",
-		BashComplete: DefaultAppComplete,
-		Action:       helpCommand.Action,
-		Compiled:     compileTime(),
-		Author:       "Author",
-		Email:        "unknown@email",
-		Writer:       os.Stdout,
-	}
-}
-
-// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
-func (a *App) Run(arguments []string) error {
-	if HelpPrinter == nil {
-		defer func() {
-			HelpPrinter = nil
-		}()
-
-		HelpPrinter = func(templ string, data interface{}) {
-			w := tabwriter.NewWriter(a.Writer, 0, 8, 1, '\t', 0)
-			t := template.Must(template.New("help").Parse(templ))
-			err := t.Execute(w, data)
-			if err != nil {
-				panic(err)
-			}
-			w.Flush()
-		}
-	}
-
-	// append help to commands
-	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-		a.Commands = append(a.Commands, helpCommand)
-		if (HelpFlag != BoolFlag{}) {
-			a.appendFlag(HelpFlag)
-		}
-	}
-
-	//append version/help flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	if !a.HideVersion {
-		a.appendFlag(VersionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err := set.Parse(arguments[1:])
-	nerr := normalizeFlags(a.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		context := NewContext(a, set, set)
-		ShowAppHelp(context)
-		fmt.Fprintln(a.Writer)
-		return nerr
-	}
-	context := NewContext(a, set, set)
-
-	if err != nil {
-		fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
-		ShowAppHelp(context)
-		fmt.Fprintln(a.Writer)
-		return err
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if checkHelp(context) {
-		return nil
-	}
-
-	if checkVersion(context) {
-		return nil
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-	return nil
-}
-
-// Another entry point to the cli app, takes care of passing arguments and error handling
-func (a *App) RunAndExitOnError() {
-	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
-func (a *App) RunAsSubcommand(ctx *Context) error {
-	// append help to commands
-	if len(a.Commands) > 0 {
-		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-			a.Commands = append(a.Commands, helpCommand)
-			if (HelpFlag != BoolFlag{}) {
-				a.appendFlag(HelpFlag)
-			}
-		}
-	}
-
-	// append flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err := set.Parse(ctx.Args().Tail())
-	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx.globalSet)
-
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		if len(a.Commands) > 0 {
-			ShowSubcommandHelp(context)
-		} else {
-			ShowCommandHelp(ctx, context.Args().First())
-		}
-		fmt.Fprintln(a.Writer)
-		return nerr
-	}
-
-	if err != nil {
-		fmt.Fprintf(a.Writer, "Incorrect Usage.\n\n")
-		ShowSubcommandHelp(context)
-		return err
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if len(a.Commands) > 0 {
-		if checkSubcommandHelp(context) {
-			return nil
-		}
-	} else {
-		if checkCommandHelp(ctx, context.Args().First()) {
-			return nil
-		}
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-
-	return nil
-}
-
-// Returns the named command on App. Returns nil if the command does not exist
-func (a *App) Command(name string) *Command {
-	for _, c := range a.Commands {
-		if c.HasName(name) {
-			return &c
-		}
-	}
-
-	return nil
-}
-
-func (a *App) hasFlag(flag Flag) bool {
-	for _, f := range a.Flags {
-		if flag == f {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (a *App) appendFlag(flag Flag) {
-	if !a.hasFlag(flag) {
-		a.Flags = append(a.Flags, flag)
-	}
-}

vendor/github.com/codegangsta/cli/cli.go

@@ -1,19 +0,0 @@
-// Package cli provides a minimal framework for creating and organizing command line
-// Go applications. cli is designed to be easy to understand and write, the most simple
-// cli application can be written as follows:
-//   func main() {
-//     cli.NewApp().Run(os.Args)
-//   }
-//
-// Of course this application does not do much, so let's make this an actual application:
-//   func main() {
-//     app := cli.NewApp()
-//     app.Name = "greet"
-//     app.Usage = "say a greeting"
-//     app.Action = func(c *cli.Context) {
-//       println("Greetings")
-//     }
-//
-//     app.Run(os.Args)
-//   }
-package cli

vendor/github.com/codegangsta/cli/command.go

@@ -1,156 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io/ioutil"
-	"strings"
-)
-
-// Command is a subcommand for a cli.App.
-type Command struct {
-	// The name of the command
-	Name string
-	// short name of the command. Typically one character
-	ShortName string
-	// A short description of the usage of this command
-	Usage string
-	// A longer explanation of how the command works
-	Description string
-	// The function to call when checking for bash command completions
-	BashComplete func(context *Context)
-	// An action to execute before any sub-subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no sub-subcommands are run
-	Before func(context *Context) error
-	// The function to call when this command is invoked
-	Action func(context *Context)
-	// List of child commands
-	Subcommands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Treat all flags as normal arguments if true
-	SkipFlagParsing bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-}
-
-// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
-func (c Command) Run(ctx *Context) error {
-
-	if len(c.Subcommands) > 0 || c.Before != nil {
-		return c.startApp(ctx)
-	}
-
-	if !c.HideHelp && (HelpFlag != BoolFlag{}) {
-		// append help to flags
-		c.Flags = append(
-			c.Flags,
-			HelpFlag,
-		)
-	}
-
-	if ctx.App.EnableBashCompletion {
-		c.Flags = append(c.Flags, BashCompletionFlag)
-	}
-
-	set := flagSet(c.Name, c.Flags)
-	set.SetOutput(ioutil.Discard)
-
-	firstFlagIndex := -1
-	terminatorIndex := -1
-	for index, arg := range ctx.Args() {
-		if arg == "--" {
-			terminatorIndex = index
-			break
-		} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
-			firstFlagIndex = index
-		}
-	}
-
-	var err error
-	if firstFlagIndex > -1 && !c.SkipFlagParsing {
-		args := ctx.Args()
-		regularArgs := make([]string, len(args[1:firstFlagIndex]))
-		copy(regularArgs, args[1:firstFlagIndex])
-
-		var flagArgs []string
-		if terminatorIndex > -1 {
-			flagArgs = args[firstFlagIndex:terminatorIndex]
-			regularArgs = append(regularArgs, args[terminatorIndex:]...)
-		} else {
-			flagArgs = args[firstFlagIndex:]
-		}
-
-		err = set.Parse(append(flagArgs, regularArgs...))
-	} else {
-		err = set.Parse(ctx.Args().Tail())
-	}
-
-	if err != nil {
-		fmt.Fprint(ctx.App.Writer, "Incorrect Usage.\n\n")
-		ShowCommandHelp(ctx, c.Name)
-		fmt.Fprintln(ctx.App.Writer)
-		return err
-	}
-
-	nerr := normalizeFlags(c.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(ctx.App.Writer, nerr)
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		fmt.Fprintln(ctx.App.Writer)
-		return nerr
-	}
-	context := NewContext(ctx.App, set, ctx.globalSet)
-
-	if checkCommandCompletions(context, c.Name) {
-		return nil
-	}
-
-	if checkCommandHelp(context, c.Name) {
-		return nil
-	}
-	context.Command = c
-	c.Action(context)
-	return nil
-}
-
-// Returns true if Command.Name or Command.ShortName matches given name
-func (c Command) HasName(name string) bool {
-	return c.Name == name || c.ShortName == name
-}
-
-func (c Command) startApp(ctx *Context) error {
-	app := NewApp()
-
-	// set the name and usage
-	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	if c.Description != "" {
-		app.Usage = c.Description
-	} else {
-		app.Usage = c.Usage
-	}
-
-	// set CommandNotFound
-	app.CommandNotFound = ctx.App.CommandNotFound
-
-	// set the flags and commands
-	app.Commands = c.Subcommands
-	app.Flags = c.Flags
-	app.HideHelp = c.HideHelp
-
-	// bash completion
-	app.EnableBashCompletion = ctx.App.EnableBashCompletion
-	if c.BashComplete != nil {
-		app.BashComplete = c.BashComplete
-	}
-
-	// set the actions
-	app.Before = c.Before
-	if c.Action != nil {
-		app.Action = c.Action
-	} else {
-		app.Action = helpSubcommand.Action
-	}
-
-	return app.RunAsSubcommand(ctx)
-}

vendor/github.com/codegangsta/cli/context.go

@@ -1,339 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Context is a type that is passed through to
-// each Handler action in a cli application. Context
-// can be used to retrieve context-specific Args and
-// parsed command-line options.
-type Context struct {
-	App            *App
-	Command        Command
-	flagSet        *flag.FlagSet
-	globalSet      *flag.FlagSet
-	setFlags       map[string]bool
-	globalSetFlags map[string]bool
-}
-
-// Creates a new context. For use in when invoking an App or Command action.
-func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
-	return &Context{App: app, flagSet: set, globalSet: globalSet}
-}
-
-// Looks up the value of a local int flag, returns 0 if no int flag exists
-func (c *Context) Int(name string) int {
-	return lookupInt(name, c.flagSet)
-}
-
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) Duration(name string) time.Duration {
-	return lookupDuration(name, c.flagSet)
-}
-
-// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
-func (c *Context) Float64(name string) float64 {
-	return lookupFloat64(name, c.flagSet)
-}
-
-// Looks up the value of a local bool flag, returns false if no bool flag exists
-func (c *Context) Bool(name string) bool {
-	return lookupBool(name, c.flagSet)
-}
-
-// Looks up the value of a local boolT flag, returns false if no bool flag exists
-func (c *Context) BoolT(name string) bool {
-	return lookupBoolT(name, c.flagSet)
-}
-
-// Looks up the value of a local string flag, returns "" if no string flag exists
-func (c *Context) String(name string) string {
-	return lookupString(name, c.flagSet)
-}
-
-// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
-func (c *Context) StringSlice(name string) []string {
-	return lookupStringSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
-func (c *Context) IntSlice(name string) []int {
-	return lookupIntSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local generic flag, returns nil if no generic flag exists
-func (c *Context) Generic(name string) interface{} {
-	return lookupGeneric(name, c.flagSet)
-}
-
-// Looks up the value of a global int flag, returns 0 if no int flag exists
-func (c *Context) GlobalInt(name string) int {
-	return lookupInt(name, c.globalSet)
-}
-
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) GlobalDuration(name string) time.Duration {
-	return lookupDuration(name, c.globalSet)
-}
-
-// Looks up the value of a global bool flag, returns false if no bool flag exists
-func (c *Context) GlobalBool(name string) bool {
-	return lookupBool(name, c.globalSet)
-}
-
-// Looks up the value of a global string flag, returns "" if no string flag exists
-func (c *Context) GlobalString(name string) string {
-	return lookupString(name, c.globalSet)
-}
-
-// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
-func (c *Context) GlobalStringSlice(name string) []string {
-	return lookupStringSlice(name, c.globalSet)
-}
-
-// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
-func (c *Context) GlobalIntSlice(name string) []int {
-	return lookupIntSlice(name, c.globalSet)
-}
-
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
-func (c *Context) GlobalGeneric(name string) interface{} {
-	return lookupGeneric(name, c.globalSet)
-}
-
-// Determines if the flag was actually set
-func (c *Context) IsSet(name string) bool {
-	if c.setFlags == nil {
-		c.setFlags = make(map[string]bool)
-		c.flagSet.Visit(func(f *flag.Flag) {
-			c.setFlags[f.Name] = true
-		})
-	}
-	return c.setFlags[name] == true
-}
-
-// Determines if the global flag was actually set
-func (c *Context) GlobalIsSet(name string) bool {
-	if c.globalSetFlags == nil {
-		c.globalSetFlags = make(map[string]bool)
-		c.globalSet.Visit(func(f *flag.Flag) {
-			c.globalSetFlags[f.Name] = true
-		})
-	}
-	return c.globalSetFlags[name] == true
-}
-
-// Returns a slice of flag names used in this context.
-func (c *Context) FlagNames() (names []string) {
-	for _, flag := range c.Command.Flags {
-		name := strings.Split(flag.getName(), ",")[0]
-		if name == "help" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns a slice of global flag names used by the app.
-func (c *Context) GlobalFlagNames() (names []string) {
-	for _, flag := range c.App.Flags {
-		name := strings.Split(flag.getName(), ",")[0]
-		if name == "help" || name == "version" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-type Args []string
-
-// Returns the command line arguments associated with the context.
-func (c *Context) Args() Args {
-	args := Args(c.flagSet.Args())
-	return args
-}
-
-// Returns the nth argument, or else a blank string
-func (a Args) Get(n int) string {
-	if len(a) > n {
-		return a[n]
-	}
-	return ""
-}
-
-// Returns the first argument, or else a blank string
-func (a Args) First() string {
-	return a.Get(0)
-}
-
-// Return the rest of the arguments (not the first one)
-// or else an empty string slice
-func (a Args) Tail() []string {
-	if len(a) >= 2 {
-		return []string(a)[1:]
-	}
-	return []string{}
-}
-
-// Checks if there are any arguments present
-func (a Args) Present() bool {
-	return len(a) != 0
-}
-
-// Swaps arguments at the given indexes
-func (a Args) Swap(from, to int) error {
-	if from >= len(a) || to >= len(a) {
-		return errors.New("index out of range")
-	}
-	a[from], a[to] = a[to], a[from]
-	return nil
-}
-
-func lookupInt(name string, set *flag.FlagSet) int {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.Atoi(f.Value.String())
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupDuration(name string, set *flag.FlagSet) time.Duration {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := time.ParseDuration(f.Value.String())
-		if err == nil {
-			return val
-		}
-	}
-
-	return 0
-}
-
-func lookupFloat64(name string, set *flag.FlagSet) float64 {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseFloat(f.Value.String(), 64)
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupString(name string, set *flag.FlagSet) string {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value.String()
-	}
-
-	return ""
-}
-
-func lookupStringSlice(name string, set *flag.FlagSet) []string {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*StringSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupIntSlice(name string, set *flag.FlagSet) []int {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*IntSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupGeneric(name string, set *flag.FlagSet) interface{} {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value
-	}
-	return nil
-}
-
-func lookupBool(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return false
-		}
-		return val
-	}
-
-	return false
-}
-
-func lookupBoolT(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return true
-		}
-		return val
-	}
-
-	return false
-}
-
-func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
-	switch ff.Value.(type) {
-	case *StringSlice:
-	default:
-		set.Set(name, ff.Value.String())
-	}
-}
-
-func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
-	visited := make(map[string]bool)
-	set.Visit(func(f *flag.Flag) {
-		visited[f.Name] = true
-	})
-	for _, f := range flags {
-		parts := strings.Split(f.getName(), ",")
-		if len(parts) == 1 {
-			continue
-		}
-		var ff *flag.Flag
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if visited[name] {
-				if ff != nil {
-					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
-				}
-				ff = set.Lookup(name)
-			}
-		}
-		if ff == nil {
-			continue
-		}
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if !visited[name] {
-				copyFlag(name, ff, set)
-			}
-		}
-	}
-	return nil
-}

vendor/github.com/codegangsta/cli/flag.go

@@ -1,454 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// This flag enables bash-completion for all commands and subcommands
-var BashCompletionFlag = BoolFlag{
-	Name: "generate-bash-completion",
-}
-
-// This flag prints the version for the application
-var VersionFlag = BoolFlag{
-	Name:  "version, v",
-	Usage: "print the version",
-}
-
-// This flag prints the help for all commands and subcommands
-// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
-// unless HideHelp is set to true)
-var HelpFlag = BoolFlag{
-	Name:  "help, h",
-	Usage: "show help",
-}
-
-// Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recomended that
-// this interface be implemented.
-type Flag interface {
-	fmt.Stringer
-	// Apply Flag settings to the given flag set
-	Apply(*flag.FlagSet)
-	getName() string
-}
-
-func flagSet(name string, flags []Flag) *flag.FlagSet {
-	set := flag.NewFlagSet(name, flag.ContinueOnError)
-
-	for _, f := range flags {
-		f.Apply(set)
-	}
-	return set
-}
-
-func eachName(longName string, fn func(string)) {
-	parts := strings.Split(longName, ",")
-	for _, name := range parts {
-		name = strings.Trim(name, " ")
-		fn(name)
-	}
-}
-
-// Generic is a generic parseable type identified by a specific flag
-type Generic interface {
-	Set(value string) error
-	String() string
-}
-
-// GenericFlag is the flag type for types implementing Generic
-type GenericFlag struct {
-	Name   string
-	Value  Generic
-	Usage  string
-	EnvVar string
-}
-
-// String returns the string representation of the generic flag to display the
-// help text to the user (uses the String() method of the generic flag to show
-// the value)
-func (f GenericFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s \"%v\"\t%v", prefixFor(f.Name), f.Name, f.Value, f.Usage))
-}
-
-// Apply takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
-func (f GenericFlag) Apply(set *flag.FlagSet) {
-	val := f.Value
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				val.Set(envVal)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f GenericFlag) getName() string {
-	return f.Name
-}
-
-type StringSlice []string
-
-func (f *StringSlice) Set(value string) error {
-	*f = append(*f, value)
-	return nil
-}
-
-func (f *StringSlice) String() string {
-	return fmt.Sprintf("%s", *f)
-}
-
-func (f *StringSlice) Value() []string {
-	return *f
-}
-
-type StringSliceFlag struct {
-	Name   string
-	Value  *StringSlice
-	Usage  string
-	EnvVar string
-}
-
-func (f StringSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-func (f StringSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &StringSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					newVal.Set(s)
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f StringSliceFlag) getName() string {
-	return f.Name
-}
-
-type IntSlice []int
-
-func (f *IntSlice) Set(value string) error {
-
-	tmp, err := strconv.Atoi(value)
-	if err != nil {
-		return err
-	} else {
-		*f = append(*f, tmp)
-	}
-	return nil
-}
-
-func (f *IntSlice) String() string {
-	return fmt.Sprintf("%d", *f)
-}
-
-func (f *IntSlice) Value() []int {
-	return *f
-}
-
-type IntSliceFlag struct {
-	Name   string
-	Value  *IntSlice
-	Usage  string
-	EnvVar string
-}
-
-func (f IntSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-func (f IntSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &IntSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					err := newVal.Set(s)
-					if err != nil {
-						fmt.Fprintf(os.Stderr, err.Error())
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f IntSliceFlag) getName() string {
-	return f.Name
-}
-
-type BoolFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-}
-
-func (f BoolFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-func (f BoolFlag) Apply(set *flag.FlagSet) {
-	val := false
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-				}
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolFlag) getName() string {
-	return f.Name
-}
-
-type BoolTFlag struct {
-	Name   string
-	Usage  string
-	EnvVar string
-}
-
-func (f BoolTFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-func (f BoolTFlag) Apply(set *flag.FlagSet) {
-	val := true
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolTFlag) getName() string {
-	return f.Name
-}
-
-type StringFlag struct {
-	Name   string
-	Value  string
-	Usage  string
-	EnvVar string
-}
-
-func (f StringFlag) String() string {
-	var fmtString string
-	fmtString = "%s %v\t%v"
-
-	if len(f.Value) > 0 {
-		fmtString = "%s \"%v\"\t%v"
-	} else {
-		fmtString = "%s %v\t%v"
-	}
-
-	return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f StringFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				f.Value = envVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.String(name, f.Value, f.Usage)
-	})
-}
-
-func (f StringFlag) getName() string {
-	return f.Name
-}
-
-type IntFlag struct {
-	Name   string
-	Value  int
-	Usage  string
-	EnvVar string
-}
-
-func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f IntFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err == nil {
-					f.Value = int(envValInt)
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Int(name, f.Value, f.Usage)
-	})
-}
-
-func (f IntFlag) getName() string {
-	return f.Name
-}
-
-type DurationFlag struct {
-	Name   string
-	Value  time.Duration
-	Usage  string
-	EnvVar string
-}
-
-func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f DurationFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValDuration, err := time.ParseDuration(envVal)
-				if err == nil {
-					f.Value = envValDuration
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Duration(name, f.Value, f.Usage)
-	})
-}
-
-func (f DurationFlag) getName() string {
-	return f.Name
-}
-
-type Float64Flag struct {
-	Name   string
-	Value  float64
-	Usage  string
-	EnvVar string
-}
-
-func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-func (f Float64Flag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValFloat, err := strconv.ParseFloat(envVal, 10)
-				if err == nil {
-					f.Value = float64(envValFloat)
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Float64(name, f.Value, f.Usage)
-	})
-}
-
-func (f Float64Flag) getName() string {
-	return f.Name
-}
-
-func prefixFor(name string) (prefix string) {
-	if len(name) == 1 {
-		prefix = "-"
-	} else {
-		prefix = "--"
-	}
-
-	return
-}
-
-func prefixedNames(fullName string) (prefixed string) {
-	parts := strings.Split(fullName, ",")
-	for i, name := range parts {
-		name = strings.Trim(name, " ")
-		prefixed += prefixFor(name) + name
-		if i < len(parts)-1 {
-			prefixed += ", "
-		}
-	}
-	return
-}
-
-func withEnvHint(envVar, str string) string {
-	envText := ""
-	if envVar != "" {
-		envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
-	}
-	return str + envText
-}

vendor/github.com/codegangsta/cli/help.go

@@ -1,211 +0,0 @@
-package cli
-
-import "fmt"
-
-// The text template for the Default help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var AppHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   {{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...]
-
-VERSION:
-   {{.Version}}{{if or .Author .Email}}
-
-AUTHOR:{{if .Author}}
-  {{.Author}}{{if .Email}} - <{{.Email}}>{{end}}{{else}}
-  {{.Email}}{{end}}{{end}}
-
-COMMANDS:
-   {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
-GLOBAL OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}
-`
-
-// The text template for the command help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var CommandHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   command {{.Name}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
-
-DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
-
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{ end }}
-`
-
-// The text template for the subcommand help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var SubcommandHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   {{.Name}} command{{if .Flags}} [command options]{{end}} [arguments...]
-
-COMMANDS:
-   {{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}
-`
-
-var helpCommand = Command{
-	Name:      "help",
-	ShortName: "h",
-	Usage:     "Shows a list of commands or help for one command",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowAppHelp(c)
-		}
-	},
-}
-
-var helpSubcommand = Command{
-	Name:      "help",
-	ShortName: "h",
-	Usage:     "Shows a list of commands or help for one command",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowSubcommandHelp(c)
-		}
-	},
-}
-
-// Prints help for the App
-type helpPrinter func(templ string, data interface{})
-
-var HelpPrinter helpPrinter = nil
-
-// Prints version for the App
-var VersionPrinter = printVersion
-
-func ShowAppHelp(c *Context) {
-	HelpPrinter(AppHelpTemplate, c.App)
-}
-
-// Prints the list of subcommands as the default app completion method
-func DefaultAppComplete(c *Context) {
-	for _, command := range c.App.Commands {
-		fmt.Fprintln(c.App.Writer, command.Name)
-		if command.ShortName != "" {
-			fmt.Fprintln(c.App.Writer, command.ShortName)
-		}
-	}
-}
-
-// Prints help for the given command
-func ShowCommandHelp(c *Context, command string) {
-	for _, c := range c.App.Commands {
-		if c.HasName(command) {
-			HelpPrinter(CommandHelpTemplate, c)
-			return
-		}
-	}
-
-	if c.App.CommandNotFound != nil {
-		c.App.CommandNotFound(c, command)
-	} else {
-		fmt.Fprintf(c.App.Writer, "No help topic for '%v'\n", command)
-	}
-}
-
-// Prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
-	ShowCommandHelp(c, c.Command.Name)
-}
-
-// Prints the version number of the App
-func ShowVersion(c *Context) {
-	VersionPrinter(c)
-}
-
-func printVersion(c *Context) {
-	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
-}
-
-// Prints the lists of commands within a given context
-func ShowCompletions(c *Context) {
-	a := c.App
-	if a != nil && a.BashComplete != nil {
-		a.BashComplete(c)
-	}
-}
-
-// Prints the custom completions for a given command
-func ShowCommandCompletions(ctx *Context, command string) {
-	c := ctx.App.Command(command)
-	if c != nil && c.BashComplete != nil {
-		c.BashComplete(ctx)
-	}
-}
-
-func checkVersion(c *Context) bool {
-	if c.GlobalBool("version") {
-		ShowVersion(c)
-		return true
-	}
-
-	return false
-}
-
-func checkHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
-		ShowAppHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCommandHelp(c *Context, name string) bool {
-	if c.Bool("h") || c.Bool("help") {
-		ShowCommandHelp(c, name)
-		return true
-	}
-
-	return false
-}
-
-func checkSubcommandHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
-		ShowSubcommandHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCompletions(c *Context) bool {
-	if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
-		ShowCompletions(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCommandCompletions(c *Context, name string) bool {
-	if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
-		ShowCommandCompletions(c, name)
-		return true
-	}
-
-	return false
-}

vendor/github.com/dustin/go-humanize/.gitignore

@@ -1,6 +0,0 @@
-#*
-*.[568]
-*.a
-*~
-[568].out
-_*

vendor/github.com/dustin/go-humanize/LICENSE

@@ -1,21 +0,0 @@
-Copyright (c) 2005-2008  Dustin Sallings <dustin@spy.net>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-<http://www.opensource.org/licenses/mit-license.php>

vendor/github.com/dustin/go-humanize/README.markdown

@@ -1,92 +0,0 @@
-# Humane Units
-
-Just a few functions for helping humanize times and sizes.
-
-`go get` it as `github.com/dustin/go-humanize`, import it as
-`"github.com/dustin/go-humanize"`, use it as `humanize`
-
-See [godoc](https://godoc.org/github.com/dustin/go-humanize) for
-complete documentation.
-
-## Sizes
-
-This lets you take numbers like `82854982` and convert them to useful
-strings like, `83MB` or `79MiB` (whichever you prefer).
-
-Example:
-
-```go
-fmt.Printf("That file is %s.", humanize.Bytes(82854982))
-```
-
-## Times
-
-This lets you take a `time.Time` and spit it out in relative terms.
-For example, `12 seconds ago` or `3 days from now`.
-
-Example:
-
-```go
-fmt.Printf("This was touched %s", humanize.Time(someTimeInstance))
-```
-
-Thanks to Kyle Lemons for the time implementation from an IRC
-conversation one day.  It's pretty neat.
-
-## Ordinals
-
-From a [mailing list discussion][odisc] where a user wanted to be able
-to label ordinals.
-
-    0 -> 0th
-    1 -> 1st
-    2 -> 2nd
-    3 -> 3rd
-    4 -> 4th
-    [...]
-
-Example:
-
-```go
-fmt.Printf("You're my %s best friend.", humanize.Ordinal(193))
-```
-
-## Commas
-
-Want to shove commas into numbers?  Be my guest.
-
-    0 -> 0
-    100 -> 100
-    1000 -> 1,000
-    1000000000 -> 1,000,000,000
-    -100000 -> -100,000
-
-Example:
-
-```go
-fmt.Printf("You owe $%s.\n", humanize.Comma(6582491))
-```
-
-## Ftoa
-
-Nicer float64 formatter that removes trailing zeros.
-
-```go
-fmt.Printf("%f", 2.24)                   // 2.240000
-fmt.Printf("%s", humanize.Ftoa(2.24))    // 2.24
-fmt.Printf("%f", 2.0)                    // 2.000000
-fmt.Printf("%s", humanize.Ftoa(2.0))     // 2
-```
-
-## SI notation
-
-Format numbers with [SI notation][sinotation].
-
-Example:
-
-```go
-humanize.SI(0.00000000223, "M")    // 2.23nM
-```
-
-[odisc]: https://groups.google.com/d/topic/golang-nuts/l8NhI74jl-4/discussion
-[sinotation]: http://en.wikipedia.org/wiki/Metric_prefix

vendor/github.com/dustin/go-humanize/big.go

@@ -1,31 +0,0 @@
-package humanize
-
-import (
-	"math/big"
-)
-
-// order of magnitude (to a max order)
-func oomm(n, b *big.Int, maxmag int) (float64, int) {
-	mag := 0
-	m := &big.Int{}
-	for n.Cmp(b) >= 0 {
-		n.DivMod(n, b, m)
-		mag++
-		if mag == maxmag && maxmag >= 0 {
-			break
-		}
-	}
-	return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
-}
-
-// total order of magnitude
-// (same as above, but with no upper limit)
-func oom(n, b *big.Int) (float64, int) {
-	mag := 0
-	m := &big.Int{}
-	for n.Cmp(b) >= 0 {
-		n.DivMod(n, b, m)
-		mag++
-	}
-	return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
-}

vendor/github.com/dustin/go-humanize/bigbytes.go

@@ -1,164 +0,0 @@
-package humanize
-
-import (
-	"fmt"
-	"math/big"
-	"strings"
-	"unicode"
-)
-
-var (
-	bigIECExp = big.NewInt(1024)
-
-	// BigByte is one byte in bit.Ints
-	BigByte = big.NewInt(1)
-	// BigKiByte is 1,024 bytes in bit.Ints
-	BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)
-	// BigMiByte is 1,024 k bytes in bit.Ints
-	BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)
-	// BigGiByte is 1,024 m bytes in bit.Ints
-	BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)
-	// BigTiByte is 1,024 g bytes in bit.Ints
-	BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)
-	// BigPiByte is 1,024 t bytes in bit.Ints
-	BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)
-	// BigEiByte is 1,024 p bytes in bit.Ints
-	BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)
-	// BigZiByte is 1,024 e bytes in bit.Ints
-	BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)
-	// BigYiByte is 1,024 z bytes in bit.Ints
-	BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)
-)
-
-var (
-	bigSIExp = big.NewInt(1000)
-
-	// BigSIByte is one SI byte in big.Ints
-	BigSIByte = big.NewInt(1)
-	// BigKByte is 1,000 SI bytes in big.Ints
-	BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)
-	// BigMByte is 1,000 SI k bytes in big.Ints
-	BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)
-	// BigGByte is 1,000 SI m bytes in big.Ints
-	BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)
-	// BigTByte is 1,000 SI g bytes in big.Ints
-	BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)
-	// BigPByte is 1,000 SI t bytes in big.Ints
-	BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)
-	// BigEByte is 1,000 SI p bytes in big.Ints
-	BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)
-	// BigZByte is 1,000 SI e bytes in big.Ints
-	BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)
-	// BigYByte is 1,000 SI z bytes in big.Ints
-	BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)
-)
-
-var bigBytesSizeTable = map[string]*big.Int{
-	"b":   BigByte,
-	"kib": BigKiByte,
-	"kb":  BigKByte,
-	"mib": BigMiByte,
-	"mb":  BigMByte,
-	"gib": BigGiByte,
-	"gb":  BigGByte,
-	"tib": BigTiByte,
-	"tb":  BigTByte,
-	"pib": BigPiByte,
-	"pb":  BigPByte,
-	"eib": BigEiByte,
-	"eb":  BigEByte,
-	"zib": BigZiByte,
-	"zb":  BigZByte,
-	"yib": BigYiByte,
-	"yb":  BigYByte,
-	// Without suffix
-	"":   BigByte,
-	"ki": BigKiByte,
-	"k":  BigKByte,
-	"mi": BigMiByte,
-	"m":  BigMByte,
-	"gi": BigGiByte,
-	"g":  BigGByte,
-	"ti": BigTiByte,
-	"t":  BigTByte,
-	"pi": BigPiByte,
-	"p":  BigPByte,
-	"ei": BigEiByte,
-	"e":  BigEByte,
-	"z":  BigZByte,
-	"zi": BigZiByte,
-	"y":  BigYByte,
-	"yi": BigYiByte,
-}
-
-var ten = big.NewInt(10)
-
-func humanateBigBytes(s, base *big.Int, sizes []string) string {
-	if s.Cmp(ten) < 0 {
-		return fmt.Sprintf("%d B", s)
-	}
-	c := (&big.Int{}).Set(s)
-	val, mag := oomm(c, base, len(sizes)-1)
-	suffix := sizes[mag]
-	f := "%.0f %s"
-	if val < 10 {
-		f = "%.1f %s"
-	}
-
-	return fmt.Sprintf(f, val, suffix)
-
-}
-
-// BigBytes produces a human readable representation of an SI size.
-//
-// See also: ParseBigBytes.
-//
-// BigBytes(82854982) -> 83MB
-func BigBytes(s *big.Int) string {
-	sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}
-	return humanateBigBytes(s, bigSIExp, sizes)
-}
-
-// BigIBytes produces a human readable representation of an IEC size.
-//
-// See also: ParseBigBytes.
-//
-// BigIBytes(82854982) -> 79MiB
-func BigIBytes(s *big.Int) string {
-	sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}
-	return humanateBigBytes(s, bigIECExp, sizes)
-}
-
-// ParseBigBytes parses a string representation of bytes into the number
-// of bytes it represents.
-//
-// See also: BigBytes, BigIBytes.
-//
-// ParseBigBytes("42MB") -> 42000000, nil
-// ParseBigBytes("42mib") -> 44040192, nil
-func ParseBigBytes(s string) (*big.Int, error) {
-	lastDigit := 0
-	for _, r := range s {
-		if !(unicode.IsDigit(r) || r == '.') {
-			break
-		}
-		lastDigit++
-	}
-
-	val := &big.Rat{}
-	_, err := fmt.Sscanf(s[:lastDigit], "%f", val)
-	if err != nil {
-		return nil, err
-	}
-
-	extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
-	if m, ok := bigBytesSizeTable[extra]; ok {
-		mv := (&big.Rat{}).SetInt(m)
-		val.Mul(val, mv)
-		rv := &big.Int{}
-		rv.Div(val.Num(), val.Denom())
-		return rv, nil
-	}
-
-	return nil, fmt.Errorf("unhandled size name: %v", extra)
-}

vendor/github.com/dustin/go-humanize/bytes.go

@@ -1,134 +0,0 @@
-package humanize
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-// IEC Sizes.
-// kibis of bits
-const (
-	Byte = 1 << (iota * 10)
-	KiByte
-	MiByte
-	GiByte
-	TiByte
-	PiByte
-	EiByte
-)
-
-// SI Sizes.
-const (
-	IByte = 1
-	KByte = IByte * 1000
-	MByte = KByte * 1000
-	GByte = MByte * 1000
-	TByte = GByte * 1000
-	PByte = TByte * 1000
-	EByte = PByte * 1000
-)
-
-var bytesSizeTable = map[string]uint64{
-	"b":   Byte,
-	"kib": KiByte,
-	"kb":  KByte,
-	"mib": MiByte,
-	"mb":  MByte,
-	"gib": GiByte,
-	"gb":  GByte,
-	"tib": TiByte,
-	"tb":  TByte,
-	"pib": PiByte,
-	"pb":  PByte,
-	"eib": EiByte,
-	"eb":  EByte,
-	// Without suffix
-	"":   Byte,
-	"ki": KiByte,
-	"k":  KByte,
-	"mi": MiByte,
-	"m":  MByte,
-	"gi": GiByte,
-	"g":  GByte,
-	"ti": TiByte,
-	"t":  TByte,
-	"pi": PiByte,
-	"p":  PByte,
-	"ei": EiByte,
-	"e":  EByte,
-}
-
-func logn(n, b float64) float64 {
-	return math.Log(n) / math.Log(b)
-}
-
-func humanateBytes(s uint64, base float64, sizes []string) string {
-	if s < 10 {
-		return fmt.Sprintf("%d B", s)
-	}
-	e := math.Floor(logn(float64(s), base))
-	suffix := sizes[int(e)]
-	val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
-	f := "%.0f %s"
-	if val < 10 {
-		f = "%.1f %s"
-	}
-
-	return fmt.Sprintf(f, val, suffix)
-}
-
-// Bytes produces a human readable representation of an SI size.
-//
-// See also: ParseBytes.
-//
-// Bytes(82854982) -> 83MB
-func Bytes(s uint64) string {
-	sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"}
-	return humanateBytes(s, 1000, sizes)
-}
-
-// IBytes produces a human readable representation of an IEC size.
-//
-// See also: ParseBytes.
-//
-// IBytes(82854982) -> 79MiB
-func IBytes(s uint64) string {
-	sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}
-	return humanateBytes(s, 1024, sizes)
-}
-
-// ParseBytes parses a string representation of bytes into the number
-// of bytes it represents.
-//
-// See Also: Bytes, IBytes.
-//
-// ParseBytes("42MB") -> 42000000, nil
-// ParseBytes("42mib") -> 44040192, nil
-func ParseBytes(s string) (uint64, error) {
-	lastDigit := 0
-	for _, r := range s {
-		if !(unicode.IsDigit(r) || r == '.') {
-			break
-		}
-		lastDigit++
-	}
-
-	f, err := strconv.ParseFloat(s[:lastDigit], 64)
-	if err != nil {
-		return 0, err
-	}
-
-	extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
-	if m, ok := bytesSizeTable[extra]; ok {
-		f *= float64(m)
-		if f >= math.MaxUint64 {
-			return 0, fmt.Errorf("too large: %v", s)
-		}
-		return uint64(f), nil
-	}
-
-	return 0, fmt.Errorf("unhandled size name: %v", extra)
-}

vendor/github.com/dustin/go-humanize/comma.go

@@ -1,101 +0,0 @@
-package humanize
-
-import (
-	"bytes"
-	"math/big"
-	"strconv"
-	"strings"
-)
-
-// Comma produces a string form of the given number in base 10 with
-// commas after every three orders of magnitude.
-//
-// e.g. Comma(834142) -> 834,142
-func Comma(v int64) string {
-	sign := ""
-	if v < 0 {
-		sign = "-"
-		v = 0 - v
-	}
-
-	parts := []string{"", "", "", "", "", "", ""}
-	j := len(parts) - 1
-
-	for v > 999 {
-		parts[j] = strconv.FormatInt(v%1000, 10)
-		switch len(parts[j]) {
-		case 2:
-			parts[j] = "0" + parts[j]
-		case 1:
-			parts[j] = "00" + parts[j]
-		}
-		v = v / 1000
-		j--
-	}
-	parts[j] = strconv.Itoa(int(v))
-	return sign + strings.Join(parts[j:], ",")
-}
-
-// Commaf produces a string form of the given number in base 10 with
-// commas after every three orders of magnitude.
-//
-// e.g. Comma(834142.32) -> 834,142.32
-func Commaf(v float64) string {
-	buf := &bytes.Buffer{}
-	if v < 0 {
-		buf.Write([]byte{'-'})
-		v = 0 - v
-	}
-
-	comma := []byte{','}
-
-	parts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), ".")
-	pos := 0
-	if len(parts[0])%3 != 0 {
-		pos += len(parts[0]) % 3
-		buf.WriteString(parts[0][:pos])
-		buf.Write(comma)
-	}
-	for ; pos < len(parts[0]); pos += 3 {
-		buf.WriteString(parts[0][pos : pos+3])
-		buf.Write(comma)
-	}
-	buf.Truncate(buf.Len() - 1)
-
-	if len(parts) > 1 {
-		buf.Write([]byte{'.'})
-		buf.WriteString(parts[1])
-	}
-	return buf.String()
-}
-
-// BigComma produces a string form of the given big.Int in base 10
-// with commas after every three orders of magnitude.
-func BigComma(b *big.Int) string {
-	sign := ""
-	if b.Sign() < 0 {
-		sign = "-"
-		b.Abs(b)
-	}
-
-	athousand := big.NewInt(1000)
-	c := (&big.Int{}).Set(b)
-	_, m := oom(c, athousand)
-	parts := make([]string, m+1)
-	j := len(parts) - 1
-
-	mod := &big.Int{}
-	for b.Cmp(athousand) >= 0 {
-		b.DivMod(b, athousand, mod)
-		parts[j] = strconv.FormatInt(mod.Int64(), 10)
-		switch len(parts[j]) {
-		case 2:
-			parts[j] = "0" + parts[j]
-		case 1:
-			parts[j] = "00" + parts[j]
-		}
-		j--
-	}
-	parts[j] = strconv.Itoa(int(b.Int64()))
-	return sign + strings.Join(parts[j:], ",")
-}

vendor/github.com/dustin/go-humanize/ftoa.go

@@ -1,23 +0,0 @@
-package humanize
-
-import "strconv"
-
-func stripTrailingZeros(s string) string {
-	offset := len(s) - 1
-	for offset > 0 {
-		if s[offset] == '.' {
-			offset--
-			break
-		}
-		if s[offset] != '0' {
-			break
-		}
-		offset--
-	}
-	return s[:offset+1]
-}
-
-// Ftoa converts a float to a string with no trailing zeros.
-func Ftoa(num float64) string {
-	return stripTrailingZeros(strconv.FormatFloat(num, 'f', 6, 64))
-}

vendor/github.com/dustin/go-humanize/humanize.go

@@ -1,8 +0,0 @@
-/*
-Package humanize converts boring ugly numbers to human-friendly strings and back.
-
-Durations can be turned into strings such as "3 days ago", numbers
-representing sizes like 82854982 into useful strings like, "83MB" or
-"79MiB" (whichever you prefer).
-*/
-package humanize

vendor/github.com/dustin/go-humanize/number.go

@@ -1,192 +0,0 @@
-package humanize
-
-/*
-Slightly adapted from the source to fit go-humanize.
-
-Author: https://github.com/gorhill
-Source: https://gist.github.com/gorhill/5285193
-
-*/
-
-import (
-	"math"
-	"strconv"
-)
-
-var (
-	renderFloatPrecisionMultipliers = [...]float64{
-		1,
-		10,
-		100,
-		1000,
-		10000,
-		100000,
-		1000000,
-		10000000,
-		100000000,
-		1000000000,
-	}
-
-	renderFloatPrecisionRounders = [...]float64{
-		0.5,
-		0.05,
-		0.005,
-		0.0005,
-		0.00005,
-		0.000005,
-		0.0000005,
-		0.00000005,
-		0.000000005,
-		0.0000000005,
-	}
-)
-
-// FormatFloat produces a formatted number as string based on the following user-specified criteria:
-// * thousands separator
-// * decimal separator
-// * decimal precision
-//
-// Usage: s := RenderFloat(format, n)
-// The format parameter tells how to render the number n.
-//
-// See examples: http://play.golang.org/p/LXc1Ddm1lJ
-//
-// Examples of format strings, given n = 12345.6789:
-// "#,###.##" => "12,345.67"
-// "#,###." => "12,345"
-// "#,###" => "12345,678"
-// "#\u202F###,##" => "12 345,68"
-// "#.###,###### => 12.345,678900
-// "" (aka default format) => 12,345.67
-//
-// The highest precision allowed is 9 digits after the decimal symbol.
-// There is also a version for integer number, FormatInteger(),
-// which is convenient for calls within template.
-func FormatFloat(format string, n float64) string {
-	// Special cases:
-	//   NaN = "NaN"
-	//   +Inf = "+Infinity"
-	//   -Inf = "-Infinity"
-	if math.IsNaN(n) {
-		return "NaN"
-	}
-	if n > math.MaxFloat64 {
-		return "Infinity"
-	}
-	if n < -math.MaxFloat64 {
-		return "-Infinity"
-	}
-
-	// default format
-	precision := 2
-	decimalStr := "."
-	thousandStr := ","
-	positiveStr := ""
-	negativeStr := "-"
-
-	if len(format) > 0 {
-		format := []rune(format)
-
-		// If there is an explicit format directive,
-		// then default values are these:
-		precision = 9
-		thousandStr = ""
-
-		// collect indices of meaningful formatting directives
-		formatIndx := []int{}
-		for i, char := range format {
-			if char != '#' && char != '0' {
-				formatIndx = append(formatIndx, i)
-			}
-		}
-
-		if len(formatIndx) > 0 {
-			// Directive at index 0:
-			//   Must be a '+'
-			//   Raise an error if not the case
-			// index: 0123456789
-			//        +0.000,000
-			//        +000,000.0
-			//        +0000.00
-			//        +0000
-			if formatIndx[0] == 0 {
-				if format[formatIndx[0]] != '+' {
-					panic("RenderFloat(): invalid positive sign directive")
-				}
-				positiveStr = "+"
-				formatIndx = formatIndx[1:]
-			}
-
-			// Two directives:
-			//   First is thousands separator
-			//   Raise an error if not followed by 3-digit
-			// 0123456789
-			// 0.000,000
-			// 000,000.00
-			if len(formatIndx) == 2 {
-				if (formatIndx[1] - formatIndx[0]) != 4 {
-					panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
-				}
-				thousandStr = string(format[formatIndx[0]])
-				formatIndx = formatIndx[1:]
-			}
-
-			// One directive:
-			//   Directive is decimal separator
-			//   The number of digit-specifier following the separator indicates wanted precision
-			// 0123456789
-			// 0.00
-			// 000,0000
-			if len(formatIndx) == 1 {
-				decimalStr = string(format[formatIndx[0]])
-				precision = len(format) - formatIndx[0] - 1
-			}
-		}
-	}
-
-	// generate sign part
-	var signStr string
-	if n >= 0.000000001 {
-		signStr = positiveStr
-	} else if n <= -0.000000001 {
-		signStr = negativeStr
-		n = -n
-	} else {
-		signStr = ""
-		n = 0.0
-	}
-
-	// split number into integer and fractional parts
-	intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
-
-	// generate integer part string
-	intStr := strconv.Itoa(int(intf))
-
-	// add thousand separator if required
-	if len(thousandStr) > 0 {
-		for i := len(intStr); i > 3; {
-			i -= 3
-			intStr = intStr[:i] + thousandStr + intStr[i:]
-		}
-	}
-
-	// no fractional part, we can leave now
-	if precision == 0 {
-		return signStr + intStr
-	}
-
-	// generate fractional part
-	fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
-	// may need padding
-	if len(fracStr) < precision {
-		fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
-	}
-
-	return signStr + intStr + decimalStr + fracStr
-}
-
-// FormatInteger produces a formatted number as string.
-// See FormatFloat.
-func FormatInteger(format string, n int) string {
-	return FormatFloat(format, float64(n))
-}

vendor/github.com/dustin/go-humanize/ordinals.go

@@ -1,25 +0,0 @@
-package humanize
-
-import "strconv"
-
-// Ordinal gives you the input number in a rank/ordinal format.
-//
-// Ordinal(3) -> 3rd
-func Ordinal(x int) string {
-	suffix := "th"
-	switch x % 10 {
-	case 1:
-		if x%100 != 11 {
-			suffix = "st"
-		}
-	case 2:
-		if x%100 != 12 {
-			suffix = "nd"
-		}
-	case 3:
-		if x%100 != 13 {
-			suffix = "rd"
-		}
-	}
-	return strconv.Itoa(x) + suffix
-}

vendor/github.com/dustin/go-humanize/si.go

@@ -1,110 +0,0 @@
-package humanize
-
-import (
-	"errors"
-	"math"
-	"regexp"
-	"strconv"
-)
-
-var siPrefixTable = map[float64]string{
-	-24: "y", // yocto
-	-21: "z", // zepto
-	-18: "a", // atto
-	-15: "f", // femto
-	-12: "p", // pico
-	-9:  "n", // nano
-	-6:  "µ", // micro
-	-3:  "m", // milli
-	0:   "",
-	3:   "k", // kilo
-	6:   "M", // mega
-	9:   "G", // giga
-	12:  "T", // tera
-	15:  "P", // peta
-	18:  "E", // exa
-	21:  "Z", // zetta
-	24:  "Y", // yotta
-}
-
-var revSIPrefixTable = revfmap(siPrefixTable)
-
-// revfmap reverses the map and precomputes the power multiplier
-func revfmap(in map[float64]string) map[string]float64 {
-	rv := map[string]float64{}
-	for k, v := range in {
-		rv[v] = math.Pow(10, k)
-	}
-	return rv
-}
-
-var riParseRegex *regexp.Regexp
-
-func init() {
-	ri := `^([0-9.]+)\s?([`
-	for _, v := range siPrefixTable {
-		ri += v
-	}
-	ri += `]?)(.*)`
-
-	riParseRegex = regexp.MustCompile(ri)
-}
-
-// ComputeSI finds the most appropriate SI prefix for the given number
-// and returns the prefix along with the value adjusted to be within
-// that prefix.
-//
-// See also: SI, ParseSI.
-//
-// e.g. ComputeSI(2.2345e-12) -> (2.2345, "p")
-func ComputeSI(input float64) (float64, string) {
-	if input == 0 {
-		return 0, ""
-	}
-	exponent := math.Floor(logn(input, 10))
-	exponent = math.Floor(exponent/3) * 3
-
-	value := input / math.Pow(10, exponent)
-
-	// Handle special case where value is exactly 1000.0
-	// Should return 1M instead of 1000k
-	if value == 1000.0 {
-		exponent += 3
-		value = input / math.Pow(10, exponent)
-	}
-
-	prefix := siPrefixTable[exponent]
-	return value, prefix
-}
-
-// SI returns a string with default formatting.
-//
-// SI uses Ftoa to format float value, removing trailing zeros.
-//
-// See also: ComputeSI, ParseSI.
-//
-// e.g. SI(1000000, B) -> 1MB
-// e.g. SI(2.2345e-12, "F") -> 2.2345pF
-func SI(input float64, unit string) string {
-	value, prefix := ComputeSI(input)
-	return Ftoa(value) + " " + prefix + unit
-}
-
-var errInvalid = errors.New("invalid input")
-
-// ParseSI parses an SI string back into the number and unit.
-//
-// See also: SI, ComputeSI.
-//
-// e.g. ParseSI(2.2345pF) -> (2.2345e-12, "F", nil)
-func ParseSI(input string) (float64, string, error) {
-	found := riParseRegex.FindStringSubmatch(input)
-	if len(found) != 4 {
-		return 0, "", errInvalid
-	}
-	mag := revSIPrefixTable[found[2]]
-	unit := found[3]
-
-	base, err := strconv.ParseFloat(found[1], 64)
-	return base * mag, unit, err
-}

vendor/github.com/dustin/go-humanize/times.go

@@ -1,91 +0,0 @@
-package humanize
-
-import (
-	"fmt"
-	"math"
-	"sort"
-	"time"
-)
-
-// Seconds-based time units
-const (
-	Minute   = 60
-	Hour     = 60 * Minute
-	Day      = 24 * Hour
-	Week     = 7 * Day
-	Month    = 30 * Day
-	Year     = 12 * Month
-	LongTime = 37 * Year
-)
-
-// Time formats a time into a relative string.
-//
-// Time(someT) -> "3 weeks ago"
-func Time(then time.Time) string {
-	return RelTime(then, time.Now(), "ago", "from now")
-}
-
-var magnitudes = []struct {
-	d      int64
-	format string
-	divby  int64
-}{
-	{1, "now", 1},
-	{2, "1 second %s", 1},
-	{Minute, "%d seconds %s", 1},
-	{2 * Minute, "1 minute %s", 1},
-	{Hour, "%d minutes %s", Minute},
-	{2 * Hour, "1 hour %s", 1},
-	{Day, "%d hours %s", Hour},
-	{2 * Day, "1 day %s", 1},
-	{Week, "%d days %s", Day},
-	{2 * Week, "1 week %s", 1},
-	{Month, "%d weeks %s", Week},
-	{2 * Month, "1 month %s", 1},
-	{Year, "%d months %s", Month},
-	{18 * Month, "1 year %s", 1},
-	{2 * Year, "2 years %s", 1},
-	{LongTime, "%d years %s", Year},
-	{math.MaxInt64, "a long while %s", 1},
-}
-
-// RelTime formats a time into a relative string.
-//
-// It takes two times and two labels.  In addition to the generic time
-// delta string (e.g. 5 minutes), the labels are used applied so that
-// the label corresponding to the smaller time is applied.
-//
-// RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier"
-func RelTime(a, b time.Time, albl, blbl string) string {
-	lbl := albl
-	diff := b.Unix() - a.Unix()
-
-	after := a.After(b)
-	if after {
-		lbl = blbl
-		diff = a.Unix() - b.Unix()
-	}
-
-	n := sort.Search(len(magnitudes), func(i int) bool {
-		return magnitudes[i].d > diff
-	})
-
-	mag := magnitudes[n]
-	args := []interface{}{}
-	escaped := false
-	for _, ch := range mag.format {
-		if escaped {
-			switch ch {
-			case '%':
-			case 's':
-				args = append(args, lbl)
-			case 'd':
-				args = append(args, diff/mag.divby)
-			}
-			escaped = false
-		} else {
-			escaped = ch == '%'
-		}
-	}
-	return fmt.Sprintf(mag.format, args...)
-}

vendor/github.com/golang/freetype/AUTHORS

@@ -1,20 +0,0 @@
-# This is the official list of Freetype-Go authors for copyright purposes.
-# This file is distinct from the CONTRIBUTORS files.
-# See the latter for an explanation.
-#
-# Freetype-Go is derived from Freetype, which is written in C. The latter
-# is copyright 1996-2010 David Turner, Robert Wilhelm, and Werner Lemberg.
-
-# Names should be added to this file as
-#	Name or Organization <email address>
-# The email address is not required for organizations.
-
-# Please keep the list sorted.
-
-Google Inc.
-Jeff R. Allen <jra@nella.org>
-Maksim Kochkin <maxxarts@gmail.com>
-Michael Fogleman <fogleman@gmail.com>
-Rémy Oudompheng <oudomphe@phare.normalesup.org>
-Roger Peppe <rogpeppe@gmail.com>
-Steven Edwards <steven@stephenwithav.com>

vendor/github.com/golang/freetype/CONTRIBUTORS

@@ -1,38 +0,0 @@
-# This is the official list of people who can contribute
-# (and typically have contributed) code to the Freetype-Go repository.
-# The AUTHORS file lists the copyright holders; this file
-# lists people.  For example, Google employees are listed here
-# but not in AUTHORS, because Google holds the copyright.
-#
-# The submission process automatically checks to make sure
-# that people submitting code are listed in this file (by email address).
-#
-# Names should be added to this file only after verifying that
-# the individual or the individual's organization has agreed to
-# the appropriate Contributor License Agreement, found here:
-#
-#     http://code.google.com/legal/individual-cla-v1.0.html
-#     http://code.google.com/legal/corporate-cla-v1.0.html
-#
-# The agreement for individuals can be filled out on the web.
-#
-# When adding J Random Contributor's name to this file,
-# either J's name or J's organization's name should be
-# added to the AUTHORS file, depending on whether the
-# individual or corporate CLA was used.
-
-# Names should be added to this file like so:
-#     Name <email address>
-
-# Please keep the list sorted.
-
-Andrew Gerrand <adg@golang.org>
-Jeff R. Allen <jra@nella.org> <jeff.allen@gmail.com>
-Maksim Kochkin <maxxarts@gmail.com>
-Michael Fogleman <fogleman@gmail.com>
-Nigel Tao <nigeltao@golang.org>
-Rémy Oudompheng <oudomphe@phare.normalesup.org> <remyoudompheng@gmail.com>
-Rob Pike <r@golang.org>
-Roger Peppe <rogpeppe@gmail.com>
-Russ Cox <rsc@golang.org>
-Steven Edwards <steven@stephenwithav.com>

vendor/github.com/golang/freetype/LICENSE

@@ -1,12 +0,0 @@
-Use of the Freetype-Go software is subject to your choice of exactly one of
-the following two licenses:
-  * The FreeType License, which is similar to the original BSD license with
-    an advertising clause, or
-  * The GNU General Public License (GPL), version 2 or later.
-
-The text of these licenses are available in the licenses/ftl.txt and the
-licenses/gpl.txt files respectively. They are also available at
-http://freetype.sourceforge.net/license.html
-
-The Luxi fonts in the testdata directory are licensed separately. See the
-testdata/COPYING file for details.

vendor/github.com/golang/freetype/README

@@ -1,21 +0,0 @@
-The Freetype font rasterizer in the Go programming language.
-
-To download and install from source:
-$ go get github.com/golang/freetype
-
-It is an incomplete port:
-  * It only supports TrueType fonts, and not Type 1 fonts nor bitmap fonts.
-  * It only supports the Unicode encoding.
-
-There are also some implementation differences:
-  * It uses a 26.6 fixed point co-ordinate system everywhere internally,
-    as opposed to the original Freetype's mix of 26.6 (or 10.6 for 16-bit
-    systems) in some places, and 24.8 in the "smooth" rasterizer.
-
-Freetype-Go is derived from Freetype, which is written in C. Freetype is
-copyright 1996-2010 David Turner, Robert Wilhelm, and Werner Lemberg.
-Freetype-Go is copyright The Freetype-Go Authors, who are listed in the
-AUTHORS file.
-
-Unless otherwise noted, the Freetype-Go source files are distributed
-under the BSD-style license found in the LICENSE file.

vendor/github.com/golang/freetype/freetype.go

@@ -1,341 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-// The freetype package provides a convenient API to draw text onto an image.
-// Use the freetype/raster and freetype/truetype packages for lower level
-// control over rasterization and TrueType parsing.
-package freetype
-
-import (
-	"errors"
-	"image"
-	"image/draw"
-
-	"github.com/golang/freetype/raster"
-	"github.com/golang/freetype/truetype"
-	"golang.org/x/image/font"
-	"golang.org/x/image/math/fixed"
-)
-
-// These constants determine the size of the glyph cache. The cache is keyed
-// primarily by the glyph index modulo nGlyphs, and secondarily by sub-pixel
-// position for the mask image. Sub-pixel positions are quantized to
-// nXFractions possible values in both the x and y directions.
-const (
-	nGlyphs     = 256
-	nXFractions = 4
-	nYFractions = 1
-)
-
-// An entry in the glyph cache is keyed explicitly by the glyph index and
-// implicitly by the quantized x and y fractional offset. It maps to a mask
-// image and an offset.
-type cacheEntry struct {
-	valid        bool
-	glyph        truetype.Index
-	advanceWidth fixed.Int26_6
-	mask         *image.Alpha
-	offset       image.Point
-}
-
-// ParseFont just calls the Parse function from the freetype/truetype package.
-// It is provided here so that code that imports this package doesn't need
-// to also include the freetype/truetype package.
-func ParseFont(b []byte) (*truetype.Font, error) {
-	return truetype.Parse(b)
-}
-
-// Pt converts from a co-ordinate pair measured in pixels to a fixed.Point26_6
-// co-ordinate pair measured in fixed.Int26_6 units.
-func Pt(x, y int) fixed.Point26_6 {
-	return fixed.Point26_6{
-		X: fixed.Int26_6(x << 6),
-		Y: fixed.Int26_6(y << 6),
-	}
-}
-
-// A Context holds the state for drawing text in a given font and size.
-type Context struct {
-	r        *raster.Rasterizer
-	f        *truetype.Font
-	glyphBuf truetype.GlyphBuf
-	// clip is the clip rectangle for drawing.
-	clip image.Rectangle
-	// dst and src are the destination and source images for drawing.
-	dst draw.Image
-	src image.Image
-	// fontSize and dpi are used to calculate scale. scale is the number of
-	// 26.6 fixed point units in 1 em. hinting is the hinting policy.
-	fontSize, dpi float64
-	scale         fixed.Int26_6
-	hinting       font.Hinting
-	// cache is the glyph cache.
-	cache [nGlyphs * nXFractions * nYFractions]cacheEntry
-}
-
-// PointToFixed converts the given number of points (as in "a 12 point font")
-// into a 26.6 fixed point number of pixels.
-func (c *Context) PointToFixed(x float64) fixed.Int26_6 {
-	return fixed.Int26_6(x * float64(c.dpi) * (64.0 / 72.0))
-}
-
-// drawContour draws the given closed contour with the given offset.
-func (c *Context) drawContour(ps []truetype.Point, dx, dy fixed.Int26_6) {
-	if len(ps) == 0 {
-		return
-	}
-
-	// The low bit of each point's Flags value is whether the point is on the
-	// curve. Truetype fonts only have quadratic Bézier curves, not cubics.
-	// Thus, two consecutive off-curve points imply an on-curve point in the
-	// middle of those two.
-	//
-	// See http://chanae.walon.org/pub/ttf/ttf_glyphs.htm for more details.
-
-	// ps[0] is a truetype.Point measured in FUnits and positive Y going
-	// upwards. start is the same thing measured in fixed point units and
-	// positive Y going downwards, and offset by (dx, dy).
-	start := fixed.Point26_6{
-		X: dx + ps[0].X,
-		Y: dy - ps[0].Y,
-	}
-	others := []truetype.Point(nil)
-	if ps[0].Flags&0x01 != 0 {
-		others = ps[1:]
-	} else {
-		last := fixed.Point26_6{
-			X: dx + ps[len(ps)-1].X,
-			Y: dy - ps[len(ps)-1].Y,
-		}
-		if ps[len(ps)-1].Flags&0x01 != 0 {
-			start = last
-			others = ps[:len(ps)-1]
-		} else {
-			start = fixed.Point26_6{
-				X: (start.X + last.X) / 2,
-				Y: (start.Y + last.Y) / 2,
-			}
-			others = ps
-		}
-	}
-	c.r.Start(start)
-	q0, on0 := start, true
-	for _, p := range others {
-		q := fixed.Point26_6{
-			X: dx + p.X,
-			Y: dy - p.Y,
-		}
-		on := p.Flags&0x01 != 0
-		if on {
-			if on0 {
-				c.r.Add1(q)
-			} else {
-				c.r.Add2(q0, q)
-			}
-		} else {
-			if on0 {
-				// No-op.
-			} else {
-				mid := fixed.Point26_6{
-					X: (q0.X + q.X) / 2,
-					Y: (q0.Y + q.Y) / 2,
-				}
-				c.r.Add2(q0, mid)
-			}
-		}
-		q0, on0 = q, on
-	}
-	// Close the curve.
-	if on0 {
-		c.r.Add1(start)
-	} else {
-		c.r.Add2(q0, start)
-	}
-}
-
-// rasterize returns the advance width, glyph mask and integer-pixel offset
-// to render the given glyph at the given sub-pixel offsets.
-// The 26.6 fixed point arguments fx and fy must be in the range [0, 1).
-func (c *Context) rasterize(glyph truetype.Index, fx, fy fixed.Int26_6) (
-	fixed.Int26_6, *image.Alpha, image.Point, error) {
-
-	if err := c.glyphBuf.Load(c.f, c.scale, glyph, c.hinting); err != nil {
-		return 0, nil, image.Point{}, err
-	}
-	// Calculate the integer-pixel bounds for the glyph.
-	xmin := int(fx+c.glyphBuf.Bounds.Min.X) >> 6
-	ymin := int(fy-c.glyphBuf.Bounds.Max.Y) >> 6
-	xmax := int(fx+c.glyphBuf.Bounds.Max.X+0x3f) >> 6
-	ymax := int(fy-c.glyphBuf.Bounds.Min.Y+0x3f) >> 6
-	if xmin > xmax || ymin > ymax {
-		return 0, nil, image.Point{}, errors.New("freetype: negative sized glyph")
-	}
-	// A TrueType's glyph's nodes can have negative co-ordinates, but the
-	// rasterizer clips anything left of x=0 or above y=0. xmin and ymin are
-	// the pixel offsets, based on the font's FUnit metrics, that let a
-	// negative co-ordinate in TrueType space be non-negative in rasterizer
-	// space. xmin and ymin are typically <= 0.
-	fx -= fixed.Int26_6(xmin << 6)
-	fy -= fixed.Int26_6(ymin << 6)
-	// Rasterize the glyph's vectors.
-	c.r.Clear()
-	e0 := 0
-	for _, e1 := range c.glyphBuf.Ends {
-		c.drawContour(c.glyphBuf.Points[e0:e1], fx, fy)
-		e0 = e1
-	}
-	a := image.NewAlpha(image.Rect(0, 0, xmax-xmin, ymax-ymin))
-	c.r.Rasterize(raster.NewAlphaSrcPainter(a))
-	return c.glyphBuf.AdvanceWidth, a, image.Point{xmin, ymin}, nil
-}
-
-// glyph returns the advance width, glyph mask and integer-pixel offset to
-// render the given glyph at the given sub-pixel point. It is a cache for the
-// rasterize method. Unlike rasterize, p's co-ordinates do not have to be in
-// the range [0, 1).
-func (c *Context) glyph(glyph truetype.Index, p fixed.Point26_6) (
-	fixed.Int26_6, *image.Alpha, image.Point, error) {
-
-	// Split p.X and p.Y into their integer and fractional parts.
-	ix, fx := int(p.X>>6), p.X&0x3f
-	iy, fy := int(p.Y>>6), p.Y&0x3f
-	// Calculate the index t into the cache array.
-	tg := int(glyph) % nGlyphs
-	tx := int(fx) / (64 / nXFractions)
-	ty := int(fy) / (64 / nYFractions)
-	t := ((tg*nXFractions)+tx)*nYFractions + ty
-	// Check for a cache hit.
-	if e := c.cache[t]; e.valid && e.glyph == glyph {
-		return e.advanceWidth, e.mask, e.offset.Add(image.Point{ix, iy}), nil
-	}
-	// Rasterize the glyph and put the result into the cache.
-	advanceWidth, mask, offset, err := c.rasterize(glyph, fx, fy)
-	if err != nil {
-		return 0, nil, image.Point{}, err
-	}
-	c.cache[t] = cacheEntry{true, glyph, advanceWidth, mask, offset}
-	return advanceWidth, mask, offset.Add(image.Point{ix, iy}), nil
-}
-
-// DrawString draws s at p and returns p advanced by the text extent. The text
-// is placed so that the left edge of the em square of the first character of s
-// and the baseline intersect at p. The majority of the affected pixels will be
-// above and to the right of the point, but some may be below or to the left.
-// For example, drawing a string that starts with a 'J' in an italic font may
-// affect pixels below and left of the point.
-//
-// p is a fixed.Point26_6 and can therefore represent sub-pixel positions.
-func (c *Context) DrawString(s string, p fixed.Point26_6) (fixed.Point26_6, error) {
-	if c.f == nil {
-		return fixed.Point26_6{}, errors.New("freetype: DrawText called with a nil font")
-	}
-	prev, hasPrev := truetype.Index(0), false
-	for _, rune := range s {
-		index := c.f.Index(rune)
-		if hasPrev {
-			kern := c.f.Kern(c.scale, prev, index)
-			if c.hinting != font.HintingNone {
-				kern = (kern + 32) &^ 63
-			}
-			p.X += kern
-		}
-		advanceWidth, mask, offset, err := c.glyph(index, p)
-		if err != nil {
-			return fixed.Point26_6{}, err
-		}
-		p.X += advanceWidth
-		glyphRect := mask.Bounds().Add(offset)
-		dr := c.clip.Intersect(glyphRect)
-		if !dr.Empty() {
-			mp := image.Point{0, dr.Min.Y - glyphRect.Min.Y}
-			draw.DrawMask(c.dst, dr, c.src, image.ZP, mask, mp, draw.Over)
-		}
-		prev, hasPrev = index, true
-	}
-	return p, nil
-}
-
-// recalc recalculates scale and bounds values from the font size, screen
-// resolution and font metrics, and invalidates the glyph cache.
-func (c *Context) recalc() {
-	c.scale = fixed.Int26_6(c.fontSize * c.dpi * (64.0 / 72.0))
-	if c.f == nil {
-		c.r.SetBounds(0, 0)
-	} else {
-		// Set the rasterizer's bounds to be big enough to handle the largest glyph.
-		b := c.f.Bounds(c.scale)
-		xmin := +int(b.Min.X) >> 6
-		ymin := -int(b.Max.Y) >> 6
-		xmax := +int(b.Max.X+63) >> 6
-		ymax := -int(b.Min.Y-63) >> 6
-		c.r.SetBounds(xmax-xmin, ymax-ymin)
-	}
-	for i := range c.cache {
-		c.cache[i] = cacheEntry{}
-	}
-}
-
-// SetDPI sets the screen resolution in dots per inch.
-func (c *Context) SetDPI(dpi float64) {
-	if c.dpi == dpi {
-		return
-	}
-	c.dpi = dpi
-	c.recalc()
-}
-
-// SetFont sets the font used to draw text.
-func (c *Context) SetFont(f *truetype.Font) {
-	if c.f == f {
-		return
-	}
-	c.f = f
-	c.recalc()
-}
-
-// SetFontSize sets the font size in points (as in "a 12 point font").
-func (c *Context) SetFontSize(fontSize float64) {
-	if c.fontSize == fontSize {
-		return
-	}
-	c.fontSize = fontSize
-	c.recalc()
-}
-
-// SetHinting sets the hinting policy.
-func (c *Context) SetHinting(hinting font.Hinting) {
-	c.hinting = hinting
-	for i := range c.cache {
-		c.cache[i] = cacheEntry{}
-	}
-}
-
-// SetDst sets the destination image for draw operations.
-func (c *Context) SetDst(dst draw.Image) {
-	c.dst = dst
-}
-
-// SetSrc sets the source image for draw operations. This is typically an
-// image.Uniform.
-func (c *Context) SetSrc(src image.Image) {
-	c.src = src
-}
-
-// SetClip sets the clip rectangle for drawing.
-func (c *Context) SetClip(clip image.Rectangle) {
-	c.clip = clip
-}
-
-// TODO(nigeltao): implement Context.SetGamma.
-
-// NewContext creates a new Context.
-func NewContext() *Context {
-	return &Context{
-		r:        raster.NewRasterizer(0, 0),
-		fontSize: 12,
-		dpi:      72,
-		scale:    12 << 6,
-	}
-}

vendor/github.com/golang/freetype/raster/geom.go

@@ -1,245 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package raster
-
-import (
-	"fmt"
-	"math"
-
-	"golang.org/x/image/math/fixed"
-)
-
-// maxAbs returns the maximum of abs(a) and abs(b).
-func maxAbs(a, b fixed.Int26_6) fixed.Int26_6 {
-	if a < 0 {
-		a = -a
-	}
-	if b < 0 {
-		b = -b
-	}
-	if a < b {
-		return b
-	}
-	return a
-}
-
-// pNeg returns the vector -p, or equivalently p rotated by 180 degrees.
-func pNeg(p fixed.Point26_6) fixed.Point26_6 {
-	return fixed.Point26_6{-p.X, -p.Y}
-}
-
-// pDot returns the dot product p·q.
-func pDot(p fixed.Point26_6, q fixed.Point26_6) fixed.Int52_12 {
-	px, py := int64(p.X), int64(p.Y)
-	qx, qy := int64(q.X), int64(q.Y)
-	return fixed.Int52_12(px*qx + py*qy)
-}
-
-// pLen returns the length of the vector p.
-func pLen(p fixed.Point26_6) fixed.Int26_6 {
-	// TODO(nigeltao): use fixed point math.
-	x := float64(p.X)
-	y := float64(p.Y)
-	return fixed.Int26_6(math.Sqrt(x*x + y*y))
-}
-
-// pNorm returns the vector p normalized to the given length, or zero if p is
-// degenerate.
-func pNorm(p fixed.Point26_6, length fixed.Int26_6) fixed.Point26_6 {
-	d := pLen(p)
-	if d == 0 {
-		return fixed.Point26_6{}
-	}
-	s, t := int64(length), int64(d)
-	x := int64(p.X) * s / t
-	y := int64(p.Y) * s / t
-	return fixed.Point26_6{fixed.Int26_6(x), fixed.Int26_6(y)}
-}
-
-// pRot45CW returns the vector p rotated clockwise by 45 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot45CW is {1/√2, 1/√2}.
-func pRot45CW(p fixed.Point26_6) fixed.Point26_6 {
-	// 181/256 is approximately 1/√2, or sin(π/4).
-	px, py := int64(p.X), int64(p.Y)
-	qx := (+px - py) * 181 / 256
-	qy := (+px + py) * 181 / 256
-	return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)}
-}
-
-// pRot90CW returns the vector p rotated clockwise by 90 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot90CW is {0, 1}.
-func pRot90CW(p fixed.Point26_6) fixed.Point26_6 {
-	return fixed.Point26_6{-p.Y, p.X}
-}
-
-// pRot135CW returns the vector p rotated clockwise by 135 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot135CW is {-1/√2, 1/√2}.
-func pRot135CW(p fixed.Point26_6) fixed.Point26_6 {
-	// 181/256 is approximately 1/√2, or sin(π/4).
-	px, py := int64(p.X), int64(p.Y)
-	qx := (-px - py) * 181 / 256
-	qy := (+px - py) * 181 / 256
-	return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)}
-}
-
-// pRot45CCW returns the vector p rotated counter-clockwise by 45 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot45CCW is {1/√2, -1/√2}.
-func pRot45CCW(p fixed.Point26_6) fixed.Point26_6 {
-	// 181/256 is approximately 1/√2, or sin(π/4).
-	px, py := int64(p.X), int64(p.Y)
-	qx := (+px + py) * 181 / 256
-	qy := (-px + py) * 181 / 256
-	return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)}
-}
-
-// pRot90CCW returns the vector p rotated counter-clockwise by 90 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot90CCW is {0, -1}.
-func pRot90CCW(p fixed.Point26_6) fixed.Point26_6 {
-	return fixed.Point26_6{p.Y, -p.X}
-}
-
-// pRot135CCW returns the vector p rotated counter-clockwise by 135 degrees.
-//
-// Note that the Y-axis grows downwards, so {1, 0}.Rot135CCW is {-1/√2, -1/√2}.
-func pRot135CCW(p fixed.Point26_6) fixed.Point26_6 {
-	// 181/256 is approximately 1/√2, or sin(π/4).
-	px, py := int64(p.X), int64(p.Y)
-	qx := (-px + py) * 181 / 256
-	qy := (-px - py) * 181 / 256
-	return fixed.Point26_6{fixed.Int26_6(qx), fixed.Int26_6(qy)}
-}
-
-// An Adder accumulates points on a curve.
-type Adder interface {
-	// Start starts a new curve at the given point.
-	Start(a fixed.Point26_6)
-	// Add1 adds a linear segment to the current curve.
-	Add1(b fixed.Point26_6)
-	// Add2 adds a quadratic segment to the current curve.
-	Add2(b, c fixed.Point26_6)
-	// Add3 adds a cubic segment to the current curve.
-	Add3(b, c, d fixed.Point26_6)
-}
-
-// A Path is a sequence of curves, and a curve is a start point followed by a
-// sequence of linear, quadratic or cubic segments.
-type Path []fixed.Int26_6
-
-// String returns a human-readable representation of a Path.
-func (p Path) String() string {
-	s := ""
-	for i := 0; i < len(p); {
-		if i != 0 {
-			s += " "
-		}
-		switch p[i] {
-		case 0:
-			s += "S0" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+3]))
-			i += 4
-		case 1:
-			s += "A1" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+3]))
-			i += 4
-		case 2:
-			s += "A2" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+5]))
-			i += 6
-		case 3:
-			s += "A3" + fmt.Sprint([]fixed.Int26_6(p[i+1:i+7]))
-			i += 8
-		default:
-			panic("freetype/raster: bad path")
-		}
-	}
-	return s
-}
-
-// Clear cancels any previous calls to p.Start or p.AddXxx.
-func (p *Path) Clear() {
-	*p = (*p)[:0]
-}
-
-// Start starts a new curve at the given point.
-func (p *Path) Start(a fixed.Point26_6) {
-	*p = append(*p, 0, a.X, a.Y, 0)
-}
-
-// Add1 adds a linear segment to the current curve.
-func (p *Path) Add1(b fixed.Point26_6) {
-	*p = append(*p, 1, b.X, b.Y, 1)
-}
-
-// Add2 adds a quadratic segment to the current curve.
-func (p *Path) Add2(b, c fixed.Point26_6) {
-	*p = append(*p, 2, b.X, b.Y, c.X, c.Y, 2)
-}
-
-// Add3 adds a cubic segment to the current curve.
-func (p *Path) Add3(b, c, d fixed.Point26_6) {
-	*p = append(*p, 3, b.X, b.Y, c.X, c.Y, d.X, d.Y, 3)
-}
-
-// AddPath adds the Path q to p.
-func (p *Path) AddPath(q Path) {
-	*p = append(*p, q...)
-}
-
-// AddStroke adds a stroked Path.
-func (p *Path) AddStroke(q Path, width fixed.Int26_6, cr Capper, jr Joiner) {
-	Stroke(p, q, width, cr, jr)
-}
-
-// firstPoint returns the first point in a non-empty Path.
-func (p Path) firstPoint() fixed.Point26_6 {
-	return fixed.Point26_6{p[1], p[2]}
-}
-
-// lastPoint returns the last point in a non-empty Path.
-func (p Path) lastPoint() fixed.Point26_6 {
-	return fixed.Point26_6{p[len(p)-3], p[len(p)-2]}
-}
-
-// addPathReversed adds q reversed to p.
-// For example, if q consists of a linear segment from A to B followed by a
-// quadratic segment from B to C to D, then the values of q looks like:
-// index: 01234567890123
-// value: 0AA01BB12CCDD2
-// So, when adding q backwards to p, we want to Add2(C, B) followed by Add1(A).
-func addPathReversed(p Adder, q Path) {
-	if len(q) == 0 {
-		return
-	}
-	i := len(q) - 1
-	for {
-		switch q[i] {
-		case 0:
-			return
-		case 1:
-			i -= 4
-			p.Add1(
-				fixed.Point26_6{q[i-2], q[i-1]},
-			)
-		case 2:
-			i -= 6
-			p.Add2(
-				fixed.Point26_6{q[i+2], q[i+3]},
-				fixed.Point26_6{q[i-2], q[i-1]},
-			)
-		case 3:
-			i -= 8
-			p.Add3(
-				fixed.Point26_6{q[i+4], q[i+5]},
-				fixed.Point26_6{q[i+2], q[i+3]},
-				fixed.Point26_6{q[i-2], q[i-1]},
-			)
-		default:
-			panic("freetype/raster: bad path")
-		}
-	}
-}

vendor/github.com/golang/freetype/raster/paint.go

@@ -1,287 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package raster
-
-import (
-	"image"
-	"image/color"
-	"image/draw"
-	"math"
-)
-
-// A Span is a horizontal segment of pixels with constant alpha. X0 is an
-// inclusive bound and X1 is exclusive, the same as for slices. A fully opaque
-// Span has Alpha == 0xffff.
-type Span struct {
-	Y, X0, X1 int
-	Alpha     uint32
-}
-
-// A Painter knows how to paint a batch of Spans. Rasterization may involve
-// Painting multiple batches, and done will be true for the final batch. The
-// Spans' Y values are monotonically increasing during a rasterization. Paint
-// may use all of ss as scratch space during the call.
-type Painter interface {
-	Paint(ss []Span, done bool)
-}
-
-// The PainterFunc type adapts an ordinary function to the Painter interface.
-type PainterFunc func(ss []Span, done bool)
-
-// Paint just delegates the call to f.
-func (f PainterFunc) Paint(ss []Span, done bool) { f(ss, done) }
-
-// An AlphaOverPainter is a Painter that paints Spans onto a *image.Alpha using
-// the Over Porter-Duff composition operator.
-type AlphaOverPainter struct {
-	Image *image.Alpha
-}
-
-// Paint satisfies the Painter interface.
-func (r AlphaOverPainter) Paint(ss []Span, done bool) {
-	b := r.Image.Bounds()
-	for _, s := range ss {
-		if s.Y < b.Min.Y {
-			continue
-		}
-		if s.Y >= b.Max.Y {
-			return
-		}
-		if s.X0 < b.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > b.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-		base := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride - r.Image.Rect.Min.X
-		p := r.Image.Pix[base+s.X0 : base+s.X1]
-		a := int(s.Alpha >> 8)
-		for i, c := range p {
-			v := int(c)
-			p[i] = uint8((v*255 + (255-v)*a) / 255)
-		}
-	}
-}
-
-// NewAlphaOverPainter creates a new AlphaOverPainter for the given image.
-func NewAlphaOverPainter(m *image.Alpha) AlphaOverPainter {
-	return AlphaOverPainter{m}
-}
-
-// An AlphaSrcPainter is a Painter that paints Spans onto a *image.Alpha using
-// the Src Porter-Duff composition operator.
-type AlphaSrcPainter struct {
-	Image *image.Alpha
-}
-
-// Paint satisfies the Painter interface.
-func (r AlphaSrcPainter) Paint(ss []Span, done bool) {
-	b := r.Image.Bounds()
-	for _, s := range ss {
-		if s.Y < b.Min.Y {
-			continue
-		}
-		if s.Y >= b.Max.Y {
-			return
-		}
-		if s.X0 < b.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > b.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-		base := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride - r.Image.Rect.Min.X
-		p := r.Image.Pix[base+s.X0 : base+s.X1]
-		color := uint8(s.Alpha >> 8)
-		for i := range p {
-			p[i] = color
-		}
-	}
-}
-
-// NewAlphaSrcPainter creates a new AlphaSrcPainter for the given image.
-func NewAlphaSrcPainter(m *image.Alpha) AlphaSrcPainter {
-	return AlphaSrcPainter{m}
-}
-
-// An RGBAPainter is a Painter that paints Spans onto a *image.RGBA.
-type RGBAPainter struct {
-	// Image is the image to compose onto.
-	Image *image.RGBA
-	// Op is the Porter-Duff composition operator.
-	Op draw.Op
-	// cr, cg, cb and ca are the 16-bit color to paint the spans.
-	cr, cg, cb, ca uint32
-}
-
-// Paint satisfies the Painter interface.
-func (r *RGBAPainter) Paint(ss []Span, done bool) {
-	b := r.Image.Bounds()
-	for _, s := range ss {
-		if s.Y < b.Min.Y {
-			continue
-		}
-		if s.Y >= b.Max.Y {
-			return
-		}
-		if s.X0 < b.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > b.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-		// This code mimics drawGlyphOver in $GOROOT/src/image/draw/draw.go.
-		ma := s.Alpha
-		const m = 1<<16 - 1
-		i0 := (s.Y-r.Image.Rect.Min.Y)*r.Image.Stride + (s.X0-r.Image.Rect.Min.X)*4
-		i1 := i0 + (s.X1-s.X0)*4
-		if r.Op == draw.Over {
-			for i := i0; i < i1; i += 4 {
-				dr := uint32(r.Image.Pix[i+0])
-				dg := uint32(r.Image.Pix[i+1])
-				db := uint32(r.Image.Pix[i+2])
-				da := uint32(r.Image.Pix[i+3])
-				a := (m - (r.ca * ma / m)) * 0x101
-				r.Image.Pix[i+0] = uint8((dr*a + r.cr*ma) / m >> 8)
-				r.Image.Pix[i+1] = uint8((dg*a + r.cg*ma) / m >> 8)
-				r.Image.Pix[i+2] = uint8((db*a + r.cb*ma) / m >> 8)
-				r.Image.Pix[i+3] = uint8((da*a + r.ca*ma) / m >> 8)
-			}
-		} else {
-			for i := i0; i < i1; i += 4 {
-				r.Image.Pix[i+0] = uint8(r.cr * ma / m >> 8)
-				r.Image.Pix[i+1] = uint8(r.cg * ma / m >> 8)
-				r.Image.Pix[i+2] = uint8(r.cb * ma / m >> 8)
-				r.Image.Pix[i+3] = uint8(r.ca * ma / m >> 8)
-			}
-		}
-	}
-}
-
-// SetColor sets the color to paint the spans.
-func (r *RGBAPainter) SetColor(c color.Color) {
-	r.cr, r.cg, r.cb, r.ca = c.RGBA()
-}
-
-// NewRGBAPainter creates a new RGBAPainter for the given image.
-func NewRGBAPainter(m *image.RGBA) *RGBAPainter {
-	return &RGBAPainter{Image: m}
-}
-
-// A MonochromePainter wraps another Painter, quantizing each Span's alpha to
-// be either fully opaque or fully transparent.
-type MonochromePainter struct {
-	Painter   Painter
-	y, x0, x1 int
-}
-
-// Paint delegates to the wrapped Painter after quantizing each Span's alpha
-// value and merging adjacent fully opaque Spans.
-func (m *MonochromePainter) Paint(ss []Span, done bool) {
-	// We compact the ss slice, discarding any Spans whose alpha quantizes to zero.
-	j := 0
-	for _, s := range ss {
-		if s.Alpha >= 0x8000 {
-			if m.y == s.Y && m.x1 == s.X0 {
-				m.x1 = s.X1
-			} else {
-				ss[j] = Span{m.y, m.x0, m.x1, 1<<16 - 1}
-				j++
-				m.y, m.x0, m.x1 = s.Y, s.X0, s.X1
-			}
-		}
-	}
-	if done {
-		// Flush the accumulated Span.
-		finalSpan := Span{m.y, m.x0, m.x1, 1<<16 - 1}
-		if j < len(ss) {
-			ss[j] = finalSpan
-			j++
-			m.Painter.Paint(ss[:j], true)
-		} else if j == len(ss) {
-			m.Painter.Paint(ss, false)
-			if cap(ss) > 0 {
-				ss = ss[:1]
-			} else {
-				ss = make([]Span, 1)
-			}
-			ss[0] = finalSpan
-			m.Painter.Paint(ss, true)
-		} else {
-			panic("unreachable")
-		}
-		// Reset the accumulator, so that this Painter can be re-used.
-		m.y, m.x0, m.x1 = 0, 0, 0
-	} else {
-		m.Painter.Paint(ss[:j], false)
-	}
-}
-
-// NewMonochromePainter creates a new MonochromePainter that wraps the given
-// Painter.
-func NewMonochromePainter(p Painter) *MonochromePainter {
-	return &MonochromePainter{Painter: p}
-}
-
-// A GammaCorrectionPainter wraps another Painter, performing gamma-correction
-// on each Span's alpha value.
-type GammaCorrectionPainter struct {
-	// Painter is the wrapped Painter.
-	Painter Painter
-	// a is the precomputed alpha values for linear interpolation, with fully
-	// opaque == 0xffff.
-	a [256]uint16
-	// gammaIsOne is whether gamma correction is a no-op.
-	gammaIsOne bool
-}
-
-// Paint delegates to the wrapped Painter after performing gamma-correction on
-// each Span.
-func (g *GammaCorrectionPainter) Paint(ss []Span, done bool) {
-	if !g.gammaIsOne {
-		const n = 0x101
-		for i, s := range ss {
-			if s.Alpha == 0 || s.Alpha == 0xffff {
-				continue
-			}
-			p, q := s.Alpha/n, s.Alpha%n
-			// The resultant alpha is a linear interpolation of g.a[p] and g.a[p+1].
-			a := uint32(g.a[p])*(n-q) + uint32(g.a[p+1])*q
-			ss[i].Alpha = (a + n/2) / n
-		}
-	}
-	g.Painter.Paint(ss, done)
-}
-
-// SetGamma sets the gamma value.
-func (g *GammaCorrectionPainter) SetGamma(gamma float64) {
-	g.gammaIsOne = gamma == 1
-	if g.gammaIsOne {
-		return
-	}
-	for i := 0; i < 256; i++ {
-		a := float64(i) / 0xff
-		a = math.Pow(a, gamma)
-		g.a[i] = uint16(0xffff * a)
-	}
-}
-
-// NewGammaCorrectionPainter creates a new GammaCorrectionPainter that wraps
-// the given Painter.
-func NewGammaCorrectionPainter(p Painter, gamma float64) *GammaCorrectionPainter {
-	g := &GammaCorrectionPainter{Painter: p}
-	g.SetGamma(gamma)
-	return g
-}

vendor/github.com/golang/freetype/raster/raster.go

@@ -1,601 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-// Package raster provides an anti-aliasing 2-D rasterizer.
-//
-// It is part of the larger Freetype suite of font-related packages, but the
-// raster package is not specific to font rasterization, and can be used
-// standalone without any other Freetype package.
-//
-// Rasterization is done by the same area/coverage accumulation algorithm as
-// the Freetype "smooth" module, and the Anti-Grain Geometry library. A
-// description of the area/coverage algorithm is at
-// http://projects.tuxee.net/cl-vectors/section-the-cl-aa-algorithm
-package raster
-
-import (
-	"strconv"
-
-	"golang.org/x/image/math/fixed"
-)
-
-// A cell is part of a linked list (for a given yi co-ordinate) of accumulated
-// area/coverage for the pixel at (xi, yi).
-type cell struct {
-	xi          int
-	area, cover int
-	next        int
-}
-
-type Rasterizer struct {
-	// If false, the default behavior is to use the even-odd winding fill
-	// rule during Rasterize.
-	UseNonZeroWinding bool
-	// An offset (in pixels) to the painted spans.
-	Dx, Dy int
-
-	// The width of the Rasterizer. The height is implicit in len(cellIndex).
-	width int
-	// splitScaleN is the scaling factor used to determine how many times
-	// to decompose a quadratic or cubic segment into a linear approximation.
-	splitScale2, splitScale3 int
-
-	// The current pen position.
-	a fixed.Point26_6
-	// The current cell and its area/coverage being accumulated.
-	xi, yi      int
-	area, cover int
-
-	// Saved cells.
-	cell []cell
-	// Linked list of cells, one per row.
-	cellIndex []int
-	// Buffers.
-	cellBuf      [256]cell
-	cellIndexBuf [64]int
-	spanBuf      [64]Span
-}
-
-// findCell returns the index in r.cell for the cell corresponding to
-// (r.xi, r.yi). The cell is created if necessary.
-func (r *Rasterizer) findCell() int {
-	if r.yi < 0 || r.yi >= len(r.cellIndex) {
-		return -1
-	}
-	xi := r.xi
-	if xi < 0 {
-		xi = -1
-	} else if xi > r.width {
-		xi = r.width
-	}
-	i, prev := r.cellIndex[r.yi], -1
-	for i != -1 && r.cell[i].xi <= xi {
-		if r.cell[i].xi == xi {
-			return i
-		}
-		i, prev = r.cell[i].next, i
-	}
-	c := len(r.cell)
-	if c == cap(r.cell) {
-		buf := make([]cell, c, 4*c)
-		copy(buf, r.cell)
-		r.cell = buf[0 : c+1]
-	} else {
-		r.cell = r.cell[0 : c+1]
-	}
-	r.cell[c] = cell{xi, 0, 0, i}
-	if prev == -1 {
-		r.cellIndex[r.yi] = c
-	} else {
-		r.cell[prev].next = c
-	}
-	return c
-}
-
-// saveCell saves any accumulated r.area/r.cover for (r.xi, r.yi).
-func (r *Rasterizer) saveCell() {
-	if r.area != 0 || r.cover != 0 {
-		i := r.findCell()
-		if i != -1 {
-			r.cell[i].area += r.area
-			r.cell[i].cover += r.cover
-		}
-		r.area = 0
-		r.cover = 0
-	}
-}
-
-// setCell sets the (xi, yi) cell that r is accumulating area/coverage for.
-func (r *Rasterizer) setCell(xi, yi int) {
-	if r.xi != xi || r.yi != yi {
-		r.saveCell()
-		r.xi, r.yi = xi, yi
-	}
-}
-
-// scan accumulates area/coverage for the yi'th scanline, going from
-// x0 to x1 in the horizontal direction (in 26.6 fixed point co-ordinates)
-// and from y0f to y1f fractional vertical units within that scanline.
-func (r *Rasterizer) scan(yi int, x0, y0f, x1, y1f fixed.Int26_6) {
-	// Break the 26.6 fixed point X co-ordinates into integral and fractional parts.
-	x0i := int(x0) / 64
-	x0f := x0 - fixed.Int26_6(64*x0i)
-	x1i := int(x1) / 64
-	x1f := x1 - fixed.Int26_6(64*x1i)
-
-	// A perfectly horizontal scan.
-	if y0f == y1f {
-		r.setCell(x1i, yi)
-		return
-	}
-	dx, dy := x1-x0, y1f-y0f
-	// A single cell scan.
-	if x0i == x1i {
-		r.area += int((x0f + x1f) * dy)
-		r.cover += int(dy)
-		return
-	}
-	// There are at least two cells. Apart from the first and last cells,
-	// all intermediate cells go through the full width of the cell,
-	// or 64 units in 26.6 fixed point format.
-	var (
-		p, q, edge0, edge1 fixed.Int26_6
-		xiDelta            int
-	)
-	if dx > 0 {
-		p, q = (64-x0f)*dy, dx
-		edge0, edge1, xiDelta = 0, 64, 1
-	} else {
-		p, q = x0f*dy, -dx
-		edge0, edge1, xiDelta = 64, 0, -1
-	}
-	yDelta, yRem := p/q, p%q
-	if yRem < 0 {
-		yDelta -= 1
-		yRem += q
-	}
-	// Do the first cell.
-	xi, y := x0i, y0f
-	r.area += int((x0f + edge1) * yDelta)
-	r.cover += int(yDelta)
-	xi, y = xi+xiDelta, y+yDelta
-	r.setCell(xi, yi)
-	if xi != x1i {
-		// Do all the intermediate cells.
-		p = 64 * (y1f - y + yDelta)
-		fullDelta, fullRem := p/q, p%q
-		if fullRem < 0 {
-			fullDelta -= 1
-			fullRem += q
-		}
-		yRem -= q
-		for xi != x1i {
-			yDelta = fullDelta
-			yRem += fullRem
-			if yRem >= 0 {
-				yDelta += 1
-				yRem -= q
-			}
-			r.area += int(64 * yDelta)
-			r.cover += int(yDelta)
-			xi, y = xi+xiDelta, y+yDelta
-			r.setCell(xi, yi)
-		}
-	}
-	// Do the last cell.
-	yDelta = y1f - y
-	r.area += int((edge0 + x1f) * yDelta)
-	r.cover += int(yDelta)
-}
-
-// Start starts a new curve at the given point.
-func (r *Rasterizer) Start(a fixed.Point26_6) {
-	r.setCell(int(a.X/64), int(a.Y/64))
-	r.a = a
-}
-
-// Add1 adds a linear segment to the current curve.
-func (r *Rasterizer) Add1(b fixed.Point26_6) {
-	x0, y0 := r.a.X, r.a.Y
-	x1, y1 := b.X, b.Y
-	dx, dy := x1-x0, y1-y0
-	// Break the 26.6 fixed point Y co-ordinates into integral and fractional
-	// parts.
-	y0i := int(y0) / 64
-	y0f := y0 - fixed.Int26_6(64*y0i)
-	y1i := int(y1) / 64
-	y1f := y1 - fixed.Int26_6(64*y1i)
-
-	if y0i == y1i {
-		// There is only one scanline.
-		r.scan(y0i, x0, y0f, x1, y1f)
-
-	} else if dx == 0 {
-		// This is a vertical line segment. We avoid calling r.scan and instead
-		// manipulate r.area and r.cover directly.
-		var (
-			edge0, edge1 fixed.Int26_6
-			yiDelta      int
-		)
-		if dy > 0 {
-			edge0, edge1, yiDelta = 0, 64, 1
-		} else {
-			edge0, edge1, yiDelta = 64, 0, -1
-		}
-		x0i, yi := int(x0)/64, y0i
-		x0fTimes2 := (int(x0) - (64 * x0i)) * 2
-		// Do the first pixel.
-		dcover := int(edge1 - y0f)
-		darea := int(x0fTimes2 * dcover)
-		r.area += darea
-		r.cover += dcover
-		yi += yiDelta
-		r.setCell(x0i, yi)
-		// Do all the intermediate pixels.
-		dcover = int(edge1 - edge0)
-		darea = int(x0fTimes2 * dcover)
-		for yi != y1i {
-			r.area += darea
-			r.cover += dcover
-			yi += yiDelta
-			r.setCell(x0i, yi)
-		}
-		// Do the last pixel.
-		dcover = int(y1f - edge0)
-		darea = int(x0fTimes2 * dcover)
-		r.area += darea
-		r.cover += dcover
-
-	} else {
-		// There are at least two scanlines. Apart from the first and last
-		// scanlines, all intermediate scanlines go through the full height of
-		// the row, or 64 units in 26.6 fixed point format.
-		var (
-			p, q, edge0, edge1 fixed.Int26_6
-			yiDelta            int
-		)
-		if dy > 0 {
-			p, q = (64-y0f)*dx, dy
-			edge0, edge1, yiDelta = 0, 64, 1
-		} else {
-			p, q = y0f*dx, -dy
-			edge0, edge1, yiDelta = 64, 0, -1
-		}
-		xDelta, xRem := p/q, p%q
-		if xRem < 0 {
-			xDelta -= 1
-			xRem += q
-		}
-		// Do the first scanline.
-		x, yi := x0, y0i
-		r.scan(yi, x, y0f, x+xDelta, edge1)
-		x, yi = x+xDelta, yi+yiDelta
-		r.setCell(int(x)/64, yi)
-		if yi != y1i {
-			// Do all the intermediate scanlines.
-			p = 64 * dx
-			fullDelta, fullRem := p/q, p%q
-			if fullRem < 0 {
-				fullDelta -= 1
-				fullRem += q
-			}
-			xRem -= q
-			for yi != y1i {
-				xDelta = fullDelta
-				xRem += fullRem
-				if xRem >= 0 {
-					xDelta += 1
-					xRem -= q
-				}
-				r.scan(yi, x, edge0, x+xDelta, edge1)
-				x, yi = x+xDelta, yi+yiDelta
-				r.setCell(int(x)/64, yi)
-			}
-		}
-		// Do the last scanline.
-		r.scan(yi, x, edge0, x1, y1f)
-	}
-	// The next lineTo starts from b.
-	r.a = b
-}
-
-// Add2 adds a quadratic segment to the current curve.
-func (r *Rasterizer) Add2(b, c fixed.Point26_6) {
-	// Calculate nSplit (the number of recursive decompositions) based on how
-	// 'curvy' it is. Specifically, how much the middle point b deviates from
-	// (a+c)/2.
-	dev := maxAbs(r.a.X-2*b.X+c.X, r.a.Y-2*b.Y+c.Y) / fixed.Int26_6(r.splitScale2)
-	nsplit := 0
-	for dev > 0 {
-		dev /= 4
-		nsplit++
-	}
-	// dev is 32-bit, and nsplit++ every time we shift off 2 bits, so maxNsplit
-	// is 16.
-	const maxNsplit = 16
-	if nsplit > maxNsplit {
-		panic("freetype/raster: Add2 nsplit too large: " + strconv.Itoa(nsplit))
-	}
-	// Recursively decompose the curve nSplit levels deep.
-	var (
-		pStack [2*maxNsplit + 3]fixed.Point26_6
-		sStack [maxNsplit + 1]int
-		i      int
-	)
-	sStack[0] = nsplit
-	pStack[0] = c
-	pStack[1] = b
-	pStack[2] = r.a
-	for i >= 0 {
-		s := sStack[i]
-		p := pStack[2*i:]
-		if s > 0 {
-			// Split the quadratic curve p[:3] into an equivalent set of two
-			// shorter curves: p[:3] and p[2:5]. The new p[4] is the old p[2],
-			// and p[0] is unchanged.
-			mx := p[1].X
-			p[4].X = p[2].X
-			p[3].X = (p[4].X + mx) / 2
-			p[1].X = (p[0].X + mx) / 2
-			p[2].X = (p[1].X + p[3].X) / 2
-			my := p[1].Y
-			p[4].Y = p[2].Y
-			p[3].Y = (p[4].Y + my) / 2
-			p[1].Y = (p[0].Y + my) / 2
-			p[2].Y = (p[1].Y + p[3].Y) / 2
-			// The two shorter curves have one less split to do.
-			sStack[i] = s - 1
-			sStack[i+1] = s - 1
-			i++
-		} else {
-			// Replace the level-0 quadratic with a two-linear-piece
-			// approximation.
-			midx := (p[0].X + 2*p[1].X + p[2].X) / 4
-			midy := (p[0].Y + 2*p[1].Y + p[2].Y) / 4
-			r.Add1(fixed.Point26_6{midx, midy})
-			r.Add1(p[0])
-			i--
-		}
-	}
-}
-
-// Add3 adds a cubic segment to the current curve.
-func (r *Rasterizer) Add3(b, c, d fixed.Point26_6) {
-	// Calculate nSplit (the number of recursive decompositions) based on how
-	// 'curvy' it is.
-	dev2 := maxAbs(r.a.X-3*(b.X+c.X)+d.X, r.a.Y-3*(b.Y+c.Y)+d.Y) / fixed.Int26_6(r.splitScale2)
-	dev3 := maxAbs(r.a.X-2*b.X+d.X, r.a.Y-2*b.Y+d.Y) / fixed.Int26_6(r.splitScale3)
-	nsplit := 0
-	for dev2 > 0 || dev3 > 0 {
-		dev2 /= 8
-		dev3 /= 4
-		nsplit++
-	}
-	// devN is 32-bit, and nsplit++ every time we shift off 2 bits, so
-	// maxNsplit is 16.
-	const maxNsplit = 16
-	if nsplit > maxNsplit {
-		panic("freetype/raster: Add3 nsplit too large: " + strconv.Itoa(nsplit))
-	}
-	// Recursively decompose the curve nSplit levels deep.
-	var (
-		pStack [3*maxNsplit + 4]fixed.Point26_6
-		sStack [maxNsplit + 1]int
-		i      int
-	)
-	sStack[0] = nsplit
-	pStack[0] = d
-	pStack[1] = c
-	pStack[2] = b
-	pStack[3] = r.a
-	for i >= 0 {
-		s := sStack[i]
-		p := pStack[3*i:]
-		if s > 0 {
-			// Split the cubic curve p[:4] into an equivalent set of two
-			// shorter curves: p[:4] and p[3:7]. The new p[6] is the old p[3],
-			// and p[0] is unchanged.
-			m01x := (p[0].X + p[1].X) / 2
-			m12x := (p[1].X + p[2].X) / 2
-			m23x := (p[2].X + p[3].X) / 2
-			p[6].X = p[3].X
-			p[5].X = m23x
-			p[1].X = m01x
-			p[2].X = (m01x + m12x) / 2
-			p[4].X = (m12x + m23x) / 2
-			p[3].X = (p[2].X + p[4].X) / 2
-			m01y := (p[0].Y + p[1].Y) / 2
-			m12y := (p[1].Y + p[2].Y) / 2
-			m23y := (p[2].Y + p[3].Y) / 2
-			p[6].Y = p[3].Y
-			p[5].Y = m23y
-			p[1].Y = m01y
-			p[2].Y = (m01y + m12y) / 2
-			p[4].Y = (m12y + m23y) / 2
-			p[3].Y = (p[2].Y + p[4].Y) / 2
-			// The two shorter curves have one less split to do.
-			sStack[i] = s - 1
-			sStack[i+1] = s - 1
-			i++
-		} else {
-			// Replace the level-0 cubic with a two-linear-piece approximation.
-			midx := (p[0].X + 3*(p[1].X+p[2].X) + p[3].X) / 8
-			midy := (p[0].Y + 3*(p[1].Y+p[2].Y) + p[3].Y) / 8
-			r.Add1(fixed.Point26_6{midx, midy})
-			r.Add1(p[0])
-			i--
-		}
-	}
-}
-
-// AddPath adds the given Path.
-func (r *Rasterizer) AddPath(p Path) {
-	for i := 0; i < len(p); {
-		switch p[i] {
-		case 0:
-			r.Start(
-				fixed.Point26_6{p[i+1], p[i+2]},
-			)
-			i += 4
-		case 1:
-			r.Add1(
-				fixed.Point26_6{p[i+1], p[i+2]},
-			)
-			i += 4
-		case 2:
-			r.Add2(
-				fixed.Point26_6{p[i+1], p[i+2]},
-				fixed.Point26_6{p[i+3], p[i+4]},
-			)
-			i += 6
-		case 3:
-			r.Add3(
-				fixed.Point26_6{p[i+1], p[i+2]},
-				fixed.Point26_6{p[i+3], p[i+4]},
-				fixed.Point26_6{p[i+5], p[i+6]},
-			)
-			i += 8
-		default:
-			panic("freetype/raster: bad path")
-		}
-	}
-}
-
-// AddStroke adds a stroked Path.
-func (r *Rasterizer) AddStroke(q Path, width fixed.Int26_6, cr Capper, jr Joiner) {
-	Stroke(r, q, width, cr, jr)
-}
-
-// areaToAlpha converts an area value to a uint32 alpha value. A completely
-// filled pixel corresponds to an area of 64*64*2, and an alpha of 0xffff. The
-// conversion of area values greater than this depends on the winding rule:
-// even-odd or non-zero.
-func (r *Rasterizer) areaToAlpha(area int) uint32 {
-	// The C Freetype implementation (version 2.3.12) does "alpha := area>>1"
-	// without the +1. Round-to-nearest gives a more symmetric result than
-	// round-down. The C implementation also returns 8-bit alpha, not 16-bit
-	// alpha.
-	a := (area + 1) >> 1
-	if a < 0 {
-		a = -a
-	}
-	alpha := uint32(a)
-	if r.UseNonZeroWinding {
-		if alpha > 0x0fff {
-			alpha = 0x0fff
-		}
-	} else {
-		alpha &= 0x1fff
-		if alpha > 0x1000 {
-			alpha = 0x2000 - alpha
-		} else if alpha == 0x1000 {
-			alpha = 0x0fff
-		}
-	}
-	// alpha is now in the range [0x0000, 0x0fff]. Convert that 12-bit alpha to
-	// 16-bit alpha.
-	return alpha<<4 | alpha>>8
-}
-
-// Rasterize converts r's accumulated curves into Spans for p. The Spans passed
-// to p are non-overlapping, and sorted by Y and then X. They all have non-zero
-// width (and 0 <= X0 < X1 <= r.width) and non-zero A, except for the final
-// Span, which has Y, X0, X1 and A all equal to zero.
-func (r *Rasterizer) Rasterize(p Painter) {
-	r.saveCell()
-	s := 0
-	for yi := 0; yi < len(r.cellIndex); yi++ {
-		xi, cover := 0, 0
-		for c := r.cellIndex[yi]; c != -1; c = r.cell[c].next {
-			if cover != 0 && r.cell[c].xi > xi {
-				alpha := r.areaToAlpha(cover * 64 * 2)
-				if alpha != 0 {
-					xi0, xi1 := xi, r.cell[c].xi
-					if xi0 < 0 {
-						xi0 = 0
-					}
-					if xi1 >= r.width {
-						xi1 = r.width
-					}
-					if xi0 < xi1 {
-						r.spanBuf[s] = Span{yi + r.Dy, xi0 + r.Dx, xi1 + r.Dx, alpha}
-						s++
-					}
-				}
-			}
-			cover += r.cell[c].cover
-			alpha := r.areaToAlpha(cover*64*2 - r.cell[c].area)
-			xi = r.cell[c].xi + 1
-			if alpha != 0 {
-				xi0, xi1 := r.cell[c].xi, xi
-				if xi0 < 0 {
-					xi0 = 0
-				}
-				if xi1 >= r.width {
-					xi1 = r.width
-				}
-				if xi0 < xi1 {
-					r.spanBuf[s] = Span{yi + r.Dy, xi0 + r.Dx, xi1 + r.Dx, alpha}
-					s++
-				}
-			}
-			if s > len(r.spanBuf)-2 {
-				p.Paint(r.spanBuf[:s], false)
-				s = 0
-			}
-		}
-	}
-	p.Paint(r.spanBuf[:s], true)
-}
-
-// Clear cancels any previous calls to r.Start or r.AddXxx.
-func (r *Rasterizer) Clear() {
-	r.a = fixed.Point26_6{}
-	r.xi = 0
-	r.yi = 0
-	r.area = 0
-	r.cover = 0
-	r.cell = r.cell[:0]
-	for i := 0; i < len(r.cellIndex); i++ {
-		r.cellIndex[i] = -1
-	}
-}
-
-// SetBounds sets the maximum width and height of the rasterized image and
-// calls Clear. The width and height are in pixels, not fixed.Int26_6 units.
-func (r *Rasterizer) SetBounds(width, height int) {
-	if width < 0 {
-		width = 0
-	}
-	if height < 0 {
-		height = 0
-	}
-	// Use the same ssN heuristic as the C Freetype (version 2.4.0)
-	// implementation.
-	ss2, ss3 := 32, 16
-	if width > 24 || height > 24 {
-		ss2, ss3 = 2*ss2, 2*ss3
-		if width > 120 || height > 120 {
-			ss2, ss3 = 2*ss2, 2*ss3
-		}
-	}
-	r.width = width
-	r.splitScale2 = ss2
-	r.splitScale3 = ss3
-	r.cell = r.cellBuf[:0]
-	if height > len(r.cellIndexBuf) {
-		r.cellIndex = make([]int, height)
-	} else {
-		r.cellIndex = r.cellIndexBuf[:height]
-	}
-	r.Clear()
-}
-
-// NewRasterizer creates a new Rasterizer with the given bounds.
-func NewRasterizer(width, height int) *Rasterizer {
-	r := new(Rasterizer)
-	r.SetBounds(width, height)
-	return r
-}

vendor/github.com/golang/freetype/raster/stroke.go

@@ -1,483 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package raster
-
-import (
-	"golang.org/x/image/math/fixed"
-)
-
-// Two points are considered practically equal if the square of the distance
-// between them is less than one quarter (i.e. 1024 / 4096).
-const epsilon = fixed.Int52_12(1024)
-
-// A Capper signifies how to begin or end a stroked path.
-type Capper interface {
-	// Cap adds a cap to p given a pivot point and the normal vector of a
-	// terminal segment. The normal's length is half of the stroke width.
-	Cap(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6)
-}
-
-// The CapperFunc type adapts an ordinary function to be a Capper.
-type CapperFunc func(Adder, fixed.Int26_6, fixed.Point26_6, fixed.Point26_6)
-
-func (f CapperFunc) Cap(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) {
-	f(p, halfWidth, pivot, n1)
-}
-
-// A Joiner signifies how to join interior nodes of a stroked path.
-type Joiner interface {
-	// Join adds a join to the two sides of a stroked path given a pivot
-	// point and the normal vectors of the trailing and leading segments.
-	// Both normals have length equal to half of the stroke width.
-	Join(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6)
-}
-
-// The JoinerFunc type adapts an ordinary function to be a Joiner.
-type JoinerFunc func(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6)
-
-func (f JoinerFunc) Join(lhs, rhs Adder, halfWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) {
-	f(lhs, rhs, halfWidth, pivot, n0, n1)
-}
-
-// RoundCapper adds round caps to a stroked path.
-var RoundCapper Capper = CapperFunc(roundCapper)
-
-func roundCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) {
-	// The cubic Bézier approximation to a circle involves the magic number
-	// (√2 - 1) * 4/3, which is approximately 35/64.
-	const k = 35
-	e := pRot90CCW(n1)
-	side := pivot.Add(e)
-	start, end := pivot.Sub(n1), pivot.Add(n1)
-	d, e := n1.Mul(k), e.Mul(k)
-	p.Add3(start.Add(e), side.Sub(d), side)
-	p.Add3(side.Add(d), end.Add(e), end)
-}
-
-// ButtCapper adds butt caps to a stroked path.
-var ButtCapper Capper = CapperFunc(buttCapper)
-
-func buttCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) {
-	p.Add1(pivot.Add(n1))
-}
-
-// SquareCapper adds square caps to a stroked path.
-var SquareCapper Capper = CapperFunc(squareCapper)
-
-func squareCapper(p Adder, halfWidth fixed.Int26_6, pivot, n1 fixed.Point26_6) {
-	e := pRot90CCW(n1)
-	side := pivot.Add(e)
-	p.Add1(side.Sub(n1))
-	p.Add1(side.Add(n1))
-	p.Add1(pivot.Add(n1))
-}
-
-// RoundJoiner adds round joins to a stroked path.
-var RoundJoiner Joiner = JoinerFunc(roundJoiner)
-
-func roundJoiner(lhs, rhs Adder, haflWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) {
-	dot := pDot(pRot90CW(n0), n1)
-	if dot >= 0 {
-		addArc(lhs, pivot, n0, n1)
-		rhs.Add1(pivot.Sub(n1))
-	} else {
-		lhs.Add1(pivot.Add(n1))
-		addArc(rhs, pivot, pNeg(n0), pNeg(n1))
-	}
-}
-
-// BevelJoiner adds bevel joins to a stroked path.
-var BevelJoiner Joiner = JoinerFunc(bevelJoiner)
-
-func bevelJoiner(lhs, rhs Adder, haflWidth fixed.Int26_6, pivot, n0, n1 fixed.Point26_6) {
-	lhs.Add1(pivot.Add(n1))
-	rhs.Add1(pivot.Sub(n1))
-}
-
-// addArc adds a circular arc from pivot+n0 to pivot+n1 to p. The shorter of
-// the two possible arcs is taken, i.e. the one spanning <= 180 degrees. The
-// two vectors n0 and n1 must be of equal length.
-func addArc(p Adder, pivot, n0, n1 fixed.Point26_6) {
-	// r2 is the square of the length of n0.
-	r2 := pDot(n0, n0)
-	if r2 < epsilon {
-		// The arc radius is so small that we collapse to a straight line.
-		p.Add1(pivot.Add(n1))
-		return
-	}
-	// We approximate the arc by 0, 1, 2 or 3 45-degree quadratic segments plus
-	// a final quadratic segment from s to n1. Each 45-degree segment has
-	// control points {1, 0}, {1, tan(π/8)} and {1/√2, 1/√2} suitably scaled,
-	// rotated and translated. tan(π/8) is approximately 27/64.
-	const tpo8 = 27
-	var s fixed.Point26_6
-	// We determine which octant the angle between n0 and n1 is in via three
-	// dot products. m0, m1 and m2 are n0 rotated clockwise by 45, 90 and 135
-	// degrees.
-	m0 := pRot45CW(n0)
-	m1 := pRot90CW(n0)
-	m2 := pRot90CW(m0)
-	if pDot(m1, n1) >= 0 {
-		if pDot(n0, n1) >= 0 {
-			if pDot(m2, n1) <= 0 {
-				// n1 is between 0 and 45 degrees clockwise of n0.
-				s = n0
-			} else {
-				// n1 is between 45 and 90 degrees clockwise of n0.
-				p.Add2(pivot.Add(n0).Add(m1.Mul(tpo8)), pivot.Add(m0))
-				s = m0
-			}
-		} else {
-			pm1, n0t := pivot.Add(m1), n0.Mul(tpo8)
-			p.Add2(pivot.Add(n0).Add(m1.Mul(tpo8)), pivot.Add(m0))
-			p.Add2(pm1.Add(n0t), pm1)
-			if pDot(m0, n1) >= 0 {
-				// n1 is between 90 and 135 degrees clockwise of n0.
-				s = m1
-			} else {
-				// n1 is between 135 and 180 degrees clockwise of n0.
-				p.Add2(pm1.Sub(n0t), pivot.Add(m2))
-				s = m2
-			}
-		}
-	} else {
-		if pDot(n0, n1) >= 0 {
-			if pDot(m0, n1) >= 0 {
-				// n1 is between 0 and 45 degrees counter-clockwise of n0.
-				s = n0
-			} else {
-				// n1 is between 45 and 90 degrees counter-clockwise of n0.
-				p.Add2(pivot.Add(n0).Sub(m1.Mul(tpo8)), pivot.Sub(m2))
-				s = pNeg(m2)
-			}
-		} else {
-			pm1, n0t := pivot.Sub(m1), n0.Mul(tpo8)
-			p.Add2(pivot.Add(n0).Sub(m1.Mul(tpo8)), pivot.Sub(m2))
-			p.Add2(pm1.Add(n0t), pm1)
-			if pDot(m2, n1) <= 0 {
-				// n1 is between 90 and 135 degrees counter-clockwise of n0.
-				s = pNeg(m1)
-			} else {
-				// n1 is between 135 and 180 degrees counter-clockwise of n0.
-				p.Add2(pm1.Sub(n0t), pivot.Sub(m0))
-				s = pNeg(m0)
-			}
-		}
-	}
-	// The final quadratic segment has two endpoints s and n1 and the middle
-	// control point is a multiple of s.Add(n1), i.e. it is on the angle
-	// bisector of those two points. The multiple ranges between 128/256 and
-	// 150/256 as the angle between s and n1 ranges between 0 and 45 degrees.
-	//
-	// When the angle is 0 degrees (i.e. s and n1 are coincident) then
-	// s.Add(n1) is twice s and so the middle control point of the degenerate
-	// quadratic segment should be half s.Add(n1), and half = 128/256.
-	//
-	// When the angle is 45 degrees then 150/256 is the ratio of the lengths of
-	// the two vectors {1, tan(π/8)} and {1 + 1/√2, 1/√2}.
-	//
-	// d is the normalized dot product between s and n1. Since the angle ranges
-	// between 0 and 45 degrees then d ranges between 256/256 and 181/256.
-	d := 256 * pDot(s, n1) / r2
-	multiple := fixed.Int26_6(150-(150-128)*(d-181)/(256-181)) >> 2
-	p.Add2(pivot.Add(s.Add(n1).Mul(multiple)), pivot.Add(n1))
-}
-
-// midpoint returns the midpoint of two Points.
-func midpoint(a, b fixed.Point26_6) fixed.Point26_6 {
-	return fixed.Point26_6{(a.X + b.X) / 2, (a.Y + b.Y) / 2}
-}
-
-// angleGreaterThan45 returns whether the angle between two vectors is more
-// than 45 degrees.
-func angleGreaterThan45(v0, v1 fixed.Point26_6) bool {
-	v := pRot45CCW(v0)
-	return pDot(v, v1) < 0 || pDot(pRot90CW(v), v1) < 0
-}
-
-// interpolate returns the point (1-t)*a + t*b.
-func interpolate(a, b fixed.Point26_6, t fixed.Int52_12) fixed.Point26_6 {
-	s := 1<<12 - t
-	x := s*fixed.Int52_12(a.X) + t*fixed.Int52_12(b.X)
-	y := s*fixed.Int52_12(a.Y) + t*fixed.Int52_12(b.Y)
-	return fixed.Point26_6{fixed.Int26_6(x >> 12), fixed.Int26_6(y >> 12)}
-}
-
-// curviest2 returns the value of t for which the quadratic parametric curve
-// (1-t)²*a + 2*t*(1-t).b + t²*c has maximum curvature.
-//
-// The curvature of the parametric curve f(t) = (x(t), y(t)) is
-// |x′y″-y′x″| / (x′²+y′²)^(3/2).
-//
-// Let d = b-a and e = c-2*b+a, so that f′(t) = 2*d+2*e*t and f″(t) = 2*e.
-// The curvature's numerator is (2*dx+2*ex*t)*(2*ey)-(2*dy+2*ey*t)*(2*ex),
-// which simplifies to 4*dx*ey-4*dy*ex, which is constant with respect to t.
-//
-// Thus, curvature is extreme where the denominator is extreme, i.e. where
-// (x′²+y′²) is extreme. The first order condition is that
-// 2*x′*x″+2*y′*y″ = 0, or (dx+ex*t)*ex + (dy+ey*t)*ey = 0.
-// Solving for t gives t = -(dx*ex+dy*ey) / (ex*ex+ey*ey).
-func curviest2(a, b, c fixed.Point26_6) fixed.Int52_12 {
-	dx := int64(b.X - a.X)
-	dy := int64(b.Y - a.Y)
-	ex := int64(c.X - 2*b.X + a.X)
-	ey := int64(c.Y - 2*b.Y + a.Y)
-	if ex == 0 && ey == 0 {
-		return 2048
-	}
-	return fixed.Int52_12(-4096 * (dx*ex + dy*ey) / (ex*ex + ey*ey))
-}
-
-// A stroker holds state for stroking a path.
-type stroker struct {
-	// p is the destination that records the stroked path.
-	p Adder
-	// u is the half-width of the stroke.
-	u fixed.Int26_6
-	// cr and jr specify how to end and connect path segments.
-	cr Capper
-	jr Joiner
-	// r is the reverse path. Stroking a path involves constructing two
-	// parallel paths 2*u apart. The first path is added immediately to p,
-	// the second path is accumulated in r and eventually added in reverse.
-	r Path
-	// a is the most recent segment point. anorm is the segment normal of
-	// length u at that point.
-	a, anorm fixed.Point26_6
-}
-
-// addNonCurvy2 adds a quadratic segment to the stroker, where the segment
-// defined by (k.a, b, c) achieves maximum curvature at either k.a or c.
-func (k *stroker) addNonCurvy2(b, c fixed.Point26_6) {
-	// We repeatedly divide the segment at its middle until it is straight
-	// enough to approximate the stroke by just translating the control points.
-	// ds and ps are stacks of depths and points. t is the top of the stack.
-	const maxDepth = 5
-	var (
-		ds [maxDepth + 1]int
-		ps [2*maxDepth + 3]fixed.Point26_6
-		t  int
-	)
-	// Initially the ps stack has one quadratic segment of depth zero.
-	ds[0] = 0
-	ps[2] = k.a
-	ps[1] = b
-	ps[0] = c
-	anorm := k.anorm
-	var cnorm fixed.Point26_6
-
-	for {
-		depth := ds[t]
-		a := ps[2*t+2]
-		b := ps[2*t+1]
-		c := ps[2*t+0]
-		ab := b.Sub(a)
-		bc := c.Sub(b)
-		abIsSmall := pDot(ab, ab) < fixed.Int52_12(1<<12)
-		bcIsSmall := pDot(bc, bc) < fixed.Int52_12(1<<12)
-		if abIsSmall && bcIsSmall {
-			// Approximate the segment by a circular arc.
-			cnorm = pRot90CCW(pNorm(bc, k.u))
-			mac := midpoint(a, c)
-			addArc(k.p, mac, anorm, cnorm)
-			addArc(&k.r, mac, pNeg(anorm), pNeg(cnorm))
-		} else if depth < maxDepth && angleGreaterThan45(ab, bc) {
-			// Divide the segment in two and push both halves on the stack.
-			mab := midpoint(a, b)
-			mbc := midpoint(b, c)
-			t++
-			ds[t+0] = depth + 1
-			ds[t-1] = depth + 1
-			ps[2*t+2] = a
-			ps[2*t+1] = mab
-			ps[2*t+0] = midpoint(mab, mbc)
-			ps[2*t-1] = mbc
-			continue
-		} else {
-			// Translate the control points.
-			bnorm := pRot90CCW(pNorm(c.Sub(a), k.u))
-			cnorm = pRot90CCW(pNorm(bc, k.u))
-			k.p.Add2(b.Add(bnorm), c.Add(cnorm))
-			k.r.Add2(b.Sub(bnorm), c.Sub(cnorm))
-		}
-		if t == 0 {
-			k.a, k.anorm = c, cnorm
-			return
-		}
-		t--
-		anorm = cnorm
-	}
-	panic("unreachable")
-}
-
-// Add1 adds a linear segment to the stroker.
-func (k *stroker) Add1(b fixed.Point26_6) {
-	bnorm := pRot90CCW(pNorm(b.Sub(k.a), k.u))
-	if len(k.r) == 0 {
-		k.p.Start(k.a.Add(bnorm))
-		k.r.Start(k.a.Sub(bnorm))
-	} else {
-		k.jr.Join(k.p, &k.r, k.u, k.a, k.anorm, bnorm)
-	}
-	k.p.Add1(b.Add(bnorm))
-	k.r.Add1(b.Sub(bnorm))
-	k.a, k.anorm = b, bnorm
-}
-
-// Add2 adds a quadratic segment to the stroker.
-func (k *stroker) Add2(b, c fixed.Point26_6) {
-	ab := b.Sub(k.a)
-	bc := c.Sub(b)
-	abnorm := pRot90CCW(pNorm(ab, k.u))
-	if len(k.r) == 0 {
-		k.p.Start(k.a.Add(abnorm))
-		k.r.Start(k.a.Sub(abnorm))
-	} else {
-		k.jr.Join(k.p, &k.r, k.u, k.a, k.anorm, abnorm)
-	}
-
-	// Approximate nearly-degenerate quadratics by linear segments.
-	abIsSmall := pDot(ab, ab) < epsilon
-	bcIsSmall := pDot(bc, bc) < epsilon
-	if abIsSmall || bcIsSmall {
-		acnorm := pRot90CCW(pNorm(c.Sub(k.a), k.u))
-		k.p.Add1(c.Add(acnorm))
-		k.r.Add1(c.Sub(acnorm))
-		k.a, k.anorm = c, acnorm
-		return
-	}
-
-	// The quadratic segment (k.a, b, c) has a point of maximum curvature.
-	// If this occurs at an end point, we process the segment as a whole.
-	t := curviest2(k.a, b, c)
-	if t <= 0 || 4096 <= t {
-		k.addNonCurvy2(b, c)
-		return
-	}
-
-	// Otherwise, we perform a de Casteljau decomposition at the point of
-	// maximum curvature and process the two straighter parts.
-	mab := interpolate(k.a, b, t)
-	mbc := interpolate(b, c, t)
-	mabc := interpolate(mab, mbc, t)
-
-	// If the vectors ab and bc are close to being in opposite directions,
-	// then the decomposition can become unstable, so we approximate the
-	// quadratic segment by two linear segments joined by an arc.
-	bcnorm := pRot90CCW(pNorm(bc, k.u))
-	if pDot(abnorm, bcnorm) < -fixed.Int52_12(k.u)*fixed.Int52_12(k.u)*2047/2048 {
-		pArc := pDot(abnorm, bc) < 0
-
-		k.p.Add1(mabc.Add(abnorm))
-		if pArc {
-			z := pRot90CW(abnorm)
-			addArc(k.p, mabc, abnorm, z)
-			addArc(k.p, mabc, z, bcnorm)
-		}
-		k.p.Add1(mabc.Add(bcnorm))
-		k.p.Add1(c.Add(bcnorm))
-
-		k.r.Add1(mabc.Sub(abnorm))
-		if !pArc {
-			z := pRot90CW(abnorm)
-			addArc(&k.r, mabc, pNeg(abnorm), z)
-			addArc(&k.r, mabc, z, pNeg(bcnorm))
-		}
-		k.r.Add1(mabc.Sub(bcnorm))
-		k.r.Add1(c.Sub(bcnorm))
-
-		k.a, k.anorm = c, bcnorm
-		return
-	}
-
-	// Process the decomposed parts.
-	k.addNonCurvy2(mab, mabc)
-	k.addNonCurvy2(mbc, c)
-}
-
-// Add3 adds a cubic segment to the stroker.
-func (k *stroker) Add3(b, c, d fixed.Point26_6) {
-	panic("freetype/raster: stroke unimplemented for cubic segments")
-}
-
-// stroke adds the stroked Path q to p, where q consists of exactly one curve.
-func (k *stroker) stroke(q Path) {
-	// Stroking is implemented by deriving two paths each k.u apart from q.
-	// The left-hand-side path is added immediately to k.p; the right-hand-side
-	// path is accumulated in k.r. Once we've finished adding the LHS to k.p,
-	// we add the RHS in reverse order.
-	k.r = make(Path, 0, len(q))
-	k.a = fixed.Point26_6{q[1], q[2]}
-	for i := 4; i < len(q); {
-		switch q[i] {
-		case 1:
-			k.Add1(
-				fixed.Point26_6{q[i+1], q[i+2]},
-			)
-			i += 4
-		case 2:
-			k.Add2(
-				fixed.Point26_6{q[i+1], q[i+2]},
-				fixed.Point26_6{q[i+3], q[i+4]},
-			)
-			i += 6
-		case 3:
-			k.Add3(
-				fixed.Point26_6{q[i+1], q[i+2]},
-				fixed.Point26_6{q[i+3], q[i+4]},
-				fixed.Point26_6{q[i+5], q[i+6]},
-			)
-			i += 8
-		default:
-			panic("freetype/raster: bad path")
-		}
-	}
-	if len(k.r) == 0 {
-		return
-	}
-	// TODO(nigeltao): if q is a closed curve then we should join the first and
-	// last segments instead of capping them.
-	k.cr.Cap(k.p, k.u, q.lastPoint(), pNeg(k.anorm))
-	addPathReversed(k.p, k.r)
-	pivot := q.firstPoint()
-	k.cr.Cap(k.p, k.u, pivot, pivot.Sub(fixed.Point26_6{k.r[1], k.r[2]}))
-}
-
-// Stroke adds q stroked with the given width to p. The result is typically
-// self-intersecting and should be rasterized with UseNonZeroWinding.
-// cr and jr may be nil, which defaults to a RoundCapper or RoundJoiner.
-func Stroke(p Adder, q Path, width fixed.Int26_6, cr Capper, jr Joiner) {
-	if len(q) == 0 {
-		return
-	}
-	if cr == nil {
-		cr = RoundCapper
-	}
-	if jr == nil {
-		jr = RoundJoiner
-	}
-	if q[0] != 0 {
-		panic("freetype/raster: bad path")
-	}
-	s := stroker{p: p, u: width / 2, cr: cr, jr: jr}
-	i := 0
-	for j := 4; j < len(q); {
-		switch q[j] {
-		case 0:
-			s.stroke(q[i:j])
-			i, j = j, j+4
-		case 1:
-			j += 4
-		case 2:
-			j += 6
-		case 3:
-			j += 8
-		default:
-			panic("freetype/raster: bad path")
-		}
-	}
-	s.stroke(q[i:])
-}

vendor/github.com/golang/freetype/truetype/face.go

@@ -1,507 +0,0 @@
-// Copyright 2015 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package truetype
-
-import (
-	"image"
-	"math"
-
-	"github.com/golang/freetype/raster"
-	"golang.org/x/image/font"
-	"golang.org/x/image/math/fixed"
-)
-
-func powerOf2(i int) bool {
-	return i != 0 && (i&(i-1)) == 0
-}
-
-// Options are optional arguments to NewFace.
-type Options struct {
-	// Size is the font size in points, as in "a 10 point font size".
-	//
-	// A zero value means to use a 12 point font size.
-	Size float64
-
-	// DPI is the dots-per-inch resolution.
-	//
-	// A zero value means to use 72 DPI.
-	DPI float64
-
-	// Hinting is how to quantize the glyph nodes.
-	//
-	// A zero value means to use no hinting.
-	Hinting font.Hinting
-
-	// GlyphCacheEntries is the number of entries in the glyph mask image
-	// cache.
-	//
-	// If non-zero, it must be a power of 2.
-	//
-	// A zero value means to use 512 entries.
-	GlyphCacheEntries int
-
-	// SubPixelsX is the number of sub-pixel locations a glyph's dot is
-	// quantized to, in the horizontal direction. For example, a value of 8
-	// means that the dot is quantized to 1/8th of a pixel. This quantization
-	// only affects the glyph mask image, not its bounding box or advance
-	// width. A higher value gives a more faithful glyph image, but reduces the
-	// effectiveness of the glyph cache.
-	//
-	// If non-zero, it must be a power of 2, and be between 1 and 64 inclusive.
-	//
-	// A zero value means to use 4 sub-pixel locations.
-	SubPixelsX int
-
-	// SubPixelsY is the number of sub-pixel locations a glyph's dot is
-	// quantized to, in the vertical direction. For example, a value of 8
-	// means that the dot is quantized to 1/8th of a pixel. This quantization
-	// only affects the glyph mask image, not its bounding box or advance
-	// width. A higher value gives a more faithful glyph image, but reduces the
-	// effectiveness of the glyph cache.
-	//
-	// If non-zero, it must be a power of 2, and be between 1 and 64 inclusive.
-	//
-	// A zero value means to use 1 sub-pixel location.
-	SubPixelsY int
-}
-
-func (o *Options) size() float64 {
-	if o != nil && o.Size > 0 {
-		return o.Size
-	}
-	return 12
-}
-
-func (o *Options) dpi() float64 {
-	if o != nil && o.DPI > 0 {
-		return o.DPI
-	}
-	return 72
-}
-
-func (o *Options) hinting() font.Hinting {
-	if o != nil {
-		switch o.Hinting {
-		case font.HintingVertical, font.HintingFull:
-			// TODO: support vertical hinting.
-			return font.HintingFull
-		}
-	}
-	return font.HintingNone
-}
-
-func (o *Options) glyphCacheEntries() int {
-	if o != nil && powerOf2(o.GlyphCacheEntries) {
-		return o.GlyphCacheEntries
-	}
-	// 512 is 128 * 4 * 1, which lets us cache 128 glyphs at 4 * 1 subpixel
-	// locations in the X and Y direction.
-	return 512
-}
-
-func (o *Options) subPixelsX() (value uint32, halfQuantum, mask fixed.Int26_6) {
-	if o != nil {
-		switch o.SubPixelsX {
-		case 1, 2, 4, 8, 16, 32, 64:
-			return subPixels(o.SubPixelsX)
-		}
-	}
-	// This default value of 4 isn't based on anything scientific, merely as
-	// small a number as possible that looks almost as good as no quantization,
-	// or returning subPixels(64).
-	return subPixels(4)
-}
-
-func (o *Options) subPixelsY() (value uint32, halfQuantum, mask fixed.Int26_6) {
-	if o != nil {
-		switch o.SubPixelsX {
-		case 1, 2, 4, 8, 16, 32, 64:
-			return subPixels(o.SubPixelsX)
-		}
-	}
-	// This default value of 1 isn't based on anything scientific, merely that
-	// vertical sub-pixel glyph rendering is pretty rare. Baseline locations
-	// can usually afford to snap to the pixel grid, so the vertical direction
-	// doesn't have the deal with the horizontal's fractional advance widths.
-	return subPixels(1)
-}
-
-// subPixels returns q and the bias and mask that leads to q quantized
-// sub-pixel locations per full pixel.
-//
-// For example, q == 4 leads to a bias of 8 and a mask of 0xfffffff0, or -16,
-// because we want to round fractions of fixed.Int26_6 as:
-//	-  0 to  7 rounds to 0.
-//	-  8 to 23 rounds to 16.
-//	- 24 to 39 rounds to 32.
-//	- 40 to 55 rounds to 48.
-//	- 56 to 63 rounds to 64.
-// which means to add 8 and then bitwise-and with -16, in two's complement
-// representation.
-//
-// When q ==  1, we want bias == 32 and mask == -64.
-// When q ==  2, we want bias == 16 and mask == -32.
-// When q ==  4, we want bias ==  8 and mask == -16.
-// ...
-// When q == 64, we want bias ==  0 and mask ==  -1. (The no-op case).
-// The pattern is clear.
-func subPixels(q int) (value uint32, bias, mask fixed.Int26_6) {
-	return uint32(q), 32 / fixed.Int26_6(q), -64 / fixed.Int26_6(q)
-}
-
-// glyphCacheEntry caches the arguments and return values of rasterize.
-type glyphCacheEntry struct {
-	key glyphCacheKey
-	val glyphCacheVal
-}
-
-type glyphCacheKey struct {
-	index  Index
-	fx, fy uint8
-}
-
-type glyphCacheVal struct {
-	advanceWidth fixed.Int26_6
-	offset       image.Point
-	gw           int
-	gh           int
-}
-
-type indexCacheEntry struct {
-	rune  rune
-	index Index
-}
-
-// NewFace returns a new font.Face for the given Font.
-func NewFace(f *Font, opts *Options) font.Face {
-	a := &face{
-		f:          f,
-		hinting:    opts.hinting(),
-		scale:      fixed.Int26_6(0.5 + (opts.size() * opts.dpi() * 64 / 72)),
-		glyphCache: make([]glyphCacheEntry, opts.glyphCacheEntries()),
-	}
-	a.subPixelX, a.subPixelBiasX, a.subPixelMaskX = opts.subPixelsX()
-	a.subPixelY, a.subPixelBiasY, a.subPixelMaskY = opts.subPixelsY()
-
-	// Fill the cache with invalid entries. Valid glyph cache entries have fx
-	// and fy in the range [0, 64). Valid index cache entries have rune >= 0.
-	for i := range a.glyphCache {
-		a.glyphCache[i].key.fy = 0xff
-	}
-	for i := range a.indexCache {
-		a.indexCache[i].rune = -1
-	}
-
-	// Set the rasterizer's bounds to be big enough to handle the largest glyph.
-	b := f.Bounds(a.scale)
-	xmin := +int(b.Min.X) >> 6
-	ymin := -int(b.Max.Y) >> 6
-	xmax := +int(b.Max.X+63) >> 6
-	ymax := -int(b.Min.Y-63) >> 6
-	a.maxw = xmax - xmin
-	a.maxh = ymax - ymin
-	a.masks = image.NewAlpha(image.Rect(0, 0, a.maxw, a.maxh*len(a.glyphCache)))
-	a.r.SetBounds(a.maxw, a.maxh)
-	a.p = facePainter{a}
-
-	return a
-}
-
-type face struct {
-	f             *Font
-	hinting       font.Hinting
-	scale         fixed.Int26_6
-	subPixelX     uint32
-	subPixelBiasX fixed.Int26_6
-	subPixelMaskX fixed.Int26_6
-	subPixelY     uint32
-	subPixelBiasY fixed.Int26_6
-	subPixelMaskY fixed.Int26_6
-	masks         *image.Alpha
-	glyphCache    []glyphCacheEntry
-	r             raster.Rasterizer
-	p             raster.Painter
-	paintOffset   int
-	maxw          int
-	maxh          int
-	glyphBuf      GlyphBuf
-	indexCache    [indexCacheLen]indexCacheEntry
-
-	// TODO: clip rectangle?
-}
-
-const indexCacheLen = 256
-
-func (a *face) index(r rune) Index {
-	const mask = indexCacheLen - 1
-	c := &a.indexCache[r&mask]
-	if c.rune == r {
-		return c.index
-	}
-	i := a.f.Index(r)
-	c.rune = r
-	c.index = i
-	return i
-}
-
-// Close satisfies the font.Face interface.
-func (a *face) Close() error { return nil }
-
-// Metrics satisfies the font.Face interface.
-func (a *face) Metrics() font.Metrics {
-	scale := float64(a.scale)
-	fupe := float64(a.f.FUnitsPerEm())
-	return font.Metrics{
-		Height:  a.scale,
-		Ascent:  fixed.Int26_6(math.Ceil(scale * float64(+a.f.ascent) / fupe)),
-		Descent: fixed.Int26_6(math.Ceil(scale * float64(-a.f.descent) / fupe)),
-	}
-}
-
-// Kern satisfies the font.Face interface.
-func (a *face) Kern(r0, r1 rune) fixed.Int26_6 {
-	i0 := a.index(r0)
-	i1 := a.index(r1)
-	kern := a.f.Kern(a.scale, i0, i1)
-	if a.hinting != font.HintingNone {
-		kern = (kern + 32) &^ 63
-	}
-	return kern
-}
-
-// Glyph satisfies the font.Face interface.
-func (a *face) Glyph(dot fixed.Point26_6, r rune) (
-	dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
-
-	// Quantize to the sub-pixel granularity.
-	dotX := (dot.X + a.subPixelBiasX) & a.subPixelMaskX
-	dotY := (dot.Y + a.subPixelBiasY) & a.subPixelMaskY
-
-	// Split the coordinates into their integer and fractional parts.
-	ix, fx := int(dotX>>6), dotX&0x3f
-	iy, fy := int(dotY>>6), dotY&0x3f
-
-	index := a.index(r)
-	cIndex := uint32(index)
-	cIndex = cIndex*a.subPixelX - uint32(fx/a.subPixelMaskX)
-	cIndex = cIndex*a.subPixelY - uint32(fy/a.subPixelMaskY)
-	cIndex &= uint32(len(a.glyphCache) - 1)
-	a.paintOffset = a.maxh * int(cIndex)
-	k := glyphCacheKey{
-		index: index,
-		fx:    uint8(fx),
-		fy:    uint8(fy),
-	}
-	var v glyphCacheVal
-	if a.glyphCache[cIndex].key != k {
-		var ok bool
-		v, ok = a.rasterize(index, fx, fy)
-		if !ok {
-			return image.Rectangle{}, nil, image.Point{}, 0, false
-		}
-		a.glyphCache[cIndex] = glyphCacheEntry{k, v}
-	} else {
-		v = a.glyphCache[cIndex].val
-	}
-
-	dr.Min = image.Point{
-		X: ix + v.offset.X,
-		Y: iy + v.offset.Y,
-	}
-	dr.Max = image.Point{
-		X: dr.Min.X + v.gw,
-		Y: dr.Min.Y + v.gh,
-	}
-	return dr, a.masks, image.Point{Y: a.paintOffset}, v.advanceWidth, true
-}
-
-func (a *face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
-	if err := a.glyphBuf.Load(a.f, a.scale, a.index(r), a.hinting); err != nil {
-		return fixed.Rectangle26_6{}, 0, false
-	}
-	xmin := +a.glyphBuf.Bounds.Min.X
-	ymin := -a.glyphBuf.Bounds.Max.Y
-	xmax := +a.glyphBuf.Bounds.Max.X
-	ymax := -a.glyphBuf.Bounds.Min.Y
-	if xmin > xmax || ymin > ymax {
-		return fixed.Rectangle26_6{}, 0, false
-	}
-	return fixed.Rectangle26_6{
-		Min: fixed.Point26_6{
-			X: xmin,
-			Y: ymin,
-		},
-		Max: fixed.Point26_6{
-			X: xmax,
-			Y: ymax,
-		},
-	}, a.glyphBuf.AdvanceWidth, true
-}
-
-func (a *face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
-	if err := a.glyphBuf.Load(a.f, a.scale, a.index(r), a.hinting); err != nil {
-		return 0, false
-	}
-	return a.glyphBuf.AdvanceWidth, true
-}
-
-// rasterize returns the advance width, integer-pixel offset to render at, and
-// the width and height of the given glyph at the given sub-pixel offsets.
-//
-// The 26.6 fixed point arguments fx and fy must be in the range [0, 1).
-func (a *face) rasterize(index Index, fx, fy fixed.Int26_6) (v glyphCacheVal, ok bool) {
-	if err := a.glyphBuf.Load(a.f, a.scale, index, a.hinting); err != nil {
-		return glyphCacheVal{}, false
-	}
-	// Calculate the integer-pixel bounds for the glyph.
-	xmin := int(fx+a.glyphBuf.Bounds.Min.X) >> 6
-	ymin := int(fy-a.glyphBuf.Bounds.Max.Y) >> 6
-	xmax := int(fx+a.glyphBuf.Bounds.Max.X+0x3f) >> 6
-	ymax := int(fy-a.glyphBuf.Bounds.Min.Y+0x3f) >> 6
-	if xmin > xmax || ymin > ymax {
-		return glyphCacheVal{}, false
-	}
-	// A TrueType's glyph's nodes can have negative co-ordinates, but the
-	// rasterizer clips anything left of x=0 or above y=0. xmin and ymin are
-	// the pixel offsets, based on the font's FUnit metrics, that let a
-	// negative co-ordinate in TrueType space be non-negative in rasterizer
-	// space. xmin and ymin are typically <= 0.
-	fx -= fixed.Int26_6(xmin << 6)
-	fy -= fixed.Int26_6(ymin << 6)
-	// Rasterize the glyph's vectors.
-	a.r.Clear()
-	pixOffset := a.paintOffset * a.maxw
-	clear(a.masks.Pix[pixOffset : pixOffset+a.maxw*a.maxh])
-	e0 := 0
-	for _, e1 := range a.glyphBuf.Ends {
-		a.drawContour(a.glyphBuf.Points[e0:e1], fx, fy)
-		e0 = e1
-	}
-	a.r.Rasterize(a.p)
-	return glyphCacheVal{
-		a.glyphBuf.AdvanceWidth,
-		image.Point{xmin, ymin},
-		xmax - xmin,
-		ymax - ymin,
-	}, true
-}
-
-func clear(pix []byte) {
-	for i := range pix {
-		pix[i] = 0
-	}
-}
-
-// drawContour draws the given closed contour with the given offset.
-func (a *face) drawContour(ps []Point, dx, dy fixed.Int26_6) {
-	if len(ps) == 0 {
-		return
-	}
-
-	// The low bit of each point's Flags value is whether the point is on the
-	// curve. Truetype fonts only have quadratic Bézier curves, not cubics.
-	// Thus, two consecutive off-curve points imply an on-curve point in the
-	// middle of those two.
-	//
-	// See http://chanae.walon.org/pub/ttf/ttf_glyphs.htm for more details.
-
-	// ps[0] is a truetype.Point measured in FUnits and positive Y going
-	// upwards. start is the same thing measured in fixed point units and
-	// positive Y going downwards, and offset by (dx, dy).
-	start := fixed.Point26_6{
-		X: dx + ps[0].X,
-		Y: dy - ps[0].Y,
-	}
-	var others []Point
-	if ps[0].Flags&0x01 != 0 {
-		others = ps[1:]
-	} else {
-		last := fixed.Point26_6{
-			X: dx + ps[len(ps)-1].X,
-			Y: dy - ps[len(ps)-1].Y,
-		}
-		if ps[len(ps)-1].Flags&0x01 != 0 {
-			start = last
-			others = ps[:len(ps)-1]
-		} else {
-			start = fixed.Point26_6{
-				X: (start.X + last.X) / 2,
-				Y: (start.Y + last.Y) / 2,
-			}
-			others = ps
-		}
-	}
-	a.r.Start(start)
-	q0, on0 := start, true
-	for _, p := range others {
-		q := fixed.Point26_6{
-			X: dx + p.X,
-			Y: dy - p.Y,
-		}
-		on := p.Flags&0x01 != 0
-		if on {
-			if on0 {
-				a.r.Add1(q)
-			} else {
-				a.r.Add2(q0, q)
-			}
-		} else {
-			if on0 {
-				// No-op.
-			} else {
-				mid := fixed.Point26_6{
-					X: (q0.X + q.X) / 2,
-					Y: (q0.Y + q.Y) / 2,
-				}
-				a.r.Add2(q0, mid)
-			}
-		}
-		q0, on0 = q, on
-	}
-	// Close the curve.
-	if on0 {
-		a.r.Add1(start)
-	} else {
-		a.r.Add2(q0, start)
-	}
-}
-
-// facePainter is like a raster.AlphaSrcPainter, with an additional Y offset
-// (face.paintOffset) to the painted spans.
-type facePainter struct {
-	a *face
-}
-
-func (p facePainter) Paint(ss []raster.Span, done bool) {
-	m := p.a.masks
-	b := m.Bounds()
-	b.Min.Y = p.a.paintOffset
-	b.Max.Y = p.a.paintOffset + p.a.maxh
-	for _, s := range ss {
-		s.Y += p.a.paintOffset
-		if s.Y < b.Min.Y {
-			continue
-		}
-		if s.Y >= b.Max.Y {
-			return
-		}
-		if s.X0 < b.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > b.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-		base := (s.Y-m.Rect.Min.Y)*m.Stride - m.Rect.Min.X
-		p := m.Pix[base+s.X0 : base+s.X1]
-		color := uint8(s.Alpha >> 8)
-		for i := range p {
-			p[i] = color
-		}
-	}
-}

vendor/github.com/golang/freetype/truetype/glyph.go

@@ -1,517 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package truetype
-
-import (
-	"golang.org/x/image/font"
-	"golang.org/x/image/math/fixed"
-)
-
-// TODO: implement VerticalHinting.
-
-// A Point is a co-ordinate pair plus whether it is 'on' a contour or an 'off'
-// control point.
-type Point struct {
-	X, Y fixed.Int26_6
-	// The Flags' LSB means whether or not this Point is 'on' the contour.
-	// Other bits are reserved for internal use.
-	Flags uint32
-}
-
-// A GlyphBuf holds a glyph's contours. A GlyphBuf can be re-used to load a
-// series of glyphs from a Font.
-type GlyphBuf struct {
-	// AdvanceWidth is the glyph's advance width.
-	AdvanceWidth fixed.Int26_6
-	// Bounds is the glyph's bounding box.
-	Bounds fixed.Rectangle26_6
-	// Points contains all Points from all contours of the glyph. If hinting
-	// was used to load a glyph then Unhinted contains those Points before they
-	// were hinted, and InFontUnits contains those Points before they were
-	// hinted and scaled.
-	Points, Unhinted, InFontUnits []Point
-	// Ends is the point indexes of the end point of each contour. The length
-	// of Ends is the number of contours in the glyph. The i'th contour
-	// consists of points Points[Ends[i-1]:Ends[i]], where Ends[-1] is
-	// interpreted to mean zero.
-	Ends []int
-
-	font    *Font
-	scale   fixed.Int26_6
-	hinting font.Hinting
-	hinter  hinter
-	// phantomPoints are the co-ordinates of the synthetic phantom points
-	// used for hinting and bounding box calculations.
-	phantomPoints [4]Point
-	// pp1x is the X co-ordinate of the first phantom point. The '1' is
-	// using 1-based indexing; pp1x is almost always phantomPoints[0].X.
-	// TODO: eliminate this and consistently use phantomPoints[0].X.
-	pp1x fixed.Int26_6
-	// metricsSet is whether the glyph's metrics have been set yet. For a
-	// compound glyph, a sub-glyph may override the outer glyph's metrics.
-	metricsSet bool
-	// tmp is a scratch buffer.
-	tmp []Point
-}
-
-// Flags for decoding a glyph's contours. These flags are documented at
-// http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html.
-const (
-	flagOnCurve = 1 << iota
-	flagXShortVector
-	flagYShortVector
-	flagRepeat
-	flagPositiveXShortVector
-	flagPositiveYShortVector
-
-	// The remaining flags are for internal use.
-	flagTouchedX
-	flagTouchedY
-)
-
-// The same flag bits (0x10 and 0x20) are overloaded to have two meanings,
-// dependent on the value of the flag{X,Y}ShortVector bits.
-const (
-	flagThisXIsSame = flagPositiveXShortVector
-	flagThisYIsSame = flagPositiveYShortVector
-)
-
-// Load loads a glyph's contours from a Font, overwriting any previously loaded
-// contours for this GlyphBuf. scale is the number of 26.6 fixed point units in
-// 1 em, i is the glyph index, and h is the hinting policy.
-func (g *GlyphBuf) Load(f *Font, scale fixed.Int26_6, i Index, h font.Hinting) error {
-	g.Points = g.Points[:0]
-	g.Unhinted = g.Unhinted[:0]
-	g.InFontUnits = g.InFontUnits[:0]
-	g.Ends = g.Ends[:0]
-	g.font = f
-	g.hinting = h
-	g.scale = scale
-	g.pp1x = 0
-	g.phantomPoints = [4]Point{}
-	g.metricsSet = false
-
-	if h != font.HintingNone {
-		if err := g.hinter.init(f, scale); err != nil {
-			return err
-		}
-	}
-	if err := g.load(0, i, true); err != nil {
-		return err
-	}
-	// TODO: this selection of either g.pp1x or g.phantomPoints[0].X isn't ideal,
-	// and should be cleaned up once we have all the testScaling tests passing,
-	// plus additional tests for Freetype-Go's bounding boxes matching C Freetype's.
-	pp1x := g.pp1x
-	if h != font.HintingNone {
-		pp1x = g.phantomPoints[0].X
-	}
-	if pp1x != 0 {
-		for i := range g.Points {
-			g.Points[i].X -= pp1x
-		}
-	}
-
-	advanceWidth := g.phantomPoints[1].X - g.phantomPoints[0].X
-	if h != font.HintingNone {
-		if len(f.hdmx) >= 8 {
-			if n := u32(f.hdmx, 4); n > 3+uint32(i) {
-				for hdmx := f.hdmx[8:]; uint32(len(hdmx)) >= n; hdmx = hdmx[n:] {
-					if fixed.Int26_6(hdmx[0]) == scale>>6 {
-						advanceWidth = fixed.Int26_6(hdmx[2+i]) << 6
-						break
-					}
-				}
-			}
-		}
-		advanceWidth = (advanceWidth + 32) &^ 63
-	}
-	g.AdvanceWidth = advanceWidth
-
-	// Set g.Bounds to the 'control box', which is the bounding box of the
-	// Bézier curves' control points. This is easier to calculate, no smaller
-	// than and often equal to the tightest possible bounding box of the curves
-	// themselves. This approach is what C Freetype does. We can't just scale
-	// the nominal bounding box in the glyf data as the hinting process and
-	// phantom point adjustment may move points outside of that box.
-	if len(g.Points) == 0 {
-		g.Bounds = fixed.Rectangle26_6{}
-	} else {
-		p := g.Points[0]
-		g.Bounds.Min.X = p.X
-		g.Bounds.Max.X = p.X
-		g.Bounds.Min.Y = p.Y
-		g.Bounds.Max.Y = p.Y
-		for _, p := range g.Points[1:] {
-			if g.Bounds.Min.X > p.X {
-				g.Bounds.Min.X = p.X
-			} else if g.Bounds.Max.X < p.X {
-				g.Bounds.Max.X = p.X
-			}
-			if g.Bounds.Min.Y > p.Y {
-				g.Bounds.Min.Y = p.Y
-			} else if g.Bounds.Max.Y < p.Y {
-				g.Bounds.Max.Y = p.Y
-			}
-		}
-		// Snap the box to the grid, if hinting is on.
-		if h != font.HintingNone {
-			g.Bounds.Min.X &^= 63
-			g.Bounds.Min.Y &^= 63
-			g.Bounds.Max.X += 63
-			g.Bounds.Max.X &^= 63
-			g.Bounds.Max.Y += 63
-			g.Bounds.Max.Y &^= 63
-		}
-	}
-	return nil
-}
-
-func (g *GlyphBuf) load(recursion uint32, i Index, useMyMetrics bool) (err error) {
-	// The recursion limit here is arbitrary, but defends against malformed glyphs.
-	if recursion >= 32 {
-		return UnsupportedError("excessive compound glyph recursion")
-	}
-	// Find the relevant slice of g.font.glyf.
-	var g0, g1 uint32
-	if g.font.locaOffsetFormat == locaOffsetFormatShort {
-		g0 = 2 * uint32(u16(g.font.loca, 2*int(i)))
-		g1 = 2 * uint32(u16(g.font.loca, 2*int(i)+2))
-	} else {
-		g0 = u32(g.font.loca, 4*int(i))
-		g1 = u32(g.font.loca, 4*int(i)+4)
-	}
-
-	// Decode the contour count and nominal bounding box, from the first
-	// 10 bytes of the glyf data. boundsYMin and boundsXMax, at offsets 4
-	// and 6, are unused.
-	glyf, ne, boundsXMin, boundsYMax := []byte(nil), 0, fixed.Int26_6(0), fixed.Int26_6(0)
-	if g0+10 <= g1 {
-		glyf = g.font.glyf[g0:g1]
-		ne = int(int16(u16(glyf, 0)))
-		boundsXMin = fixed.Int26_6(int16(u16(glyf, 2)))
-		boundsYMax = fixed.Int26_6(int16(u16(glyf, 8)))
-	}
-
-	// Create the phantom points.
-	uhm, pp1x := g.font.unscaledHMetric(i), fixed.Int26_6(0)
-	uvm := g.font.unscaledVMetric(i, boundsYMax)
-	g.phantomPoints = [4]Point{
-		{X: boundsXMin - uhm.LeftSideBearing},
-		{X: boundsXMin - uhm.LeftSideBearing + uhm.AdvanceWidth},
-		{X: uhm.AdvanceWidth / 2, Y: boundsYMax + uvm.TopSideBearing},
-		{X: uhm.AdvanceWidth / 2, Y: boundsYMax + uvm.TopSideBearing - uvm.AdvanceHeight},
-	}
-	if len(glyf) == 0 {
-		g.addPhantomsAndScale(len(g.Points), len(g.Points), true, true)
-		copy(g.phantomPoints[:], g.Points[len(g.Points)-4:])
-		g.Points = g.Points[:len(g.Points)-4]
-		return nil
-	}
-
-	// Load and hint the contours.
-	if ne < 0 {
-		if ne != -1 {
-			// http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html says that
-			// "the values -2, -3, and so forth, are reserved for future use."
-			return UnsupportedError("negative number of contours")
-		}
-		pp1x = g.font.scale(g.scale * (boundsXMin - uhm.LeftSideBearing))
-		if err := g.loadCompound(recursion, uhm, i, glyf, useMyMetrics); err != nil {
-			return err
-		}
-	} else {
-		np0, ne0 := len(g.Points), len(g.Ends)
-		program := g.loadSimple(glyf, ne)
-		g.addPhantomsAndScale(np0, np0, true, true)
-		pp1x = g.Points[len(g.Points)-4].X
-		if g.hinting != font.HintingNone {
-			if len(program) != 0 {
-				err := g.hinter.run(
-					program,
-					g.Points[np0:],
-					g.Unhinted[np0:],
-					g.InFontUnits[np0:],
-					g.Ends[ne0:],
-				)
-				if err != nil {
-					return err
-				}
-			}
-			// Drop the four phantom points.
-			g.InFontUnits = g.InFontUnits[:len(g.InFontUnits)-4]
-			g.Unhinted = g.Unhinted[:len(g.Unhinted)-4]
-		}
-		if useMyMetrics {
-			copy(g.phantomPoints[:], g.Points[len(g.Points)-4:])
-		}
-		g.Points = g.Points[:len(g.Points)-4]
-		if np0 != 0 {
-			// The hinting program expects the []Ends values to be indexed
-			// relative to the inner glyph, not the outer glyph, so we delay
-			// adding np0 until after the hinting program (if any) has run.
-			for i := ne0; i < len(g.Ends); i++ {
-				g.Ends[i] += np0
-			}
-		}
-	}
-	if useMyMetrics && !g.metricsSet {
-		g.metricsSet = true
-		g.pp1x = pp1x
-	}
-	return nil
-}
-
-// loadOffset is the initial offset for loadSimple and loadCompound. The first
-// 10 bytes are the number of contours and the bounding box.
-const loadOffset = 10
-
-func (g *GlyphBuf) loadSimple(glyf []byte, ne int) (program []byte) {
-	offset := loadOffset
-	for i := 0; i < ne; i++ {
-		g.Ends = append(g.Ends, 1+int(u16(glyf, offset)))
-		offset += 2
-	}
-
-	// Note the TrueType hinting instructions.
-	instrLen := int(u16(glyf, offset))
-	offset += 2
-	program = glyf[offset : offset+instrLen]
-	offset += instrLen
-
-	np0 := len(g.Points)
-	np1 := np0 + int(g.Ends[len(g.Ends)-1])
-
-	// Decode the flags.
-	for i := np0; i < np1; {
-		c := uint32(glyf[offset])
-		offset++
-		g.Points = append(g.Points, Point{Flags: c})
-		i++
-		if c&flagRepeat != 0 {
-			count := glyf[offset]
-			offset++
-			for ; count > 0; count-- {
-				g.Points = append(g.Points, Point{Flags: c})
-				i++
-			}
-		}
-	}
-
-	// Decode the co-ordinates.
-	var x int16
-	for i := np0; i < np1; i++ {
-		f := g.Points[i].Flags
-		if f&flagXShortVector != 0 {
-			dx := int16(glyf[offset])
-			offset++
-			if f&flagPositiveXShortVector == 0 {
-				x -= dx
-			} else {
-				x += dx
-			}
-		} else if f&flagThisXIsSame == 0 {
-			x += int16(u16(glyf, offset))
-			offset += 2
-		}
-		g.Points[i].X = fixed.Int26_6(x)
-	}
-	var y int16
-	for i := np0; i < np1; i++ {
-		f := g.Points[i].Flags
-		if f&flagYShortVector != 0 {
-			dy := int16(glyf[offset])
-			offset++
-			if f&flagPositiveYShortVector == 0 {
-				y -= dy
-			} else {
-				y += dy
-			}
-		} else if f&flagThisYIsSame == 0 {
-			y += int16(u16(glyf, offset))
-			offset += 2
-		}
-		g.Points[i].Y = fixed.Int26_6(y)
-	}
-
-	return program
-}
-
-func (g *GlyphBuf) loadCompound(recursion uint32, uhm HMetric, i Index,
-	glyf []byte, useMyMetrics bool) error {
-
-	// Flags for decoding a compound glyph. These flags are documented at
-	// http://developer.apple.com/fonts/TTRefMan/RM06/Chap6glyf.html.
-	const (
-		flagArg1And2AreWords = 1 << iota
-		flagArgsAreXYValues
-		flagRoundXYToGrid
-		flagWeHaveAScale
-		flagUnused
-		flagMoreComponents
-		flagWeHaveAnXAndYScale
-		flagWeHaveATwoByTwo
-		flagWeHaveInstructions
-		flagUseMyMetrics
-		flagOverlapCompound
-	)
-	np0, ne0 := len(g.Points), len(g.Ends)
-	offset := loadOffset
-	for {
-		flags := u16(glyf, offset)
-		component := Index(u16(glyf, offset+2))
-		dx, dy, transform, hasTransform := fixed.Int26_6(0), fixed.Int26_6(0), [4]int16{}, false
-		if flags&flagArg1And2AreWords != 0 {
-			dx = fixed.Int26_6(int16(u16(glyf, offset+4)))
-			dy = fixed.Int26_6(int16(u16(glyf, offset+6)))
-			offset += 8
-		} else {
-			dx = fixed.Int26_6(int16(int8(glyf[offset+4])))
-			dy = fixed.Int26_6(int16(int8(glyf[offset+5])))
-			offset += 6
-		}
-		if flags&flagArgsAreXYValues == 0 {
-			return UnsupportedError("compound glyph transform vector")
-		}
-		if flags&(flagWeHaveAScale|flagWeHaveAnXAndYScale|flagWeHaveATwoByTwo) != 0 {
-			hasTransform = true
-			switch {
-			case flags&flagWeHaveAScale != 0:
-				transform[0] = int16(u16(glyf, offset+0))
-				transform[3] = transform[0]
-				offset += 2
-			case flags&flagWeHaveAnXAndYScale != 0:
-				transform[0] = int16(u16(glyf, offset+0))
-				transform[3] = int16(u16(glyf, offset+2))
-				offset += 4
-			case flags&flagWeHaveATwoByTwo != 0:
-				transform[0] = int16(u16(glyf, offset+0))
-				transform[1] = int16(u16(glyf, offset+2))
-				transform[2] = int16(u16(glyf, offset+4))
-				transform[3] = int16(u16(glyf, offset+6))
-				offset += 8
-			}
-		}
-		savedPP := g.phantomPoints
-		np0 := len(g.Points)
-		componentUMM := useMyMetrics && (flags&flagUseMyMetrics != 0)
-		if err := g.load(recursion+1, component, componentUMM); err != nil {
-			return err
-		}
-		if flags&flagUseMyMetrics == 0 {
-			g.phantomPoints = savedPP
-		}
-		if hasTransform {
-			for j := np0; j < len(g.Points); j++ {
-				p := &g.Points[j]
-				newX := 0 +
-					fixed.Int26_6((int64(p.X)*int64(transform[0])+1<<13)>>14) +
-					fixed.Int26_6((int64(p.Y)*int64(transform[2])+1<<13)>>14)
-				newY := 0 +
-					fixed.Int26_6((int64(p.X)*int64(transform[1])+1<<13)>>14) +
-					fixed.Int26_6((int64(p.Y)*int64(transform[3])+1<<13)>>14)
-				p.X, p.Y = newX, newY
-			}
-		}
-		dx = g.font.scale(g.scale * dx)
-		dy = g.font.scale(g.scale * dy)
-		if flags&flagRoundXYToGrid != 0 {
-			dx = (dx + 32) &^ 63
-			dy = (dy + 32) &^ 63
-		}
-		for j := np0; j < len(g.Points); j++ {
-			p := &g.Points[j]
-			p.X += dx
-			p.Y += dy
-		}
-		// TODO: also adjust g.InFontUnits and g.Unhinted?
-		if flags&flagMoreComponents == 0 {
-			break
-		}
-	}
-
-	instrLen := 0
-	if g.hinting != font.HintingNone && offset+2 <= len(glyf) {
-		instrLen = int(u16(glyf, offset))
-		offset += 2
-	}
-
-	g.addPhantomsAndScale(np0, len(g.Points), false, instrLen > 0)
-	points, ends := g.Points[np0:], g.Ends[ne0:]
-	g.Points = g.Points[:len(g.Points)-4]
-	for j := range points {
-		points[j].Flags &^= flagTouchedX | flagTouchedY
-	}
-
-	if instrLen == 0 {
-		if !g.metricsSet {
-			copy(g.phantomPoints[:], points[len(points)-4:])
-		}
-		return nil
-	}
-
-	// Hint the compound glyph.
-	program := glyf[offset : offset+instrLen]
-	// Temporarily adjust the ends to be relative to this compound glyph.
-	if np0 != 0 {
-		for i := range ends {
-			ends[i] -= np0
-		}
-	}
-	// Hinting instructions of a composite glyph completely refer to the
-	// (already) hinted subglyphs.
-	g.tmp = append(g.tmp[:0], points...)
-	if err := g.hinter.run(program, points, g.tmp, g.tmp, ends); err != nil {
-		return err
-	}
-	if np0 != 0 {
-		for i := range ends {
-			ends[i] += np0
-		}
-	}
-	if !g.metricsSet {
-		copy(g.phantomPoints[:], points[len(points)-4:])
-	}
-	return nil
-}
-
-func (g *GlyphBuf) addPhantomsAndScale(np0, np1 int, simple, adjust bool) {
-	// Add the four phantom points.
-	g.Points = append(g.Points, g.phantomPoints[:]...)
-	// Scale the points.
-	if simple && g.hinting != font.HintingNone {
-		g.InFontUnits = append(g.InFontUnits, g.Points[np1:]...)
-	}
-	for i := np1; i < len(g.Points); i++ {
-		p := &g.Points[i]
-		p.X = g.font.scale(g.scale * p.X)
-		p.Y = g.font.scale(g.scale * p.Y)
-	}
-	if g.hinting == font.HintingNone {
-		return
-	}
-	// Round the 1st phantom point to the grid, shifting all other points equally.
-	// Note that "all other points" starts from np0, not np1.
-	// TODO: delete this adjustment and the np0/np1 distinction, when
-	// we update the compatibility tests to C Freetype 2.5.3.
-	// See http://git.savannah.gnu.org/cgit/freetype/freetype2.git/commit/?id=05c786d990390a7ca18e62962641dac740bacb06
-	if adjust {
-		pp1x := g.Points[len(g.Points)-4].X
-		if dx := ((pp1x + 32) &^ 63) - pp1x; dx != 0 {
-			for i := np0; i < len(g.Points); i++ {
-				g.Points[i].X += dx
-			}
-		}
-	}
-	if simple {
-		g.Unhinted = append(g.Unhinted, g.Points[np1:]...)
-	}
-	// Round the 2nd and 4th phantom point to the grid.
-	p := &g.Points[len(g.Points)-3]
-	p.X = (p.X + 32) &^ 63
-	p = &g.Points[len(g.Points)-1]
-	p.Y = (p.Y + 32) &^ 63
-}

vendor/github.com/golang/freetype/truetype/opcodes.go

@@ -1,289 +0,0 @@
-// Copyright 2012 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-package truetype
-
-// The Truetype opcodes are summarized at
-// https://developer.apple.com/fonts/TTRefMan/RM07/appendixA.html
-
-const (
-	opSVTCA0    = 0x00 // Set freedom and projection Vectors To Coordinate Axis
-	opSVTCA1    = 0x01 // .
-	opSPVTCA0   = 0x02 // Set Projection Vector To Coordinate Axis
-	opSPVTCA1   = 0x03 // .
-	opSFVTCA0   = 0x04 // Set Freedom Vector to Coordinate Axis
-	opSFVTCA1   = 0x05 // .
-	opSPVTL0    = 0x06 // Set Projection Vector To Line
-	opSPVTL1    = 0x07 // .
-	opSFVTL0    = 0x08 // Set Freedom Vector To Line
-	opSFVTL1    = 0x09 // .
-	opSPVFS     = 0x0a // Set Projection Vector From Stack
-	opSFVFS     = 0x0b // Set Freedom Vector From Stack
-	opGPV       = 0x0c // Get Projection Vector
-	opGFV       = 0x0d // Get Freedom Vector
-	opSFVTPV    = 0x0e // Set Freedom Vector To Projection Vector
-	opISECT     = 0x0f // moves point p to the InterSECTion of two lines
-	opSRP0      = 0x10 // Set Reference Point 0
-	opSRP1      = 0x11 // Set Reference Point 1
-	opSRP2      = 0x12 // Set Reference Point 2
-	opSZP0      = 0x13 // Set Zone Pointer 0
-	opSZP1      = 0x14 // Set Zone Pointer 1
-	opSZP2      = 0x15 // Set Zone Pointer 2
-	opSZPS      = 0x16 // Set Zone PointerS
-	opSLOOP     = 0x17 // Set LOOP variable
-	opRTG       = 0x18 // Round To Grid
-	opRTHG      = 0x19 // Round To Half Grid
-	opSMD       = 0x1a // Set Minimum Distance
-	opELSE      = 0x1b // ELSE clause
-	opJMPR      = 0x1c // JuMP Relative
-	opSCVTCI    = 0x1d // Set Control Value Table Cut-In
-	opSSWCI     = 0x1e // Set Single Width Cut-In
-	opSSW       = 0x1f // Set Single Width
-	opDUP       = 0x20 // DUPlicate top stack element
-	opPOP       = 0x21 // POP top stack element
-	opCLEAR     = 0x22 // CLEAR the stack
-	opSWAP      = 0x23 // SWAP the top two elements on the stack
-	opDEPTH     = 0x24 // DEPTH of the stack
-	opCINDEX    = 0x25 // Copy the INDEXed element to the top of the stack
-	opMINDEX    = 0x26 // Move the INDEXed element to the top of the stack
-	opALIGNPTS  = 0x27 // ALIGN PoinTS
-	op_0x28     = 0x28 // deprecated
-	opUTP       = 0x29 // UnTouch Point
-	opLOOPCALL  = 0x2a // LOOP and CALL function
-	opCALL      = 0x2b // CALL function
-	opFDEF      = 0x2c // Function DEFinition
-	opENDF      = 0x2d // END Function definition
-	opMDAP0     = 0x2e // Move Direct Absolute Point
-	opMDAP1     = 0x2f // .
-	opIUP0      = 0x30 // Interpolate Untouched Points through the outline
-	opIUP1      = 0x31 // .
-	opSHP0      = 0x32 // SHift Point using reference point
-	opSHP1      = 0x33 // .
-	opSHC0      = 0x34 // SHift Contour using reference point
-	opSHC1      = 0x35 // .
-	opSHZ0      = 0x36 // SHift Zone using reference point
-	opSHZ1      = 0x37 // .
-	opSHPIX     = 0x38 // SHift point by a PIXel amount
-	opIP        = 0x39 // Interpolate Point
-	opMSIRP0    = 0x3a // Move Stack Indirect Relative Point
-	opMSIRP1    = 0x3b // .
-	opALIGNRP   = 0x3c // ALIGN to Reference Point
-	opRTDG      = 0x3d // Round To Double Grid
-	opMIAP0     = 0x3e // Move Indirect Absolute Point
-	opMIAP1     = 0x3f // .
-	opNPUSHB    = 0x40 // PUSH N Bytes
-	opNPUSHW    = 0x41 // PUSH N Words
-	opWS        = 0x42 // Write Store
-	opRS        = 0x43 // Read Store
-	opWCVTP     = 0x44 // Write Control Value Table in Pixel units
-	opRCVT      = 0x45 // Read Control Value Table entry
-	opGC0       = 0x46 // Get Coordinate projected onto the projection vector
-	opGC1       = 0x47 // .
-	opSCFS      = 0x48 // Sets Coordinate From the Stack using projection vector and freedom vector
-	opMD0       = 0x49 // Measure Distance
-	opMD1       = 0x4a // .
-	opMPPEM     = 0x4b // Measure Pixels Per EM
-	opMPS       = 0x4c // Measure Point Size
-	opFLIPON    = 0x4d // set the auto FLIP Boolean to ON
-	opFLIPOFF   = 0x4e // set the auto FLIP Boolean to OFF
-	opDEBUG     = 0x4f // DEBUG call
-	opLT        = 0x50 // Less Than
-	opLTEQ      = 0x51 // Less Than or EQual
-	opGT        = 0x52 // Greater Than
-	opGTEQ      = 0x53 // Greater Than or EQual
-	opEQ        = 0x54 // EQual
-	opNEQ       = 0x55 // Not EQual
-	opODD       = 0x56 // ODD
-	opEVEN      = 0x57 // EVEN
-	opIF        = 0x58 // IF test
-	opEIF       = 0x59 // End IF
-	opAND       = 0x5a // logical AND
-	opOR        = 0x5b // logical OR
-	opNOT       = 0x5c // logical NOT
-	opDELTAP1   = 0x5d // DELTA exception P1
-	opSDB       = 0x5e // Set Delta Base in the graphics state
-	opSDS       = 0x5f // Set Delta Shift in the graphics state
-	opADD       = 0x60 // ADD
-	opSUB       = 0x61 // SUBtract
-	opDIV       = 0x62 // DIVide
-	opMUL       = 0x63 // MULtiply
-	opABS       = 0x64 // ABSolute value
-	opNEG       = 0x65 // NEGate
-	opFLOOR     = 0x66 // FLOOR
-	opCEILING   = 0x67 // CEILING
-	opROUND00   = 0x68 // ROUND value
-	opROUND01   = 0x69 // .
-	opROUND10   = 0x6a // .
-	opROUND11   = 0x6b // .
-	opNROUND00  = 0x6c // No ROUNDing of value
-	opNROUND01  = 0x6d // .
-	opNROUND10  = 0x6e // .
-	opNROUND11  = 0x6f // .
-	opWCVTF     = 0x70 // Write Control Value Table in Funits
-	opDELTAP2   = 0x71 // DELTA exception P2
-	opDELTAP3   = 0x72 // DELTA exception P3
-	opDELTAC1   = 0x73 // DELTA exception C1
-	opDELTAC2   = 0x74 // DELTA exception C2
-	opDELTAC3   = 0x75 // DELTA exception C3
-	opSROUND    = 0x76 // Super ROUND
-	opS45ROUND  = 0x77 // Super ROUND 45 degrees
-	opJROT      = 0x78 // Jump Relative On True
-	opJROF      = 0x79 // Jump Relative On False
-	opROFF      = 0x7a // Round OFF
-	op_0x7b     = 0x7b // deprecated
-	opRUTG      = 0x7c // Round Up To Grid
-	opRDTG      = 0x7d // Round Down To Grid
-	opSANGW     = 0x7e // Set ANGle Weight
-	opAA        = 0x7f // Adjust Angle
-	opFLIPPT    = 0x80 // FLIP PoinT
-	opFLIPRGON  = 0x81 // FLIP RanGe ON
-	opFLIPRGOFF = 0x82 // FLIP RanGe OFF
-	op_0x83     = 0x83 // deprecated
-	op_0x84     = 0x84 // deprecated
-	opSCANCTRL  = 0x85 // SCAN conversion ConTRoL
-	opSDPVTL0   = 0x86 // Set Dual Projection Vector To Line
-	opSDPVTL1   = 0x87 // .
-	opGETINFO   = 0x88 // GET INFOrmation
-	opIDEF      = 0x89 // Instruction DEFinition
-	opROLL      = 0x8a // ROLL the top three stack elements
-	opMAX       = 0x8b // MAXimum of top two stack elements
-	opMIN       = 0x8c // MINimum of top two stack elements
-	opSCANTYPE  = 0x8d // SCANTYPE
-	opINSTCTRL  = 0x8e // INSTRuction execution ConTRoL
-	op_0x8f     = 0x8f
-	op_0x90     = 0x90
-	op_0x91     = 0x91
-	op_0x92     = 0x92
-	op_0x93     = 0x93
-	op_0x94     = 0x94
-	op_0x95     = 0x95
-	op_0x96     = 0x96
-	op_0x97     = 0x97
-	op_0x98     = 0x98
-	op_0x99     = 0x99
-	op_0x9a     = 0x9a
-	op_0x9b     = 0x9b
-	op_0x9c     = 0x9c
-	op_0x9d     = 0x9d
-	op_0x9e     = 0x9e
-	op_0x9f     = 0x9f
-	op_0xa0     = 0xa0
-	op_0xa1     = 0xa1
-	op_0xa2     = 0xa2
-	op_0xa3     = 0xa3
-	op_0xa4     = 0xa4
-	op_0xa5     = 0xa5
-	op_0xa6     = 0xa6
-	op_0xa7     = 0xa7
-	op_0xa8     = 0xa8
-	op_0xa9     = 0xa9
-	op_0xaa     = 0xaa
-	op_0xab     = 0xab
-	op_0xac     = 0xac
-	op_0xad     = 0xad
-	op_0xae     = 0xae
-	op_0xaf     = 0xaf
-	opPUSHB000  = 0xb0 // PUSH Bytes
-	opPUSHB001  = 0xb1 // .
-	opPUSHB010  = 0xb2 // .
-	opPUSHB011  = 0xb3 // .
-	opPUSHB100  = 0xb4 // .
-	opPUSHB101  = 0xb5 // .
-	opPUSHB110  = 0xb6 // .
-	opPUSHB111  = 0xb7 // .
-	opPUSHW000  = 0xb8 // PUSH Words
-	opPUSHW001  = 0xb9 // .
-	opPUSHW010  = 0xba // .
-	opPUSHW011  = 0xbb // .
-	opPUSHW100  = 0xbc // .
-	opPUSHW101  = 0xbd // .
-	opPUSHW110  = 0xbe // .
-	opPUSHW111  = 0xbf // .
-	opMDRP00000 = 0xc0 // Move Direct Relative Point
-	opMDRP00001 = 0xc1 // .
-	opMDRP00010 = 0xc2 // .
-	opMDRP00011 = 0xc3 // .
-	opMDRP00100 = 0xc4 // .
-	opMDRP00101 = 0xc5 // .
-	opMDRP00110 = 0xc6 // .
-	opMDRP00111 = 0xc7 // .
-	opMDRP01000 = 0xc8 // .
-	opMDRP01001 = 0xc9 // .
-	opMDRP01010 = 0xca // .
-	opMDRP01011 = 0xcb // .
-	opMDRP01100 = 0xcc // .
-	opMDRP01101 = 0xcd // .
-	opMDRP01110 = 0xce // .
-	opMDRP01111 = 0xcf // .
-	opMDRP10000 = 0xd0 // .
-	opMDRP10001 = 0xd1 // .
-	opMDRP10010 = 0xd2 // .
-	opMDRP10011 = 0xd3 // .
-	opMDRP10100 = 0xd4 // .
-	opMDRP10101 = 0xd5 // .
-	opMDRP10110 = 0xd6 // .
-	opMDRP10111 = 0xd7 // .
-	opMDRP11000 = 0xd8 // .
-	opMDRP11001 = 0xd9 // .
-	opMDRP11010 = 0xda // .
-	opMDRP11011 = 0xdb // .
-	opMDRP11100 = 0xdc // .
-	opMDRP11101 = 0xdd // .
-	opMDRP11110 = 0xde // .
-	opMDRP11111 = 0xdf // .
-	opMIRP00000 = 0xe0 // Move Indirect Relative Point
-	opMIRP00001 = 0xe1 // .
-	opMIRP00010 = 0xe2 // .
-	opMIRP00011 = 0xe3 // .
-	opMIRP00100 = 0xe4 // .
-	opMIRP00101 = 0xe5 // .
-	opMIRP00110 = 0xe6 // .
-	opMIRP00111 = 0xe7 // .
-	opMIRP01000 = 0xe8 // .
-	opMIRP01001 = 0xe9 // .
-	opMIRP01010 = 0xea // .
-	opMIRP01011 = 0xeb // .
-	opMIRP01100 = 0xec // .
-	opMIRP01101 = 0xed // .
-	opMIRP01110 = 0xee // .
-	opMIRP01111 = 0xef // .
-	opMIRP10000 = 0xf0 // .
-	opMIRP10001 = 0xf1 // .
-	opMIRP10010 = 0xf2 // .
-	opMIRP10011 = 0xf3 // .
-	opMIRP10100 = 0xf4 // .
-	opMIRP10101 = 0xf5 // .
-	opMIRP10110 = 0xf6 // .
-	opMIRP10111 = 0xf7 // .
-	opMIRP11000 = 0xf8 // .
-	opMIRP11001 = 0xf9 // .
-	opMIRP11010 = 0xfa // .
-	opMIRP11011 = 0xfb // .
-	opMIRP11100 = 0xfc // .
-	opMIRP11101 = 0xfd // .
-	opMIRP11110 = 0xfe // .
-	opMIRP11111 = 0xff // .
-)
-
-// popCount is the number of stack elements that each opcode pops.
-var popCount = [256]uint8{
-	// 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f
-	0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 5, // 0x00 - 0x0f
-	1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, // 0x10 - 0x1f
-	1, 1, 0, 2, 0, 1, 1, 2, 0, 1, 2, 1, 1, 0, 1, 1, // 0x20 - 0x2f
-	0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 2, 2, 0, 0, 2, 2, // 0x30 - 0x3f
-	0, 0, 2, 1, 2, 1, 1, 1, 2, 2, 2, 0, 0, 0, 0, 0, // 0x40 - 0x4f
-	2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 2, 2, 1, 1, 1, 1, // 0x50 - 0x5f
-	2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6f
-	2, 1, 1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 1, 1, // 0x70 - 0x7f
-	0, 2, 2, 0, 0, 1, 2, 2, 1, 1, 3, 2, 2, 1, 2, 0, // 0x80 - 0x8f
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x90 - 0x9f
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xa0 - 0xaf
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xb0 - 0xbf
-	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xc0 - 0xcf
-	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xd0 - 0xdf
-	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xe0 - 0xef
-	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xf0 - 0xff
-}

vendor/github.com/golang/freetype/truetype/truetype.go

@@ -1,643 +0,0 @@
-// Copyright 2010 The Freetype-Go Authors. All rights reserved.
-// Use of this source code is governed by your choice of either the
-// FreeType License or the GNU General Public License version 2 (or
-// any later version), both of which can be found in the LICENSE file.
-
-// Package truetype provides a parser for the TTF and TTC file formats.
-// Those formats are documented at http://developer.apple.com/fonts/TTRefMan/
-// and http://www.microsoft.com/typography/otspec/
-//
-// Some of a font's methods provide lengths or co-ordinates, e.g. bounds, font
-// metrics and control points. All these methods take a scale parameter, which
-// is the number of pixels in 1 em, expressed as a 26.6 fixed point value. For
-// example, if 1 em is 10 pixels then scale is fixed.I(10), which is equal to
-// fixed.Int26_6(10 << 6).
-//
-// To measure a TrueType font in ideal FUnit space, use scale equal to
-// font.FUnitsPerEm().
-package truetype
-
-import (
-	"fmt"
-
-	"golang.org/x/image/math/fixed"
-)
-
-// An Index is a Font's index of a rune.
-type Index uint16
-
-// A NameID identifies a name table entry.
-//
-// See https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html
-type NameID uint16
-
-const (
-	NameIDCopyright          NameID = 0
-	NameIDFontFamily                = 1
-	NameIDFontSubfamily             = 2
-	NameIDUniqueSubfamilyID         = 3
-	NameIDFontFullName              = 4
-	NameIDNameTableVersion          = 5
-	NameIDPostscriptName            = 6
-	NameIDTrademarkNotice           = 7
-	NameIDManufacturerName          = 8
-	NameIDDesignerName              = 9
-	NameIDFontDescription           = 10
-	NameIDFontVendorURL             = 11
-	NameIDFontDesignerURL           = 12
-	NameIDFontLicense               = 13
-	NameIDFontLicenseURL            = 14
-	NameIDPreferredFamily           = 16
-	NameIDPreferredSubfamily        = 17
-	NameIDCompatibleName            = 18
-	NameIDSampleText                = 19
-)
-
-const (
-	// A 32-bit encoding consists of a most-significant 16-bit Platform ID and a
-	// least-significant 16-bit Platform Specific ID. The magic numbers are
-	// specified at https://www.microsoft.com/typography/otspec/name.htm
-	unicodeEncoding         = 0x00000003 // PID = 0 (Unicode), PSID = 3 (Unicode 2.0)
-	microsoftSymbolEncoding = 0x00030000 // PID = 3 (Microsoft), PSID = 0 (Symbol)
-	microsoftUCS2Encoding   = 0x00030001 // PID = 3 (Microsoft), PSID = 1 (UCS-2)
-	microsoftUCS4Encoding   = 0x0003000a // PID = 3 (Microsoft), PSID = 10 (UCS-4)
-)
-
-// An HMetric holds the horizontal metrics of a single glyph.
-type HMetric struct {
-	AdvanceWidth, LeftSideBearing fixed.Int26_6
-}
-
-// A VMetric holds the vertical metrics of a single glyph.
-type VMetric struct {
-	AdvanceHeight, TopSideBearing fixed.Int26_6
-}
-
-// A FormatError reports that the input is not a valid TrueType font.
-type FormatError string
-
-func (e FormatError) Error() string {
-	return "freetype: invalid TrueType format: " + string(e)
-}
-
-// An UnsupportedError reports that the input uses a valid but unimplemented
-// TrueType feature.
-type UnsupportedError string
-
-func (e UnsupportedError) Error() string {
-	return "freetype: unsupported TrueType feature: " + string(e)
-}
-
-// u32 returns the big-endian uint32 at b[i:].
-func u32(b []byte, i int) uint32 {
-	return uint32(b[i])<<24 | uint32(b[i+1])<<16 | uint32(b[i+2])<<8 | uint32(b[i+3])
-}
-
-// u16 returns the big-endian uint16 at b[i:].
-func u16(b []byte, i int) uint16 {
-	return uint16(b[i])<<8 | uint16(b[i+1])
-}
-
-// readTable returns a slice of the TTF data given by a table's directory entry.
-func readTable(ttf []byte, offsetLength []byte) ([]byte, error) {
-	offset := int(u32(offsetLength, 0))
-	if offset < 0 {
-		return nil, FormatError(fmt.Sprintf("offset too large: %d", uint32(offset)))
-	}
-	length := int(u32(offsetLength, 4))
-	if length < 0 {
-		return nil, FormatError(fmt.Sprintf("length too large: %d", uint32(length)))
-	}
-	end := offset + length
-	if end < 0 || end > len(ttf) {
-		return nil, FormatError(fmt.Sprintf("offset + length too large: %d", uint32(offset)+uint32(length)))
-	}
-	return ttf[offset:end], nil
-}
-
-// parseSubtables returns the offset and platformID of the best subtable in
-// table, where best favors a Unicode cmap encoding, and failing that, a
-// Microsoft cmap encoding. offset is the offset of the first subtable in
-// table, and size is the size of each subtable.
-//
-// If pred is non-nil, then only subtables that satisfy that predicate will be
-// considered.
-func parseSubtables(table []byte, name string, offset, size int, pred func([]byte) bool) (
-	bestOffset int, bestPID uint32, retErr error) {
-
-	if len(table) < 4 {
-		return 0, 0, FormatError(name + " too short")
-	}
-	nSubtables := int(u16(table, 2))
-	if len(table) < size*nSubtables+offset {
-		return 0, 0, FormatError(name + " too short")
-	}
-	ok := false
-	for i := 0; i < nSubtables; i, offset = i+1, offset+size {
-		if pred != nil && !pred(table[offset:]) {
-			continue
-		}
-		// We read the 16-bit Platform ID and 16-bit Platform Specific ID as a single uint32.
-		// All values are big-endian.
-		pidPsid := u32(table, offset)
-		// We prefer the Unicode cmap encoding. Failing to find that, we fall
-		// back onto the Microsoft cmap encoding.
-		if pidPsid == unicodeEncoding {
-			bestOffset, bestPID, ok = offset, pidPsid>>16, true
-			break
-
-		} else if pidPsid == microsoftSymbolEncoding ||
-			pidPsid == microsoftUCS2Encoding ||
-			pidPsid == microsoftUCS4Encoding {
-
-			bestOffset, bestPID, ok = offset, pidPsid>>16, true
-			// We don't break out of the for loop, so that Unicode can override Microsoft.
-		}
-	}
-	if !ok {
-		return 0, 0, UnsupportedError(name + " encoding")
-	}
-	return bestOffset, bestPID, nil
-}
-
-const (
-	locaOffsetFormatUnknown int = iota
-	locaOffsetFormatShort
-	locaOffsetFormatLong
-)
-
-// A cm holds a parsed cmap entry.
-type cm struct {
-	start, end, delta, offset uint32
-}
-
-// A Font represents a Truetype font.
-type Font struct {
-	// Tables sliced from the TTF data. The different tables are documented
-	// at http://developer.apple.com/fonts/TTRefMan/RM06/Chap6.html
-	cmap, cvt, fpgm, glyf, hdmx, head, hhea, hmtx, kern, loca, maxp, name, os2, prep, vmtx []byte
-
-	cmapIndexes []byte
-
-	// Cached values derived from the raw ttf data.
-	cm                      []cm
-	locaOffsetFormat        int
-	nGlyph, nHMetric, nKern int
-	fUnitsPerEm             int32
-	ascent                  int32               // In FUnits.
-	descent                 int32               // In FUnits; typically negative.
-	bounds                  fixed.Rectangle26_6 // In FUnits.
-	// Values from the maxp section.
-	maxTwilightPoints, maxStorage, maxFunctionDefs, maxStackElements uint16
-}
-
-func (f *Font) parseCmap() error {
-	const (
-		cmapFormat4         = 4
-		cmapFormat12        = 12
-		languageIndependent = 0
-	)
-
-	offset, _, err := parseSubtables(f.cmap, "cmap", 4, 8, nil)
-	if err != nil {
-		return err
-	}
-	offset = int(u32(f.cmap, offset+4))
-	if offset <= 0 || offset > len(f.cmap) {
-		return FormatError("bad cmap offset")
-	}
-
-	cmapFormat := u16(f.cmap, offset)
-	switch cmapFormat {
-	case cmapFormat4:
-		language := u16(f.cmap, offset+4)
-		if language != languageIndependent {
-			return UnsupportedError(fmt.Sprintf("language: %d", language))
-		}
-		segCountX2 := int(u16(f.cmap, offset+6))
-		if segCountX2%2 == 1 {
-			return FormatError(fmt.Sprintf("bad segCountX2: %d", segCountX2))
-		}
-		segCount := segCountX2 / 2
-		offset += 14
-		f.cm = make([]cm, segCount)
-		for i := 0; i < segCount; i++ {
-			f.cm[i].end = uint32(u16(f.cmap, offset))
-			offset += 2
-		}
-		offset += 2
-		for i := 0; i < segCount; i++ {
-			f.cm[i].start = uint32(u16(f.cmap, offset))
-			offset += 2
-		}
-		for i := 0; i < segCount; i++ {
-			f.cm[i].delta = uint32(u16(f.cmap, offset))
-			offset += 2
-		}
-		for i := 0; i < segCount; i++ {
-			f.cm[i].offset = uint32(u16(f.cmap, offset))
-			offset += 2
-		}
-		f.cmapIndexes = f.cmap[offset:]
-		return nil
-
-	case cmapFormat12:
-		if u16(f.cmap, offset+2) != 0 {
-			return FormatError(fmt.Sprintf("cmap format: % x", f.cmap[offset:offset+4]))
-		}
-		length := u32(f.cmap, offset+4)
-		language := u32(f.cmap, offset+8)
-		if language != languageIndependent {
-			return UnsupportedError(fmt.Sprintf("language: %d", language))
-		}
-		nGroups := u32(f.cmap, offset+12)
-		if length != 12*nGroups+16 {
-			return FormatError("inconsistent cmap length")
-		}
-		offset += 16
-		f.cm = make([]cm, nGroups)
-		for i := uint32(0); i < nGroups; i++ {
-			f.cm[i].start = u32(f.cmap, offset+0)
-			f.cm[i].end = u32(f.cmap, offset+4)
-			f.cm[i].delta = u32(f.cmap, offset+8) - f.cm[i].start
-			offset += 12
-		}
-		return nil
-	}
-	return UnsupportedError(fmt.Sprintf("cmap format: %d", cmapFormat))
-}
-
-func (f *Font) parseHead() error {
-	if len(f.head) != 54 {
-		return FormatError(fmt.Sprintf("bad head length: %d", len(f.head)))
-	}
-	f.fUnitsPerEm = int32(u16(f.head, 18))
-	f.bounds.Min.X = fixed.Int26_6(int16(u16(f.head, 36)))
-	f.bounds.Min.Y = fixed.Int26_6(int16(u16(f.head, 38)))
-	f.bounds.Max.X = fixed.Int26_6(int16(u16(f.head, 40)))
-	f.bounds.Max.Y = fixed.Int26_6(int16(u16(f.head, 42)))
-	switch i := u16(f.head, 50); i {
-	case 0:
-		f.locaOffsetFormat = locaOffsetFormatShort
-	case 1:
-		f.locaOffsetFormat = locaOffsetFormatLong
-	default:
-		return FormatError(fmt.Sprintf("bad indexToLocFormat: %d", i))
-	}
-	return nil
-}
-
-func (f *Font) parseHhea() error {
-	if len(f.hhea) != 36 {
-		return FormatError(fmt.Sprintf("bad hhea length: %d", len(f.hhea)))
-	}
-	f.ascent = int32(int16(u16(f.hhea, 4)))
-	f.descent = int32(int16(u16(f.hhea, 6)))
-	f.nHMetric = int(u16(f.hhea, 34))
-	if 4*f.nHMetric+2*(f.nGlyph-f.nHMetric) != len(f.hmtx) {
-		return FormatError(fmt.Sprintf("bad hmtx length: %d", len(f.hmtx)))
-	}
-	return nil
-}
-
-func (f *Font) parseKern() error {
-	// Apple's TrueType documentation (http://developer.apple.com/fonts/TTRefMan/RM06/Chap6kern.html) says:
-	// "Previous versions of the 'kern' table defined both the version and nTables fields in the header
-	// as UInt16 values and not UInt32 values. Use of the older format on the Mac OS is discouraged
-	// (although AAT can sense an old kerning table and still make correct use of it). Microsoft
-	// Windows still uses the older format for the 'kern' table and will not recognize the newer one.
-	// Fonts targeted for the Mac OS only should use the new format; fonts targeted for both the Mac OS
-	// and Windows should use the old format."
-	// Since we expect that almost all fonts aim to be Windows-compatible, we only parse the "older" format,
-	// just like the C Freetype implementation.
-	if len(f.kern) == 0 {
-		if f.nKern != 0 {
-			return FormatError("bad kern table length")
-		}
-		return nil
-	}
-	if len(f.kern) < 18 {
-		return FormatError("kern data too short")
-	}
-	version, offset := u16(f.kern, 0), 2
-	if version != 0 {
-		return UnsupportedError(fmt.Sprintf("kern version: %d", version))
-	}
-	n, offset := u16(f.kern, offset), offset+2
-	if n != 1 {
-		return UnsupportedError(fmt.Sprintf("kern nTables: %d", n))
-	}
-	offset += 2
-	length, offset := int(u16(f.kern, offset)), offset+2
-	coverage, offset := u16(f.kern, offset), offset+2
-	if coverage != 0x0001 {
-		// We only support horizontal kerning.
-		return UnsupportedError(fmt.Sprintf("kern coverage: 0x%04x", coverage))
-	}
-	f.nKern, offset = int(u16(f.kern, offset)), offset+2
-	if 6*f.nKern != length-14 {
-		return FormatError("bad kern table length")
-	}
-	return nil
-}
-
-func (f *Font) parseMaxp() error {
-	if len(f.maxp) != 32 {
-		return FormatError(fmt.Sprintf("bad maxp length: %d", len(f.maxp)))
-	}
-	f.nGlyph = int(u16(f.maxp, 4))
-	f.maxTwilightPoints = u16(f.maxp, 16)
-	f.maxStorage = u16(f.maxp, 18)
-	f.maxFunctionDefs = u16(f.maxp, 20)
-	f.maxStackElements = u16(f.maxp, 24)
-	return nil
-}
-
-// scale returns x divided by f.fUnitsPerEm, rounded to the nearest integer.
-func (f *Font) scale(x fixed.Int26_6) fixed.Int26_6 {
-	if x >= 0 {
-		x += fixed.Int26_6(f.fUnitsPerEm) / 2
-	} else {
-		x -= fixed.Int26_6(f.fUnitsPerEm) / 2
-	}
-	return x / fixed.Int26_6(f.fUnitsPerEm)
-}
-
-// Bounds returns the union of a Font's glyphs' bounds.
-func (f *Font) Bounds(scale fixed.Int26_6) fixed.Rectangle26_6 {
-	b := f.bounds
-	b.Min.X = f.scale(scale * b.Min.X)
-	b.Min.Y = f.scale(scale * b.Min.Y)
-	b.Max.X = f.scale(scale * b.Max.X)
-	b.Max.Y = f.scale(scale * b.Max.Y)
-	return b
-}
-
-// FUnitsPerEm returns the number of FUnits in a Font's em-square's side.
-func (f *Font) FUnitsPerEm() int32 {
-	return f.fUnitsPerEm
-}
-
-// Index returns a Font's index for the given rune.
-func (f *Font) Index(x rune) Index {
-	c := uint32(x)
-	for i, j := 0, len(f.cm); i < j; {
-		h := i + (j-i)/2
-		cm := &f.cm[h]
-		if c < cm.start {
-			j = h
-		} else if cm.end < c {
-			i = h + 1
-		} else if cm.offset == 0 {
-			return Index(c + cm.delta)
-		} else {
-			offset := int(cm.offset) + 2*(h-len(f.cm)+int(c-cm.start))
-			return Index(u16(f.cmapIndexes, offset))
-		}
-	}
-	return 0
-}
-
-// Name returns the Font's name value for the given NameID. It returns "" if
-// there was an error, or if that name was not found.
-func (f *Font) Name(id NameID) string {
-	x, platformID, err := parseSubtables(f.name, "name", 6, 12, func(b []byte) bool {
-		return NameID(u16(b, 6)) == id
-	})
-	if err != nil {
-		return ""
-	}
-	offset, length := u16(f.name, 4)+u16(f.name, x+10), u16(f.name, x+8)
-	// Return the ASCII value of the encoded string.
-	// The string is encoded as UTF-16 on non-Apple platformIDs; Apple is platformID 1.
-	src := f.name[offset : offset+length]
-	var dst []byte
-	if platformID != 1 { // UTF-16.
-		if len(src)&1 != 0 {
-			return ""
-		}
-		dst = make([]byte, len(src)/2)
-		for i := range dst {
-			dst[i] = printable(u16(src, 2*i))
-		}
-	} else { // ASCII.
-		dst = make([]byte, len(src))
-		for i, c := range src {
-			dst[i] = printable(uint16(c))
-		}
-	}
-	return string(dst)
-}
-
-func printable(r uint16) byte {
-	if 0x20 <= r && r < 0x7f {
-		return byte(r)
-	}
-	return '?'
-}
-
-// unscaledHMetric returns the unscaled horizontal metrics for the glyph with
-// the given index.
-func (f *Font) unscaledHMetric(i Index) (h HMetric) {
-	j := int(i)
-	if j < 0 || f.nGlyph <= j {
-		return HMetric{}
-	}
-	if j >= f.nHMetric {
-		p := 4 * (f.nHMetric - 1)
-		return HMetric{
-			AdvanceWidth:    fixed.Int26_6(u16(f.hmtx, p)),
-			LeftSideBearing: fixed.Int26_6(int16(u16(f.hmtx, p+2*(j-f.nHMetric)+4))),
-		}
-	}
-	return HMetric{
-		AdvanceWidth:    fixed.Int26_6(u16(f.hmtx, 4*j)),
-		LeftSideBearing: fixed.Int26_6(int16(u16(f.hmtx, 4*j+2))),
-	}
-}
-
-// HMetric returns the horizontal metrics for the glyph with the given index.
-func (f *Font) HMetric(scale fixed.Int26_6, i Index) HMetric {
-	h := f.unscaledHMetric(i)
-	h.AdvanceWidth = f.scale(scale * h.AdvanceWidth)
-	h.LeftSideBearing = f.scale(scale * h.LeftSideBearing)
-	return h
-}
-
-// unscaledVMetric returns the unscaled vertical metrics for the glyph with
-// the given index. yMax is the top of the glyph's bounding box.
-func (f *Font) unscaledVMetric(i Index, yMax fixed.Int26_6) (v VMetric) {
-	j := int(i)
-	if j < 0 || f.nGlyph <= j {
-		return VMetric{}
-	}
-	if 4*j+4 <= len(f.vmtx) {
-		return VMetric{
-			AdvanceHeight:  fixed.Int26_6(u16(f.vmtx, 4*j)),
-			TopSideBearing: fixed.Int26_6(int16(u16(f.vmtx, 4*j+2))),
-		}
-	}
-	// The OS/2 table has grown over time.
-	// https://developer.apple.com/fonts/TTRefMan/RM06/Chap6OS2.html
-	// says that it was originally 68 bytes. Optional fields, including
-	// the ascender and descender, are described at
-	// http://www.microsoft.com/typography/otspec/os2.htm
-	if len(f.os2) >= 72 {
-		sTypoAscender := fixed.Int26_6(int16(u16(f.os2, 68)))
-		sTypoDescender := fixed.Int26_6(int16(u16(f.os2, 70)))
-		return VMetric{
-			AdvanceHeight:  sTypoAscender - sTypoDescender,
-			TopSideBearing: sTypoAscender - yMax,
-		}
-	}
-	return VMetric{
-		AdvanceHeight:  fixed.Int26_6(f.fUnitsPerEm),
-		TopSideBearing: 0,
-	}
-}
-
-// VMetric returns the vertical metrics for the glyph with the given index.
-func (f *Font) VMetric(scale fixed.Int26_6, i Index) VMetric {
-	// TODO: should 0 be bounds.YMax?
-	v := f.unscaledVMetric(i, 0)
-	v.AdvanceHeight = f.scale(scale * v.AdvanceHeight)
-	v.TopSideBearing = f.scale(scale * v.TopSideBearing)
-	return v
-}
-
-// Kern returns the horizontal adjustment for the given glyph pair. A positive
-// kern means to move the glyphs further apart.
-func (f *Font) Kern(scale fixed.Int26_6, i0, i1 Index) fixed.Int26_6 {
-	if f.nKern == 0 {
-		return 0
-	}
-	g := uint32(i0)<<16 | uint32(i1)
-	lo, hi := 0, f.nKern
-	for lo < hi {
-		i := (lo + hi) / 2
-		ig := u32(f.kern, 18+6*i)
-		if ig < g {
-			lo = i + 1
-		} else if ig > g {
-			hi = i
-		} else {
-			return f.scale(scale * fixed.Int26_6(int16(u16(f.kern, 22+6*i))))
-		}
-	}
-	return 0
-}
-
-// Parse returns a new Font for the given TTF or TTC data.
-//
-// For TrueType Collections, the first font in the collection is parsed.
-func Parse(ttf []byte) (font *Font, err error) {
-	return parse(ttf, 0)
-}
-
-func parse(ttf []byte, offset int) (font *Font, err error) {
-	if len(ttf)-offset < 12 {
-		err = FormatError("TTF data is too short")
-		return
-	}
-	originalOffset := offset
-	magic, offset := u32(ttf, offset), offset+4
-	switch magic {
-	case 0x00010000:
-		// No-op.
-	case 0x74746366: // "ttcf" as a big-endian uint32.
-		if originalOffset != 0 {
-			err = FormatError("recursive TTC")
-			return
-		}
-		ttcVersion, offset := u32(ttf, offset), offset+4
-		if ttcVersion != 0x00010000 {
-			// TODO: support TTC version 2.0, once I have such a .ttc file to test with.
-			err = FormatError("bad TTC version")
-			return
-		}
-		numFonts, offset := int(u32(ttf, offset)), offset+4
-		if numFonts <= 0 {
-			err = FormatError("bad number of TTC fonts")
-			return
-		}
-		if len(ttf[offset:])/4 < numFonts {
-			err = FormatError("TTC offset table is too short")
-			return
-		}
-		// TODO: provide an API to select which font in a TrueType collection to return,
-		// not just the first one. This may require an API to parse a TTC's name tables,
-		// so users of this package can select the font in a TTC by name.
-		offset = int(u32(ttf, offset))
-		if offset <= 0 || offset > len(ttf) {
-			err = FormatError("bad TTC offset")
-			return
-		}
-		return parse(ttf, offset)
-	default:
-		err = FormatError("bad TTF version")
-		return
-	}
-	n, offset := int(u16(ttf, offset)), offset+2
-	if len(ttf) < 16*n+12 {
-		err = FormatError("TTF data is too short")
-		return
-	}
-	f := new(Font)
-	// Assign the table slices.
-	for i := 0; i < n; i++ {
-		x := 16*i + 12
-		switch string(ttf[x : x+4]) {
-		case "cmap":
-			f.cmap, err = readTable(ttf, ttf[x+8:x+16])
-		case "cvt ":
-			f.cvt, err = readTable(ttf, ttf[x+8:x+16])
-		case "fpgm":
-			f.fpgm, err = readTable(ttf, ttf[x+8:x+16])
-		case "glyf":
-			f.glyf, err = readTable(ttf, ttf[x+8:x+16])
-		case "hdmx":
-			f.hdmx, err = readTable(ttf, ttf[x+8:x+16])
-		case "head":
-			f.head, err = readTable(ttf, ttf[x+8:x+16])
-		case "hhea":
-			f.hhea, err = readTable(ttf, ttf[x+8:x+16])
-		case "hmtx":
-			f.hmtx, err = readTable(ttf, ttf[x+8:x+16])
-		case "kern":
-			f.kern, err = readTable(ttf, ttf[x+8:x+16])
-		case "loca":
-			f.loca, err = readTable(ttf, ttf[x+8:x+16])
-		case "maxp":
-			f.maxp, err = readTable(ttf, ttf[x+8:x+16])
-		case "name":
-			f.name, err = readTable(ttf, ttf[x+8:x+16])
-		case "OS/2":
-			f.os2, err = readTable(ttf, ttf[x+8:x+16])
-		case "prep":
-			f.prep, err = readTable(ttf, ttf[x+8:x+16])
-		case "vmtx":
-			f.vmtx, err = readTable(ttf, ttf[x+8:x+16])
-		}
-		if err != nil {
-			return
-		}
-	}
-	// Parse and sanity-check the TTF data.
-	if err = f.parseHead(); err != nil {
-		return
-	}
-	if err = f.parseMaxp(); err != nil {
-		return
-	}
-	if err = f.parseCmap(); err != nil {
-		return
-	}
-	if err = f.parseKern(); err != nil {
-		return
-	}
-	if err = f.parseHhea(); err != nil {
-		return
-	}
-	font = f
-	return
-}

vendor/github.com/lucasb-eyer/go-colorful/.gitignore

@@ -1,25 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Vim swap files
-.*.sw?
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe

vendor/github.com/lucasb-eyer/go-colorful/README.md

@@ -1,390 +0,0 @@
-go-colorful
-===========
-A library for playing with colors in go (golang).
-
-Why?
-====
-I love games. I make games. I love detail and I get lost in detail.
-One such detail popped up during the development of [Memory Which Does Not Suck](https://github.com/lucasb-eyer/mwdns/),
-when we wanted the server to assign the players random colors. Sometimes
-two players got very similar colors, which bugged me. The very same evening,
-[I want hue](http://tools.medialab.sciences-po.fr/iwanthue/) was the top post
-on HackerNews' frontpage and showed me how to Do It Right™. Last but not
-least, there was no library for handling color spaces available in go. Colorful
-does just that and implements Go's color.Color interface.
-
-What?
-=====
-Go-Colorful stores colors in RGB and provides methods from converting these to various color-spaces. Currently supported colorspaces are:
-
-- **RGB:** All three of Red, Green and Blue in [0..1].
-- **HSV:** Hue in [0..360], Saturation and Value in [0..1]. You probably shouldn't use this.
-- **Hex RGB:** The "internet" color format, as in #FF00FF.
-- **Linear RGB:** See [gamma correct rendering](http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).
-- **CIE-XYZ:** CIE's standard color space, almost in [0..1].
-- **CIE-xyY:** encodes chromacity in x and y and luminance in Y, all in [0..1]
-- **CIE-L\*a\*b\*:** A *perceptually uniform* color space, i.e. distances are meaningful. L\* in [0..1] and a\*, b\* almost in [-1..1].
-- **CIE-L\*u\*v\*:** Very similar to CIE-L\*a\*b\*, there is [no consensus](http://en.wikipedia.org/wiki/CIELUV#Historical_background) on which one is "better".
-- **CIE-L\*C\*h° (HCL):** This is generally the [most useful](http://vis4.net/blog/posts/avoid-equidistant-hsv-colors/) one; CIE-L\*a\*b\* space in polar coordinates, i.e. a *better* HSV. H° is in [0..360], C\* almost in [-1..1] and L\* as in CIE-L\*a\*b\*.
-
-For the colorspaces where it makes sense (XYZ, Lab, Luv, HCl), the
-[D65](http://en.wikipedia.org/wiki/Illuminant_D65) is used as reference white
-by default but methods for using your own reference white are provided.
-
-A coordinate being *almost in* a range means that generally it is, but for very
-bright colors and depending on the reference white, it might overflow this
-range slightly. For example, C\* of #0000ff is 1.338.
-
-Unit-tests are provided.
-
-Nice, but what's it useful for?
--------------------------------
-
-- Converting color spaces. Some people like to do that.
-- Blending (interpolating) between colors in a "natural" look by using the right colorspace.
-- Generating random colors under some constraints (e.g. colors of the same shade, or shades of one color.)
-- Generating gorgeous random palettes with distinct colors of a same temperature.
-
-What not (yet)?
-===============
-There are a few features which are currently missing and might be useful.
-I just haven't implemented them yet because I didn't have the need for it.
-Pull requests welcome.
-
-- Functions for computing distances in various spaces. Note that this seems to be [a whole science on its own](http://mmir.doc.ic.ac.uk/mmir2005/CameraReadyMissaoui.pdf).
-- Sorting colors (potentially using above mentioned distances)
-
-So which colorspace should I use?
-=================================
-It depends on what you want to do. I think the folks from *I want hue* are
-on-spot when they say that RGB fits to how *screens produce* color, CIE L\*a\*b\*
-fits how *humans perceive* color and HCL fits how *humans think* colors.
-
-Whenever you'd use HSV, rather go for CIE-L\*C\*h°. for fixed lightness L\* and
-chroma C\* values, the hue angle h° rotates through colors of the same
-perceived brightness and intensity.
-
-How?
-====
-
-### Installing
-Installing the library is as easy as
-
-```bash
-$ go get github.com/lucasb-eyer/go-colorful
-```
-
-The package can then be used through an
-
-```go
-import "github.com/lucasb-eyer/go-colorful"
-```
-
-### Basic usage
-
-Create a beautiful blue color using different source space:
-
-```go
-// Any of the following should be the same
-c := colorful.Color{0.313725, 0.478431, 0.721569}
-c, err := colorful.Hex("#517AB8")
-if err != nil{
-    log.Fatal(err)
-}
-c = colorful.Hsv(216.0, 0.56, 0.722)
-c = colorful.Xyz(0.189165, 0.190837, 0.480248)
-c = colorful.Xyy(0.219895, 0.221839, 0.190837)
-c = colorful.Lab(0.507850, 0.040585,-0.370945)
-c = colorful.Luv(0.507849,-0.194172,-0.567924)
-c = colorful.Hcl(276.2440, 0.373160, 0.507849)
-fmt.Printf("RGB values: %v, %v, %v", c.R, c.G, c.B)
-```
-
-And then converting this color back into various color spaces:
-
-```go
-hex := c.Hex()
-h, s, v := c.Hsv()
-x, y, z := c.Xyz()
-x, y, Y := c.Xyy()
-l, a, b := c.Lab()
-l, u, v := c.Luv()
-h, c, l := c.Hcl()
-```
-
-Note that, because of Go's unfortunate choice of requiring an initial uppercase,
-the name of the functions relating to the xyY space are just off. If you have
-any good suggestion, please open an issue. (I don't consider XyY good.)
-
-### Comparing colors
-In the RGB color space, the Euclidian distance between colors *doesn't* correspond
-to visual/perceptual distance. This means that two pairs of colors which have the
-same distance in RGB space can look much further apart. This is fixed by the
-CIE-L\*a\*b\*, CIE-L\*u\*v\* and CIE-L\*C\*h° color spaces.
-Thus you should only compare colors in any of these space.
-(Note that the distance in CIE-L\*a\*b\* and CIE-L\*C\*h° are the same, since it's the same space but in cylindrical coordinates)
-
-![Color distance comparison](doc/colordist/colordist.png)
-
-The two colors shown on the top look much more different than the two shown on
-the bottom. Still, in RGB space, their distance is the same.
-Here is a little example program which shows the distances between the top two
-and bottom two colors in RGB, CIE-L\*a\*b\* and CIE-L\*u\*v\* space. You can find it in `doc/colordist/colordist.go`.
-
-```go
-package main
-
-import "fmt"
-import "github.com/lucasb-eyer/go-colorful"
-
-func main() {
-    c1a := colorful.Color{150.0/255.0, 10.0/255.0, 150.0/255.0}
-    c1b := colorful.Color{ 53.0/255.0, 10.0/255.0, 150.0/255.0}
-    c2a := colorful.Color{10.0/255.0, 150.0/255.0, 50.0/255.0}
-    c2b := colorful.Color{99.9/255.0, 150.0/255.0, 10.0/255.0}
-
-    fmt.Printf("DistanceRgb:   c1: %v\tand c2: %v\n", c1a.DistanceRgb(c1b), c2a.DistanceRgb(c2b))
-    fmt.Printf("DistanceLab:   c1: %v\tand c2: %v\n", c1a.DistanceLab(c1b), c2a.DistanceLab(c2b))
-    fmt.Printf("DistanceLuv:   c1: %v\tand c2: %v\n", c1a.DistanceLuv(c1b), c2a.DistanceLuv(c2b))
-    fmt.Printf("DistanceCIE76: c1: %v\tand c2: %v\n", c1a.DistanceCIE76(c1b), c2a.DistanceCIE76(c2b))
-    fmt.Printf("DistanceCIE94: c1: %v\tand c2: %v\n", c1a.DistanceCIE94(c1b), c2a.DistanceCIE94(c2b))
-}
-```
-
-Running the above program shows that you should always prefer any of the CIE distances:
-
-```bash
-$ go run colordist.go
-DistanceRgb:   c1: 0.3803921568627451   and c2: 0.3858713931171159
-DistanceLab:   c1: 0.3204845831279805   and c2: 0.2439715175856528
-DistanceLuv:   c1: 0.5134369614199698   and c2: 0.25686928398606323
-DistanceCIE76: c1: 0.3204845831279805   and c2: 0.2439715175856528
-DistanceCIE94: c1: 0.31730280878910067  and c2: 0.24150613806134172
-```
-
-It also shows that `DistanceLab` is more formally known as `DistanceCIE76` and
-has been superseded by the slightly more accurate, but much more expensive
-`DistanceCIE94`.
-
-Note that `AlmostEqualRgb` is provided mainly for (unit-)testing purposes. Use
-it only if you really know what you're doing. It will eat your cat.
-
-### Blending colors
-Blending is highly connected to distance, since it basically "walks through" the
-colorspace thus, if the colorspace maps distances well, the walk is "smooth".
-
-Colorful comes with blending functions in RGB, HSV and any of the LAB spaces.
-Of course, you'd rather want to use the blending functions of the LAB spaces since
-these spaces map distances well but, just in case, here is an example showing
-you how the blendings (`#fdffcc` to `#242a42`) are done in the various spaces:
-
-![Blending colors in different spaces.](doc/colorblend/colorblend.png)
-
-What you see is that HSV is really bad: it adds some green, which is not present
-in the original colors at all! RGB is much better, but it stays light a little
-too long. LUV and LAB both hit the right lightness but LAB has a little more
-color. HCL works in the same vein as HSV (both cylindrical interpolations) but
-it does it right in that there is no green appearing and the lighthness changes
-in a linear manner.
-
-While this seems all good, you need to know one thing: When interpolating in any
-of the CIE color spaces, you might get invalid RGB colors! This is important if
-the starting and ending colors are user-input or random. An example of where this
-happens is when blending between `#eeef61` and `#1e3140`:
-
-![Invalid RGB colors may crop up when blending in CIE spaces.](doc/colorblend/invalid.png)
-
-You can test whether a color is a valid RGB color by calling the `IsValid` method
-and indeed, calling IsValid will return false for the redish colors on the bottom.
-One way to "fix" this is to get a valid color close to the invalid one by calling
-`Clamped`, which always returns a nearby valid color. Doing this, we get the
-following result, which is satisfactory:
-
-![Fixing invalid RGB colors by clamping them to the valid range.](doc/colorblend/clamped.png)
-
-The following is the code creating the above three images; it can be found in `doc/colorblend/colorblend.go`
-
-```go
-package main
-
-import "fmt"
-import "github.com/lucasb-eyer/go-colorful"
-import "image"
-import "image/draw"
-import "image/png"
-import "os"
-
-func main() {
-    blocks := 10
-    blockw := 40
-    img := image.NewRGBA(image.Rect(0,0,blocks*blockw,200))
-
-    c1, _ := colorful.Hex("#fdffcc")
-    c2, _ := colorful.Hex("#242a42")
-
-    // Use these colors to get invalid RGB in the gradient.
-    //c1, _ := colorful.Hex("#EEEF61")
-    //c2, _ := colorful.Hex("#1E3140")
-
-    for i := 0 ; i < blocks ; i++ {
-        draw.Draw(img, image.Rect(i*blockw,  0,(i+1)*blockw, 40), &image.Uniform{c1.BlendHsv(c2, float64(i)/float64(blocks-1))}, image.ZP, draw.Src)
-        draw.Draw(img, image.Rect(i*blockw, 40,(i+1)*blockw, 80), &image.Uniform{c1.BlendLuv(c2, float64(i)/float64(blocks-1))}, image.ZP, draw.Src)
-        draw.Draw(img, image.Rect(i*blockw, 80,(i+1)*blockw,120), &image.Uniform{c1.BlendRgb(c2, float64(i)/float64(blocks-1))}, image.ZP, draw.Src)
-        draw.Draw(img, image.Rect(i*blockw,120,(i+1)*blockw,160), &image.Uniform{c1.BlendLab(c2, float64(i)/float64(blocks-1))}, image.ZP, draw.Src)
-        draw.Draw(img, image.Rect(i*blockw,160,(i+1)*blockw,200), &image.Uniform{c1.BlendHcl(c2, float64(i)/float64(blocks-1))}, image.ZP, draw.Src)
-
-        // This can be used to "fix" invalid colors in the gradient.
-        //draw.Draw(img, image.Rect(i*blockw,160,(i+1)*blockw,200), &image.Uniform{c1.BlendHcl(c2, float64(i)/float64(blocks-1)).Clamped()}, image.ZP, draw.Src)
-    }
-
-    toimg, err := os.Create("colorblend.png")
-    if err != nil {
-        fmt.Printf("Error: %v", err)
-        return
-    }
-    defer toimg.Close()
-
-    png.Encode(toimg, img)
-}
-```
-
-#### Generating color gradients
-A very common reason to blend colors is creating gradients. There is an example
-program in [doc/gradientgen.go](doc/gradientgen/gradientgen.go); it doesn't use any API
-which hasn't been used in the previous example code, so I won't bother pasting
-the code in here. Just look at that gorgeous gradient it generated in HCL space:
-
-!["Spectral" colorbrewer gradient in HCL space.](doc/gradientgen/gradientgen.png)
-
-### Getting random colors
-It is sometimes necessary to generate random colors. You could simply do this
-on your own by generating colors with random values. By restricting the random
-values to a range smaller than [0..1] and using a space such as CIE-H\*C\*l° or
-HSV, you can generate both random shades of a color or random colors of a
-lightness:
-
-```go
-random_blue := colorful.Hcl(180.0+rand.Float64()*50.0, 0.2+rand.Float64()*0.8, 0.3+rand.Float64()*0.7)
-random_dark := colorful.Hcl(rand.Float64()*360.0, rand.Float64(), rand.Float64()*0.4)
-random_light := colorful.Hcl(rand.Float64()*360.0, rand.Float64(), 0.6+rand.Float64()*0.4)
-```
-
-Since getting random "warm" and "happy" colors is quite a common task, there
-are some helper functions:
-
-```go
-colorful.WarmColor()
-colorful.HappyColor()
-colorful.FastWarmColor()
-colorful.FastHappyColor()
-```
-
-The ones prefixed by `Fast` are faster but less coherent since they use the HSV
-space as opposed to the regular ones which use CIE-L\*C\*h° space. The
-following picture shows the warm colors in the top two rows and happy colors
-in the bottom two rows. Within these, the first is the regular one and the
-second is the fast one.
-
-![Warm, fast warm, happy and fast happy random colors, respectively.](doc/colorgens/colorgens.png)
-
-Don't forget to initialize the random seed! You can see the code used for
-generating this picture in `doc/colorgens/golorgens.go`.
-
-### Getting random palettes
-As soon as you need to generate more than one random color, you probably want
-them to be distinguishible. Playing against an opponent which has almost the
-same blue as I do is not fun. This is where random palettes can help.
-
-These palettes are generated using an algorithm which ensures that all colors
-on the palette are as distinguishible as possible. Again, there is a `Fast`
-method which works in HSV and is less perceptually uniform and a non-`Fast`
-method which works in CIE spaces. For more theory on `SoftPalette`, check out
-[I want hue](http://tools.medialab.sciences-po.fr/iwanthue/theory.php). Yet
-again, there is a `Happy` and a `Warm` version, which do what you expect, but
-now there is an additional `Soft` version, which is more configurable: you can
-give a constraint on the color space in order to get colors within a certain *feel*.
-
-Let's start with the simple methods first, all they take is the amount of
-colors to generate, which could, for example, be the player count. They return
-an array of `colorful.Color` objects:
-
-```go
-pal1, err1 := colorful.WarmPalette(10)
-pal2 := colorful.FastWarmPalette(10)
-pal3, err3 := colorful.HappyPalette(10)
-pal4 := colorful.FastHappyPalette(10)
-pal5, err5 := colorful.SoftPalette(10)
-```
-
-Note that the non-fast methods *may* fail if you ask for way too many colors.
-Let's move on to the advanced one, namely `SoftPaletteEx`. Besides the color
-count, this function takes a `SoftPaletteSettings` object as argument. The
-interesting part here is its `CheckColor` member, which is a boolean function
-taking three floating points as arguments: `l`, `a` and `b`. This function
-should return `true` for colors which lie within the region you want and `false`
-otherwise. The other members are `Iteration`, which should be within [5..100]
-where higher means slower but more exact palette, and `ManySamples` which you
-should set to `true` in case your `CheckColor` constraint rejects a large part
-of the color space.
-
-For example, to create a palette of 10 brownish colors, you'd call it like this:
-
-```go
-func isbrowny(l, a, b float64) bool {
-    h, c, L := colorful.LabToHcl(l, a, b)
-    return 10.0 < h && h < 50.0 && 0.1 < c && c < 0.5 && L < 0.5
-}
-// Since the above function is pretty restrictive, we set ManySamples to true.
-brownies := colorful.SoftPaletteEx(10, colorful.SoftPaletteSettings{isbrowny, 50, true})
-```
-
-The following picture shows the palettes generated by all of these methods
-(sourcecode in `doc/palettegens/palettegens.go`), in the order they were presented, i.e.
-from top to bottom: `Warm`, `FastWarm`, `Happy`, `FastHappy`, `Soft`,
-`SoftEx(isbrowny)`. All of them contain some randomness, so YMMV.
-
-![All example palettes](doc/palettegens/palettegens.png)
-
-### Sorting colors
-TODO: Sort using dist fn.
-
-### Using linear RGB for computations
-There are two methods for transforming RGB<->Linear RGB: a fast and almost precise one,
-and a slow and precise one.
-
-```go
-r, g, b := colorful.Hex("#FF0000").FastLinearRgb()
-```
-
-TODO: describe some more.
-
-### Want to use some other reference point?
-
-```go
-c := colorful.LabWhiteRef(0.507850, 0.040585,-0.370945, colorful.D50)
-l, a, b := c.LabWhiteRef(colorful.D50)
-```
-
-FAQ
-===
-
-### Q: I get all f!@#ed up values! Your library sucks!
-A: You probably provided values in the wrong range. For example, RGB values are
-expected to reside between 0 and 1, *not* between 0 and 255. Normalize your colors.
-
-Who?
-====
-
-This library has been developed by Lucas Beyer with contributions from
-Bastien Dejean (@baskerville) and Phil Kulak (@pkulak).
-
-License: MIT
-============
-Copyright (c) 2013 Lucas Beyer
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

vendor/github.com/lucasb-eyer/go-colorful/colorgens.go

@@ -1,54 +0,0 @@
-// Various ways to generate single random colors
-
-package colorful
-
-import (
-    "math/rand"
-)
-
-// Creates a random dark, "warm" color through a restricted HSV space.
-func FastWarmColor() Color {
-    return Hsv(
-        rand.Float64() * 360.0,
-        0.5 + rand.Float64()*0.3,
-        0.3 + rand.Float64()*0.3)
-}
-
-// Creates a random dark, "warm" color through restricted HCL space.
-// This is slower than FastWarmColor but will likely give you colors which have
-// the same "warmness" if you run it many times.
-func WarmColor() (c Color) {
-    for c = randomWarm() ; !c.IsValid() ; c = randomWarm() {}
-    return
-}
-
-func randomWarm() Color {
-    return Hcl(
-        rand.Float64() * 360.0,
-        0.1 + rand.Float64()*0.3,
-        0.2 + rand.Float64()*0.3)
-}
-
-// Creates a random bright, "pimpy" color through a restricted HSV space.
-func FastHappyColor() Color {
-    return Hsv(
-        rand.Float64() * 360.0,
-        0.7 + rand.Float64()*0.3,
-        0.6 + rand.Float64()*0.3)
-}
-
-// Creates a random bright, "pimpy" color through restricted HCL space.
-// This is slower than FastHappyColor but will likely give you colors which
-// have the same "brightness" if you run it many times.
-func HappyColor() (c Color) {
-    for c = randomPimp() ; !c.IsValid() ; c = randomPimp() {}
-    return
-}
-
-func randomPimp() Color {
-    return Hcl(
-        rand.Float64() * 360.0,
-        0.5 + rand.Float64()*0.3,
-        0.5 + rand.Float64()*0.3)
-}
-

vendor/github.com/lucasb-eyer/go-colorful/colors.go

@@ -1,617 +0,0 @@
-// The colorful package provides all kinds of functions for working with colors.
-package colorful
-
-import(
-    "fmt"
-    "math"
-)
-
-// A color is stored internally using sRGB (standard RGB) values in the range 0-1
-type Color struct {
-    R, G, B float64
-}
-
-// Implement the Go color.Color interface.
-func (col Color) RGBA() (r, g, b, a uint32) {
-    r = uint32(col.R*65535.0)
-    g = uint32(col.G*65535.0)
-    b = uint32(col.B*65535.0)
-    a = 0xFFFF
-    return
-}
-
-// Might come in handy sometimes to reduce boilerplate code.
-func (col Color) RGB255() (r, g, b uint8) {
-    r = uint8(col.R*255.0)
-    g = uint8(col.G*255.0)
-    b = uint8(col.B*255.0)
-    return
-}
-
-// This is the tolerance used when comparing colors using AlmostEqualRgb.
-const Delta = 1.0/255.0
-
-// This is the default reference white point.
-var D65 = [3]float64{0.95047, 1.00000, 1.08883}
-
-// And another one.
-var D50 = [3]float64{0.96422, 1.00000, 0.82521}
-
-// Checks whether the color exists in RGB space, i.e. all values are in [0..1]
-func (c Color) IsValid() bool {
-    return 0.0 <= c.R && c.R <= 1.0 &&
-           0.0 <= c.G && c.G <= 1.0 &&
-           0.0 <= c.B && c.B <= 1.0
-}
-
-func clamp01(v float64) float64 {
-    return math.Max(0.0, math.Min(v, 1.0))
-}
-
-// Returns Clamps the color into valid range, clamping each value to [0..1]
-// If the color is valid already, this is a no-op.
-func (c Color) Clamped() Color {
-    return Color{clamp01(c.R), clamp01(c.G), clamp01(c.B)}
-}
-
-func sq(v float64) float64 {
-    return v * v;
-}
-
-func cub(v float64) float64 {
-    return v * v * v;
-}
-
-// DistanceRgb computes the distance between two colors in RGB space.
-// This is not a good measure! Rather do it in Lab space.
-func (c1 Color) DistanceRgb(c2 Color) float64 {
-    return math.Sqrt(sq(c1.R-c2.R) + sq(c1.G-c2.G) + sq(c1.B-c2.B))
-}
-
-// Check for equality between colors within the tolerance Delta (1/255).
-func (c1 Color) AlmostEqualRgb(c2 Color) bool {
-    return math.Abs(c1.R - c2.R) +
-           math.Abs(c1.G - c2.G) +
-           math.Abs(c1.B - c2.B) < 3.0*Delta
-}
-
-// You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.
-func (c1 Color) BlendRgb(c2 Color, t float64) Color {
-    return Color{c1.R + t*(c2.R - c1.R),
-                 c1.G + t*(c2.G - c1.G),
-                 c1.B + t*(c2.B - c1.B)}
-}
-
-
-/// HSV ///
-///////////
-// From http://en.wikipedia.org/wiki/HSL_and_HSV
-// Note that h is in [0..360] and s,v in [0..1]
-
-// Hsv returns the Hue [0..360], Saturation and Value [0..1] of the color.
-func (col Color) Hsv() (h, s, v float64) {
-    min := math.Min(math.Min(col.R, col.G), col.B)
-    v    = math.Max(math.Max(col.R, col.G), col.B)
-    C := v - min
-
-    s = 0.0
-    if v != 0.0 {
-        s = C / v
-    }
-
-    h = 0.0  // We use 0 instead of undefined as in wp.
-    if min != v {
-        if v == col.R { h = math.Mod((col.G - col.B) / C, 6.0) }
-        if v == col.G { h = (col.B - col.R) / C + 2.0 }
-        if v == col.B { h = (col.R - col.G) / C + 4.0 }
-        h *= 60.0
-        if h < 0.0 { h += 360.0 }
-    }
-    return
-}
-
-// Hsv creates a new Color given a Hue in [0..360], a Saturation and a Value in [0..1]
-func Hsv(H, S, V float64) Color {
-    Hp := H/60.0
-    C := V*S
-    X := C*(1.0-math.Abs(math.Mod(Hp, 2.0)-1.0))
-
-    m := V-C;
-    r, g, b := 0.0, 0.0, 0.0
-
-    switch {
-    case 0.0 <= Hp && Hp < 1.0: r = C; g = X
-    case 1.0 <= Hp && Hp < 2.0: r = X; g = C
-    case 2.0 <= Hp && Hp < 3.0: g = C; b = X
-    case 3.0 <= Hp && Hp < 4.0: g = X; b = C
-    case 4.0 <= Hp && Hp < 5.0: r = X; b = C
-    case 5.0 <= Hp && Hp < 6.0: r = C; b = X
-    }
-
-    return Color{m+r, m+g, m+b}
-}
-
-// You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.
-func (c1 Color) BlendHsv(c2 Color, t float64) Color {
-    h1, s1, v1 := c1.Hsv()
-    h2, s2, v2 := c2.Hsv()
-
-    // We know that h are both in [0..360]
-    var H float64
-    if math.Abs(h2 - h1) <= 180.0 {
-        // Won't wrap
-        H = h1 + t*(h2-h1)
-    } else if h1 < h2 {
-        // Will wrap
-        H = math.Mod(h1 + 360.0 + t*(h2 - h1 - 360.0), 360.0)
-    } else {
-        // Will wrap
-        H = math.Mod(h2 + 360.0 + t*(h1 - h2 - 360.0), 360.0)
-    }
-
-    return Hsv(H, s1 + t*(s2 - s1), v1 + t*(v2 - v1))
-}
-
-/// Hex ///
-///////////
-
-// Hex returns the hex "html" representation of the color, as in #ff0080.
-func (col Color) Hex() string {
-    // Add 0.5 for rounding
-    return fmt.Sprintf("#%02x%02x%02x", uint8(col.R*255.0+0.5), uint8(col.G*255.0+0.5), uint8(col.B*255.0+0.5))
-}
-
-// Hex parses a "html" hex color-string, either in the 3 "#f0c" or 6 "#ff1034" digits form.
-func Hex(scol string) (Color, error) {
-    format := "#%02x%02x%02x"
-    factor := 1.0/255.0
-    if len(scol) == 4 {
-        format = "#%1x%1x%1x"
-        factor = 1.0/15.0
-    }
-
-    var r, g, b uint8
-    n, err := fmt.Sscanf(scol, format, &r, &g, &b)
-    if err != nil {
-        return Color{}, err
-    }
-    if n != 3 {
-        return Color{}, fmt.Errorf("color: %v is not a hex-color", scol)
-    }
-
-    return Color{float64(r)*factor, float64(g)*factor, float64(b)*factor}, nil
-}
-
-/// Linear ///
-//////////////
-// http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/
-// http://www.brucelindbloom.com/Eqn_RGB_to_XYZ.html
-
-func linearize(v float64) float64 {
-    if v <= 0.04045 {
-        return v / 12.92
-    }
-    return math.Pow((v + 0.055)/1.055, 2.4)
-}
-
-// LinearRgb converts the color into the linear RGB space (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).
-func (col Color) LinearRgb() (r, g, b float64) {
-    r = linearize(col.R)
-    g = linearize(col.G)
-    b = linearize(col.B)
-    return
-}
-
-// FastLinearRgb is much faster than and almost as accurate as LinearRgb.
-func (col Color) FastLinearRgb() (r, g, b float64) {
-    r = math.Pow(col.R, 2.2)
-    g = math.Pow(col.G, 2.2)
-    b = math.Pow(col.B, 2.2)
-    return
-}
-
-func delinearize(v float64) float64 {
-    if v <= 0.0031308 {
-        return 12.92 * v
-    }
-    return 1.055 * math.Pow(v, 1.0/2.4) - 0.055
-}
-
-// LinearRgb creates an sRGB color out of the given linear RGB color (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).
-func LinearRgb(r, g, b float64) Color {
-    return Color{delinearize(r), delinearize(g), delinearize(b)}
-}
-
-// FastLinearRgb is much faster than and almost as accurate as LinearRgb.
-func FastLinearRgb(r, g, b float64) Color {
-    return Color{math.Pow(r, 1.0/2.2), math.Pow(g, 1.0/2.2), math.Pow(b, 1.0/2.2)}
-}
-
-// XyzToLinearRgb converts from CIE XYZ-space to Linear RGB space.
-func XyzToLinearRgb(x, y, z float64) (r, g, b float64) {
-    r =  3.2404542*x - 1.5371385*y - 0.4985314*z
-    g = -0.9692660*x + 1.8760108*y + 0.0415560*z
-    b =  0.0556434*x - 0.2040259*y + 1.0572252*z
-    return
-}
-
-func LinearRgbToXyz(r, g, b float64) (x, y, z float64) {
-    x = 0.4124564*r + 0.3575761*g + 0.1804375*b
-    y = 0.2126729*r + 0.7151522*g + 0.0721750*b
-    z = 0.0193339*r + 0.1191920*g + 0.9503041*b
-    return
-}
-
-/// XYZ ///
-///////////
-// http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/
-
-func (col Color) Xyz() (x, y, z float64) {
-    return LinearRgbToXyz(col.LinearRgb())
-}
-
-func Xyz(x, y, z float64) Color {
-    return LinearRgb(XyzToLinearRgb(x, y, z))
-}
-
-/// xyY ///
-///////////
-// http://www.brucelindbloom.com/Eqn_XYZ_to_xyY.html
-
-// Well, the name is bad, since it's xyY but Golang needs me to start with a
-// capital letter to make the method public.
-func XyzToXyy(X, Y, Z float64) (x, y, Yout float64) {
-    return XyzToXyyWhiteRef(X, Y, Z, D65)
-}
-
-func XyzToXyyWhiteRef(X, Y, Z float64, wref [3]float64) (x, y, Yout float64) {
-    Yout = Y
-    N := X + Y + Z
-    if math.Abs(N) < 1e-14 {
-        // When we have black, Bruce Lindbloom recommends to use
-        // the reference white's chromacity for x and y.
-        x = wref[0] / (wref[0] + wref[1] + wref[2])
-        y = wref[1] / (wref[0] + wref[1] + wref[2])
-    } else {
-        x = X / N
-        y = Y / N
-    }
-    return
-}
-
-func XyyToXyz(x, y, Y float64) (X, Yout, Z float64) {
-    Yout = Y
-
-    if -1e-14 < y && y < 1e-14 {
-        X = 0.0
-        Z = 0.0
-    } else {
-        X = Y / y * x
-        Z = Y / y * (1.0 - x - y)
-    }
-
-    return
-}
-
-// Converts the given color to CIE xyY space using D65 as reference white.
-// (Note that the reference white is only used for black input.)
-// x, y and Y are in [0..1]
-func (col Color) Xyy() (x, y, Y float64) {
-    return XyzToXyy(col.Xyz())
-}
-
-// Converts the given color to CIE xyY space, taking into account
-// a given reference white. (i.e. the monitor's white)
-// (Note that the reference white is only used for black input.)
-// x, y and Y are in [0..1]
-func (col Color) XyyWhiteRef(wref [3]float64) (x, y, Y float64) {
-    X, Y2, Z := col.Xyz()
-    return XyzToXyyWhiteRef(X, Y2, Z, wref)
-}
-
-// Generates a color by using data given in CIE xyY space.
-// x, y and Y are in [0..1]
-func Xyy(x, y, Y float64) Color {
-    return Xyz(XyyToXyz(x, y, Y))
-}
-
-/// L*a*b* ///
-//////////////
-// http://en.wikipedia.org/wiki/Lab_color_space#CIELAB-CIEXYZ_conversions
-// For L*a*b*, we need to L*a*b*<->XYZ->RGB and the first one is device dependent.
-
-func lab_f(t float64) float64 {
-    if t > 6.0/29.0 * 6.0/29.0 * 6.0/29.0 {
-        return math.Cbrt(t)
-    }
-    return t/3.0 * 29.0/6.0 * 29.0/6.0 + 4.0/29.0
-}
-
-func XyzToLab(x, y, z float64) (l, a, b float64) {
-    // Use D65 white as reference point by default.
-    // http://www.fredmiranda.com/forum/topic/1035332
-    // http://en.wikipedia.org/wiki/Standard_illuminant
-    return XyzToLabWhiteRef(x, y, z, D65)
-}
-
-func XyzToLabWhiteRef(x, y, z float64, wref [3]float64) (l, a, b float64) {
-    fy := lab_f(y/wref[1])
-    l = 1.16*fy - 0.16
-    a = 5.0*(lab_f(x/wref[0]) - fy)
-    b = 2.0*(fy - lab_f(z/wref[2]))
-    return
-}
-
-func lab_finv(t float64) float64 {
-    if t > 6.0/29.0 {
-        return t * t * t
-    }
-    return 3.0 * 6.0/29.0 * 6.0/29.0 * (t - 4.0/29.0)
-}
-
-func LabToXyz(l, a, b float64) (x, y, z float64) {
-    // D65 white (see above).
-    return LabToXyzWhiteRef(l, a, b, D65)
-}
-
-func LabToXyzWhiteRef(l, a, b float64, wref [3]float64) (x, y, z float64) {
-    l2 := (l + 0.16) / 1.16
-    x = wref[0] * lab_finv(l2 + a/5.0)
-    y = wref[1] * lab_finv(l2)
-    z = wref[2] * lab_finv(l2 - b/2.0)
-    return
-}
-
-// Converts the given color to CIE L*a*b* space using D65 as reference white.
-func (col Color) Lab() (l, a, b float64) {
-    return XyzToLab(col.Xyz())
-}
-
-// Converts the given color to CIE L*a*b* space, taking into account
-// a given reference white. (i.e. the monitor's white)
-func (col Color) LabWhiteRef(wref [3]float64) (l, a, b float64) {
-    x, y, z := col.Xyz()
-    return XyzToLabWhiteRef(x, y, z, wref)
-}
-
-// Generates a color by using data given in CIE L*a*b* space using D65 as reference white.
-func Lab(l, a, b float64) Color {
-    return Xyz(LabToXyz(l, a, b))
-}
-
-// Generates a color by using data given in CIE L*a*b* space, taking
-// into account a given reference white. (i.e. the monitor's white)
-func LabWhiteRef(l, a, b float64, wref [3]float64) Color {
-    return Xyz(LabToXyzWhiteRef(l, a, b, wref))
-}
-
-// DistanceLab is a good measure of visual similarity between two colors!
-// A result of 0 would mean identical colors, while a result of 1 or higher
-// means the colors differ a lot.
-func (c1 Color) DistanceLab(c2 Color) float64 {
-    l1, a1, b1 := c1.Lab()
-    l2, a2, b2 := c2.Lab()
-    return math.Sqrt(sq(l1-l2) + sq(a1-a2) + sq(b1-b2))
-}
-
-// That's actually the same, but I don't want to break code.
-func (c1 Color) DistanceCIE76(c2 Color) float64 {
-    return c1.DistanceLab(c2)
-}
-
-// Uses the CIE94 formula to calculate color distance. More accurate than
-// DistanceLab, but also more work.
-func (cl Color) DistanceCIE94(cr Color) float64 {
-    l1, a1, b1 := cl.Lab()
-    l2, a2, b2 := cr.Lab()
-
-    kl := 1.0
-    k1 := 0.045
-    k2 := 0.015
-
-    deltaL := l1 - l2
-    c1 := math.Sqrt(sq(a1) + sq(b1))
-    c2 := math.Sqrt(sq(a2) + sq(b2))
-    deltaCab := c1 - c2
-    deltaHab := math.Sqrt(sq(a1-a2) + sq(b1-b2) - sq(deltaCab))
-    sl := 1.0
-    sc := 1.0 + k1*c1
-    sh := 1.0 + k2*c1
-
-    return math.Sqrt(sq(deltaL/(kl*sl)) + sq(deltaCab/sc) + sq(deltaHab/sh))
-}
-
-// BlendLab blends two colors in the L*a*b* color-space, which should result in a smoother blend.
-// t == 0 results in c1, t == 1 results in c2
-func (c1 Color) BlendLab(c2 Color, t float64) Color {
-    l1, a1, b1 := c1.Lab()
-    l2, a2, b2 := c2.Lab()
-    return Lab(l1 + t*(l2 - l1),
-               a1 + t*(a2 - a1),
-               b1 + t*(b2 - b1))
-}
-
-/// L*u*v* ///
-//////////////
-// http://en.wikipedia.org/wiki/CIELUV#XYZ_.E2.86.92_CIELUV_and_CIELUV_.E2.86.92_XYZ_conversions
-// For L*u*v*, we need to L*u*v*<->XYZ<->RGB and the first one is device dependent.
-
-func XyzToLuv(x, y, z float64) (l, a, b float64) {
-    // Use D65 white as reference point by default.
-    // http://www.fredmiranda.com/forum/topic/1035332
-    // http://en.wikipedia.org/wiki/Standard_illuminant
-    return XyzToLuvWhiteRef(x, y, z, D65)
-}
-
-func XyzToLuvWhiteRef(x, y, z float64, wref [3]float64) (l, u, v float64) {
-    if y/wref[1] <= 6.0/29.0 * 6.0/29.0 * 6.0/29.0 {
-        l = y/wref[1] * 29.0/3.0 * 29.0/3.0 * 29.0/3.0
-    } else {
-        l = 1.16 * math.Cbrt(y/wref[1]) - 0.16
-    }
-    ubis, vbis := xyz_to_uv(x, y, z)
-    un, vn := xyz_to_uv(wref[0], wref[1], wref[2])
-    u = 13.0*l * (ubis - un)
-    v = 13.0*l * (vbis - vn)
-    return
-}
-
-// For this part, we do as R's graphics.hcl does, not as wikipedia does.
-// Or is it the same?
-func xyz_to_uv(x, y, z float64) (u, v float64) {
-    denom := x + 15.0*y + 3.0*z
-    if denom == 0.0 {
-        u, v = 0.0, 0.0
-    } else {
-        u = 4.0*x/denom
-        v = 9.0*y/denom
-    }
-    return
-}
-
-func LuvToXyz(l, u, v float64) (x, y, z float64) {
-    // D65 white (see above).
-    return LuvToXyzWhiteRef(l, u, v, D65)
-}
-
-func LuvToXyzWhiteRef(l, u, v float64, wref [3]float64) (x, y, z float64) {
-    //y = wref[1] * lab_finv((l + 0.16) / 1.16)
-    if l <= 0.08 {
-        y = wref[1] * l * 100.0 * 3.0/29.0 * 3.0/29.0 * 3.0/29.0
-    } else {
-        y = wref[1] * cub((l+0.16)/1.16)
-    }
-    un, vn := xyz_to_uv(wref[0], wref[1], wref[2])
-    if l != 0.0 {
-        ubis := u/(13.0*l) + un
-        vbis := v/(13.0*l) + vn
-        x = y*9.0*ubis/(4.0*vbis)
-        z = y*(12.0-3.0*ubis-20.0*vbis)/(4.0*vbis)
-    } else {
-        x, y = 0.0, 0.0
-    }
-    return
-}
-
-// Converts the given color to CIE L*u*v* space using D65 as reference white.
-// L* is in [0..1] and both u* and v* are in about [-1..1]
-func (col Color) Luv() (l, u, v float64) {
-    return XyzToLuv(col.Xyz())
-}
-
-// Converts the given color to CIE L*u*v* space, taking into account
-// a given reference white. (i.e. the monitor's white)
-// L* is in [0..1] and both u* and v* are in about [-1..1]
-func (col Color) LuvWhiteRef(wref [3]float64) (l, u, v float64) {
-    x, y, z := col.Xyz()
-    return XyzToLuvWhiteRef(x, y, z, wref)
-}
-
-// Generates a color by using data given in CIE L*u*v* space using D65 as reference white.
-// L* is in [0..1] and both u* and v* are in about [-1..1]
-func Luv(l, u, v float64) Color {
-    return Xyz(LuvToXyz(l, u, v))
-}
-
-// Generates a color by using data given in CIE L*u*v* space, taking
-// into account a given reference white. (i.e. the monitor's white)
-// L* is in [0..1] and both u* and v* are in about [-1..1]
-func LuvWhiteRef(l, u, v float64, wref [3]float64) Color {
-    return Xyz(LuvToXyzWhiteRef(l, u, v, wref))
-}
-
-// DistanceLuv is a good measure of visual similarity between two colors!
-// A result of 0 would mean identical colors, while a result of 1 or higher
-// means the colors differ a lot.
-func (c1 Color) DistanceLuv(c2 Color) float64 {
-    l1, u1, v1 := c1.Luv()
-    l2, u2, v2 := c2.Luv()
-    return math.Sqrt(sq(l1-l2) + sq(u1-u2) + sq(v1-v2))
-}
-
-// BlendLuv blends two colors in the CIE-L*u*v* color-space, which should result in a smoother blend.
-// t == 0 results in c1, t == 1 results in c2
-func (c1 Color) BlendLuv(c2 Color, t float64) Color {
-    l1, u1, v1 := c1.Luv()
-    l2, u2, v2 := c2.Luv()
-    return Luv(l1 + t*(l2 - l1),
-               u1 + t*(u2 - u1),
-               v1 + t*(v2 - v1))
-}
-
-/// HCL ///
-///////////
-// HCL is nothing else than L*a*b* in cylindrical coordinates!
-// (this was wrong on English wikipedia, I fixed it, let's hope the fix stays.)
-// But it is widely popular since it is a "correct HSV"
-// http://www.hunterlab.com/appnotes/an09_96a.pdf
-
-// Converts the given color to HCL space using D65 as reference white.
-// H values are in [0..360], C and L values are in [0..1] although C can overshoot 1.0
-func (col Color) Hcl() (h, c, l float64) {
-    return col.HclWhiteRef(D65)
-}
-
-func LabToHcl(L, a, b float64) (h, c, l float64) {
-    // Oops, floating point workaround necessary if a ~= b and both are very small (i.e. almost zero).
-    if math.Abs(b - a) > 1e-4 && math.Abs(a) > 1e-4 {
-        h = math.Mod(57.29577951308232087721*math.Atan2(b, a) + 360.0, 360.0) // Rad2Deg
-    } else {
-        h = 0.0
-    }
-    c = math.Sqrt(sq(a) + sq(b))
-    l = L
-    return
-}
-
-// Converts the given color to HCL space, taking into account
-// a given reference white. (i.e. the monitor's white)
-// H values are in [0..360], C and L values are in [0..1]
-func (col Color) HclWhiteRef(wref [3]float64) (h, c, l float64) {
-    L, a, b := col.LabWhiteRef(wref)
-    return LabToHcl(L, a, b)
-}
-
-// Generates a color by using data given in HCL space using D65 as reference white.
-// H values are in [0..360], C and L values are in [0..1]
-func Hcl(h, c, l float64) Color {
-    return HclWhiteRef(h, c, l, D65)
-}
-
-func HclToLab(h, c, l float64) (L, a, b float64) {
-    H := 0.01745329251994329576*h // Deg2Rad
-    a = c*math.Cos(H)
-    b = c*math.Sin(H)
-    L = l
-    return
-}
-
-// Generates a color by using data given in HCL space, taking
-// into account a given reference white. (i.e. the monitor's white)
-// H values are in [0..360], C and L values are in [0..1]
-func HclWhiteRef(h, c, l float64, wref [3]float64) Color {
-    L, a, b := HclToLab(h, c, l)
-    return LabWhiteRef(L, a, b, wref)
-}
-
-// BlendHcl blends two colors in the CIE-L*C*h° color-space, which should result in a smoother blend.
-// t == 0 results in c1, t == 1 results in c2
-func (col1 Color) BlendHcl(col2 Color, t float64) Color {
-    h1, c1, l1 := col1.Hcl()
-    h2, c2, l2 := col2.Hcl()
-
-    // We know that h are both in [0..360]
-    var H float64
-    if math.Abs(h2 - h1) <= 180.0 {
-        // Won't wrap
-        H = h1 + t*(h2-h1)
-    } else if h1 < h2 {
-        // Will wrap
-        H = math.Mod(h1 + 360.0 + t*(h2 - h1 - 360.0), 360.0)
-    } else {
-        // Will wrap
-        H = math.Mod(h2 + 360.0 + t*(h1 - h2 - 360.0), 360.0)
-    }
-
-    return Hcl(H, c1 + t*(c2 - c1), l1 + t*(l2 - l1))
-}

vendor/github.com/lucasb-eyer/go-colorful/happy_palettegen.go

@@ -1,26 +0,0 @@
-package colorful
-
-import (
-    "math/rand"
-)
-
-// Uses the HSV color space to generate colors with similar S,V but distributed
-// evenly along their Hue. This is fast but not always pretty.
-// If you've got time to spare, use Lab (the non-fast below).
-func FastHappyPalette(colorsCount int) (colors []Color) {
-    colors = make([]Color, colorsCount)
-
-    for i := 0 ; i < colorsCount ; i++ {
-        colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.8 + rand.Float64()*0.2, 0.65 + rand.Float64()*0.2)
-    }
-    return
-}
-
-func HappyPalette(colorsCount int) ([]Color, error) {
-    pimpy := func(l, a, b float64) bool {
-        _, c, _ := LabToHcl(l, a, b)
-        return 0.3 <= c && 0.4 <= l && l <= 0.8
-    }
-    return SoftPaletteEx(colorsCount, SoftPaletteSettings{pimpy, 50, true})
-}
-

vendor/github.com/lucasb-eyer/go-colorful/soft_palettegen.go

@@ -1,185 +0,0 @@
-// Largely inspired by the descriptions in http://lab.medialab.sciences-po.fr/iwanthue/
-// but written from scratch.
-
-package colorful
-
-import (
-    "fmt"
-    "math"
-    "math/rand"
-)
-
-// The algorithm works in L*a*b* color space and converts to RGB in the end.
-// L* in [0..1], a* and b* in [-1..1]
-type lab_t struct {
-    L, A, B float64
-}
-
-type SoftPaletteSettings struct {
-    // A function which can be used to restrict the allowed color-space.
-    CheckColor func(l, a, b float64) bool
-
-    // The higher, the better quality but the slower. Usually two figures.
-    Iterations int
-
-    // Use up to 160000 or 8000 samples of the L*a*b* space (and thus calls to CheckColor).
-    // Set this to true only if your CheckColor shapes the Lab space weirdly.
-    ManySamples bool
-}
-
-// Yeah, windows-stype Foo, FooEx, screw you golang...
-// Uses K-means to cluster the color-space and return the means of the clusters
-// as a new palette of distinctive colors. Falls back to K-medoid if the mean
-// happens to fall outside of the color-space, which can only happen if you
-// specify a CheckColor function.
-func SoftPaletteEx(colorsCount int, settings SoftPaletteSettings) ([]Color, error) {
-
-    // Checks whether it's a valid RGB and also fulfills the potentially provided constraint.
-    check := func(col lab_t) bool {
-        c := Lab(col.L, col.A, col.B)
-        return c.IsValid() && (settings.CheckColor == nil || settings.CheckColor(col.L, col.A, col.B))
-    }
-
-    // Sample the color space. These will be the points k-means is run on.
-    dl := 0.05
-    dab := 0.1
-    if settings.ManySamples {
-        dl = 0.01
-        dab = 0.05
-    }
-
-    samples := make([]lab_t, 0, int(1.0/dl * 2.0/dab * 2.0/dab))
-    for l := 0.0; l <= 1.0; l += dl {
-        for a := -1.0; a <= 1.0; a += dab {
-            for b := -1.0; b <= 1.0; b += dab {
-                if check(lab_t{l,a,b}) {
-                    samples = append(samples, lab_t{l, a, b})
-                }
-            }
-        }
-    }
-
-    // That would cause some infinite loops down there...
-    if len(samples) < colorsCount {
-        return nil, fmt.Errorf("palettegen: more colors requested (%v) than samples available (%v). Your requested color count may be wrong, you might want to use many samples or your constraint function makes the valid color space too small.", colorsCount, len(samples))
-    } else if len(samples) == colorsCount {
-        return labs2cols(samples), nil // Oops?
-    }
-
-    // We take the initial means out of the samples, so they are in fact medoids.
-    // This helps us avoid infinite loops or arbitrary cutoffs with too restrictive constraints.
-    means := make([]lab_t, colorsCount)
-    for i := 0; i < colorsCount; i++ {
-        for means[i] = samples[rand.Intn(len(samples))] ; in(means, i, means[i]) ; means[i] = samples[rand.Intn(len(samples))] {
-        }
-    }
-
-    clusters := make([]int, len(samples))
-    samples_used := make([]bool, len(samples))
-
-    // The actual k-means/medoid iterations
-    for i := 0; i < settings.Iterations; i++ {
-        // Reassing the samples to clusters, i.e. to their closest mean.
-        // By the way, also check if any sample is used as a medoid and if so, mark that.
-        for isample, sample := range samples {
-            samples_used[isample] = false
-            mindist := math.Inf(+1)
-            for imean, mean := range means {
-                dist := lab_dist(sample, mean)
-                if dist < mindist {
-                    mindist = dist
-                    clusters[isample] = imean
-                }
-
-                // Mark samples which are used as a medoid.
-                if lab_eq(sample, mean) {
-                    samples_used[isample] = true
-                }
-            }
-        }
-
-        // Compute new means according to the samples.
-        for imean := range means {
-            // The new mean is the average of all samples belonging to it..
-            nsamples := 0
-            newmean := lab_t{0.0, 0.0, 0.0}
-            for isample, sample := range samples {
-                if clusters[isample] == imean {
-                    nsamples++
-                    newmean.L += sample.L
-                    newmean.A += sample.A
-                    newmean.B += sample.B
-                }
-            }
-            if nsamples > 0 {
-                newmean.L /= float64(nsamples)
-                newmean.A /= float64(nsamples)
-                newmean.B /= float64(nsamples)
-            } else {
-                // That mean doesn't have any samples? Get a new mean from the sample list!
-                var inewmean int
-                for inewmean = rand.Intn(len(samples_used)); samples_used[inewmean]; inewmean = rand.Intn(len(samples_used)) {
-                }
-                newmean = samples[inewmean]
-                samples_used[inewmean] = true
-            }
-
-            // But now we still need to check whether the new mean is an allowed color.
-            if nsamples > 0 && check(newmean) {
-                // It does, life's good (TM)
-                means[imean] = newmean
-            } else {
-                // New mean isn't an allowed color or doesn't have any samples!
-                // Switch to medoid mode and pick the closest (unused) sample.
-                // This should always find something thanks to len(samples) >= colorsCount
-                mindist := math.Inf(+1)
-                for isample, sample := range samples {
-                    if !samples_used[isample] {
-                        dist := lab_dist(sample, newmean)
-                        if dist < mindist {
-                            mindist = dist
-                            newmean = sample
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return labs2cols(means), nil
-}
-
-// A wrapper which uses common parameters.
-func SoftPalette(colorsCount int) ([]Color, error) {
-    return SoftPaletteEx(colorsCount, SoftPaletteSettings{nil, 50, false})
-}
-
-func in(haystack []lab_t, upto int, needle lab_t) bool {
-    for i := 0 ; i < upto && i < len(haystack) ; i++ {
-        if haystack[i] == needle {
-            return true
-        }
-    }
-    return false
-}
-
-const LAB_DELTA = 1e-6
-func lab_eq(lab1, lab2 lab_t) bool {
-    return math.Abs(lab1.L - lab2.L) < LAB_DELTA &&
-           math.Abs(lab1.A - lab2.A) < LAB_DELTA &&
-           math.Abs(lab1.B - lab2.B) < LAB_DELTA
-}
-
-// That's faster than using colorful's DistanceLab since we would have to
-// convert back and forth for that. Here is no conversion.
-func lab_dist(lab1, lab2 lab_t) float64 {
-    return math.Sqrt(sq(lab1.L-lab2.L) + sq(lab1.A-lab2.A) + sq(lab1.B-lab2.B))
-}
-
-func labs2cols(labs []lab_t) (cols []Color) {
-    cols = make([]Color, len(labs))
-    for k, v := range labs {
-        cols[k] = Lab(v.L, v.A, v.B)
-    }
-    return cols
-}
-

vendor/github.com/lucasb-eyer/go-colorful/warm_palettegen.go

@@ -1,26 +0,0 @@
-package colorful
-
-import (
-    "math/rand"
-)
-
-// Uses the HSV color space to generate colors with similar S,V but distributed
-// evenly along their Hue. This is fast but not always pretty.
-// If you've got time to spare, use Lab (the non-fast below).
-func FastWarmPalette(colorsCount int) (colors []Color) {
-    colors = make([]Color, colorsCount)
-
-    for i := 0 ; i < colorsCount ; i++ {
-        colors[i] = Hsv(float64(i)*(360.0/float64(colorsCount)), 0.55 + rand.Float64()*0.2, 0.35 + rand.Float64()*0.2)
-    }
-    return
-}
-
-func WarmPalette(colorsCount int) ([]Color, error) {
-    warmy := func(l, a, b float64) bool {
-        _, c, _ := LabToHcl(l, a, b)
-        return 0.1 <= c && c <= 0.4 && 0.2 <= l && l <= 0.5
-    }
-    return SoftPaletteEx(colorsCount, SoftPaletteSettings{warmy, 50, true})
-}
-

vendor/golang.org/x/image/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/image/PATENTS

@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.

vendor/golang.org/x/image/font/font.go

@@ -1,230 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package font defines an interface for font faces, for drawing text on an
-// image.
-//
-// Other packages provide font face implementations. For example, a truetype
-// package would provide one based on .ttf font files.
-package font
-
-import (
-	"image"
-	"image/draw"
-	"io"
-
-	"golang.org/x/image/math/fixed"
-)
-
-// TODO: who is responsible for caches (glyph images, glyph indices, kerns)?
-// The Drawer or the Face?
-
-// Face is a font face. Its glyphs are often derived from a font file, such as
-// "Comic_Sans_MS.ttf", but a face has a specific size, style, weight and
-// hinting. For example, the 12pt and 18pt versions of Comic Sans are two
-// different faces, even if derived from the same font file.
-//
-// A Face is not safe for concurrent use by multiple goroutines, as its methods
-// may re-use implementation-specific caches and mask image buffers.
-//
-// To create a Face, look to other packages that implement specific font file
-// formats.
-type Face interface {
-	io.Closer
-
-	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
-	// glyph at the sub-pixel destination location dot, and that glyph's
-	// advance width.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	//
-	// The contents of the mask image returned by one Glyph call may change
-	// after the next Glyph call. Callers that want to cache the mask must make
-	// a copy.
-	Glyph(dot fixed.Point26_6, r rune) (
-		dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool)
-
-	// GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal
-	// to the origin, and that glyph's advance width.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	//
-	// The glyph's ascent and descent equal -bounds.Min.Y and +bounds.Max.Y. A
-	// visual depiction of what these metrics are is at
-	// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
-	GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool)
-
-	// GlyphAdvance returns the advance width of r's glyph.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool)
-
-	// Kern returns the horizontal adjustment for the kerning pair (r0, r1). A
-	// positive kern means to move the glyphs further apart.
-	Kern(r0, r1 rune) fixed.Int26_6
-
-	// Metrics returns the metrics for this Face.
-	Metrics() Metrics
-
-	// TODO: ColoredGlyph for various emoji?
-	// TODO: Ligatures? Shaping?
-}
-
-// Metrics holds the metrics for a Face. A visual depiction is at
-// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
-type Metrics struct {
-	// Height is the recommended amount of vertical space between two lines of
-	// text.
-	Height fixed.Int26_6
-
-	// Ascent is the distance from the top of a line to its baseline.
-	Ascent fixed.Int26_6
-
-	// Descent is the distance from the bottom of a line to its baseline. The
-	// value is typically positive, even though a descender goes below the
-	// baseline.
-	Descent fixed.Int26_6
-}
-
-// TODO: Drawer.Layout or Drawer.Measure methods to measure text without
-// drawing?
-
-// Drawer draws text on a destination image.
-//
-// A Drawer is not safe for concurrent use by multiple goroutines, since its
-// Face is not.
-type Drawer struct {
-	// Dst is the destination image.
-	Dst draw.Image
-	// Src is the source image.
-	Src image.Image
-	// Face provides the glyph mask images.
-	Face Face
-	// Dot is the baseline location to draw the next glyph. The majority of the
-	// affected pixels will be above and to the right of the dot, but some may
-	// be below or to the left. For example, drawing a 'j' in an italic face
-	// may affect pixels below and to the left of the dot.
-	Dot fixed.Point26_6
-
-	// TODO: Clip image.Image?
-	// TODO: SrcP image.Point for Src images other than *image.Uniform? How
-	// does it get updated during DrawString?
-}
-
-// TODO: should DrawString return the last rune drawn, so the next DrawString
-// call can kern beforehand? Or should that be the responsibility of the caller
-// if they really want to do that, since they have to explicitly shift d.Dot
-// anyway?
-//
-// In general, we'd have a DrawBytes([]byte) and DrawRuneReader(io.RuneReader)
-// and the last case can't assume that you can rewind the stream.
-//
-// TODO: how does this work with line breaking: drawing text up until a
-// vertical line? Should DrawString return the number of runes drawn?
-
-// DrawString draws s at the dot and advances the dot's location.
-func (d *Drawer) DrawString(s string) {
-	var prevC rune
-	for i, c := range s {
-		if i != 0 {
-			d.Dot.X += d.Face.Kern(prevC, c)
-		}
-		dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
-		d.Dot.X += advance
-		prevC = c
-	}
-}
-
-// MeasureString returns how far dot would advance by drawing s.
-func (d *Drawer) MeasureString(s string) (advance fixed.Int26_6) {
-	return MeasureString(d.Face, s)
-}
-
-// MeasureString returns how far dot would advance by drawing s with f.
-func MeasureString(f Face, s string) (advance fixed.Int26_6) {
-	var prevC rune
-	for i, c := range s {
-		if i != 0 {
-			advance += f.Kern(prevC, c)
-		}
-		a, ok := f.GlyphAdvance(c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		advance += a
-		prevC = c
-	}
-	return advance
-}
-
-// Hinting selects how to quantize a vector font's glyph nodes.
-//
-// Not all fonts support hinting.
-type Hinting int
-
-const (
-	HintingNone Hinting = iota
-	HintingVertical
-	HintingFull
-)
-
-// Stretch selects a normal, condensed, or expanded face.
-//
-// Not all fonts support stretches.
-type Stretch int
-
-const (
-	StretchUltraCondensed Stretch = -4
-	StretchExtraCondensed Stretch = -3
-	StretchCondensed      Stretch = -2
-	StretchSemiCondensed  Stretch = -1
-	StretchNormal         Stretch = +0
-	StretchSemiExpanded   Stretch = +1
-	StretchExpanded       Stretch = +2
-	StretchExtraExpanded  Stretch = +3
-	StretchUltraExpanded  Stretch = +4
-)
-
-// Style selects a normal, italic, or oblique face.
-//
-// Not all fonts support styles.
-type Style int
-
-const (
-	StyleNormal Style = iota
-	StyleItalic
-	StyleOblique
-)
-
-// Weight selects a normal, light or bold face.
-//
-// Not all fonts support weights.
-//
-// The named Weight constants (e.g. WeightBold) correspond to CSS' common
-// weight names (e.g. "Bold"), but the numerical values differ, so that in Go,
-// the zero value means to use a normal weight. For the CSS names and values,
-// see https://developer.mozilla.org/en/docs/Web/CSS/font-weight
-type Weight int
-
-const (
-	WeightThin       Weight = -3 // CSS font-weight value 100.
-	WeightExtraLight Weight = -2 // CSS font-weight value 200.
-	WeightLight      Weight = -1 // CSS font-weight value 300.
-	WeightNormal     Weight = +0 // CSS font-weight value 400.
-	WeightMedium     Weight = +1 // CSS font-weight value 500.
-	WeightSemiBold   Weight = +2 // CSS font-weight value 600.
-	WeightBold       Weight = +3 // CSS font-weight value 700.
-	WeightExtraBold  Weight = +4 // CSS font-weight value 800.
-	WeightBlack      Weight = +5 // CSS font-weight value 900.
-)

vendor/golang.org/x/image/math/fixed/fixed.go

@@ -1,202 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fixed implements fixed-point integer types.
-package fixed
-
-import (
-	"fmt"
-)
-
-// TODO: implement fmt.Formatter for %f and %g.
-
-// I returns the integer value i as an Int26_6.
-//
-// For example, passing the integer value 2 yields Int26_6(128).
-func I(i int) Int26_6 {
-	return Int26_6(i << 6)
-}
-
-// Int26_6 is a signed 26.6 fixed-point number.
-//
-// The integer part ranges from -33554432 to 33554431, inclusive. The
-// fractional part has 6 bits of precision.
-//
-// For example, the number one-and-a-quarter is Int26_6(1<<6 + 1<<4).
-type Int26_6 int32
-
-// String returns a human-readable representation of a 26.6 fixed-point number.
-//
-// For example, the number one-and-a-quarter becomes "1:16".
-func (x Int26_6) String() string {
-	const shift, mask = 6, 1<<6 - 1
-	if x >= 0 {
-		return fmt.Sprintf("%d:%02d", int32(x>>shift), int32(x&mask))
-	}
-	x = -x
-	if x >= 0 {
-		return fmt.Sprintf("-%d:%02d", int32(x>>shift), int32(x&mask))
-	}
-	return "-33554432:00" // The minimum value is -(1<<25).
-}
-
-// Floor returns the greatest integer value less than or equal to x.
-//
-// Its return type is int, not Int26_6.
-func (x Int26_6) Floor() int { return int((x + 0x00) >> 6) }
-
-// Round returns the nearest integer value to x. Ties are rounded up.
-//
-// Its return type is int, not Int26_6.
-func (x Int26_6) Round() int { return int((x + 0x20) >> 6) }
-
-// Ceil returns the least integer value greater than or equal to x.
-//
-// Its return type is int, not Int26_6.
-func (x Int26_6) Ceil() int { return int((x + 0x3f) >> 6) }
-
-// Int52_12 is a signed 52.12 fixed-point number.
-//
-// The integer part ranges from -2251799813685248 to 2251799813685247,
-// inclusive. The fractional part has 12 bits of precision.
-//
-// For example, the number one-and-a-quarter is Int52_12(1<<12 + 1<<10).
-type Int52_12 int64
-
-// String returns a human-readable representation of a 52.12 fixed-point
-// number.
-//
-// For example, the number one-and-a-quarter becomes "1:1024".
-func (x Int52_12) String() string {
-	const shift, mask = 12, 1<<12 - 1
-	if x >= 0 {
-		return fmt.Sprintf("%d:%04d", int64(x>>shift), int64(x&mask))
-	}
-	x = -x
-	if x >= 0 {
-		return fmt.Sprintf("-%d:%04d", int64(x>>shift), int64(x&mask))
-	}
-	return "-2251799813685248:0000" // The minimum value is -(1<<51).
-}
-
-// Floor returns the greatest integer value less than or equal to x.
-//
-// Its return type is int, not Int52_12.
-func (x Int52_12) Floor() int { return int((x + 0x000) >> 12) }
-
-// Round returns the nearest integer value to x. Ties are rounded up.
-//
-// Its return type is int, not Int52_12.
-func (x Int52_12) Round() int { return int((x + 0x800) >> 12) }
-
-// Ceil returns the least integer value greater than or equal to x.
-//
-// Its return type is int, not Int52_12.
-func (x Int52_12) Ceil() int { return int((x + 0xfff) >> 12) }
-
-// P returns the integer values x and y as a Point26_6.
-//
-// For example, passing the integer values (2, -3) yields Point26_6{128, -192}.
-func P(x, y int) Point26_6 {
-	return Point26_6{Int26_6(x << 6), Int26_6(y << 6)}
-}
-
-// Point26_6 is a 26.6 fixed-point coordinate pair.
-//
-// It is analogous to the image.Point type in the standard library.
-type Point26_6 struct {
-	X, Y Int26_6
-}
-
-// Add returns the vector p+q.
-func (p Point26_6) Add(q Point26_6) Point26_6 {
-	return Point26_6{p.X + q.X, p.Y + q.Y}
-}
-
-// Sub returns the vector p-q.
-func (p Point26_6) Sub(q Point26_6) Point26_6 {
-	return Point26_6{p.X - q.X, p.Y - q.Y}
-}
-
-// Mul returns the vector p*k.
-func (p Point26_6) Mul(k Int26_6) Point26_6 {
-	return Point26_6{p.X * k / 64, p.Y * k / 64}
-}
-
-// Div returns the vector p/k.
-func (p Point26_6) Div(k Int26_6) Point26_6 {
-	return Point26_6{p.X * 64 / k, p.Y * 64 / k}
-}
-
-// Point52_12 is a 52.12 fixed-point coordinate pair.
-//
-// It is analogous to the image.Point type in the standard library.
-type Point52_12 struct {
-	X, Y Int52_12
-}
-
-// Add returns the vector p+q.
-func (p Point52_12) Add(q Point52_12) Point52_12 {
-	return Point52_12{p.X + q.X, p.Y + q.Y}
-}
-
-// Sub returns the vector p-q.
-func (p Point52_12) Sub(q Point52_12) Point52_12 {
-	return Point52_12{p.X - q.X, p.Y - q.Y}
-}
-
-// Mul returns the vector p*k.
-func (p Point52_12) Mul(k Int52_12) Point52_12 {
-	return Point52_12{p.X * k / 4096, p.Y * k / 4096}
-}
-
-// Div returns the vector p/k.
-func (p Point52_12) Div(k Int52_12) Point52_12 {
-	return Point52_12{p.X * 4096 / k, p.Y * 4096 / k}
-}
-
-// R returns the integer values minX, minY, maxX, maxY as a Rectangle26_6.
-//
-// For example, passing the integer values (0, 1, 2, 3) yields
-// Rectangle26_6{Point26_6{0, 64}, Point26_6{128, 192}}.
-//
-// Like the image.Rect function in the standard library, the returned rectangle
-// has minimum and maximum coordinates swapped if necessary so that it is
-// well-formed.
-func R(minX, minY, maxX, maxY int) Rectangle26_6 {
-	if minX > maxX {
-		minX, maxX = maxX, minX
-	}
-	if minY > maxY {
-		minY, maxY = maxY, minY
-	}
-	return Rectangle26_6{
-		Point26_6{
-			Int26_6(minX << 6),
-			Int26_6(minY << 6),
-		},
-		Point26_6{
-			Int26_6(maxX << 6),
-			Int26_6(maxY << 6),
-		},
-	}
-}
-
-// Rectangle26_6 is a 26.6 fixed-point coordinate rectangle. The Min bound is
-// inclusive and the Max bound is exclusive. It is well-formed if Min.X <=
-// Max.X and likewise for Y.
-//
-// It is analogous to the image.Rectangle type in the standard library.
-type Rectangle26_6 struct {
-	Min, Max Point26_6
-}
-
-// Rectangle52_12 is a 52.12 fixed-point coordinate rectangle. The Min bound is
-// inclusive and the Max bound is exclusive. It is well-formed if Min.X <=
-// Max.X and likewise for Y.
-//
-// It is analogous to the image.Rectangle type in the standard library.
-type Rectangle52_12 struct {
-	Min, Max Point52_12
-}