removed dokuwiki

4 files changed, 0 insertions, 4806 deletions

diff --git a/wiki/vendor/marcusschwarz/lesserphp/HISTORY.md b/wiki/vendor/marcusschwarz/lesserphp/HISTORY.md
deleted file mode 100644
index 19ec7dc..0000000
--- a/wiki/vendor/marcusschwarz/lesserphp/HISTORY.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# lesserphp v0.5.1
-
-Originally written by Leaf Corcoran, obviously abandoned circa 2014
-https://github.com/leafo/lessphp
-
-Last version provided by Leaf was 0.5.0
-
-### v.0.5.1
-* 2016-09-30: renaming it to lesserphp for easier distinction
-* 2016-09-30: applying some pull requests of the origin repository
-  * https://github.com/leafo/lessphp/pull/584
-  * https://github.com/leafo/lessphp/pull/607
-  * https://github.com/leafo/lessphp/pull/619
-* 2016-09-29: applying some pull requests of the origin repository
-  * https://github.com/leafo/lessphp/pull/590
-  * https://github.com/leafo/lessphp/pull/523
-  * https://github.com/leafo/lessphp/pull/540
-  * https://github.com/leafo/lessphp/pull/564
-  * https://github.com/leafo/lessphp/pull/566
-* 2016-09-26: applying some pull requests of the origin repository
-  * https://github.com/leafo/lessphp/pull/592
-  * https://github.com/leafo/lessphp/pull/601
-  * https://github.com/leafo/lessphp/pull/603
-  * https://github.com/leafo/lessphp/pull/604
-  * https://github.com/leafo/lessphp/pull/605
-  * https://github.com/leafo/lessphp/pull/610
-  * https://github.com/leafo/lessphp/pull/616
-* 2016-09-26: making it compatible with php7.x
-* 2016-09-26: Forking master from https://github.com/leafo/lessphp
diff --git a/wiki/vendor/marcusschwarz/lesserphp/LICENSE b/wiki/vendor/marcusschwarz/lesserphp/LICENSE
deleted file mode 100644
index 5290202..0000000
--- a/wiki/vendor/marcusschwarz/lesserphp/LICENSE
+++ /dev/null
@@ -1,661 +0,0 @@
-For ease of distribution, lessphp 0.5.1 is under a dual license.
-You are free to pick which one suits your needs.
-
-
-
-
-MIT LICENSE
-
-
-
-
-Copyright (c) 2013 - 2015 Leaf Corcoran, http://leafo.net/lessphp
-Copyright (c) 2016 -  Marcus Schwarz, https://www.maswaba.de
-
-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.
-
-
-
-
-GPL VERSION 3
-
-
-
-
-					GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://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.
-
diff --git a/wiki/vendor/marcusschwarz/lesserphp/README.md b/wiki/vendor/marcusschwarz/lesserphp/README.md
deleted file mode 100644
index b30e07e..0000000
--- a/wiki/vendor/marcusschwarz/lesserphp/README.md
+++ /dev/null
@@ -1,97 +0,0 @@
-[![Build Status](https://travis-ci.org/MarcusSchwarz/lessphp.svg?branch=0.5.1)](https://travis-ci.org/MarcusSchwarz/lessphp)
-
-# lesserphp v0.5.1
-### <http://github.com/MarcusSchwarz/lesserphp>
-
-`lesserphp` is a compiler for LESS written in PHP. It is based on lessphp bei leafo.
-The documentation is great,
-so check it out: <http://leafo.net/lessphp/docs/>.
-
-Here's a quick tutorial:
-
-### How to use in your PHP project
-
-The only file required is `lessc.inc.php`, so copy that to your include directory.
-
-The typical flow of **lesserphp** is to create a new instance of `lessc`,
-configure it how you like, then tell it to compile something using one built in
-compile methods.
-
-The `compile` method compiles a string of LESS code to CSS.
-
-```php
-<?php
-require "lessc.inc.php";
-
-$less = new lessc;
-echo $less->compile(".block { padding: 3 + 4px }");
-```
-
-The `compileFile` method reads and compiles a file. It will either return the
-result or write it to the path specified by an optional second argument.
-
-```php
-<?php
-echo $less->compileFile("input.less");
-```
-
-The `checkedCompile` method is like `compileFile`, but it only compiles if the output
-file doesn't exist or it's older than the input file:
-
-```php
-<?php
-$less->checkedCompile("input.less", "output.css");
-```
-
-If there any problem compiling your code, an exception is thrown with a helpful message:
-
-```php
-<?php
-try {
-  $less->compile("invalid LESS } {");
-} catch (\Exception $e) {
-  echo "fatal error: " . $e->getMessage();
-}
-```
-
-The `lessc` object can be configured through an assortment of instance methods.
-Some possible configuration options include [changing the output format][1],
-[setting variables from PHP][2], and [controlling the preservation of
-comments][3], writing [custom functions][4] and much more. It's all described
-in [the documentation][0].
-
-
- [0]: http://leafo.net/lessphp/docs/
- [1]: http://leafo.net/lessphp/docs/#output_formatting
- [2]: http://leafo.net/lessphp/docs/#setting_variables_from_php
- [3]: http://leafo.net/lessphp/docs/#preserving_comments
- [4]: http://leafo.net/lessphp/docs/#custom_functions
-
-
-### How to use from the command line
-
-An additional script has been included to use the compiler from the command
-line. In the simplest invocation, you specify an input file and the compiled
-css is written to standard out:
-
-    $ plessc input.less > output.css
-
-Using the -r flag, you can specify LESS code directly as an argument or, if
-the argument is left off, from standard in:
-
-    $ plessc -r "my less code here"
-
-Finally, by using the -w flag you can watch a specified input file and have it
-compile as needed to the output file:
-
-    $ plessc -w input-file output-file
-
-Errors from watch mode are written to standard out.
-
-The -f flag sets the [output formatter][1]. For example, to compress the
-output run this:
-
-    $ plessc -f=compressed myfile.less
-
-For more help, run `plessc --help`
-
diff --git a/wiki/vendor/marcusschwarz/lesserphp/lessc.inc.php b/wiki/vendor/marcusschwarz/lesserphp/lessc.inc.php
deleted file mode 100644
index b9e80cc..0000000
--- a/wiki/vendor/marcusschwarz/lesserphp/lessc.inc.php
+++ /dev/null
@@ -1,4019 +0,0 @@
-<?php
-
-/**
- * lessphp v0.5.1
- * http://leafo.net/lessphp
- *
- * LESS CSS compiler, adapted from http://lesscss.org
- *
- * Copyright 2013, Leaf Corcoran <leafot@gmail.com>
- * Copyright 2016, Marcus Schwarz <github@maswaba.de>
- * Licensed under MIT or GPLv3, see LICENSE
- */
-
-
-/**
- * The LESS compiler and parser.
- *
- * Converting LESS to CSS is a three stage process. The incoming file is parsed
- * by `lessc_parser` into a syntax tree, then it is compiled into another tree
- * representing the CSS structure by `lessc`. The CSS tree is fed into a
- * formatter, like `lessc_formatter` which then outputs CSS as a string.
- *
- * During the first compile, all values are *reduced*, which means that their
- * types are brought to the lowest form before being dump as strings. This
- * handles math equations, variable dereferences, and the like.
- *
- * The `parse` function of `lessc` is the entry point.
- *
- * In summary:
- *
- * The `lessc` class creates an instance of the parser, feeds it LESS code,
- * then transforms the resulting tree to a CSS tree. This class also holds the
- * evaluation context, such as all available mixins and variables at any given
- * time.
- *
- * The `lessc_parser` class is only concerned with parsing its input.
- *
- * The `lessc_formatter` takes a CSS tree, and dumps it to a formatted string,
- * handling things like indentation.
- */
-class lessc {
-	static public $VERSION = "v0.5.1";
-
-	static public $TRUE = array("keyword", "true");
-	static public $FALSE = array("keyword", "false");
-
-	protected $libFunctions = array();
-	protected $registeredVars = array();
-	protected $preserveComments = false;
-
-	public $vPrefix = '@'; // prefix of abstract properties
-	public $mPrefix = '$'; // prefix of abstract blocks
-	public $parentSelector = '&';
-
-	static public $lengths = array( "px", "m", "cm", "mm", "in", "pt", "pc" );
-	static public $times = array( "s", "ms" );
-	static public $angles = array( "rad", "deg", "grad", "turn" );
-
-	static public $lengths_to_base = array( 1, 3779.52755906, 37.79527559, 3.77952756, 96, 1.33333333, 16  );
-	public $importDisabled = false;
-	public $importDir = array();
-
-	protected $numberPrecision = null;
-
-	protected $allParsedFiles = array();
-
-	// set to the parser that generated the current line when compiling
-	// so we know how to create error messages
-	protected $sourceParser = null;
-	protected $sourceLoc = null;
-
-	static protected $nextImportId = 0; // uniquely identify imports
-
-	// attempts to find the path of an import url, returns null for css files
-	protected function findImport($url) {
-		foreach ((array)$this->importDir as $dir) {
-			$full = $dir.(substr($dir, -1) != '/' ? '/' : '').$url;
-			if ($this->fileExists($file = $full.'.less') || $this->fileExists($file = $full)) {
-				return $file;
-			}
-		}
-
-		return null;
-	}
-
-	protected function fileExists($name) {
-		return is_file($name);
-	}
-
-	static public function compressList($items, $delim) {
-		if (!isset($items[1]) && isset($items[0])) return $items[0];
-		else return array('list', $delim, $items);
-	}
-
-	static public function preg_quote($what) {
-		return preg_quote($what, '/');
-	}
-
-	protected function tryImport($importPath, $parentBlock, $out) {
-		if ($importPath[0] == "function" && $importPath[1] == "url") {
-			$importPath = $this->flattenList($importPath[2]);
-		}
-
-		$str = $this->coerceString($importPath);
-		if ($str === null) return false;
-
-		$url = $this->compileValue($this->lib_e($str));
-
-		// don't import if it ends in css
-		if (substr_compare($url, '.css', -4, 4) === 0) return false;
-
-		$realPath = $this->findImport($url);
-
-		if ($realPath === null) return false;
-
-		if ($this->importDisabled) {
-			return array(false, "/* import disabled */");
-		}
-
-		if (isset($this->allParsedFiles[realpath($realPath)])) {
-			return array(false, null);
-		}
-
-		$this->addParsedFile($realPath);
-		$parser = $this->makeParser($realPath);
-		$root = $parser->parse(file_get_contents($realPath));
-
-		// set the parents of all the block props
-		foreach ($root->props as $prop) {
-			if ($prop[0] == "block") {
-				$prop[1]->parent = $parentBlock;
-			}
-		}
-
-		// copy mixins into scope, set their parents
-		// bring blocks from import into current block
-		// TODO: need to mark the source parser	these came from this file
-		foreach ($root->children as $childName => $child) {
-			if (isset($parentBlock->children[$childName])) {
-				$parentBlock->children[$childName] = array_merge(
-					$parentBlock->children[$childName],
-					$child);
-			} else {
-				$parentBlock->children[$childName] = $child;
-			}
-		}
-
-		$pi = pathinfo($realPath);
-		$dir = $pi["dirname"];
-
-		list($top, $bottom) = $this->sortProps($root->props, true);
-		$this->compileImportedProps($top, $parentBlock, $out, $parser, $dir);
-
-		return array(true, $bottom, $parser, $dir);
-	}
-
-	protected function compileImportedProps($props, $block, $out, $sourceParser, $importDir) {
-		$oldSourceParser = $this->sourceParser;
-
-		$oldImport = $this->importDir;
-
-		// TODO: this is because the importDir api is stupid
-		$this->importDir = (array)$this->importDir;
-		array_unshift($this->importDir, $importDir);
-
-		foreach ($props as $prop) {
-			$this->compileProp($prop, $block, $out);
-		}
-
-		$this->importDir = $oldImport;
-		$this->sourceParser = $oldSourceParser;
-	}
-
-	/**
-	 * Recursively compiles a block.
-	 *
-	 * A block is analogous to a CSS block in most cases. A single LESS document
-	 * is encapsulated in a block when parsed, but it does not have parent tags
-	 * so all of it's children appear on the root level when compiled.
-	 *
-	 * Blocks are made up of props and children.
-	 *
-	 * Props are property instructions, array tuples which describe an action
-	 * to be taken, eg. write a property, set a variable, mixin a block.
-	 *
-	 * The children of a block are just all the blocks that are defined within.
-	 * This is used to look up mixins when performing a mixin.
-	 *
-	 * Compiling the block involves pushing a fresh environment on the stack,
-	 * and iterating through the props, compiling each one.
-	 *
-	 * See lessc::compileProp()
-	 *
-	 */
-	protected function compileBlock($block) {
-		switch ($block->type) {
-		case "root":
-			$this->compileRoot($block);
-			break;
-		case null:
-			$this->compileCSSBlock($block);
-			break;
-		case "media":
-			$this->compileMedia($block);
-			break;
-		case "directive":
-			$name = "@" . $block->name;
-			if (!empty($block->value)) {
-				$name .= " " . $this->compileValue($this->reduce($block->value));
-			}
-
-			$this->compileNestedBlock($block, array($name));
-			break;
-		default:
-            $block->parser->throwError("unknown block type: $block->type\n", $block->count);
-		}
-	}
-
-	protected function compileCSSBlock($block) {
-		$env = $this->pushEnv();
-
-		$selectors = $this->compileSelectors($block->tags);
-		$env->selectors = $this->multiplySelectors($selectors);
-		$out = $this->makeOutputBlock(null, $env->selectors);
-
-		$this->scope->children[] = $out;
-		$this->compileProps($block, $out);
-
-		$block->scope = $env; // mixins carry scope with them!
-		$this->popEnv();
-	}
-
-	protected function compileMedia($media) {
-		$env = $this->pushEnv($media);
-		$parentScope = $this->mediaParent($this->scope);
-
-		$query = $this->compileMediaQuery($this->multiplyMedia($env));
-
-		$this->scope = $this->makeOutputBlock($media->type, array($query));
-		$parentScope->children[] = $this->scope;
-
-		$this->compileProps($media, $this->scope);
-
-		if (count($this->scope->lines) > 0) {
-			$orphanSelelectors = $this->findClosestSelectors();
-			if (!is_null($orphanSelelectors)) {
-				$orphan = $this->makeOutputBlock(null, $orphanSelelectors);
-				$orphan->lines = $this->scope->lines;
-				array_unshift($this->scope->children, $orphan);
-				$this->scope->lines = array();
-			}
-		}
-
-		$this->scope = $this->scope->parent;
-		$this->popEnv();
-	}
-
-	protected function mediaParent($scope) {
-		while (!empty($scope->parent)) {
-			if (!empty($scope->type) && $scope->type != "media") {
-				break;
-			}
-			$scope = $scope->parent;
-		}
-
-		return $scope;
-	}
-
-	protected function compileNestedBlock($block, $selectors) {
-		$this->pushEnv($block);
-		$this->scope = $this->makeOutputBlock($block->type, $selectors);
-		$this->scope->parent->children[] = $this->scope;
-
-		$this->compileProps($block, $this->scope);
-
-		$this->scope = $this->scope->parent;
-		$this->popEnv();
-	}
-
-	protected function compileRoot($root) {
-		$this->pushEnv();
-		$this->scope = $this->makeOutputBlock($root->type);
-		$this->compileProps($root, $this->scope);
-		$this->popEnv();
-	}
-
-	protected function compileProps($block, $out) {
-		foreach ($this->sortProps($block->props) as $prop) {
-			$this->compileProp($prop, $block, $out);
-		}
-		$out->lines = $this->deduplicate($out->lines);
-	}
-
-	/**
-	 * Deduplicate lines in a block. Comments are not deduplicated. If a
-	 * duplicate rule is detected, the comments immediately preceding each
-	 * occurence are consolidated.
-	 */
-	protected function deduplicate($lines) {
-		$unique = array();
-		$comments = array();
-
-		foreach($lines as $line) {
-			if (strpos($line, '/*') === 0) {
-				$comments[] = $line;
-				continue;
-			}
-			if (!in_array($line, $unique)) {
-				$unique[] = $line;
-			}
-			array_splice($unique, array_search($line, $unique), 0, $comments);
-			$comments = array();
-		}
-		return array_merge($unique, $comments);
-	}
-
-	protected function sortProps($props, $split = false) {
-		$vars = array();
-		$imports = array();
-		$other = array();
-		$stack = array();
-
-		foreach ($props as $prop) {
-			switch ($prop[0]) {
-			case "comment":
-				$stack[] = $prop;
-				break;
-			case "assign":
-				$stack[] = $prop;
-				if (isset($prop[1][0]) && $prop[1][0] == $this->vPrefix) {
-					$vars = array_merge($vars, $stack);
-				} else {
-					$other = array_merge($other, $stack);
-				}
-				$stack = array();
-				break;
-			case "import":
-				$id = self::$nextImportId++;
-				$prop[] = $id;
-				$stack[] = $prop;
-				$imports = array_merge($imports, $stack);
-				$other[] = array("import_mixin", $id);
-				$stack = array();
-				break;
-			default:
-				$stack[] = $prop;
-				$other = array_merge($other, $stack);
-				$stack = array();
-				break;
-			}
-		}
-		$other = array_merge($other, $stack);
-
-		if ($split) {
-			return array(array_merge($imports, $vars), $other);
-		} else {
-			return array_merge($imports, $vars, $other);
-		}
-	}
-
-	protected function compileMediaQuery($queries) {
-		$compiledQueries = array();
-		foreach ($queries as $query) {
-			$parts = array();
-			foreach ($query as $q) {
-				switch ($q[0]) {
-				case "mediaType":
-					$parts[] = implode(" ", array_slice($q, 1));
-					break;
-				case "mediaExp":
-					if (isset($q[2])) {
-						$parts[] = "($q[1]: " .
-							$this->compileValue($this->reduce($q[2])) . ")";
-					} else {
-						$parts[] = "($q[1])";
-					}
-					break;
-				case "variable":
-					$parts[] = $this->compileValue($this->reduce($q));
-				break;
-				}
-			}
-
-			if (count($parts) > 0) {
-				$compiledQueries[] =  implode(" and ", $parts);
-			}
-		}
-
-		$out = "@media";
-		if (!empty($parts)) {
-			$out .= " " .
-				implode($this->formatter->selectorSeparator, $compiledQueries);
-		}
-		return $out;
-	}
-
-	protected function multiplyMedia($env, $childQueries = null) {
-		if (is_null($env) ||
-			!empty($env->block->type) && $env->block->type != "media")
-		{
-			return $childQueries;
-		}
-
-		// plain old block, skip
-		if (empty($env->block->type)) {
-			return $this->multiplyMedia($env->parent, $childQueries);
-		}
-
-		$out = array();
-		$queries = $env->block->queries;
-		if (is_null($childQueries)) {
-			$out = $queries;
-		} else {
-			foreach ($queries as $parent) {
-				foreach ($childQueries as $child) {
-					$out[] = array_merge($parent, $child);
-				}
-			}
-		}
-
-		return $this->multiplyMedia($env->parent, $out);
-	}
-
-	protected function expandParentSelectors(&$tag, $replace) {
-		$parts = explode("$&$", $tag);
-		$count = 0;
-		foreach ($parts as &$part) {
-			$part = str_replace($this->parentSelector, $replace, $part, $c);
-			$count += $c;
-		}
-		$tag = implode($this->parentSelector, $parts);
-		return $count;
-	}
-
-	protected function findClosestSelectors() {
-		$env = $this->env;
-		$selectors = null;
-		while ($env !== null) {
-			if (isset($env->selectors)) {
-				$selectors = $env->selectors;
-				break;
-			}
-			$env = $env->parent;
-		}
-
-		return $selectors;
-	}
-
-
-	// multiply $selectors against the nearest selectors in env
-	protected function multiplySelectors($selectors) {
-		// find parent selectors
-
-		$parentSelectors = $this->findClosestSelectors();
-		if (is_null($parentSelectors)) {
-			// kill parent reference in top level selector
-			foreach ($selectors as &$s) {
-				$this->expandParentSelectors($s, "");
-			}
-
-			return $selectors;
-		}
-
-		$out = array();
-		foreach ($parentSelectors as $parent) {
-			foreach ($selectors as $child) {
-				$count = $this->expandParentSelectors($child, $parent);
-
-				// don't prepend the parent tag if & was used
-				if ($count > 0) {
-					$out[] = trim($child);
-				} else {
-					$out[] = trim($parent . ' ' . $child);
-				}
-			}
-		}
-
-		return $out;
-	}
-
-	// reduces selector expressions
-	protected function compileSelectors($selectors) {
-		$out = array();
-
-		foreach ($selectors as $s) {
-			if (is_array($s)) {
-				list(, $value) = $s;
-				$out[] = trim($this->compileValue($this->reduce($value)));
-			} else {
-				$out[] = $s;
-			}
-		}
-
-		return $out;
-	}
-
-	protected function eq($left, $right) {
-		return $left == $right;
-	}
-
-	protected function patternMatch($block, $orderedArgs, $keywordArgs) {
-		// match the guards if it has them
-		// any one of the groups must have all its guards pass for a match
-		if (!empty($block->guards)) {
-			$groupPassed = false;
-			foreach ($block->guards as $guardGroup) {
-				foreach ($guardGroup as $guard) {
-					$this->pushEnv();
-					$this->zipSetArgs($block->args, $orderedArgs, $keywordArgs);
-
-					$negate = false;
-					if ($guard[0] == "negate") {
-						$guard = $guard[1];
-						$negate = true;
-					}
-
-					$passed = $this->reduce($guard) == self::$TRUE;
-					if ($negate) $passed = !$passed;
-
-					$this->popEnv();
-
-					if ($passed) {
-						$groupPassed = true;
-					} else {
-						$groupPassed = false;
-						break;
-					}
-				}
-
-				if ($groupPassed) break;
-			}
-
-			if (!$groupPassed) {
-				return false;
-			}
-		}
-
-		if (empty($block->args)) {
-			return $block->isVararg || empty($orderedArgs) && empty($keywordArgs);
-		}
-
-		$remainingArgs = $block->args;
-		if ($keywordArgs) {
-			$remainingArgs = array();
-			foreach ($block->args as $arg) {
-				if ($arg[0] == "arg" && isset($keywordArgs[$arg[1]])) {
-					continue;
-				}
-
-				$remainingArgs[] = $arg;
-			}
-		}
-
-		$i = -1; // no args
-		// try to match by arity or by argument literal
-		foreach ($remainingArgs as $i => $arg) {
-			switch ($arg[0]) {
-			case "lit":
-				if (empty($orderedArgs[$i]) || !$this->eq($arg[1], $orderedArgs[$i])) {
-					return false;
-				}
-				break;
-			case "arg":
-				// no arg and no default value
-				if (!isset($orderedArgs[$i]) && !isset($arg[2])) {
-					return false;
-				}
-				break;
-			case "rest":
-				$i--; // rest can be empty
-				break 2;
-			}
-		}
-
-		if ($block->isVararg) {
-			return true; // not having enough is handled above
-		} else {
-			$numMatched = $i + 1;
-			// greater than because default values always match
-			return $numMatched >= count($orderedArgs);
-		}
-	}
-
-	protected function patternMatchAll($blocks, $orderedArgs, $keywordArgs, $skip=array()) {
-		$matches = null;
-		foreach ($blocks as $block) {
-			// skip seen blocks that don't have arguments
-			if (isset($skip[$block->id]) && !isset($block->args)) {
-				continue;
-			}
-
-			if ($this->patternMatch($block, $orderedArgs, $keywordArgs)) {
-				$matches[] = $block;
-			}
-		}
-
-		return $matches;
-	}
-
-	// attempt to find blocks matched by path and args
-	protected function findBlocks($searchIn, $path, $orderedArgs, $keywordArgs, $seen=array()) {
-		if ($searchIn == null) return null;
-		if (isset($seen[$searchIn->id])) return null;
-		$seen[$searchIn->id] = true;
-
-		$name = $path[0];
-
-		if (isset($searchIn->children[$name])) {
-			$blocks = $searchIn->children[$name];
-			if (count($path) == 1) {
-				$matches = $this->patternMatchAll($blocks, $orderedArgs, $keywordArgs, $seen);
-				if (!empty($matches)) {
-					// This will return all blocks that match in the closest
-					// scope that has any matching block, like lessjs
-					return $matches;
-				}
-			} else {
-				$matches = array();
-				foreach ($blocks as $subBlock) {
-					$subMatches = $this->findBlocks($subBlock,
-						array_slice($path, 1), $orderedArgs, $keywordArgs, $seen);
-
-					if (!is_null($subMatches)) {
-						foreach ($subMatches as $sm) {
-							$matches[] = $sm;
-						}
-					}
-				}
-
-				return count($matches) > 0 ? $matches : null;
-			}
-		}
-		if ($searchIn->parent === $searchIn) return null;
-		return $this->findBlocks($searchIn->parent, $path, $orderedArgs, $keywordArgs, $seen);
-	}
-
-	// sets all argument names in $args to either the default value
-	// or the one passed in through $values
-	protected function zipSetArgs($args, $orderedValues, $keywordValues) {
-		$assignedValues = array();
-
-		$i = 0;
-		foreach ($args as  $a) {
-			if ($a[0] == "arg") {
-				if (isset($keywordValues[$a[1]])) {
-					// has keyword arg
-					$value = $keywordValues[$a[1]];
-				} elseif (isset($orderedValues[$i])) {
-					// has ordered arg
-					$value = $orderedValues[$i];
-					$i++;
-				} elseif (isset($a[2])) {
-					// has default value
-					$value = $a[2];
-				} else {
-					$this->throwError("Failed to assign arg " . $a[1]);
-					$value = null; // :(
-				}
-
-				$value = $this->reduce($value);
-				$this->set($a[1], $value);
-				$assignedValues[] = $value;
-			} else {
-				// a lit
-				$i++;
-			}
-		}
-
-		// check for a rest
-		$last = end($args);
-		if ($last[0] == "rest") {
-			$rest = array_slice($orderedValues, count($args) - 1);
-			$this->set($last[1], $this->reduce(array("list", " ", $rest)));
-		}
-
-		// wow is this the only true use of PHP's + operator for arrays?
-		$this->env->arguments = $assignedValues + $orderedValues;
-	}
-
-	// compile a prop and update $lines or $blocks appropriately
-	protected function compileProp($prop, $block, $out) {
-		// set error position context
-		$this->sourceLoc = isset($prop[-1]) ? $prop[-1] : -1;
-
-		switch ($prop[0]) {
-		case 'assign':
-			list(, $name, $value) = $prop;
-			if ($name[0] == $this->vPrefix) {
-				$this->set($name, $value);
-			} else {
-				$out->lines[] = $this->formatter->property($name,
-						$this->compileValue($this->reduce($value)));
-			}
-			break;
-		case 'block':
-			list(, $child) = $prop;
-			$this->compileBlock($child);
-			break;
-		case 'ruleset':
-		case 'mixin':
-			list(, $path, $args, $suffix) = $prop;
-
-			$orderedArgs = array();
-			$keywordArgs = array();
-			foreach ((array)$args as $arg) {
-				$argval = null;
-				switch ($arg[0]) {
-				case "arg":
-					if (!isset($arg[2])) {
-						$orderedArgs[] = $this->reduce(array("variable", $arg[1]));
-					} else {
-						$keywordArgs[$arg[1]] = $this->reduce($arg[2]);
-					}
-					break;
-
-				case "lit":
-					$orderedArgs[] = $this->reduce($arg[1]);
-					break;
-				default:
-					$this->throwError("Unknown arg type: " . $arg[0]);
-				}
-			}
-
-			$mixins = $this->findBlocks($block, $path, $orderedArgs, $keywordArgs);
-
-			if ($mixins === null) {
-                $block->parser->throwError("{$prop[1][0]} is undefined", $block->count);
-			}
-
-			if(strpos($prop[1][0], "$") === 0) {
-				//Use Ruleset Logic - Only last element
-				$mixins = array(array_pop($mixins));
-			}
-
-			foreach ($mixins as $mixin) {
-				if ($mixin === $block && !$orderedArgs) {
-					continue;
-				}
-
-				$haveScope = false;
-				if (isset($mixin->parent->scope)) {
-					$haveScope = true;
-					$mixinParentEnv = $this->pushEnv();
-					$mixinParentEnv->storeParent = $mixin->parent->scope;
-				}
-
-				$haveArgs = false;
-				if (isset($mixin->args)) {
-					$haveArgs = true;
-					$this->pushEnv();
-					$this->zipSetArgs($mixin->args, $orderedArgs, $keywordArgs);
-				}
-
-				$oldParent = $mixin->parent;
-				if ($mixin != $block) $mixin->parent = $block;
-
-				foreach ($this->sortProps($mixin->props) as $subProp) {
-					if ($suffix !== null &&
-						$subProp[0] == "assign" &&
-						is_string($subProp[1]) &&
-						$subProp[1]{0} != $this->vPrefix)
-					{
-						$subProp[2] = array(
-							'list', ' ',
-							array($subProp[2], array('keyword', $suffix))
-						);
-					}
-
-					$this->compileProp($subProp, $mixin, $out);
-				}
-
-				$mixin->parent = $oldParent;
-
-				if ($haveArgs) $this->popEnv();
-				if ($haveScope) $this->popEnv();
-			}
-
-			break;
-		case 'raw':
-			$out->lines[] = $prop[1];
-			break;
-		case "directive":
-			list(, $name, $value) = $prop;
-			$out->lines[] = "@$name " . $this->compileValue($this->reduce($value)).';';
-			break;
-		case "comment":
-			$out->lines[] = $prop[1];
-			break;
-		case "import";
-			list(, $importPath, $importId) = $prop;
-			$importPath = $this->reduce($importPath);
-
-			if (!isset($this->env->imports)) {
-				$this->env->imports = array();
-			}
-
-			$result = $this->tryImport($importPath, $block, $out);
-
-			$this->env->imports[$importId] = $result === false ?
-				array(false, "@import " . $this->compileValue($importPath).";") :
-				$result;
-
-			break;
-		case "import_mixin":
-			list(,$importId) = $prop;
-			$import = $this->env->imports[$importId];
-			if ($import[0] === false) {
-				if (isset($import[1])) {
-					$out->lines[] = $import[1];
-				}
-			} else {
-				list(, $bottom, $parser, $importDir) = $import;
-				$this->compileImportedProps($bottom, $block, $out, $parser, $importDir);
-			}
-
-			break;
-		default:
-            $block->parser->throwError("unknown op: {$prop[0]}\n", $block->count);
-		}
-	}
-
-
-	/**
-	 * Compiles a primitive value into a CSS property value.
-	 *
-	 * Values in lessphp are typed by being wrapped in arrays, their format is
-	 * typically:
-	 *
-	 *     array(type, contents [, additional_contents]*)
-	 *
-	 * The input is expected to be reduced. This function will not work on
-	 * things like expressions and variables.
-	 */
-	public function compileValue($value) {
-		switch ($value[0]) {
-		case 'list':
-			// [1] - delimiter
-			// [2] - array of values
-			return implode($value[1], array_map(array($this, 'compileValue'), $value[2]));
-		case 'raw_color':
-			if (!empty($this->formatter->compressColors)) {
-				return $this->compileValue($this->coerceColor($value));
-			}
-			return $value[1];
-		case 'keyword':
-			// [1] - the keyword
-			return $value[1];
-		case 'number':
-			list(, $num, $unit) = $value;
-			// [1] - the number
-			// [2] - the unit
-			if ($this->numberPrecision !== null) {
-				$num = round($num, $this->numberPrecision);
-			}
-			return $num . $unit;
-		case 'string':
-			// [1] - contents of string (includes quotes)
-			list(, $delim, $content) = $value;
-			foreach ($content as &$part) {
-				if (is_array($part)) {
-					$part = $this->compileValue($part);
-				}
-			}
-			return $delim . implode($content) . $delim;
-		case 'color':
-			// [1] - red component (either number or a %)
-			// [2] - green component
-			// [3] - blue component
-			// [4] - optional alpha component
-			list(, $r, $g, $b) = $value;
-			$r = round($r);
-			$g = round($g);
-			$b = round($b);
-
-			if (count($value) == 5 && $value[4] != 1) { // rgba
-				return 'rgba('.$r.','.$g.','.$b.','.$value[4].')';
-			}
-
-			$h = sprintf("#%02x%02x%02x", $r, $g, $b);
-
-			if (!empty($this->formatter->compressColors)) {
-				// Converting hex color to short notation (e.g. #003399 to #039)
-				if ($h[1] === $h[2] && $h[3] === $h[4] && $h[5] === $h[6]) {
-					$h = '#' . $h[1] . $h[3] . $h[5];
-				}
-			}
-
-			return $h;
-
-		case 'function':
-			list(, $name, $args) = $value;
-			return $name.'('.$this->compileValue($args).')';
-		default: // assumed to be unit
-			$this->throwError("unknown value type: $value[0]");
-		}
-	}
-
-	protected function lib_pow($args) {
-		list($base, $exp) = $this->assertArgs($args, 2, "pow");
-        return array( "number", pow($this->assertNumber($base), $this->assertNumber($exp)), $args[2][0][2] );
-	}
-
-	protected function lib_pi() {
-		return pi();
-	}
-
-	protected function lib_mod($args) {
-		list($a, $b) = $this->assertArgs($args, 2, "mod");
-        return array( "number", $this->assertNumber($a) % $this->assertNumber($b), $args[2][0][2] );
- 	}
-
-	protected function lib_convert($args) {
-        list($value, $to) = $this->assertArgs($args, 2, "convert");
-
-        // If it's a keyword, grab the string version instead
-        if( is_array( $to ) && $to[0] == "keyword" )
-                $to = $to[1];
-
- 		return $this->convert( $value, $to );
- 	}
-
-	protected function lib_abs($num) {
-        return array( "number", abs($this->assertNumber($num)), $num[2] );
- 	}
-
-	protected function lib_min($args) {
-        $values = $this->assertMinArgs($args, 1, "min");
-
-        $first_format = $values[0][2];
-
-        $min_index = 0;
-        $min_value = $values[0][1];
-
-        for( $a = 0; $a < sizeof( $values ); $a++ )
-        {
-            $converted = $this->convert( $values[$a], $first_format );
-
-            if( $converted[1] < $min_value )
-            {
-                $min_index = $a;
-                $min_value = $values[$a][1];
-            }
- 		}
-
- 		return $values[ $min_index ];
- 	}
-
-	protected function lib_max($args) {
-        $values = $this->assertMinArgs($args, 1, "max");
-
-        $first_format = $values[0][2];
-
-        $max_index = 0;
-        $max_value = $values[0][1];
-
-        for( $a = 0; $a < sizeof( $values ); $a++ )
-        {
-            $converted = $this->convert( $values[$a], $first_format );
-
-            if( $converted[1] > $max_value )
-            {
-                $max_index = $a;
-                $max_value = $values[$a][1];
-            }
- 		}
-
- 		return $values[ $max_index ];
-    }
-
-	protected function lib_tan($num) {
-		return tan($this->assertNumber($num));
-	}
-
-	protected function lib_sin($num) {
-		return sin($this->assertNumber($num));
-	}
-
-	protected function lib_cos($num) {
-		return cos($this->assertNumber($num));
-	}
-
-	protected function lib_atan($num) {
-		$num = atan($this->assertNumber($num));
-		return array("number", $num, "rad");
-	}
-
-	protected function lib_asin($num) {
-		$num = asin($this->assertNumber($num));
-		return array("number", $num, "rad");
-	}
-
-	protected function lib_acos($num) {
-		$num = acos($this->assertNumber($num));
-		return array("number", $num, "rad");
-	}
-
-	protected function lib_sqrt($num) {
-		return sqrt($this->assertNumber($num));
-	}
-
-	protected function lib_extract($value) {
-		list($list, $idx) = $this->assertArgs($value, 2, "extract");
-		$idx = $this->assertNumber($idx);
-		// 1 indexed
-		if ($list[0] == "list" && isset($list[2][$idx - 1])) {
-			return $list[2][$idx - 1];
-		}
-	}
-
-	protected function lib_isnumber($value) {
-		return $this->toBool($value[0] == "number");
-	}
-
-	protected function lib_isstring($value) {
-		return $this->toBool($value[0] == "string");
-	}
-
-	protected function lib_iscolor($value) {
-		return $this->toBool($this->coerceColor($value));
-	}
-
-	protected function lib_iskeyword($value) {
-		return $this->toBool($value[0] == "keyword");
-	}
-
-	protected function lib_ispixel($value) {
-		return $this->toBool($value[0] == "number" && $value[2] == "px");
-	}
-
-	protected function lib_ispercentage($value) {
-		return $this->toBool($value[0] == "number" && $value[2] == "%");
-	}
-
-	protected function lib_isem($value) {
-		return $this->toBool($value[0] == "number" && $value[2] == "em");
-	}
-
-	protected function lib_isrem($value) {
-		return $this->toBool($value[0] == "number" && $value[2] == "rem");
-	}
-
-	protected function lib_rgbahex($color) {
-		$color = $this->coerceColor($color);
-		if (is_null($color))
-			$this->throwError("color expected for rgbahex");
-
-		return sprintf("#%02x%02x%02x%02x",
-			isset($color[4]) ? $color[4]*255 : 255,
-			$color[1],$color[2], $color[3]);
-	}
-
-	protected function lib_argb($color){
-		return $this->lib_rgbahex($color);
-	}
-
-	/**
-	 * Given an url, decide whether to output a regular link or the base64-encoded contents of the file
-	 *
-	 * @param  array  $value either an argument list (two strings) or a single string
-	 * @return string        formatted url(), either as a link or base64-encoded
-	 */
-	protected function lib_data_uri($value) {
-		$mime = ($value[0] === 'list') ? $value[2][0][2] : null;
-		$url = ($value[0] === 'list') ? $value[2][1][2][0] : $value[2][0];
-
-		$fullpath = $this->findImport($url);
-
-		if($fullpath && ($fsize = filesize($fullpath)) !== false) {
-			// IE8 can't handle data uris larger than 32KB
-			if($fsize/1024 < 32) {
-				if(is_null($mime)) {
-					if(class_exists('finfo')) { // php 5.3+
-						$finfo = new finfo(FILEINFO_MIME);
-						$mime = explode('; ', $finfo->file($fullpath));
-						$mime = $mime[0];
-					} elseif(function_exists('mime_content_type')) { // PHP 5.2
-						$mime = mime_content_type($fullpath);
-					}
-				}
-
-				if(!is_null($mime)) // fallback if the mime type is still unknown
-					$url = sprintf('data:%s;base64,%s', $mime, base64_encode(file_get_contents($fullpath)));
-			}
-		}
-
-		return 'url("'.$url.'")';
-	}
-
-	// utility func to unquote a string
-	protected function lib_e($arg) {
-		switch ($arg[0]) {
-			case "list":
-				$items = $arg[2];
-				if (isset($items[0])) {
-					return $this->lib_e($items[0]);
-				}
-				$this->throwError("unrecognised input");
-			case "string":
-				$arg[1] = "";
-				return $arg;
-			case "keyword":
-				return $arg;
-			default:
-				return array("keyword", $this->compileValue($arg));
-		}
-	}
-
-	protected function lib__sprintf($args) {
-		if ($args[0] != "list") return $args;
-		$values = $args[2];
-		$string = array_shift($values);
-		$template = $this->compileValue($this->lib_e($string));
-
-		$i = 0;
-		if (preg_match_all('/%[dsa]/', $template, $m)) {
-			foreach ($m[0] as $match) {
-				$val = isset($values[$i]) ?
-					$this->reduce($values[$i]) : array('keyword', '');
-
-				// lessjs compat, renders fully expanded color, not raw color
-				if ($color = $this->coerceColor($val)) {
-					$val = $color;
-				}
-
-				$i++;
-				$rep = $this->compileValue($this->lib_e($val));
-				$template = preg_replace('/'.self::preg_quote($match).'/',
-					$rep, $template, 1);
-			}
-		}
-
-		$d = $string[0] == "string" ? $string[1] : '"';
-		return array("string", $d, array($template));
-	}
-
-	protected function lib_floor($arg) {
-		$value = $this->assertNumber($arg);
-		return array("number", floor($value), $arg[2]);
-	}
-
-	protected function lib_ceil($arg) {
-		$value = $this->assertNumber($arg);
-		return array("number", ceil($value), $arg[2]);
-	}
-
-	protected function lib_round($arg) {
-		if($arg[0] != "list") {
-			$value = $this->assertNumber($arg);
-			return array("number", round($value), $arg[2]);
-		} else {
-			$value = $this->assertNumber($arg[2][0]);
-			$precision = $this->assertNumber($arg[2][1]);
-			return array("number", round($value, $precision), $arg[2][0][2]);
-		}
-	}
-
-	protected function lib_unit($arg) {
-		if ($arg[0] == "list") {
-			list($number, $newUnit) = $arg[2];
-			return array("number", $this->assertNumber($number),
-				$this->compileValue($this->lib_e($newUnit)));
-		} else {
-			return array("number", $this->assertNumber($arg), "");
-		}
-	}
-
-	/**
-	 * Helper function to get arguments for color manipulation functions.
-	 * takes a list that contains a color like thing and a percentage
-	 */
-	public function colorArgs($args) {
-		if ($args[0] != 'list' || count($args[2]) < 2) {
-			return array(array('color', 0, 0, 0), 0);
-		}
-		list($color, $delta) = $args[2];
-		$color = $this->assertColor($color);
-		$delta = floatval($delta[1]);
-
-		return array($color, $delta);
-	}
-
-	protected function lib_darken($args) {
-		list($color, $delta) = $this->colorArgs($args);
-
-		$hsl = $this->toHSL($color);
-		$hsl[3] = $this->clamp($hsl[3] - $delta, 100);
-		return $this->toRGB($hsl);
-	}
-
-	protected function lib_lighten($args) {
-		list($color, $delta) = $this->colorArgs($args);
-
-		$hsl = $this->toHSL($color);
-		$hsl[3] = $this->clamp($hsl[3] + $delta, 100);
-		return $this->toRGB($hsl);
-	}
-
-	protected function lib_saturate($args) {
-		list($color, $delta) = $this->colorArgs($args);
-
-		$hsl = $this->toHSL($color);
-		$hsl[2] = $this->clamp($hsl[2] + $delta, 100);
-		return $this->toRGB($hsl);
-	}
-
-	protected function lib_desaturate($args) {
-		list($color, $delta) = $this->colorArgs($args);
-
-		$hsl = $this->toHSL($color);
-		$hsl[2] = $this->clamp($hsl[2] - $delta, 100);
-		return $this->toRGB($hsl);
-	}
-
-	protected function lib_spin($args) {
-		list($color, $delta) = $this->colorArgs($args);
-
-		$hsl = $this->toHSL($color);
-
-		$hsl[1] = $hsl[1] + $delta % 360;
-		if ($hsl[1] < 0) $hsl[1] += 360;
-
-		return $this->toRGB($hsl);
-	}
-
-	protected function lib_fadeout($args) {
-		list($color, $delta) = $this->colorArgs($args);
-		$color[4] = $this->clamp((isset($color[4]) ? $color[4] : 1) - $delta/100);
-		return $color;
-	}
-
-	protected function lib_fadein($args) {
-		list($color, $delta) = $this->colorArgs($args);
-		$color[4] = $this->clamp((isset($color[4]) ? $color[4] : 1) + $delta/100);
-		return $color;
-	}
-
-	protected function lib_hue($color) {
-		$hsl = $this->toHSL($this->assertColor($color));
-		return round($hsl[1]);
-	}
-
-	protected function lib_saturation($color) {
-		$hsl = $this->toHSL($this->assertColor($color));
-		return round($hsl[2]);
-	}
-
-	protected function lib_lightness($color) {
-		$hsl = $this->toHSL($this->assertColor($color));
-		return round($hsl[3]);
-	}
-
-	// get the alpha of a color
-	// defaults to 1 for non-colors or colors without an alpha
-	protected function lib_alpha($value) {
-		if (!is_null($color = $this->coerceColor($value))) {
-			return isset($color[4]) ? $color[4] : 1;
-		}
-	}
-
-	// set the alpha of the color
-	protected function lib_fade($args) {
-		list($color, $alpha) = $this->colorArgs($args);
-		$color[4] = $this->clamp($alpha / 100.0);
-		return $color;
-	}
-
-	protected function lib_percentage($arg) {
-		$num = $this->assertNumber($arg);
-		return array("number", $num*100, "%");
-	}
-
-	// mixes two colors by weight
-	// mix(@color1, @color2, [@weight: 50%]);
-	// http://sass-lang.com/docs/yardoc/Sass/Script/Functions.html#mix-instance_method
-	protected function lib_mix($args) {
-		if ($args[0] != "list" || count($args[2]) < 2)
-			$this->throwError("mix expects (color1, color2, weight)");
-
-		list($first, $second) = $args[2];
-		$first = $this->assertColor($first);
-		$second = $this->assertColor($second);
-
-		$first_a = $this->lib_alpha($first);
-		$second_a = $this->lib_alpha($second);
-
-		if (isset($args[2][2])) {
-			$weight = $args[2][2][1] / 100.0;
-		} else {
-			$weight = 0.5;
-		}
-
-		$w = $weight * 2 - 1;
-		$a = $first_a - $second_a;
-
-		$w1 = (($w * $a == -1 ? $w : ($w + $a)/(1 + $w * $a)) + 1) / 2.0;
-		$w2 = 1.0 - $w1;
-
-		$new = array('color',
-			$w1 * $first[1] + $w2 * $second[1],
-			$w1 * $first[2] + $w2 * $second[2],
-			$w1 * $first[3] + $w2 * $second[3],
-		);
-
-		if ($first_a != 1.0 || $second_a != 1.0) {
-			$new[] = $first_a * $weight + $second_a * ($weight - 1);
-		}
-
-		return $this->fixColor($new);
-	}
-
-	protected function lib_contrast($args) {
-	    $darkColor  = array('color', 0, 0, 0);
-	    $lightColor = array('color', 255, 255, 255);
-	    $threshold  = 0.43;
-
-	    if ( $args[0] == 'list' ) {
-	        $inputColor = ( isset($args[2][0]) ) ? $this->assertColor($args[2][0])  : $lightColor;
-	        $darkColor  = ( isset($args[2][1]) ) ? $this->assertColor($args[2][1])  : $darkColor;
-	        $lightColor = ( isset($args[2][2]) ) ? $this->assertColor($args[2][2])  : $lightColor;
-            if( isset($args[2][3]) ) {
-                if( isset($args[2][3][2]) && $args[2][3][2] == '%' ) {
-                    $args[2][3][1] /= 100;
-                    unset($args[2][3][2]);
- 	        	}
- 		        $threshold = $this->assertNumber($args[2][3]);
- 	        }
-	    }
-	    else {
-	        $inputColor  = $this->assertColor($args);
-	    }
-
-	    $inputColor = $this->coerceColor($inputColor);
-	    $darkColor  = $this->coerceColor($darkColor);
-	    $lightColor = $this->coerceColor($lightColor);
-
-	    //Figure out which is actually light and dark!
-	    if ( $this->lib_luma($darkColor) > $this->lib_luma($lightColor) ) {
-	        $t  = $lightColor;
-	        $lightColor = $darkColor;
-	        $darkColor  = $t;
-	    }
-
-	    $inputColor_alpha = $this->lib_alpha($inputColor);
-	    if ( ( $this->lib_luma($inputColor) * $inputColor_alpha) < $threshold) {
-	        return $lightColor;
-	    }
-	    return $darkColor;
-	}
-
-	protected function lib_luma($color) {
-	    $color = $this->coerceColor($color);
-	    return (0.2126 * $color[0] / 255) + (0.7152 * $color[1] / 255) + (0.0722 * $color[2] / 255);
-	}
-
-
-	public function assertColor($value, $error = "expected color value") {
-		$color = $this->coerceColor($value);
-		if (is_null($color)) $this->throwError($error);
-		return $color;
-	}
-
-	public function assertNumber($value, $error = "expecting number") {
-		if ($value[0] == "number") return $value[1];
-		$this->throwError($error);
-	}
-
-	public function assertArgs($value, $expectedArgs, $name="") {
-		if ($expectedArgs == 1) {
-			return $value;
-		} else {
-			if ($value[0] !== "list" || $value[1] != ",") $this->throwError("expecting list");
-			$values = $value[2];
-			$numValues = count($values);
-			if ($expectedArgs != $numValues) {
-				if ($name) {
-					$name = $name . ": ";
-				}
-
-				$this->throwError("${name}expecting $expectedArgs arguments, got $numValues");
-			}
-
-			return $values;
-		}
-	}
-
-	public function assertMinArgs($value, $expectedMinArgs, $name="") {
-    	if ($value[0] !== "list" || $value[1] != ",") $this->throwError("expecting list");
- 		$values = $value[2];
- 		$numValues = count($values);
- 		if ($expectedMinArgs > $numValues) {
-        	if ($name) {
-            	$name = $name . ": ";
-        	}
-
- 			$this->throwError("${name}expecting at least $expectedMinArgs arguments, got $numValues");
- 		}
-
- 		return $values;
-}
-
-	protected function toHSL($color) {
-		if ($color[0] == 'hsl') return $color;
-
-		$r = $color[1] / 255;
-		$g = $color[2] / 255;
-		$b = $color[3] / 255;
-
-		$min = min($r, $g, $b);
-		$max = max($r, $g, $b);
-
-		$L = ($min + $max) / 2;
-		if ($min == $max) {
-			$S = $H = 0;
-		} else {
-			if ($L < 0.5)
-				$S = ($max - $min)/($max + $min);
-			else
-				$S = ($max - $min)/(2.0 - $max - $min);
-
-			if ($r == $max) $H = ($g - $b)/($max - $min);
-			elseif ($g == $max) $H = 2.0 + ($b - $r)/($max - $min);
-			elseif ($b == $max) $H = 4.0 + ($r - $g)/($max - $min);
-
-		}
-
-		$out = array('hsl',
-			($H < 0 ? $H + 6 : $H)*60,
-			$S*100,
-			$L*100,
-		);
-
-		if (count($color) > 4) $out[] = $color[4]; // copy alpha
-		return $out;
-	}
-
-	protected function toRGB_helper($comp, $temp1, $temp2) {
-		if ($comp < 0) $comp += 1.0;
-		elseif ($comp > 1) $comp -= 1.0;
-
-		if (6 * $comp < 1) return $temp1 + ($temp2 - $temp1) * 6 * $comp;
-		if (2 * $comp < 1) return $temp2;
-		if (3 * $comp < 2) return $temp1 + ($temp2 - $temp1)*((2/3) - $comp) * 6;
-
-		return $temp1;
-	}
-
-	/**
-	 * Converts a hsl array into a color value in rgb.
-	 * Expects H to be in range of 0 to 360, S and L in 0 to 100
-	 */
-	protected function toRGB($color) {
-		if ($color[0] == 'color') return $color;
-
-		$H = $color[1] / 360;
-		$S = $color[2] / 100;
-		$L = $color[3] / 100;
-
-		if ($S == 0) {
-			$r = $g = $b = $L;
-		} else {
-			$temp2 = $L < 0.5 ?
-				$L*(1.0 + $S) :
-				$L + $S - $L * $S;
-
-			$temp1 = 2.0 * $L - $temp2;
-
-			$r = $this->toRGB_helper($H + 1/3, $temp1, $temp2);
-			$g = $this->toRGB_helper($H, $temp1, $temp2);
-			$b = $this->toRGB_helper($H - 1/3, $temp1, $temp2);
-		}
-
-		// $out = array('color', round($r*255), round($g*255), round($b*255));
-		$out = array('color', $r*255, $g*255, $b*255);
-		if (count($color) > 4) $out[] = $color[4]; // copy alpha
-		return $out;
-	}
-
-	protected function clamp($v, $max = 1, $min = 0) {
-		return min($max, max($min, $v));
-	}
-
-	/**
-	 * Convert the rgb, rgba, hsl color literals of function type
-	 * as returned by the parser into values of color type.
-	 */
-	protected function funcToColor($func) {
-		$fname = $func[1];
-		if ($func[2][0] != 'list') return false; // need a list of arguments
-		$rawComponents = $func[2][2];
-
-		if ($fname == 'hsl' || $fname == 'hsla') {
-			$hsl = array('hsl');
-			$i = 0;
-			foreach ($rawComponents as $c) {
-				$val = $this->reduce($c);
-				$val = isset($val[1]) ? floatval($val[1]) : 0;
-
-				if ($i == 0) $clamp = 360;
-				elseif ($i < 3) $clamp = 100;
-				else $clamp = 1;
-
-				$hsl[] = $this->clamp($val, $clamp);
-				$i++;
-			}
-
-			while (count($hsl) < 4) $hsl[] = 0;
-			return $this->toRGB($hsl);
-
-		} elseif ($fname == 'rgb' || $fname == 'rgba') {
-			$components = array();
-			$i = 1;
-			foreach	($rawComponents as $c) {
-				$c = $this->reduce($c);
-				if ($i < 4) {
-					if ($c[0] == "number" && $c[2] == "%") {
-						$components[] = 255 * ($c[1] / 100);
-					} else {
-						$components[] = floatval($c[1]);
-					}
-				} elseif ($i == 4) {
-					if ($c[0] == "number" && $c[2] == "%") {
-						$components[] = 1.0 * ($c[1] / 100);
-					} else {
-						$components[] = floatval($c[1]);
-					}
-				} else break;
-
-				$i++;
-			}
-			while (count($components) < 3) $components[] = 0;
-			array_unshift($components, 'color');
-			return $this->fixColor($components);
-		}
-
-		return false;
-	}
-
-	protected function reduce($value, $forExpression = false) {
-		switch ($value[0]) {
-		case "interpolate":
-			$reduced = $this->reduce($value[1]);
-			$var = $this->compileValue($reduced);
-			$res = $this->reduce(array("variable", $this->vPrefix . $var));
-
-			if ($res[0] == "raw_color") {
-				$res = $this->coerceColor($res);
-			}
-
-			if (empty($value[2])) $res = $this->lib_e($res);
-
-			return $res;
-		case "variable":
-			$key = $value[1];
-			if (is_array($key)) {
-				$key = $this->reduce($key);
-				$key = $this->vPrefix . $this->compileValue($this->lib_e($key));
-			}
-
-			$seen =& $this->env->seenNames;
-
-			if (!empty($seen[$key])) {
-				$this->throwError("infinite loop detected: $key");
-			}
-
-			$seen[$key] = true;
-			$out = $this->reduce($this->get($key));
-			$seen[$key] = false;
-			return $out;
-		case "list":
-			foreach ($value[2] as &$item) {
-				$item = $this->reduce($item, $forExpression);
-			}
-			return $value;
-		case "expression":
-			return $this->evaluate($value);
-		case "string":
-			foreach ($value[2] as &$part) {
-				if (is_array($part)) {
-					$strip = $part[0] == "variable";
-					$part = $this->reduce($part);
-					if ($strip) $part = $this->lib_e($part);
-				}
-			}
-			return $value;
-		case "escape":
-			list(,$inner) = $value;
-			return $this->lib_e($this->reduce($inner));
-		case "function":
-			$color = $this->funcToColor($value);
-			if ($color) return $color;
-
-			list(, $name, $args) = $value;
-			if ($name == "%") $name = "_sprintf";
-
-			$f = isset($this->libFunctions[$name]) ?
-				$this->libFunctions[$name] : array($this, 'lib_'.str_replace('-', '_', $name));
-
-			if (is_callable($f)) {
-				if ($args[0] == 'list')
-					$args = self::compressList($args[2], $args[1]);
-
-				$ret = call_user_func($f, $this->reduce($args, true), $this);
-
-				if (is_null($ret)) {
-					return array("string", "", array(
-						$name, "(", $args, ")"
-					));
-				}
-
-				// convert to a typed value if the result is a php primitive
-				if (is_numeric($ret)) $ret = array('number', $ret, "");
-				elseif (!is_array($ret)) $ret = array('keyword', $ret);
-
-				return $ret;
-			}
-
-			// plain function, reduce args
-			$value[2] = $this->reduce($value[2]);
-			return $value;
-		case "unary":
-			list(, $op, $exp) = $value;
-			$exp = $this->reduce($exp);
-
-			if ($exp[0] == "number") {
-				switch ($op) {
-				case "+":
-					return $exp;
-				case "-":
-					$exp[1] *= -1;
-					return $exp;
-				}
-			}
-			return array("string", "", array($op, $exp));
-		}
-
-		if ($forExpression) {
-			switch ($value[0]) {
-			case "keyword":
-				if ($color = $this->coerceColor($value)) {
-					return $color;
-				}
-				break;
-			case "raw_color":
-				return $this->coerceColor($value);
-			}
-		}
-
-		return $value;
-	}
-
-
-	// coerce a value for use in color operation
-	protected function coerceColor($value) {
-		switch($value[0]) {
-			case 'color': return $value;
-			case 'raw_color':
-				$c = array("color", 0, 0, 0);
-				$colorStr = substr($value[1], 1);
-				$num = hexdec($colorStr);
-				$width = strlen($colorStr) == 3 ? 16 : 256;
-
-				for ($i = 3; $i > 0; $i--) { // 3 2 1
-					$t = $num % $width;
-					$num /= $width;
-
-					$c[$i] = $t * (256/$width) + $t * floor(16/$width);
-				}
-
-				return $c;
-			case 'keyword':
-				$name = $value[1];
-				if (isset(self::$cssColors[$name])) {
-					$rgba = explode(',', self::$cssColors[$name]);
-
-					if(isset($rgba[3]))
-						return array('color', $rgba[0], $rgba[1], $rgba[2], $rgba[3]);
-
-					return array('color', $rgba[0], $rgba[1], $rgba[2]);
-				}
-				return null;
-		}
-	}
-
-	// make something string like into a string
-	protected function coerceString($value) {
-		switch ($value[0]) {
-		case "string":
-			return $value;
-		case "keyword":
-			return array("string", "", array($value[1]));
-		}
-		return null;
-	}
-
-	// turn list of length 1 into value type
-	protected function flattenList($value) {
-		if ($value[0] == "list" && count($value[2]) == 1) {
-			return $this->flattenList($value[2][0]);
-		}
-		return $value;
-	}
-
-	public function toBool($a) {
-		if ($a) return self::$TRUE;
-		else return self::$FALSE;
-	}
-
-	// evaluate an expression
-	protected function evaluate($exp) {
-		list(, $op, $left, $right, $whiteBefore, $whiteAfter) = $exp;
-
-		$left = $this->reduce($left, true);
-		$right = $this->reduce($right, true);
-
-		if ($leftColor = $this->coerceColor($left)) {
-			$left = $leftColor;
-		}
-
-		if ($rightColor = $this->coerceColor($right)) {
-			$right = $rightColor;
-		}
-
-		$ltype = $left[0];
-		$rtype = $right[0];
-
-		// operators that work on all types
-		if ($op == "and") {
-			return $this->toBool($left == self::$TRUE && $right == self::$TRUE);
-		}
-
-		if ($op == "=") {
-			return $this->toBool($this->eq($left, $right) );
-		}
-
-		if ($op == "+" && !is_null($str = $this->stringConcatenate($left, $right))) {
-			return $str;
-		}
-
-		// type based operators
-		$fname = "op_${ltype}_${rtype}";
-		if (is_callable(array($this, $fname))) {
-			$out = $this->$fname($op, $left, $right);
-			if (!is_null($out)) return $out;
-		}
-
-		// make the expression look it did before being parsed
-		$paddedOp = $op;
-		if ($whiteBefore) $paddedOp = " " . $paddedOp;
-		if ($whiteAfter) $paddedOp .= " ";
-
-		return array("string", "", array($left, $paddedOp, $right));
-	}
-
-	protected function stringConcatenate($left, $right) {
-		if ($strLeft = $this->coerceString($left)) {
-			if ($right[0] == "string") {
-				$right[1] = "";
-			}
-			$strLeft[2][] = $right;
-			return $strLeft;
-		}
-
-		if ($strRight = $this->coerceString($right)) {
-			array_unshift($strRight[2], $left);
-			return $strRight;
-		}
-	}
-
-    protected function convert( $number, $to )
-    {
-        $value = $this->assertNumber( $number );
-        $from = $number[2];
-
-        // easy out
-        if( $from == $to )
-            return $number;
-
-        // check if the from value is a length
-        if( ( $from_index = array_search( $from, self::$lengths ) ) !== false ) {
-            // make sure to value is too
-            if( in_array( $to, self::$lengths ) ) {
-                // do the actual conversion
-                $to_index = array_search( $to, self::$lengths );
-                $px = $value * self::$lengths_to_base[ $from_index ];
-                $result = $px * ( 1 / self::$lengths_to_base[ $to_index ] );
-
-                $result = round( $result, 8 );
-                return array( "number", $result, $to );
-            }
-        }
-
-        // do the same check for times
-        if( in_array( $from, self::$times ) ) {
-            if( in_array( $to, self::$times ) ) {
-                // currently only ms and s are valid
-                if( $to == "ms" )
-                    $result = $value * 1000;
-                else
-                    $result = $value / 1000;
-
-                $result = round( $result, 8 );
-                return array( "number", $result, $to );
-            }
-        }
-
-        // lastly check for an angle
-        if( in_array( $from, self::$angles ) ) {
-            // convert whatever angle it is into degrees
-            if( $from == "rad" )
-                $deg = rad2deg( $value );
-
-            else if( $from == "turn" )
-                $deg = $value * 360;
-
-            else if( $from == "grad" )
-                $deg = $value / (400 / 360);
-
-            else
-                $deg = $value;
-
-            // Then convert it from degrees into desired unit
-            if( $to == "deg" )
-                $result = $deg;
-
-            if( $to == "rad" )
-                $result = deg2rad( $deg );
-
-            if( $to == "turn" )
-                $result = $value / 360;
-
-            if( $to == "grad" )
-                $result = $value * (400 / 360);
-
-            $result = round( $result, 8 );
-            return array( "number", $result, $to );
-        }
-
-        // we don't know how to convert these
-        $this->throwError( "Cannot convert {$from} to {$to}" );
-    }
-
-	// make sure a color's components don't go out of bounds
-	protected function fixColor($c) {
-		foreach (range(1, 3) as $i) {
-			if ($c[$i] < 0) $c[$i] = 0;
-			if ($c[$i] > 255) $c[$i] = 255;
-		}
-
-		return $c;
-	}
-
-	protected function op_number_color($op, $lft, $rgt) {
-		if ($op == '+' || $op == '*') {
-			return $this->op_color_number($op, $rgt, $lft);
-		}
-	}
-
-	protected function op_color_number($op, $lft, $rgt) {
-		if ($rgt[0] == '%') $rgt[1] /= 100;
-
-		return $this->op_color_color($op, $lft,
-			array_fill(1, count($lft) - 1, $rgt[1]));
-	}
-
-	protected function op_color_color($op, $left, $right) {
-		$out = array('color');
-		$max = count($left) > count($right) ? count($left) : count($right);
-		foreach (range(1, $max - 1) as $i) {
-			$lval = isset($left[$i]) ? $left[$i] : 0;
-			$rval = isset($right[$i]) ? $right[$i] : 0;
-			switch ($op) {
-			case '+':
-				$out[] = $lval + $rval;
-				break;
-			case '-':
-				$out[] = $lval - $rval;
-				break;
-			case '*':
-				$out[] = $lval * $rval;
-				break;
-			case '%':
-				$out[] = $lval % $rval;
-				break;
-			case '/':
-				if ($rval == 0) $this->throwError("evaluate error: can't divide by zero");
-				$out[] = $lval / $rval;
-				break;
-			default:
-				$this->throwError('evaluate error: color op number failed on op '.$op);
-			}
-		}
-		return $this->fixColor($out);
-	}
-
-	function lib_red($color){
-		$color = $this->coerceColor($color);
-		if (is_null($color)) {
-			$this->throwError('color expected for red()');
-		}
-
-		return $color[1];
-	}
-
-	function lib_green($color){
-		$color = $this->coerceColor($color);
-		if (is_null($color)) {
-			$this->throwError('color expected for green()');
-		}
-
-		return $color[2];
-	}
-
-	function lib_blue($color){
-		$color = $this->coerceColor($color);
-		if (is_null($color)) {
-			$this->throwError('color expected for blue()');
-		}
-
-		return $color[3];
-	}
-
-
-	// operator on two numbers
-	protected function op_number_number($op, $left, $right) {
-		$unit = empty($left[2]) ? $right[2] : $left[2];
-
-		$value = 0;
-		switch ($op) {
-		case '+':
-			$value = $left[1] + $right[1];
-			break;
-		case '*':
-			$value = $left[1] * $right[1];
-			break;
-		case '-':
-			$value = $left[1] - $right[1];
-			break;
-		case '%':
-			$value = $left[1] % $right[1];
-			break;
-		case '/':
-			if ($right[1] == 0) $this->throwError('parse error: divide by zero');
-			$value = $left[1] / $right[1];
-			break;
-		case '<':
-			return $this->toBool($left[1] < $right[1]);
-		case '>':
-			return $this->toBool($left[1] > $right[1]);
-		case '>=':
-			return $this->toBool($left[1] >= $right[1]);
-		case '=<':
-			return $this->toBool($left[1] <= $right[1]);
-		default:
-			$this->throwError('parse error: unknown number operator: '.$op);
-		}
-
-		return array("number", $value, $unit);
-	}
-
-
-	/* environment functions */
-
-	protected function makeOutputBlock($type, $selectors = null) {
-		$b = new stdclass;
-		$b->lines = array();
-		$b->children = array();
-		$b->selectors = $selectors;
-		$b->type = $type;
-		$b->parent = $this->scope;
-		return $b;
-	}
-
-	// the state of execution
-	protected function pushEnv($block = null) {
-		$e = new stdclass;
-		$e->parent = $this->env;
-		$e->store = array();
-		$e->block = $block;
-
-		$this->env = $e;
-		return $e;
-	}
-
-	// pop something off the stack
-	protected function popEnv() {
-		$old = $this->env;
-		$this->env = $this->env->parent;
-		return $old;
-	}
-
-	// set something in the current env
-	protected function set($name, $value) {
-		$this->env->store[$name] = $value;
-	}
-
-
-	// get the highest occurrence entry for a name
-	protected function get($name) {
-		$current = $this->env;
-
-        // track scope to evaluate
-        $scope_secondary = array();
-
-        $isArguments = $name == $this->vPrefix . 'arguments';
-		while ($current) {
-			if ($isArguments && isset($current->arguments)) {
-				return array('list', ' ', $current->arguments);
-			}
-
-			if (isset($current->store[$name]))
-				return $current->store[$name];
-			// has secondary scope?
-			if (isset($current->storeParent))
-				$scope_secondary[] = $current->storeParent;
-
-			if (isset($current->parent))
-				$current = $current->parent;
-			else
-				$current = null;
-		}
-
-		while (count($scope_secondary)) {
-            // pop one off
-            $current = array_shift($scope_secondary);
-            while ($current) {
-                if ($isArguments && isset($current->arguments)) {
-                    return array('list', ' ', $current->arguments);
-                }
-
-                if (isset($current->store[$name])) {
-                    return $current->store[$name];
-                }
-
-                // has secondary scope?
-                if (isset($current->storeParent)) {
-                    $scope_secondary[] = $current->storeParent;
-                }
-
-                if (isset($current->parent)) {
-                    $current = $current->parent;
-                } else {
-                    $current = null;
-                }
-            }
-        }
-
-		$this->throwError("variable $name is undefined");
-	}
-
-	// inject array of unparsed strings into environment as variables
-	protected function injectVariables($args) {
-		$this->pushEnv();
-		$parser = new lessc_parser($this, __METHOD__);
-		foreach ($args as $name => $strValue) {
-			if ($name{0} != '@') $name = '@'.$name;
-			$parser->count = 0;
-			$parser->buffer = (string)$strValue;
-			if (!$parser->propertyValue($value)) {
-				throw new \Exception("failed to parse passed in variable $name: $strValue");
-			}
-
-			$this->set($name, $value);
-		}
-	}
-
-	/**
-	 * Initialize any static state, can initialize parser for a file
-	 * $opts isn't used yet
-	 */
-	public function __construct($fname = null) {
-		if ($fname !== null) {
-			// used for deprecated parse method
-			$this->_parseFile = $fname;
-		}
-	}
-
-	public function compile($string, $name = null) {
-		$locale = setlocale(LC_NUMERIC, 0);
-		setlocale(LC_NUMERIC, "C");
-
-		$this->parser = $this->makeParser($name);
-		$root = $this->parser->parse($string);
-
-		$this->env = null;
-		$this->scope = null;
-        $this->allParsedFiles = array();
-
-		$this->formatter = $this->newFormatter();
-
-		if (!empty($this->registeredVars)) {
-			$this->injectVariables($this->registeredVars);
-		}
-
-		$this->sourceParser = $this->parser; // used for error messages
-		$this->compileBlock($root);
-
-		ob_start();
-		$this->formatter->block($this->scope);
-		$out = ob_get_clean();
-		setlocale(LC_NUMERIC, $locale);
-		return $out;
-	}
-
-	public function compileFile($fname, $outFname = null) {
-		if (!is_readable($fname)) {
-			throw new \Exception('load error: failed to find '.$fname);
-		}
-
-		$pi = pathinfo($fname);
-
-		$oldImport = $this->importDir;
-
-		$this->importDir = (array)$this->importDir;
-		$this->importDir[] = $pi['dirname'].'/';
-
-		$this->addParsedFile($fname);
-
-		$out = $this->compile(file_get_contents($fname), $fname);
-
-		$this->importDir = $oldImport;
-
-		if ($outFname !== null) {
-			return file_put_contents($outFname, $out);
-		}
-
-		return $out;
-	}
-
-    /**
-     * Based on explicit input/output files does a full change check on cache before compiling.
-     *
-     * @param string $in
-     * @param string $out
-     * @param boolean $force
-     * @return string Compiled CSS results
-     * @throws Exception
-     */
-    public function checkedCachedCompile($in, $out, $force = false) {
-        if (!is_file($in) || !is_readable($in)) {
-            throw new Exception('Invalid or unreadable input file specified.');
-        }
-        if (is_dir($out) || !is_writable(file_exists($out) ? $out : dirname($out))) {
-            throw new Exception('Invalid or unwritable output file specified.');
-        }
-
-        $outMeta = $out . '.meta';
-        $metadata = null;
-        if (!$force && is_file($outMeta)) {
-            $metadata = unserialize(file_get_contents($outMeta));
-        }
-
-        $output = $this->cachedCompile($metadata ? $metadata : $in);
-
-        if (!$metadata || $metadata['updated'] != $output['updated']) {
-            $css = $output['compiled'];
-            unset($output['compiled']);
-            file_put_contents($out, $css);
-            file_put_contents($outMeta, serialize($output));
-        } else {
-            $css = file_get_contents($out);
-        }
-
-        return $css;
-    }
-
-	// compile only if changed input has changed or output doesn't exist
-	public function checkedCompile($in, $out) {
-		if (!is_file($out) || filemtime($in) > filemtime($out)) {
-			$this->compileFile($in, $out);
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Execute lessphp on a .less file or a lessphp cache structure
-	 *
-	 * The lessphp cache structure contains information about a specific
-	 * less file having been parsed. It can be used as a hint for future
-	 * calls to determine whether or not a rebuild is required.
-	 *
-	 * The cache structure contains two important keys that may be used
-	 * externally:
-	 *
-	 * compiled: The final compiled CSS
-	 * updated: The time (in seconds) the CSS was last compiled
-	 *
-	 * The cache structure is a plain-ol' PHP associative array and can
-	 * be serialized and unserialized without a hitch.
-	 *
-	 * @param mixed $in Input
-	 * @param bool $force Force rebuild?
-	 * @return array lessphp cache structure
-	 */
-	public function cachedCompile($in, $force = false) {
-		// assume no root
-		$root = null;
-
-		if (is_string($in)) {
-			$root = $in;
-		} elseif (is_array($in) and isset($in['root'])) {
-			if ($force or ! isset($in['files'])) {
-				// If we are forcing a recompile or if for some reason the
-				// structure does not contain any file information we should
-				// specify the root to trigger a rebuild.
-				$root = $in['root'];
-			} elseif (isset($in['files']) and is_array($in['files'])) {
-				foreach ($in['files'] as $fname => $ftime ) {
-					if (!file_exists($fname) or filemtime($fname) > $ftime) {
-						// One of the files we knew about previously has changed
-						// so we should look at our incoming root again.
-						$root = $in['root'];
-						break;
-					}
-				}
-			}
-		} else {
-			// TODO: Throw an exception? We got neither a string nor something
-			// that looks like a compatible lessphp cache structure.
-			return null;
-		}
-
-		if ($root !== null) {
-			// If we have a root value which means we should rebuild.
-			$out = array();
-			$out['root'] = $root;
-			$out['compiled'] = $this->compileFile($root);
-			$out['files'] = $this->allParsedFiles();
-			$out['updated'] = time();
-			return $out;
-		} else {
-			// No changes, pass back the structure
-			// we were given initially.
-			return $in;
-		}
-
-	}
-
-	// parse and compile buffer
-	// This is deprecated
-	public function parse($str = null, $initialVariables = null) {
-		if (is_array($str)) {
-			$initialVariables = $str;
-			$str = null;
-		}
-
-		$oldVars = $this->registeredVars;
-		if ($initialVariables !== null) {
-			$this->setVariables($initialVariables);
-		}
-
-		if ($str == null) {
-			if (empty($this->_parseFile)) {
-				throw new \Exception("nothing to parse");
-			}
-
-			$out = $this->compileFile($this->_parseFile);
-		} else {
-			$out = $this->compile($str);
-		}
-
-		$this->registeredVars = $oldVars;
-		return $out;
-	}
-
-	protected function makeParser($name) {
-		$parser = new lessc_parser($this, $name);
-		$parser->writeComments = $this->preserveComments;
-
-		return $parser;
-	}
-
-	public function setFormatter($name) {
-		$this->formatterName = $name;
-	}
-
-	protected function newFormatter() {
-		$className = "lessc_formatter_lessjs";
-		if (!empty($this->formatterName)) {
-			if (!is_string($this->formatterName))
-				return $this->formatterName;
-			$className = "lessc_formatter_$this->formatterName";
-		}
-
-		return new $className;
-	}
-
-	public function setPreserveComments($preserve) {
-		$this->preserveComments = $preserve;
-	}
-
-	public function registerFunction($name, $func) {
-		$this->libFunctions[$name] = $func;
-	}
-
-	public function unregisterFunction($name) {
-		unset($this->libFunctions[$name]);
-	}
-
-	public function setVariables($variables) {
-		$this->registeredVars = array_merge($this->registeredVars, $variables);
-	}
-
-	public function unsetVariable($name) {
-		unset($this->registeredVars[$name]);
-	}
-
-	public function setImportDir($dirs) {
-		$this->importDir = (array)$dirs;
-	}
-
-	public function addImportDir($dir) {
-		$this->importDir = (array)$this->importDir;
-		$this->importDir[] = $dir;
-	}
-
-	public function allParsedFiles() {
-		return $this->allParsedFiles;
-	}
-
-	public function addParsedFile($file) {
-		$this->allParsedFiles[realpath($file)] = filemtime($file);
-	}
-
-	/**
-	 * Uses the current value of $this->count to show line and line number
-	 */
-	public function throwError($msg = null) {
-		if ($this->sourceLoc >= 0) {
-			$this->sourceParser->throwError($msg, $this->sourceLoc);
-		}
-		throw new \Exception($msg);
-	}
-
-	// compile file $in to file $out if $in is newer than $out
-	// returns true when it compiles, false otherwise
-	public static function ccompile($in, $out, $less = null) {
-		if ($less === null) {
-			$less = new self;
-		}
-		return $less->checkedCompile($in, $out);
-	}
-
-	public static function cexecute($in, $force = false, $less = null) {
-		if ($less === null) {
-			$less = new self;
-		}
-		return $less->cachedCompile($in, $force);
-	}
-
-	static protected $cssColors = array(
-		'aliceblue' => '240,248,255',
-		'antiquewhite' => '250,235,215',
-		'aqua' => '0,255,255',
-		'aquamarine' => '127,255,212',
-		'azure' => '240,255,255',
-		'beige' => '245,245,220',
-		'bisque' => '255,228,196',
-		'black' => '0,0,0',
-		'blanchedalmond' => '255,235,205',
-		'blue' => '0,0,255',
-		'blueviolet' => '138,43,226',
-		'brown' => '165,42,42',
-		'burlywood' => '222,184,135',
-		'cadetblue' => '95,158,160',
-		'chartreuse' => '127,255,0',
-		'chocolate' => '210,105,30',
-		'coral' => '255,127,80',
-		'cornflowerblue' => '100,149,237',
-		'cornsilk' => '255,248,220',
-		'crimson' => '220,20,60',
-		'cyan' => '0,255,255',
-		'darkblue' => '0,0,139',
-		'darkcyan' => '0,139,139',
-		'darkgoldenrod' => '184,134,11',
-		'darkgray' => '169,169,169',
-		'darkgreen' => '0,100,0',
-		'darkgrey' => '169,169,169',
-		'darkkhaki' => '189,183,107',
-		'darkmagenta' => '139,0,139',
-		'darkolivegreen' => '85,107,47',
-		'darkorange' => '255,140,0',
-		'darkorchid' => '153,50,204',
-		'darkred' => '139,0,0',
-		'darksalmon' => '233,150,122',
-		'darkseagreen' => '143,188,143',
-		'darkslateblue' => '72,61,139',
-		'darkslategray' => '47,79,79',
-		'darkslategrey' => '47,79,79',
-		'darkturquoise' => '0,206,209',
-		'darkviolet' => '148,0,211',
-		'deeppink' => '255,20,147',
-		'deepskyblue' => '0,191,255',
-		'dimgray' => '105,105,105',
-		'dimgrey' => '105,105,105',
-		'dodgerblue' => '30,144,255',
-		'firebrick' => '178,34,34',
-		'floralwhite' => '255,250,240',
-		'forestgreen' => '34,139,34',
-		'fuchsia' => '255,0,255',
-		'gainsboro' => '220,220,220',
-		'ghostwhite' => '248,248,255',
-		'gold' => '255,215,0',
-		'goldenrod' => '218,165,32',
-		'gray' => '128,128,128',
-		'green' => '0,128,0',
-		'greenyellow' => '173,255,47',
-		'grey' => '128,128,128',
-		'honeydew' => '240,255,240',
-		'hotpink' => '255,105,180',
-		'indianred' => '205,92,92',
-		'indigo' => '75,0,130',
-		'ivory' => '255,255,240',
-		'khaki' => '240,230,140',
-		'lavender' => '230,230,250',
-		'lavenderblush' => '255,240,245',
-		'lawngreen' => '124,252,0',
-		'lemonchiffon' => '255,250,205',
-		'lightblue' => '173,216,230',
-		'lightcoral' => '240,128,128',
-		'lightcyan' => '224,255,255',
-		'lightgoldenrodyellow' => '250,250,210',
-		'lightgray' => '211,211,211',
-		'lightgreen' => '144,238,144',
-		'lightgrey' => '211,211,211',
-		'lightpink' => '255,182,193',
-		'lightsalmon' => '255,160,122',
-		'lightseagreen' => '32,178,170',
-		'lightskyblue' => '135,206,250',
-		'lightslategray' => '119,136,153',
-		'lightslategrey' => '119,136,153',
-		'lightsteelblue' => '176,196,222',
-		'lightyellow' => '255,255,224',
-		'lime' => '0,255,0',
-		'limegreen' => '50,205,50',
-		'linen' => '250,240,230',
-		'magenta' => '255,0,255',
-		'maroon' => '128,0,0',
-		'mediumaquamarine' => '102,205,170',
-		'mediumblue' => '0,0,205',
-		'mediumorchid' => '186,85,211',
-		'mediumpurple' => '147,112,219',
-		'mediumseagreen' => '60,179,113',
-		'mediumslateblue' => '123,104,238',
-		'mediumspringgreen' => '0,250,154',
-		'mediumturquoise' => '72,209,204',
-		'mediumvioletred' => '199,21,133',
-		'midnightblue' => '25,25,112',
-		'mintcream' => '245,255,250',
-		'mistyrose' => '255,228,225',
-		'moccasin' => '255,228,181',
-		'navajowhite' => '255,222,173',
-		'navy' => '0,0,128',
-		'oldlace' => '253,245,230',
-		'olive' => '128,128,0',
-		'olivedrab' => '107,142,35',
-		'orange' => '255,165,0',
-		'orangered' => '255,69,0',
-		'orchid' => '218,112,214',
-		'palegoldenrod' => '238,232,170',
-		'palegreen' => '152,251,152',
-		'paleturquoise' => '175,238,238',
-		'palevioletred' => '219,112,147',
-		'papayawhip' => '255,239,213',
-		'peachpuff' => '255,218,185',
-		'peru' => '205,133,63',
-		'pink' => '255,192,203',
-		'plum' => '221,160,221',
-		'powderblue' => '176,224,230',
-		'purple' => '128,0,128',
-		'red' => '255,0,0',
-		'rosybrown' => '188,143,143',
-		'royalblue' => '65,105,225',
-		'saddlebrown' => '139,69,19',
-		'salmon' => '250,128,114',
-		'sandybrown' => '244,164,96',
-		'seagreen' => '46,139,87',
-		'seashell' => '255,245,238',
-		'sienna' => '160,82,45',
-		'silver' => '192,192,192',
-		'skyblue' => '135,206,235',
-		'slateblue' => '106,90,205',
-		'slategray' => '112,128,144',
-		'slategrey' => '112,128,144',
-		'snow' => '255,250,250',
-		'springgreen' => '0,255,127',
-		'steelblue' => '70,130,180',
-		'tan' => '210,180,140',
-		'teal' => '0,128,128',
-		'thistle' => '216,191,216',
-		'tomato' => '255,99,71',
-		'transparent' => '0,0,0,0',
-		'turquoise' => '64,224,208',
-		'violet' => '238,130,238',
-		'wheat' => '245,222,179',
-		'white' => '255,255,255',
-		'whitesmoke' => '245,245,245',
-		'yellow' => '255,255,0',
-		'yellowgreen' => '154,205,50'
-	);
-}
-
-// responsible for taking a string of LESS code and converting it into a
-// syntax tree
-class lessc_parser {
-	static protected $nextBlockId = 0; // used to uniquely identify blocks
-
-	static protected $precedence = array(
-		'=<' => 0,
-		'>=' => 0,
-		'=' => 0,
-		'<' => 0,
-		'>' => 0,
-
-		'+' => 1,
-		'-' => 1,
-		'*' => 2,
-		'/' => 2,
-		'%' => 2,
-	);
-
-	static protected $whitePattern;
-	static protected $commentMulti;
-
-	static protected $commentSingle = "//";
-	static protected $commentMultiLeft = "/*";
-	static protected $commentMultiRight = "*/";
-
-	// regex string to match any of the operators
-	static protected $operatorString;
-
-	// these properties will supress division unless it's inside parenthases
-	static protected $supressDivisionProps =
-		array('/border-radius$/i', '/^font$/i');
-
-	protected $blockDirectives = array("font-face", "keyframes", "page", "-moz-document", "viewport", "-moz-viewport", "-o-viewport", "-ms-viewport");
-	protected $lineDirectives = array("charset");
-
-	/**
-	 * if we are in parens we can be more liberal with whitespace around
-	 * operators because it must evaluate to a single value and thus is less
-	 * ambiguous.
-	 *
-	 * Consider:
-	 *     property1: 10 -5; // is two numbers, 10 and -5
-	 *     property2: (10 -5); // should evaluate to 5
-	 */
-	protected $inParens = false;
-
-	// caches preg escaped literals
-	static protected $literalCache = array();
-
-	public function __construct($lessc, $sourceName = null) {
-		$this->eatWhiteDefault = true;
-		// reference to less needed for vPrefix, mPrefix, and parentSelector
-		$this->lessc = $lessc;
-
-		$this->sourceName = $sourceName; // name used for error messages
-
-		$this->writeComments = false;
-
-		if (!self::$operatorString) {
-			self::$operatorString =
-				'('.implode('|', array_map(array('lessc', 'preg_quote'),
-					array_keys(self::$precedence))).')';
-
-			$commentSingle = lessc::preg_quote(self::$commentSingle);
-			$commentMultiLeft = lessc::preg_quote(self::$commentMultiLeft);
-			$commentMultiRight = lessc::preg_quote(self::$commentMultiRight);
-
-			self::$commentMulti = $commentMultiLeft.'.*?'.$commentMultiRight;
-			self::$whitePattern = '/'.$commentSingle.'[^\n]*\s*|('.self::$commentMulti.')\s*|\s+/Ais';
-		}
-	}
-
-	public function parse($buffer) {
-		$this->count = 0;
-		$this->line = 1;
-
-		$this->env = null; // block stack
-		$this->buffer = $this->writeComments ? $buffer : $this->removeComments($buffer);
-		$this->pushSpecialBlock("root");
-		$this->eatWhiteDefault = true;
-		$this->seenComments = array();
-
-		// trim whitespace on head
-		// if (preg_match('/^\s+/', $this->buffer, $m)) {
-		// 	$this->line += substr_count($m[0], "\n");
-		// 	$this->buffer = ltrim($this->buffer);
-		// }
-		$this->whitespace();
-
-		// parse the entire file
-		while (false !== $this->parseChunk());
-
-		if ($this->count != strlen($this->buffer))
-			$this->throwError();
-
-		// TODO report where the block was opened
-		if ( !property_exists($this->env, 'parent') || !is_null($this->env->parent) )
-			throw new \Exception('parse error: unclosed block');
-
-		return $this->env;
-	}
-
-	/**
-	 * Parse a single chunk off the head of the buffer and append it to the
-	 * current parse environment.
-	 * Returns false when the buffer is empty, or when there is an error.
-	 *
-	 * This function is called repeatedly until the entire document is
-	 * parsed.
-	 *
-	 * This parser is most similar to a recursive descent parser. Single
-	 * functions represent discrete grammatical rules for the language, and
-	 * they are able to capture the text that represents those rules.
-	 *
-	 * Consider the function lessc::keyword(). (all parse functions are
-	 * structured the same)
-	 *
-	 * The function takes a single reference argument. When calling the
-	 * function it will attempt to match a keyword on the head of the buffer.
-	 * If it is successful, it will place the keyword in the referenced
-	 * argument, advance the position in the buffer, and return true. If it
-	 * fails then it won't advance the buffer and it will return false.
-	 *
-	 * All of these parse functions are powered by lessc::match(), which behaves
-	 * the same way, but takes a literal regular expression. Sometimes it is
-	 * more convenient to use match instead of creating a new function.
-	 *
-	 * Because of the format of the functions, to parse an entire string of
-	 * grammatical rules, you can chain them together using &&.
-	 *
-	 * But, if some of the rules in the chain succeed before one fails, then
-	 * the buffer position will be left at an invalid state. In order to
-	 * avoid this, lessc::seek() is used to remember and set buffer positions.
-	 *
-	 * Before parsing a chain, use $s = $this->seek() to remember the current
-	 * position into $s. Then if a chain fails, use $this->seek($s) to
-	 * go back where we started.
-	 */
-	protected function parseChunk() {
-		if (empty($this->buffer)) return false;
-		$s = $this->seek();
-
-		if ($this->whitespace()) {
-			return true;
-		}
-
-		// setting a property
-		if ($this->keyword($key) && $this->assign() &&
-			$this->propertyValue($value, $key) && $this->end())
-		{
-			$this->append(array('assign', $key, $value), $s);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-
-		// look for special css blocks
-		if ($this->literal('@', false)) {
-			$this->count--;
-
-			// media
-			if ($this->literal('@media')) {
-				if (($this->mediaQueryList($mediaQueries) || true)
-					&& $this->literal('{'))
-				{
-					$media = $this->pushSpecialBlock("media");
-					$media->queries = is_null($mediaQueries) ? array() : $mediaQueries;
-					return true;
-				} else {
-					$this->seek($s);
-					return false;
-				}
-			}
-
-			if ($this->literal("@", false) && $this->keyword($dirName)) {
-				if ($this->isDirective($dirName, $this->blockDirectives)) {
-					if (($this->openString("{", $dirValue, null, array(";")) || true) &&
-						$this->literal("{"))
-					{
-						$dir = $this->pushSpecialBlock("directive");
-						$dir->name = $dirName;
-						if (isset($dirValue)) $dir->value = $dirValue;
-						return true;
-					}
-				} elseif ($this->isDirective($dirName, $this->lineDirectives)) {
-					if ($this->propertyValue($dirValue) && $this->end()) {
-						$this->append(array("directive", $dirName, $dirValue));
-						return true;
-					}
-				} elseif ($this->literal(":", true)) {
-					//Ruleset Definition
-					if (($this->openString("{", $dirValue, null, array(";")) || true) &&
-							$this->literal("{"))
-					{
-						$dir = $this->pushBlock($this->fixTags(array("@".$dirName)));
-						$dir->name = $dirName;
-						if (isset($dirValue)) $dir->value = $dirValue;
-						return true;
-					}
-				}
-			}
-
-			$this->seek($s);
-		}
-
-		// setting a variable
-		if ($this->variable($var) && $this->assign() &&
-			$this->propertyValue($value) && $this->end())
-		{
-			$this->append(array('assign', $var, $value), $s);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		if ($this->import($importValue)) {
-			$this->append($importValue, $s);
-			return true;
-		}
-
-		// opening parametric mixin
-		if ($this->tag($tag, true) && $this->argumentDef($args, $isVararg) &&
-			($this->guards($guards) || true) &&
-			$this->literal('{'))
-		{
-			$block = $this->pushBlock($this->fixTags(array($tag)));
-			$block->args = $args;
-			$block->isVararg = $isVararg;
-			if (!empty($guards)) $block->guards = $guards;
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		// opening a simple block
-		if ($this->tags($tags) && $this->literal('{', false)) {
-			$tags = $this->fixTags($tags);
-			$this->pushBlock($tags);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		// closing a block
-		if ($this->literal('}', false)) {
-			try {
-				$block = $this->pop();
-			} catch (\Exception $e) {
-				$this->seek($s);
-				$this->throwError($e->getMessage());
-			}
-
-			$hidden = false;
-			if (is_null($block->type)) {
-				$hidden = true;
-				if (!isset($block->args)) {
-					foreach ($block->tags as $tag) {
-						if (!is_string($tag) || $tag{0} != $this->lessc->mPrefix) {
-							$hidden = false;
-							break;
-						}
-					}
-				}
-
-				foreach ($block->tags as $tag) {
-					if (is_string($tag)) {
-						$this->env->children[$tag][] = $block;
-					}
-				}
-			}
-
-			if (!$hidden) {
-				$this->append(array('block', $block), $s);
-			}
-
-			// this is done here so comments aren't bundled into he block that
-			// was just closed
-			$this->whitespace();
-			return true;
-		}
-
-		// mixin
-		if ($this->mixinTags($tags) &&
-			($this->argumentDef($argv, $isVararg) || true) &&
-			($this->keyword($suffix) || true) && $this->end())
-		{
-			$tags = $this->fixTags($tags);
-			$this->append(array('mixin', $tags, $argv, $suffix), $s);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		// spare ;
-		if ($this->literal(';')) return true;
-
-		return false; // got nothing, throw error
-	}
-
-	protected function isDirective($dirname, $directives) {
-		// TODO: cache pattern in parser
-		$pattern = implode("|",
-			array_map(array("lessc", "preg_quote"), $directives));
-		$pattern = '/^(-[a-z-]+-)?(' . $pattern . ')$/i';
-
-		return preg_match($pattern, $dirname);
-	}
-
-	protected function fixTags($tags) {
-		// move @ tags out of variable namespace
-		foreach ($tags as &$tag) {
-			if ($tag{0} == $this->lessc->vPrefix)
-				$tag[0] = $this->lessc->mPrefix;
-		}
-		return $tags;
-	}
-
-	// a list of expressions
-	protected function expressionList(&$exps) {
-		$values = array();
-
-		while ($this->expression($exp)) {
-			$values[] = $exp;
-		}
-
-		if (count($values) == 0) return false;
-
-		$exps = lessc::compressList($values, ' ');
-		return true;
-	}
-
-	/**
-	 * Attempt to consume an expression.
-	 * @link http://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudo-code
-	 */
-	protected function expression(&$out) {
-		if ($this->value($lhs)) {
-			$out = $this->expHelper($lhs, 0);
-
-			// look for / shorthand
-			if (!empty($this->env->supressedDivision)) {
-				unset($this->env->supressedDivision);
-				$s = $this->seek();
-				if ($this->literal("/") && $this->value($rhs)) {
-					$out = array("list", "",
-						array($out, array("keyword", "/"), $rhs));
-				} else {
-					$this->seek($s);
-				}
-			}
-
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * recursively parse infix equation with $lhs at precedence $minP
-	 */
-	protected function expHelper($lhs, $minP) {
-		$this->inExp = true;
-		$ss = $this->seek();
-
-		while (true) {
-			$whiteBefore = isset($this->buffer[$this->count - 1]) &&
-				ctype_space($this->buffer[$this->count - 1]);
-
-			// If there is whitespace before the operator, then we require
-			// whitespace after the operator for it to be an expression
-			$needWhite = $whiteBefore && !$this->inParens;
-
-			if ($this->match(self::$operatorString.($needWhite ? '\s' : ''), $m) && self::$precedence[$m[1]] >= $minP) {
-				if (!$this->inParens && isset($this->env->currentProperty) && $m[1] == "/" && empty($this->env->supressedDivision)) {
-					foreach (self::$supressDivisionProps as $pattern) {
-						if (preg_match($pattern, $this->env->currentProperty)) {
-							$this->env->supressedDivision = true;
-							break 2;
-						}
-					}
-				}
-
-
-				$whiteAfter = isset($this->buffer[$this->count - 1]) &&
-					ctype_space($this->buffer[$this->count - 1]);
-
-				if (!$this->value($rhs)) break;
-
-				// peek for next operator to see what to do with rhs
-				if ($this->peek(self::$operatorString, $next) && self::$precedence[$next[1]] > self::$precedence[$m[1]]) {
-					$rhs = $this->expHelper($rhs, self::$precedence[$next[1]]);
-				}
-
-				$lhs = array('expression', $m[1], $lhs, $rhs, $whiteBefore, $whiteAfter);
-				$ss = $this->seek();
-
-				continue;
-			}
-
-			break;
-		}
-
-		$this->seek($ss);
-
-		return $lhs;
-	}
-
-	// consume a list of values for a property
-	public function propertyValue(&$value, $keyName = null) {
-		$values = array();
-
-		if ($keyName !== null) $this->env->currentProperty = $keyName;
-
-		$s = null;
-		while ($this->expressionList($v)) {
-			$values[] = $v;
-			$s = $this->seek();
-			if (!$this->literal(',')) break;
-		}
-
-		if ($s) $this->seek($s);
-
-		if ($keyName !== null) unset($this->env->currentProperty);
-
-		if (count($values) == 0) return false;
-
-		$value = lessc::compressList($values, ', ');
-		return true;
-	}
-
-	protected function parenValue(&$out) {
-		$s = $this->seek();
-
-		// speed shortcut
-		if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] != "(") {
-			return false;
-		}
-
-		$inParens = $this->inParens;
-		if ($this->literal("(") &&
-			($this->inParens = true) && $this->expression($exp) &&
-			$this->literal(")"))
-		{
-			$out = $exp;
-			$this->inParens = $inParens;
-			return true;
-		} else {
-			$this->inParens = $inParens;
-			$this->seek($s);
-		}
-
-		return false;
-	}
-
-	// a single value
-	protected function value(&$value) {
-		$s = $this->seek();
-
-		// speed shortcut
-		if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] == "-") {
-			// negation
-			if ($this->literal("-", false) &&
-				(($this->variable($inner) && $inner = array("variable", $inner)) ||
-				$this->unit($inner) ||
-				$this->parenValue($inner)))
-			{
-				$value = array("unary", "-", $inner);
-				return true;
-			} else {
-				$this->seek($s);
-			}
-		}
-
-		if ($this->parenValue($value)) return true;
-		if ($this->unit($value)) return true;
-		if ($this->color($value)) return true;
-		if ($this->func($value)) return true;
-		if ($this->stringValue($value)) return true;
-
-		if ($this->keyword($word)) {
-			$value = array('keyword', $word);
-			return true;
-		}
-
-		// try a variable
-		if ($this->variable($var)) {
-			$value = array('variable', $var);
-			return true;
-		}
-
-		// unquote string (should this work on any type?
-		if ($this->literal("~") && $this->stringValue($str)) {
-			$value = array("escape", $str);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		// css hack: \0
-		if ($this->literal('\\') && $this->match('([0-9]+)', $m)) {
-			$value = array('keyword', '\\'.$m[1]);
-			return true;
-		} else {
-			$this->seek($s);
-		}
-
-		return false;
-	}
-
-	// an import statement
-	protected function import(&$out) {
-		if (!$this->literal('@import')) return false;
-
-		// @import "something.css" media;
-		// @import url("something.css") media;
-		// @import url(something.css) media;
-
-		if ($this->propertyValue($value)) {
-			$out = array("import", $value);
-			return true;
-		}
-	}
-
-	protected function mediaQueryList(&$out) {
-		if ($this->genericList($list, "mediaQuery", ",", false)) {
-			$out = $list[2];
-			return true;
-		}
-		return false;
-	}
-
-	protected function mediaQuery(&$out) {
-		$s = $this->seek();
-
-		$expressions = null;
-		$parts = array();
-
-		if (($this->literal("only") && ($only = true) || $this->literal("not") && ($not = true) || true) && $this->keyword($mediaType)) {
-			$prop = array("mediaType");
-			if (isset($only)) $prop[] = "only";
-			if (isset($not)) $prop[] = "not";
-			$prop[] = $mediaType;
-			$parts[] = $prop;
-		} else {
-			$this->seek($s);
-		}
-
-
-		if (!empty($mediaType) && !$this->literal("and")) {
-			// ~
-		} else {
-			$this->genericList($expressions, "mediaExpression", "and", false);
-			if (is_array($expressions)) $parts = array_merge($parts, $expressions[2]);
-		}
-
-		if (count($parts) == 0) {
-			$this->seek($s);
-			return false;
-		}
-
-		$out = $parts;
-		return true;
-	}
-
-	protected function mediaExpression(&$out) {
-		$s = $this->seek();
-		$value = null;
-		if ($this->literal("(") &&
-			$this->keyword($feature) &&
-			($this->literal(":") && $this->expression($value) || true) &&
-			$this->literal(")"))
-		{
-			$out = array("mediaExp", $feature);
-			if ($value) $out[] = $value;
-			return true;
-		} elseif ($this->variable($variable)) {
-			$out = array('variable', $variable);
-			return true;
-		}
-
-		$this->seek($s);
-		return false;
-	}
-
-	// an unbounded string stopped by $end
-	protected function openString($end, &$out, $nestingOpen=null, $rejectStrs = null) {
-		$oldWhite = $this->eatWhiteDefault;
-		$this->eatWhiteDefault = false;
-
-		$stop = array("'", '"', "@{", $end);
-		$stop = array_map(array("lessc", "preg_quote"), $stop);
-		// $stop[] = self::$commentMulti;
-
-		if (!is_null($rejectStrs)) {
-			$stop = array_merge($stop, $rejectStrs);
-		}
-
-		$patt = '(.*?)('.implode("|", $stop).')';
-
-		$nestingLevel = 0;
-
-		$content = array();
-		while ($this->match($patt, $m, false)) {
-			if (!empty($m[1])) {
-				$content[] = $m[1];
-				if ($nestingOpen) {
-					$nestingLevel += substr_count($m[1], $nestingOpen);
-				}
-			}
-
-			$tok = $m[2];
-
-			$this->count-= strlen($tok);
-			if ($tok == $end) {
-				if ($nestingLevel == 0) {
-					break;
-				} else {
-					$nestingLevel--;
-				}
-			}
-
-			if (($tok == "'" || $tok == '"') && $this->stringValue($str)) {
-				$content[] = $str;
-				continue;
-			}
-
-			if ($tok == "@{" && $this->interpolation($inter)) {
-				$content[] = $inter;
-				continue;
-			}
-
-			if (!empty($rejectStrs) && in_array($tok, $rejectStrs)) {
-				break;
-			}
-
-			$content[] = $tok;
-			$this->count+= strlen($tok);
-		}
-
-		$this->eatWhiteDefault = $oldWhite;
-
-		if (count($content) == 0) return false;
-
-		// trim the end
-		if (is_string(end($content))) {
-			$content[count($content) - 1] = rtrim(end($content));
-		}
-
-		$out = array("string", "", $content);
-		return true;
-	}
-
-	protected function stringValue(&$out) {
-		$s = $this->seek();
-		if ($this->literal('"', false)) {
-			$delim = '"';
-		} elseif ($this->literal("'", false)) {
-			$delim = "'";
-		} else {
-			return false;
-		}
-
-		$content = array();
-
-		// look for either ending delim , escape, or string interpolation
-		$patt = '([^\n]*?)(@\{|\\\\|' .
-			lessc::preg_quote($delim).')';
-
-		$oldWhite = $this->eatWhiteDefault;
-		$this->eatWhiteDefault = false;
-
-		while ($this->match($patt, $m, false)) {
-			$content[] = $m[1];
-			if ($m[2] == "@{") {
-				$this->count -= strlen($m[2]);
-				if ($this->interpolation($inter, false)) {
-					$content[] = $inter;
-				} else {
-					$this->count += strlen($m[2]);
-					$content[] = "@{"; // ignore it
-				}
-			} elseif ($m[2] == '\\') {
-				$content[] = $m[2];
-				if ($this->literal($delim, false)) {
-					$content[] = $delim;
-				}
-			} else {
-				$this->count -= strlen($delim);
-				break; // delim
-			}
-		}
-
-		$this->eatWhiteDefault = $oldWhite;
-
-		if ($this->literal($delim)) {
-			$out = array("string", $delim, $content);
-			return true;
-		}
-
-		$this->seek($s);
-		return false;
-	}
-
-	protected function interpolation(&$out) {
-		$oldWhite = $this->eatWhiteDefault;
-		$this->eatWhiteDefault = true;
-
-		$s = $this->seek();
-		if ($this->literal("@{") &&
-			$this->openString("}", $interp, null, array("'", '"', ";")) &&
-			$this->literal("}", false))
-		{
-			$out = array("interpolate", $interp);
-			$this->eatWhiteDefault = $oldWhite;
-			if ($this->eatWhiteDefault) $this->whitespace();
-			return true;
-		}
-
-		$this->eatWhiteDefault = $oldWhite;
-		$this->seek($s);
-		return false;
-	}
-
-	protected function unit(&$unit) {
-		// speed shortcut
-		if (isset($this->buffer[$this->count])) {
-			$char = $this->buffer[$this->count];
-			if (!ctype_digit($char) && $char != ".") return false;
-		}
-
-		if ($this->match('([0-9]+(?:\.[0-9]*)?|\.[0-9]+)([%a-zA-Z]+)?', $m)) {
-			$unit = array("number", $m[1], empty($m[2]) ? "" : $m[2]);
-			return true;
-		}
-		return false;
-	}
-
-	// a # color
-	protected function color(&$out) {
-		if ($this->match('(#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3}))', $m)) {
-			if (strlen($m[1]) > 7) {
-				$out = array("string", "", array($m[1]));
-			} else {
-				$out = array("raw_color", $m[1]);
-			}
-			return true;
-		}
-
-		return false;
-	}
-
-	// consume an argument definition list surrounded by ()
-	// each argument is a variable name with optional value
-	// or at the end a ... or a variable named followed by ...
-	// arguments are separated by , unless a ; is in the list, then ; is the
-	// delimiter.
-	protected function argumentDef(&$args, &$isVararg) {
-		$s = $this->seek();
-		if (!$this->literal('(')) return false;
-
-		$values = array();
-		$delim = ",";
-		$method = "expressionList";
-
-		$isVararg = false;
-		while (true) {
-			if ($this->literal("...")) {
-				$isVararg = true;
-				break;
-			}
-
-			if ($this->$method($value)) {
-				if ($value[0] == "variable") {
-					$arg = array("arg", $value[1]);
-					$ss = $this->seek();
-
-					if ($this->assign() && $this->$method($rhs)) {
-						$arg[] = $rhs;
-					} else {
-						$this->seek($ss);
-						if ($this->literal("...")) {
-							$arg[0] = "rest";
-							$isVararg = true;
-						}
-					}
-
-					$values[] = $arg;
-					if ($isVararg) break;
-					continue;
-				} else {
-					$values[] = array("lit", $value);
-				}
-			}
-
-
-			if (!$this->literal($delim)) {
-				if ($delim == "," && $this->literal(";")) {
-					// found new delim, convert existing args
-					$delim = ";";
-					$method = "propertyValue";
-
-					// transform arg list
-					if (isset($values[1])) { // 2 items
-						$newList = array();
-						foreach ($values as $i => $arg) {
-							switch($arg[0]) {
-							case "arg":
-								if ($i) {
-									$this->throwError("Cannot mix ; and , as delimiter types");
-								}
-								$newList[] = $arg[2];
-								break;
-							case "lit":
-								$newList[] = $arg[1];
-								break;
-							case "rest":
-								$this->throwError("Unexpected rest before semicolon");
-							}
-						}
-
-						$newList = array("list", ", ", $newList);
-
-						switch ($values[0][0]) {
-						case "arg":
-							$newArg = array("arg", $values[0][1], $newList);
-							break;
-						case "lit":
-							$newArg = array("lit", $newList);
-							break;
-						}
-
-					} elseif ($values) { // 1 item
-						$newArg = $values[0];
-					}
-
-					if ($newArg) {
-						$values = array($newArg);
-					}
-				} else {
-					break;
-				}
-			}
-		}
-
-		if (!$this->literal(')')) {
-			$this->seek($s);
-			return false;
-		}
-
-		$args = $values;
-
-		return true;
-	}
-
-	// consume a list of tags
-	// this accepts a hanging delimiter
-	protected function tags(&$tags, $simple = false, $delim = ',') {
-		$tags = array();
-		while ($this->tag($tt, $simple)) {
-			$tags[] = $tt;
-			if (!$this->literal($delim)) break;
-		}
-		if (count($tags) == 0) return false;
-
-		return true;
-	}
-
-	// list of tags of specifying mixin path
-	// optionally separated by > (lazy, accepts extra >)
-	protected function mixinTags(&$tags) {
-		$tags = array();
-		while ($this->tag($tt, true)) {
-			$tags[] = $tt;
-			$this->literal(">");
-		}
-
-		if (count($tags) == 0) return false;
-
-		return true;
-	}
-
-	// a bracketed value (contained within in a tag definition)
-	protected function tagBracket(&$parts, &$hasExpression) {
-		// speed shortcut
-		if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] != "[") {
-			return false;
-		}
-
-		$s = $this->seek();
-
-		$hasInterpolation = false;
-
-		if ($this->literal("[", false)) {
-			$attrParts = array("[");
-			// keyword, string, operator
-			while (true) {
-				if ($this->literal("]", false)) {
-					$this->count--;
-					break; // get out early
-				}
-
-				if ($this->match('\s+', $m)) {
-					$attrParts[] = " ";
-					continue;
-				}
-				if ($this->stringValue($str)) {
-					// escape parent selector, (yuck)
-					foreach ($str[2] as &$chunk) {
-						$chunk = str_replace($this->lessc->parentSelector, "$&$", $chunk);
-					}
-
-					$attrParts[] = $str;
-					$hasInterpolation = true;
-					continue;
-				}
-
-				if ($this->keyword($word)) {
-					$attrParts[] = $word;
-					continue;
-				}
-
-				if ($this->interpolation($inter, false)) {
-					$attrParts[] = $inter;
-					$hasInterpolation = true;
-					continue;
-				}
-
-				// operator, handles attr namespace too
-				if ($this->match('[|-~\$\*\^=]+', $m)) {
-					$attrParts[] = $m[0];
-					continue;
-				}
-
-				break;
-			}
-
-			if ($this->literal("]", false)) {
-				$attrParts[] = "]";
-				foreach ($attrParts as $part) {
-					$parts[] = $part;
-				}
-				$hasExpression = $hasExpression || $hasInterpolation;
-				return true;
-			}
-			$this->seek($s);
-		}
-
-		$this->seek($s);
-		return false;
-	}
-
-	// a space separated list of selectors
-	protected function tag(&$tag, $simple = false) {
-		if ($simple)
-			$chars = '^@,:;{}\][>\(\) "\'';
-		else
-			$chars = '^@,;{}["\'';
-
-		$s = $this->seek();
-
-		$hasExpression = false;
-		$parts = array();
-		while ($this->tagBracket($parts, $hasExpression));
-
-		$oldWhite = $this->eatWhiteDefault;
-		$this->eatWhiteDefault = false;
-
-		while (true) {
-			if ($this->match('(['.$chars.'0-9]['.$chars.']*)', $m)) {
-				$parts[] = $m[1];
-				if ($simple) break;
-
-				while ($this->tagBracket($parts, $hasExpression));
-				continue;
-			}
-
-			if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] == "@") {
-				if ($this->interpolation($interp)) {
-					$hasExpression = true;
-					$interp[2] = true; // don't unescape
-					$parts[] = $interp;
-					continue;
-				}
-
-				if ($this->literal("@")) {
-					$parts[] = "@";
-					continue;
-				}
-			}
-
-			if ($this->unit($unit)) { // for keyframes
-				$parts[] = $unit[1];
-				$parts[] = $unit[2];
-				continue;
-			}
-
-			break;
-		}
-
-		$this->eatWhiteDefault = $oldWhite;
-		if (!$parts) {
-			$this->seek($s);
-			return false;
-		}
-
-		if ($hasExpression) {
-			$tag = array("exp", array("string", "", $parts));
-		} else {
-			$tag = trim(implode($parts));
-		}
-
-		$this->whitespace();
-		return true;
-	}
-
-	// a css function
-	protected function func(&$func) {
-		$s = $this->seek();
-
-		if ($this->match('(%|[\w\-_][\w\-_:\.]+|[\w_])', $m) && $this->literal('(')) {
-			$fname = $m[1];
-
-			$sPreArgs = $this->seek();
-
-			$args = array();
-			while (true) {
-				$ss = $this->seek();
-				// this ugly nonsense is for ie filter properties
-				if ($this->keyword($name) && $this->literal('=') && $this->expressionList($value)) {
-					$args[] = array("string", "", array($name, "=", $value));
-				} else {
-					$this->seek($ss);
-					if ($this->expressionList($value)) {
-						$args[] = $value;
-					}
-				}
-
-				if (!$this->literal(',')) break;
-			}
-			$args = array('list', ',', $args);
-
-			if ($this->literal(')')) {
-				$func = array('function', $fname, $args);
-				return true;
-			} elseif ($fname == 'url') {
-				// couldn't parse and in url? treat as string
-				$this->seek($sPreArgs);
-				if ($this->openString(")", $string) && $this->literal(")")) {
-					$func = array('function', $fname, $string);
-					return true;
-				}
-			}
-		}
-
-		$this->seek($s);
-		return false;
-	}
-
-	// consume a less variable
-	protected function variable(&$name) {
-		$s = $this->seek();
-		if ($this->literal($this->lessc->vPrefix, false) &&
-			($this->variable($sub) || $this->keyword($name)))
-		{
-			if (!empty($sub)) {
-				$name = array('variable', $sub);
-			} else {
-				$name = $this->lessc->vPrefix.$name;
-			}
-			return true;
-		}
-
-		$name = null;
-		$this->seek($s);
-		return false;
-	}
-
-	/**
-	 * Consume an assignment operator
-	 * Can optionally take a name that will be set to the current property name
-	 */
-	protected function assign($name = null) {
-		if ($name) $this->currentProperty = $name;
-		return $this->literal(':') || $this->literal('=');
-	}
-
-	// consume a keyword
-	protected function keyword(&$word) {
-		if ($this->match('([\w_\-\*!"][\w\-_"]*)', $m)) {
-			$word = $m[1];
-			return true;
-		}
-		return false;
-	}
-
-	// consume an end of statement delimiter
-	protected function end() {
-		if ($this->literal(';', false)) {
-			return true;
-		} elseif ($this->count == strlen($this->buffer) || $this->buffer[$this->count] == '}') {
-			// if there is end of file or a closing block next then we don't need a ;
-			return true;
-		}
-		return false;
-	}
-
-	protected function guards(&$guards) {
-		$s = $this->seek();
-
-		if (!$this->literal("when")) {
-			$this->seek($s);
-			return false;
-		}
-
-		$guards = array();
-
-		while ($this->guardGroup($g)) {
-			$guards[] = $g;
-			if (!$this->literal(",")) break;
-		}
-
-		if (count($guards) == 0) {
-			$guards = null;
-			$this->seek($s);
-			return false;
-		}
-
-		return true;
-	}
-
-	// a bunch of guards that are and'd together
-	// TODO rename to guardGroup
-	protected function guardGroup(&$guardGroup) {
-		$s = $this->seek();
-		$guardGroup = array();
-		while ($this->guard($guard)) {
-			$guardGroup[] = $guard;
-			if (!$this->literal("and")) break;
-		}
-
-		if (count($guardGroup) == 0) {
-			$guardGroup = null;
-			$this->seek($s);
-			return false;
-		}
-
-		return true;
-	}
-
-	protected function guard(&$guard) {
-		$s = $this->seek();
-		$negate = $this->literal("not");
-
-		if ($this->literal("(") && $this->expression($exp) && $this->literal(")")) {
-			$guard = $exp;
-			if ($negate) $guard = array("negate", $guard);
-			return true;
-		}
-
-		$this->seek($s);
-		return false;
-	}
-
-	/* raw parsing functions */
-
-	protected function literal($what, $eatWhitespace = null) {
-		if ($eatWhitespace === null) $eatWhitespace = $this->eatWhiteDefault;
-
-		// shortcut on single letter
-		if (!isset($what[1]) && isset($this->buffer[$this->count])) {
-			if ($this->buffer[$this->count] == $what) {
-				if (!$eatWhitespace) {
-					$this->count++;
-					return true;
-				}
-				// goes below...
-			} else {
-				return false;
-			}
-		}
-
-		if (!isset(self::$literalCache[$what])) {
-			self::$literalCache[$what] = lessc::preg_quote($what);
-		}
-
-		return $this->match(self::$literalCache[$what], $m, $eatWhitespace);
-	}
-
-	protected function genericList(&$out, $parseItem, $delim="", $flatten=true) {
-		$s = $this->seek();
-		$items = array();
-		while ($this->$parseItem($value)) {
-			$items[] = $value;
-			if ($delim) {
-				if (!$this->literal($delim)) break;
-			}
-		}
-
-		if (count($items) == 0) {
-			$this->seek($s);
-			return false;
-		}
-
-		if ($flatten && count($items) == 1) {
-			$out = $items[0];
-		} else {
-			$out = array("list", $delim, $items);
-		}
-
-		return true;
-	}
-
-
-	// advance counter to next occurrence of $what
-	// $until - don't include $what in advance
-	// $allowNewline, if string, will be used as valid char set
-	protected function to($what, &$out, $until = false, $allowNewline = false) {
-		if (is_string($allowNewline)) {
-			$validChars = $allowNewline;
-		} else {
-			$validChars = $allowNewline ? "." : "[^\n]";
-		}
-		if (!$this->match('('.$validChars.'*?)'.lessc::preg_quote($what), $m, !$until)) return false;
-		if ($until) $this->count -= strlen($what); // give back $what
-		$out = $m[1];
-		return true;
-	}
-
-	// try to match something on head of buffer
-	protected function match($regex, &$out, $eatWhitespace = null) {
-		if ($eatWhitespace === null) $eatWhitespace = $this->eatWhiteDefault;
-
-		$r = '/'.$regex.($eatWhitespace && !$this->writeComments ? '\s*' : '').'/Ais';
-		if (preg_match($r, $this->buffer, $out, null, $this->count)) {
-			$this->count += strlen($out[0]);
-			if ($eatWhitespace && $this->writeComments) $this->whitespace();
-			return true;
-		}
-		return false;
-	}
-
-	// match some whitespace
-	protected function whitespace() {
-		if ($this->writeComments) {
-			$gotWhite = false;
-			while (preg_match(self::$whitePattern, $this->buffer, $m, null, $this->count)) {
-				if (isset($m[1]) && empty($this->seenComments[$this->count])) {
-					$this->append(array("comment", $m[1]));
-					$this->seenComments[$this->count] = true;
-				}
-				$this->count += strlen($m[0]);
-				$gotWhite = true;
-			}
-			return $gotWhite;
-		} else {
-			$this->match("", $m);
-			return strlen($m[0]) > 0;
-		}
-	}
-
-	// match something without consuming it
-	protected function peek($regex, &$out = null, $from=null) {
-		if (is_null($from)) $from = $this->count;
-		$r = '/'.$regex.'/Ais';
-		$result = preg_match($r, $this->buffer, $out, null, $from);
-
-		return $result;
-	}
-
-	// seek to a spot in the buffer or return where we are on no argument
-	protected function seek($where = null) {
-		if ($where === null) return $this->count;
-		else $this->count = $where;
-		return true;
-	}
-
-	/* misc functions */
-
-	public function throwError($msg = "parse error", $count = null) {
-		$count = is_null($count) ? $this->count : $count;
-
-		$line = $this->line +
-			substr_count(substr($this->buffer, 0, $count), "\n");
-
-		if (!empty($this->sourceName)) {
-			$loc = "$this->sourceName on line $line";
-		} else {
-			$loc = "line: $line";
-		}
-
-		// TODO this depends on $this->count
-		if ($this->peek("(.*?)(\n|$)", $m, $count)) {
-			throw new \Exception("$msg: failed at `$m[1]` $loc");
-		} else {
-			throw new \Exception("$msg: $loc");
-		}
-	}
-
-	protected function pushBlock($selectors=null, $type=null) {
-		$b = new \stdClass();
-		$b->parent = $this->env;
-
-		$b->type = $type;
-		$b->id = self::$nextBlockId++;
-
-		$b->isVararg = false; // TODO: kill me from here
-		$b->tags = $selectors;
-
-		$b->props = array();
-		$b->children = array();
-
-        // add a reference to the parser so
-        // we can access the parser to throw errors
-        // or retrieve the sourceName of this block.
-        $b->parser = $this;
-
-        // so we know the position of this block
-        $b->count = $this->count;
-
-		$this->env = $b;
-		return $b;
-	}
-
-	// push a block that doesn't multiply tags
-	protected function pushSpecialBlock($type) {
-		return $this->pushBlock(null, $type);
-	}
-
-	// append a property to the current block
-	protected function append($prop, $pos = null) {
-		if ($pos !== null) $prop[-1] = $pos;
-		$this->env->props[] = $prop;
-	}
-
-	// pop something off the stack
-	protected function pop() {
-		$old = $this->env;
-		$this->env = $this->env->parent;
-		return $old;
-	}
-
-	// remove comments from $text
-	// todo: make it work for all functions, not just url
-	protected function removeComments($text) {
-		$look = array(
-			'url(', '//', '/*', '"', "'"
-		);
-
-		$out = '';
-		$min = null;
-		while (true) {
-			// find the next item
-			foreach ($look as $token) {
-				$pos = strpos($text, $token);
-				if ($pos !== false) {
-					if (!isset($min) || $pos < $min[1]) $min = array($token, $pos);
-				}
-			}
-
-			if (is_null($min)) break;
-
-			$count = $min[1];
-			$skip = 0;
-			$newlines = 0;
-			switch ($min[0]) {
-			case 'url(':
-				if (preg_match('/url\(.*?\)/', $text, $m, 0, $count))
-					$count += strlen($m[0]) - strlen($min[0]);
-				break;
-			case '"':
-			case "'":
-				if (preg_match('/'.$min[0].'.*?(?<!\\\\)'.$min[0].'/', $text, $m, 0, $count))
-					$count += strlen($m[0]) - 1;
-				break;
-			case '//':
-				$skip = strpos($text, "\n", $count);
-				if ($skip === false) $skip = strlen($text) - $count;
-				else $skip -= $count;
-				break;
-			case '/*':
-				if (preg_match('/\/\*.*?\*\//s', $text, $m, 0, $count)) {
-					$skip = strlen($m[0]);
-					$newlines = substr_count($m[0], "\n");
-				}
-				break;
-			}
-
-			if ($skip == 0) $count += strlen($min[0]);
-
-			$out .= substr($text, 0, $count).str_repeat("\n", $newlines);
-			$text = substr($text, $count + $skip);
-
-			$min = null;
-		}
-
-		return $out.$text;
-	}
-
-}
-
-class lessc_formatter_classic {
-	public $indentChar = "  ";
-
-	public $break = "\n";
-	public $open = " {";
-	public $close = "}";
-	public $selectorSeparator = ", ";
-	public $assignSeparator = ":";
-
-	public $openSingle = " { ";
-	public $closeSingle = " }";
-
-	public $disableSingle = false;
-	public $breakSelectors = false;
-
-	public $compressColors = false;
-
-	public function __construct() {
-		$this->indentLevel = 0;
-	}
-
-	public function indentStr($n = 0) {
-		return str_repeat($this->indentChar, max($this->indentLevel + $n, 0));
-	}
-
-	public function property($name, $value) {
-		return $name . $this->assignSeparator . $value . ";";
-	}
-
-	protected function isEmpty($block) {
-		if (empty($block->lines)) {
-			foreach ($block->children as $child) {
-				if (!$this->isEmpty($child)) return false;
-			}
-
-			return true;
-		}
-		return false;
-	}
-
-	public function block($block) {
-		if ($this->isEmpty($block)) return;
-
-		$inner = $pre = $this->indentStr();
-
-		$isSingle = !$this->disableSingle &&
-			is_null($block->type) && count($block->lines) == 1;
-
-		if (!empty($block->selectors)) {
-			$this->indentLevel++;
-
-			if ($this->breakSelectors) {
-				$selectorSeparator = $this->selectorSeparator . $this->break . $pre;
-			} else {
-				$selectorSeparator = $this->selectorSeparator;
-			}
-
-			echo $pre .
-				implode($selectorSeparator, $block->selectors);
-			if ($isSingle) {
-				echo $this->openSingle;
-				$inner = "";
-			} else {
-				echo $this->open . $this->break;
-				$inner = $this->indentStr();
-			}
-
-		}
-
-		if (!empty($block->lines)) {
-			$glue = $this->break.$inner;
-			echo $inner . implode($glue, $block->lines);
-			if (!$isSingle && !empty($block->children)) {
-				echo $this->break;
-			}
-		}
-
-		foreach ($block->children as $child) {
-			$this->block($child);
-		}
-
-		if (!empty($block->selectors)) {
-			if (!$isSingle && empty($block->children)) echo $this->break;
-
-			if ($isSingle) {
-				echo $this->closeSingle . $this->break;
-			} else {
-				echo $pre . $this->close . $this->break;
-			}
-
-			$this->indentLevel--;
-		}
-	}
-}
-
-class lessc_formatter_compressed extends lessc_formatter_classic {
-	public $disableSingle = true;
-	public $open = "{";
-	public $selectorSeparator = ",";
-	public $assignSeparator = ":";
-	public $break = "";
-	public $compressColors = true;
-
-	public function indentStr($n = 0) {
-		return "";
-	}
-}
-
-class lessc_formatter_lessjs extends lessc_formatter_classic {
-	public $disableSingle = true;
-	public $breakSelectors = true;
-	public $assignSeparator = ": ";
-	public $selectorSeparator = ",";
-}
-
-