From 3356db65558c08e04824240cb332895afd8797d4 Mon Sep 17 00:00:00 2001
From: Miraty <miraty@antopie.org>
Date: Wed, 1 Jul 2020 20:47:02 +0200
Subject: [PATCH] Adds i18n, english l10n, CHANGELOG and lesserphp instead of
 lessphp

---
 CHANGELOG.md                     |   49 +
 README.md                        |    5 +-
 config.inc.php                   |   53 +-
 inc.php                          |   48 +
 index.php                        |   96 +-
 {lessphp => lesserphp}/LICENSE   |    5 +-
 {lessphp => lesserphp}/README.md |   13 +-
 lesserphp/docs/docs.md           | 1400 +++++++++++
 lesserphp/lessc.inc.php          | 4019 ++++++++++++++++++++++++++++++
 lessphp/lessc.inc.php            | 3880 ----------------------------
 locales/en.php                   |   47 +
 locales/fr.php                   |   47 +
 locales/template.php             |   27 +
 manifest.php                     |   24 +-
 opensearch.php                   |    6 +-
 style.less                       |   10 +-
 style.min.css                    |    2 +-
 17 files changed, 5732 insertions(+), 3999 deletions(-)
 create mode 100644 CHANGELOG.md
 create mode 100644 inc.php
 rename {lessphp => lesserphp}/LICENSE (99%)
 mode change 100755 => 100644
 rename {lessphp => lesserphp}/README.md (86%)
 mode change 100755 => 100644
 create mode 100644 lesserphp/docs/docs.md
 create mode 100644 lesserphp/lessc.inc.php
 delete mode 100755 lessphp/lessc.inc.php
 create mode 100644 locales/en.php
 create mode 100644 locales/fr.php
 create mode 100644 locales/template.php

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..09a833b
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,49 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## Unreleased
+
+### Added
+
+* i18n system
+* English l10n
+* Changelog
+
+### Changed
+
+* Use lesserphp instead of lessphp
+
+## 1.2.0 - 2020-03-23
+
+### Added
+
+* Ability to chooses QR code colors
+
+### Changed
+
+* The software is now named LibreQR
+* Parameters now uses GET instead of POST
+* The OpenSearch plugin now generate QR codes with arguments used when added
+
+## 1.1.0 - 2019-03-29
+
+### Added
+
+* OpenSearch
+* WebManifest
+
+### Changed
+
+* Server-side LESS compilation
+* Icons are now themed and in multiple dimensions
+
+### Fixed
+
+* Placeholder font
+
+## 1.0.0 - 2019-02-13
+
+Initial release
diff --git a/README.md b/README.md
index 048aabf..b818c22 100755
--- a/README.md
+++ b/README.md
@@ -59,8 +59,7 @@ Par défaut, trois thèmes sont proposés :
 php themes/resize.php [nom de votre thème]
 ```
 
-Cela nécessitera d'avoir installé [ImageMagick](https://imagemagick.org)  et
-[pngquant](https://pngquant.org).
+Cela nécessitera d'avoir installé [ImageMagick](https://imagemagick.org) et [pngquant](https://pngquant.org).
 
 ## Contribuer
 
@@ -80,7 +79,7 @@ Ce code source inclus :
 
 * [phpqrcode](https://github.com/t0k4rt/phpqrcode) pour générer les codes QR
 * [La police Ubuntu packagée pour le Web](https://github.com/earaujoassis/ubuntu-fontface)
-* [lessphp](http://leafo.net/lessphp) pour compiler le [Less](http://lesscss.org)
+* [lesserphp](https://github.com/MarcusSchwarz/lesserphp) pour compiler le [Less](http://lesscss.org)
 
 ## Licence
 
diff --git a/config.inc.php b/config.inc.php
index 8e68363..9d73ace 100755
--- a/config.inc.php
+++ b/config.inc.php
@@ -1,47 +1,22 @@
 <?php
 
+// ----- Settings -----
 // ----- Paramètres -----
 
-deleteOldQR(60 * 60 * 24 * 7); // Temps en secondes après lequel le code QR sera supprimé lors du chargement d'un page
+// EN: Time in seconds after which the QR code will be deleted when a page loads.
+// Default: 60 * 60 * 24 * 7 (one week)
+// FR : Temps en secondes après lequel le code QR sera supprimé lors du chargement d'un page.
+// Par défaut : 60 * 60 * 24 * 7 (une semaine)
+deleteOldQR(60 * 60 * 24 * 7);
 
-$theme = "dark"; // dark, light ou parinux
+// EN: Theme's name (must be in the themes directory)
+// FR : Nom du thème (doit être dans le dossier themes)
+$theme = "dark";
+
+// EN: Language used if those wanted by the user are not available
+// FR : Langue utilisée si celles demandées par l'utilisateurice ne sont pas disponibles
+$locale = "fr"; // fr ou en
 
 $fileNameLenght = 32; // Longueur du nom du fichier du code QR
 
-// ----- Trucs nécessaires partout -----
-
-// Définit l'URL racine
-if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off')
-  $protocol = "https";
-else
-  $protocol = "http";
-$instPath = $protocol . "://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
-$instPath = preg_replace('#\?.*$#', '', $instPath);
-$instPath = preg_replace('#(manifest|opensearch|index).php$#i', '', $instPath);
-
-require "themes/" . $theme . "/theme.php"; // Charge le thème graphique
-
-function generateRandomString($length) {
-  $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  $charactersLength = strlen($characters);
-  $randomString = '';
-  for ($i = 0; $i < $length; $i++) {
-    $randomString .= $characters[rand(0, $charactersLength - 1)];
-  }
-  return $randomString;
-}
-
-function deleteOldQR($tempsDeSuppression) {
-  /*
-    Cette fonction supprime les fichiers (normalement des images de codes QR)
-    dans temp/ plus vieux que le temps en seconde passé en argument
-  */
-  $listeCodesQR = new DirectoryIterator("temp");
-  foreach($listeCodesQR as $listeCodesQR) {
-    if ($listeCodesQR->getFilename() != "." AND $listeCodesQR->getFilename() != ".." AND $listeCodesQR->getFilename() != ".gitkeep") {
-      if ((time() - filemtime("temp/" . $listeCodesQR->getFilename())) > $tempsDeSuppression) { // Si le temps actuel (en heure Posix) moins la date de dernière modification de l'image est supérieur à la durée de vie demandée de l'image
-        unlink("temp/" . $listeCodesQR->getFilename()); // Alors supprimer cette image
-      }
-    }
-  }
-}
+//$additionalText = "This LibreQR instance is hosted by <a href='https://foo.bar'>foo</a>.";
diff --git a/inc.php b/inc.php
new file mode 100644
index 0000000..04d911d
--- /dev/null
+++ b/inc.php
@@ -0,0 +1,48 @@
+<?php // ----- This file is included everywhere -----
+
+require "config.inc.php";
+
+// Defines locale used
+$clientLocales = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
+$clientLocales = preg_replace("#[A-Z0-9]|q=|;|-|\.#", "", $clientLocales);
+$clientLocales = explode(',', $clientLocales);
+$availableLocales = array('fr', 'en', 'template');
+foreach ($clientLocales as $clientLocale) {
+  if (in_array($clientLocale, $availableLocales)) {
+    $locale = $clientLocale;
+    break;
+  }
+}
+require "locales/" . $locale . ".php";
+
+// Defines root URL
+if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off')
+  $protocol = "https";
+else
+  $protocol = "http";
+$instPath = $protocol . "://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
+$instPath = preg_replace('#\?.*$#', '', $instPath);
+$instPath = preg_replace('#(manifest|opensearch|index).php$#i', '', $instPath);
+
+require "themes/" . $theme . "/theme.php"; // Load theme
+
+function generateRandomString($length) {
+  $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  $charactersLength = strlen($characters);
+  $randomString = '';
+  for ($i = 0; $i < $length; $i++) {
+    $randomString .= $characters[rand(0, $charactersLength - 1)];
+  }
+  return $randomString;
+}
+
+// Deletes images in temp/ older than the specified time in seconds
+function deleteOldQR($deleteAfter) {
+  $files = array_diff(scandir("temp"), array('..', '.', '.gitkeep'));
+  foreach($files as $file) {
+    // If this actual time (in Posix time) less last modification image date is greater than time asked
+    if ((time() - filemtime("temp/" . $file)) > $deleteAfter) {
+      unlink("temp/" . $file); // Deletes this image
+    }
+  }
+}
diff --git a/index.php b/index.php
index e72a97a..3835de6 100755
--- a/index.php
+++ b/index.php
@@ -1,4 +1,4 @@
-<?php require "config.inc.php"; ?>
+<?php require "inc.php"; ?>
 <!--
  _     _ _               ___  ____
 | |   (_| |__  _ __ ___ / _ \|  _ \
@@ -95,15 +95,15 @@ if (badQuery()) {
 ?>
 
 <!DOCTYPE html>
-<html lang="fr">
+<html lang="<?= $locale ?>">
   <head>
     <meta charset="UTF-8">
-    <title>Générateur de codes QR</title>
-    <meta name="description" content="Générez des codes QR librement. Choisissez le contenu, la taille, la couleur...">
+    <title>LibreQR · <?= $loc['subtitle'] ?></title>
+    <meta name="description" content="<?= $loc['description'] ?>">
     <meta name="theme-color" content="<?php echo $variablesTheme['bg']; ?>">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link rel="manifest" href="manifest.php">
-    <link rel="search" type="application/opensearchdescription+xml" title="Générer un code QR" href="opensearch.php&#63;redondancy=<?= $_GET['redondancy'] ?>&amp;margin=<?= $_GET['margin'] ?>&amp;size=<?= $_GET['size'] ?>&amp;bgColor=<?= urlencode($_GET['bgColor']) ?>&amp;mainColor=<?= urlencode($_GET['mainColor']) ?>">
+    <link rel="search" type="application/opensearchdescription+xml" title="<?= $loc['opensearch_actionName'] ?>" href="opensearch.php&#63;redondancy=<?= $_GET['redondancy'] ?>&amp;margin=<?= $_GET['margin'] ?>&amp;size=<?= $_GET['size'] ?>&amp;bgColor=<?= urlencode($_GET['bgColor']) ?>&amp;mainColor=<?= urlencode($_GET['mainColor']) ?>">
     <?php
     // If style.min.css exists
     if (file_exists("style.min.css"))
@@ -112,17 +112,17 @@ if (badQuery()) {
         // Then delete it
         unlink("style.min.css");
 
-    require "lessphp/lessc.inc.php";
+    require "lesserphp/lessc.inc.php";
     $less = new lessc;
-    $less->setVariables($variablesTheme); // Rends ces couleurs utilisables dans style.less
+    $less->setVariables($variablesTheme); // Make these colors available in style.less
     $less->setFormatter("compressed");
-    $less->checkedCompile("style.less", "style.min.css"); // Compile, minimise et met en cache style.less dans style.min.css
+    $less->checkedCompile("style.less", "style.min.css"); // Compile, minimise and cache style.less into style.min.css
     ?>
     <link type="text/css" rel="stylesheet" href="style.min.css">
     <link type="text/css" rel="stylesheet" href="ubuntu/ubuntu.min.css">
 
     <?php
-    foreach($themeDimensionsIcons as $dimFav) { // Indique toutes les dimensions d'icones
+    foreach($themeDimensionsIcons as $dimFav) { // Set all icons dimensions
         echo '    <link rel="icon" type="image/png" href="themes/' . $theme . '/icons/' . $dimFav . '.png" sizes="' . $dimFav . 'x' . $dimFav . '">' . "\n";
     } ?>
 
@@ -130,14 +130,14 @@ if (badQuery()) {
 
   <body>
 
-    <div class="center">
+    <main>
 
       <header>
         <a id="lienTitres" href="./">
-          <img id="logo" src="themes/<?php echo $theme; ?>/icons/128.png" alt="Code QR stylisé">
+          <img id="logo" src="themes/<?php echo $theme; ?>/icons/128.png">
           <div id="titres">
             <h1>LibreQR</h1>
-            <h2>Générateur de codes QR</h2>
+            <h2><?= $loc['subtitle'] ?></h2>
           </div>
         </a>
       </header>
@@ -147,24 +147,15 @@ if (badQuery()) {
         <div id="firstWrapper">
 
           <div class="param">
-            <label for="txt">Texte à encoder</label>
+            <label for="txt"><?= $loc['label_content'] ?></label>
             <span class="conteneurAide">
               <span class="boutonAide" tabindex="0"><img id="helpImg" src="help.svg.php?clr=<?= urlencode($variablesTheme["text"]) ?>" alt="Aide"></span>
               <span class="contenuAide">
-                Vous pouvez encoder ce que vous voulez sous forme de texte.<br>
-                Les logiciels qui décodent ces codes QR pourraient proposer de les ouvrir avec un logiciel dédié, en fonction de leur <a href="https://fr.wikipedia.org/wiki/Sch%C3%A9ma_d%27URI">schéma d'URI</a>.<br><br>
-                Par exemple, pour ouvrir une page Web :<br>
-                https://www.domaine.tld/<br><br>
-                Pour envoyer un mail :<br>
-                mailto:contact@domaine.tld<br><br>
-                Pour partager des coordonnées géographique :<br>
-                geo:48.867564,2.364057<br><br>
-                Pour appeler un numéro de téléphone :<br>
-                tel:0639981871
+                <?= $loc['help_content'] ?>
               </span>
             </span>
             <br>
-            <textarea rows="8" required="" id="txt" placeholder="Entrez le texte à encoder dans le code QR" name="txt"><?php
+            <textarea rows="8" required="" id="txt" placeholder="<?= $loc['placeholder'] ?>" name="txt"><?php
 
             if (isset($_GET['txt'])) {
               echo htmlspecialchars($_GET['txt']);
@@ -176,31 +167,31 @@ if (badQuery()) {
           <div id="menusDeroulants">
 
             <div class="param">
-              <label for="redondancy">Taux de redondance</label>
+              <label for="redondancy"><?= $loc['label_redondancy'] ?></label>
               <span class="conteneurAide">
                 <span class="boutonAide" tabindex="0"><img id="helpImg" src="help.svg.php?clr=<?= urlencode($variablesTheme["text"]) ?>" alt="Aide"></span>
-                <span class="contenuAide">La redondance est le "doublement" des informations dans le code QR afin de corriger les erreurs lors du décodage. Un taux plus élevé produira un code QR plus grand, mais aura plus de chance d'être décodé correctement.</span>
+                <span class="contenuAide"><?= $loc['help_redondancy'] ?></span>
               </span>
               <br>
               <select id="redondancy" name="redondancy">
-                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "L")) {echo 'selected="" ';} ?>value="L">L - 7% de redondance</option>
-                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "M")) {echo 'selected="" ';} ?>value="M">M - 15% de redondance</option>
-                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "Q")) {echo 'selected="" ';} ?>value="Q">Q - 25% de redondance</option>
-                <option <?php if ((isset($_GET['redondancy']) AND ($_GET['redondancy'] == "H")) OR (!isset($_GET['redondancy']) OR empty($_GET['redondancy']))) {echo 'selected="" ';} ?>value="H">H - 30% de redondance</option>
+                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "L")) {echo 'selected="" ';} ?>value="L">L - 7%</option>
+                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "M")) {echo 'selected="" ';} ?>value="M">M - 15%</option>
+                <option <?php if (isset($_GET['redondancy']) AND ($_GET['redondancy'] == "Q")) {echo 'selected="" ';} ?>value="Q">Q - 25%</option>
+                <option <?php if ((isset($_GET['redondancy']) AND ($_GET['redondancy'] == "H")) OR (!isset($_GET['redondancy']) OR empty($_GET['redondancy']))) {echo 'selected="" ';} ?>value="H">H - 30%</option>
               </select>
             </div>
 
             <div class="param">
-              <label for="margin">Taille de la marge</label>
+              <label for="margin"><?= $loc['label_margin'] ?></label>
               <span class="conteneurAide">
                 <span class="boutonAide" tabindex="0"><img id="helpImg" src="help.svg.php?clr=<?= urlencode($variablesTheme["text"]) ?>" alt="Aide"></span>
-                <span class="contenuAide">Nombre de pixels des bandes blanches autour du code QR.</span>
+                <span class="contenuAide"><?= $loc['help_margin'] ?></span>
               </span>
               <br>
               <select id="margin" name="margin">
                 <option <?php if (isset($_GET['margin']) AND ($_GET['margin'] == "0")) {echo 'selected="" ';} ?>value="0">0</option>
                 <option <?php if (isset($_GET['margin']) AND ($_GET['margin'] == "1")) {echo 'selected="" ';} ?>value="1">1</option>
-                <option <?php if ((isset($_GET['margin']) AND ($_GET['margin'] == "2")) OR (!isset($_GET['margin']) OR empty($_GET['margin']))) {echo 'selected="" ';} ?>value="2">2 - par défaut</option>
+                <option <?php if ((isset($_GET['margin']) AND ($_GET['margin'] == "2")) OR (!isset($_GET['margin']) OR empty($_GET['margin']))) {echo 'selected="" ';} ?>value="2">2 - <?= $loc['value_default'] ?></option>
                 <option <?php if (isset($_GET['margin']) AND ($_GET['margin'] == "3")) {echo 'selected="" ';} ?>value="3">3</option>
                 <option <?php if (isset($_GET['margin']) AND ($_GET['margin'] == "4")) {echo 'selected="" ';} ?>value="4">4</option>
                 <option <?php if (isset($_GET['margin']) AND ($_GET['margin'] == "5")) {echo 'selected="" ';} ?>value="5">5</option>
@@ -210,17 +201,17 @@ if (badQuery()) {
             </div>
 
             <div class="param">
-              <label for="size">Taille de l'image</label>
+              <label for="size"><?= $loc['label_size'] ?></label>
               <span class="conteneurAide">
                 <span class="boutonAide" tabindex="0"><img id="helpImg" src="help.svg.php?clr=<?= urlencode($variablesTheme["text"]) ?>" alt="Aide"></span>
-                <span class="contenuAide">Par combien les dimensions de l'image seront-elles multipliées ?</span>
+                <span class="contenuAide"><?= $loc['help_size'] ?></span>
               </span>
               <br>
               <select id="size" name="size">
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 1)) {echo 'selected="" ';} ?>value="1">1</option>
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 2)) {echo 'selected="" ';} ?>value="2">2</option>
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 3)) {echo 'selected="" ';} ?>value="3">3</option>
-                <option <?php if ((isset($_GET['size']) AND ($_GET['size'] == 4)) OR (!isset($_GET['size']) OR empty($_GET['size']))) {echo 'selected="" ';} ?>value="4">4 - par défaut</option>
+                <option <?php if ((isset($_GET['size']) AND ($_GET['size'] == 4)) OR (!isset($_GET['size']) OR empty($_GET['size']))) {echo 'selected="" ';} ?>value="4">4 - <?= $loc['value_default'] ?></option>
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 5)) {echo 'selected="" ';} ?>value="5">5</option>
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 6)) {echo 'selected="" ';} ?>value="6">6</option>
                 <option <?php if (isset($_GET['size']) AND ($_GET['size'] == 8)) {echo 'selected="" ';} ?>value="8">8</option>
@@ -237,22 +228,22 @@ if (badQuery()) {
         <div id="colors">
 
           <div class="param">
-            <label for="bgColor">Couleur de fond</label>
+            <label for="bgColor"><?= $loc['label_bgColor'] ?></label>
             <div class="conteneurInputColor">
                         <input type="color" name="bgColor" id="bgColor" value="<?php if (!empty($_GET['bgColor'])) {echo htmlspecialchars($_GET['bgColor']);} else {echo "#FFFFFF";} ?>">
             </div>
           </div>
 
           <div class="param">
-            <label for="mainColor">Couleur de premier plan</label>
+            <label for="mainColor"><?= $loc['label_mainColor'] ?></label>
             <div class="conteneurInputColor">
               <input type="color" name="mainColor" id="mainColor" value="<?php if (!empty($_GET['mainColor'])) {echo htmlspecialchars($_GET['mainColor']);} else {echo "#000000";} ?>">
             </div>
           </div>
         </div>
 
-        <div class="centrer">
-          <input class="bouton" type="submit" value="Générer" />
+        <div class="centered">
+          <input class="bouton" type="submit" value="<?= $loc['button_create'] ?>" />
         </div>
 
       </form>
@@ -267,31 +258,36 @@ if (badQuery()) {
         $cheminImage = "temp/" . generateRandomString($fileNameLenght) . ".png";
         QRcode::png($_GET['txt'], $cheminImage, $_GET['redondancy'], $_GET['size'], $_GET['margin'], false, hexdec($_GET['bgColor']), hexdec($_GET['mainColor']));
         ?>
-        <div class="centrer">
-          <a href="<?php echo $cheminImage; ?>" class="bouton" download="<?php echo htmlspecialchars($_GET['txt']); ?>.png">Télécharger ce code QR</a>
+        <div class="centered">
+          <a href="<?php echo $cheminImage; ?>" class="bouton" download="<?php echo htmlspecialchars($_GET['txt']); ?>.png"><?= $loc['button_download'] ?></a>
         </div>
 
-        <div class="centrer" id="showOnlyQR">
-          <a title="Cliquez pour afficher uniquement ce code QR" href="<?php echo $cheminImage; ?>"><img alt='Un code QR contenant "<?php echo htmlspecialchars($_GET['txt']); ?>"' id="qrCode" src="<?php echo $cheminImage; ?>"/></a>
+        <div class="centered" id="showOnlyQR">
+          <a title="<?= $loc['title_showOnlyQR'] ?>" href="<?php echo $cheminImage; ?>"><img alt='Un code QR contenant "<?php echo htmlspecialchars($_GET['txt']); ?>"' id="qrCode" src="<?php echo $cheminImage; ?>"/></a>
         </div>
         <?php
       }
     }
         ?>
 
-    </div>
+    </main>
 
     <div id="metaTexts">
 
       <section id="info" class="metaText">
-        <h3>Qu'est-ce qu'un code QR ?</h3>
-        Un code QR est un code-barres en 2 dimensions dans lequel est inscrit en binaire du texte. Il peut être décodé avec un appareil muni d'un capteur photo et d'un logiciel adéquat.
-        <a href="https://fr.wikipedia.org/wiki/Code_QR">Code QR sur Wikipédia</a>
+        <?= $loc['metaText_qr'] ?>
       </section>
 
       <footer class="metaText">
-        LibreQR 1.2.0 est un logiciel libre dont le <a href="https://code.antopie.org/miraty/libreqr/">code source</a> est disponible
-        selon les termes de l'<abbr title="GNU Affero General Public License version 3 ou toute version ultérieure"><a href="LICENSE.html">AGPLv3</a>+</abbr>.
+        <p>
+          <?= $loc['metaText_legal'] ?>
+        </p>
+        <?php if (isset($additionalText)) { ?>
+        <br>
+        <p>
+          <?= $additionalText ?>
+        </p>
+        <?php } ?>
       </footer>
 
     </div>
diff --git a/lessphp/LICENSE b/lesserphp/LICENSE
old mode 100755
new mode 100644
similarity index 99%
rename from lessphp/LICENSE
rename to lesserphp/LICENSE
index 3b307b5..5290202
--- a/lessphp/LICENSE
+++ b/lesserphp/LICENSE
@@ -1,4 +1,4 @@
-For ease of distribution, lessphp is under a dual license.
+For ease of distribution, lessphp 0.5.1 is under a dual license.
 You are free to pick which one suits your needs.
 
 
@@ -9,7 +9,8 @@ MIT LICENSE
 
 
 
-Copyright (c) 2014 Leaf Corcoran, http://leafo.net/lessphp
+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
diff --git a/lessphp/README.md b/lesserphp/README.md
old mode 100755
new mode 100644
similarity index 86%
rename from lessphp/README.md
rename to lesserphp/README.md
index d3d8716..8c26ab1
--- a/lessphp/README.md
+++ b/lesserphp/README.md
@@ -1,9 +1,10 @@
-[![Build Status](https://travis-ci.org/leafo/lessphp.svg?branch=master)](https://travis-ci.org/leafo/lessphp)
+[![Build Status](https://travis-ci.org/MarcusSchwarz/lesserphp.svg)](https://travis-ci.org/MarcusSchwarz/lesserphp)
 
-# lessphp v0.5.0
-### <http://leafo.net/lessphp>
+# lesserphp v0.5.4
+### <http://github.com/MarcusSchwarz/lesserphp>
 
-`lessphp` is a compiler for LESS written in PHP. The documentation is great,
+`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:
@@ -12,7 +13,7 @@ Here's a quick tutorial:
 
 The only file required is `lessc.inc.php`, so copy that to your include directory.
 
-The typical flow of **lessphp** is to create a new instance of `lessc`,
+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.
 
@@ -48,7 +49,7 @@ If there any problem compiling your code, an exception is thrown with a helpful
 <?php
 try {
   $less->compile("invalid LESS } {");
-} catch (exception $e) {
+} catch (\Exception $e) {
   echo "fatal error: " . $e->getMessage();
 }
 ```
diff --git a/lesserphp/docs/docs.md b/lesserphp/docs/docs.md
new file mode 100644
index 0000000..e25c877
--- /dev/null
+++ b/lesserphp/docs/docs.md
@@ -0,0 +1,1400 @@
+    title: v0.5.1 documentation
+    link_to_home: true
+--
+
+<h2 skip="true">Documentation v0.5.1</h2>
+
+<div style="margin-bottom: 1em;">$index</div>
+
+**lesserphp** is a compiler that generates CSS from a superset language which
+adds a collection of convenient features often seen in other languages. All CSS
+is compatible with LESS, so you can start using new features with your existing CSS.
+
+It is designed to be compatible with [less.js](http://lesscss.org), and suitable
+as a drop in replacement for PHP projects.
+
+## Getting Started
+
+The homepage for **lesserphp** can be found at [http://leafo.net/lessphp/][1].
+
+You can follow development at the project's [GitHub][2].
+
+Including **lesserphp** in your project is as simple as dropping the single
+include file into your code base and running the appropriate compile method as
+described in the [PHP Interface](#php_interface).
+
+  [1]: http://leafo.net/lessphp "lessphp homepage"
+  [2]: https://github.com/MarcusSchwarz/lesserphp "lesserphp GitHub page"
+
+## Installation
+
+**lesserphp** is distributed entirely in a single stand-alone file. Download the
+latest version from [GitHub][2].
+
+Development versions can also be downloading from GitHub.
+
+Place `lessphp.inc.php` in a location available to your PHP scripts, and
+include it. That's it! you're ready to begin.
+
+## The Language
+
+**lesserphp** is very easy to learn because it generally functions how you would
+expect it to. If you feel something is challenging or missing, feel free to
+open an issue on the [bug tracker](https://github.com/MarcusSchwarz/lesserphp/issues).
+
+It is also easy to learn because any standards-compliant CSS code is valid LESS
+code. You are free to gradually enhance your existing CSS code base with LESS
+features without having to worry about rewriting anything.
+
+The following is a description of the new languages features provided by LESS.
+
+### Line Comments
+
+Simple but very useful; line comments are started with `//`:
+
+    ```less
+    // this is a comment
+    body {
+      color: red; // as is this
+      /* block comments still work also */
+    }
+    ```
+
+### Variables
+
+Variables are identified with a name that starts with `@`. To declare a
+variable, you create an appropriately named CSS property and assign it a value:
+
+    ```less
+    @family: "verdana";
+    @color: red;
+    body {
+      @mycolor: red;
+      font-family: @family;
+      color: @color;
+      border-bottom: 1px solid @color;
+    }
+    ```
+
+Variable declarations will not appear in the output. Variables can be declared
+in the outer most scope of the file, or anywhere else a CSS property may
+appear. They can hold any CSS property value.
+
+Variables are only visible for use from their current scope, or any enclosed
+scopes.
+
+If you have a string or keyword in a variable, you can reference another
+variable by that name by repeating the `@`:
+
+    ```less
+    @value: 20px;
+    @value_name: "value";
+
+    width: @@value_name;
+    ```
+
+### Expressions
+
+Expressions let you combine values and variables in meaningful ways. For
+example you can add to a color to make it a different shade. Or divide up the
+width of your layout logically. You can even concatenate strings.
+
+Use the mathematical operators to evaluate an expression:
+
+    ```less
+    @width: 960px;
+    .nav {
+      width: @width / 3;
+      color: #001 + #abc;
+    }
+    .body {
+      width: 2 * @width / 3;
+      font-family: "hel" + "vetica";
+    }
+    ```
+
+Parentheses can be used to control the order of evaluation. They can also be
+used to force an evaluation for cases where CSS's syntax makes the expression
+ambiguous.
+
+The following property will produce two numbers, instead of doing the
+subtraction:
+
+    ```less
+    margin: 10px -5px;
+    ```
+
+To force the subtraction:
+
+    ```less
+    margin: (10px -5px);
+    ```
+
+It is also safe to surround mathematical operators by spaces to ensure that
+they are evaluated:
+
+    ```less
+    margin: 10px - 5px;
+    ```
+
+Division has a special quirk. There are certain CSS properties that use the `/`
+operator as part of their value's syntax. Namely, the [font][4] shorthand and
+[border-radius][3].
+
+  [3]: https://developer.mozilla.org/en/CSS/border-radius
+  [4]: https://developer.mozilla.org/en/CSS/font
+
+
+Thus, **lessphp** will ignore any division in these properties unless it is
+wrapped in parentheses. For example, no division will take place here:
+
+    ```less
+    .font {
+      font: 20px/80px "Times New Roman";
+    }
+    ```
+
+In order to force division we must wrap the expression in parentheses:
+
+    ```less
+    .font {
+      font: (20px/80px) "Times New Roman";
+    }
+    ```
+
+If you want to write a literal `/` expression without dividing in another
+property (or a variable), you can use [string unquoting](#string_unquoting):
+
+    ```less
+    .var {
+      @size: ~"20px/80px";
+      font: @size sans-serif;
+    }
+    ```
+
+### Nested Blocks
+
+By nesting blocks we can build up a chain of CSS selectors through scope
+instead of repeating them. In addition to reducing repetition, this also helps
+logically organize the structure of our CSS.
+
+    ```less
+    ol.list {
+      li.special {
+        border: 1px solid red;
+      }
+
+      li.plain {
+        font-weight: bold;
+      }
+    }
+    ```
+
+
+This will produce two blocks, a `ol.list li.special` and `ol.list li.plain`.
+
+Blocks can be nested as deep as required in order to build a hierarchy of
+relationships.
+
+The `&` operator can be used in a selector to represent its parent's selector.
+If the `&` operator is used, then the default action of appending the parent to
+the front of the child selector separated by space is not performed.
+
+    ```less
+    b {
+      a & {
+        color: red;
+      }
+
+      // the following have the same effect
+
+      & i {
+        color: blue;
+      }
+
+      i {
+        color: blue;
+      }
+    }
+    ```
+
+
+Because the `&` operator respects the whitespace around it, we can use it to
+control how the child blocks are joined. Consider the differences between the
+following:
+
+    ```less
+    div {
+      .child-class { color: purple; }
+
+      &.isa-class { color: green; }
+
+      #child-id { height: 200px; }
+
+      &#div-id { height: 400px; }
+
+      &:hover { color: red; }
+
+      :link { color: blue; }
+    }
+    ```
+
+The `&` operator also works with [mixins](#mixins), which produces interesting results:
+
+    ```less
+    .within_box_style() {
+      .box & {
+        color: blue;
+      }
+    }
+
+    #menu {
+      .within_box_style;
+    }
+    ```
+
+### Mixins
+
+Any block can be mixed in just by naming it:
+
+    ```less
+    .mymixin {
+      color: blue;
+      border: 1px solid red;
+
+      .special {
+        font-weight: bold;
+      }
+    }
+
+
+    h1 {
+      font-size: 200px;
+      .mymixin;
+    }
+    ```
+
+All properties and child blocks are mixed in.
+
+Mixins can be made parametric, meaning they can take arguments, in order to
+enhance their utility. A parametric mixin all by itself is not outputted when
+compiled. Its properties will only appear when mixed into another block.
+
+The canonical example is to create a rounded corners mixin that works across
+browsers:
+
+    ```less
+    .rounded-corners(@radius: 5px) {
+      border-radius: @radius;
+      -webkit-border-radius: @radius;
+      -moz-border-radius: @radius;
+    }
+
+    .header {
+      .rounded-corners();
+    }
+
+    .info {
+      background: red;
+      .rounded-corners(14px);
+    }
+    ```
+
+If you have a mixin that doesn't have any arguments, but you don't want it to
+show up in the output, give it a blank argument list:
+
+    ```less
+    .secret() {
+      font-size: 6000px;
+    }
+
+    .div {
+      .secret;
+    }
+    ```
+
+If the mixin doesn't need any arguments, you can leave off the parentheses when
+mixing it in, as seen above.
+
+You can also mixin a block that is nested inside other blocks. You can think of
+the outer block as a way of making a scope for your mixins. You just list the
+names of the mixins separated by spaces, which describes the path to the mixin
+you want to include. Optionally you can separate them by `>`.
+
+    ```less
+    .my_scope  {
+      .some_color {
+        color: red;
+        .inner_block {
+          text-decoration: underline;
+        }
+      }
+      .bold {
+        font-weight: bold;
+        color: blue;
+      }
+    }
+
+    .a_block {
+      .my_scope .some_color;
+      .my_scope .some_color .inner_block;
+    }
+
+    .another_block {
+      // the alternative syntax
+      .my_scope > .bold;
+    }
+    ```
+
+
+#### Mixin Arguments
+
+When declaring a mixin you can specify default values for each argument.  Any
+argument left out will be given the default value specified. Here's the
+syntax:
+
+```less
+.mix(@color: red, @height: 20px, @pad: 12px) {
+  border: 1px solid @color;
+  height: @height - @pad;
+  padding: @pad;
+}
+
+.default1 {
+  .mix();
+}
+
+.default2 {
+  .mix(blue);
+}
+
+.default3 {
+  .mix(blue, 40px, 5px);
+}
+```
+
+Additionally, you can also call a mixin using the argument names, this is
+useful if you want to replace a specific argument while having all the others
+take the default regardless of what position the argument appears in. The
+syntax looks something like this:
+
+
+```lessbasic
+div {
+  .my_mixin(@paddding: 4px); // @color and @height get default values
+  .my_mixin(@paddding: 4px, @height: 50px); // you can specify them in any order
+}
+```
+
+You can also combine the ordered arguments with the named ones:
+
+```lessbasic
+div {
+  // @color is blue, @padding is 4px, @height is default
+  .my_mixin(blue, @padding: 4px);
+}
+```
+
+Mixin arguments can be delimited with either a `,` or `;`, but only one can be
+active at once. This means that each argument is separated by either `,` or
+`;`. By default `,` is the delimiter, in all the above examples we used a `,`.
+
+A problem arises though, sometimes CSS value lists are made up with commas. In
+order to be able to pass a comma separated list literal we need to use `;` as
+the delimiter. (You don't need to worry about this if your list is stored in a
+variable)
+
+If a `;` appears anywhere in the argument list, then it will be used as the
+argument delimiter, and all commas we be used as part of the argument values.
+
+Here's a basic example:
+
+```less
+.fancy_mixin(@box_shadow, @color: blue) {
+  border: 1px solid @color;
+  box-shadow: @box_shadow;
+}
+
+
+div {
+  // two arguments passed separated by ;
+  .fancy_mixin(2px 2px, -2px -2px; red);
+}
+
+pre {
+  // one argument passed, ends in ;
+  .fancy_mixin(inset 4px 4px, -2px 2px;);
+}
+
+```
+
+If we only want to pass a single comma separated value we still need to use
+`;`, to do this we stick it on the end as demonstrated above.
+
+
+#### `@arguments` Variable
+
+Within an mixin there is a special variable named `@arguments` that contains
+all the arguments passed to the mixin along with any remaining arguments that
+have default values. The value of the variable has all the values separated by
+spaces.
+
+This useful for quickly assigning all the arguments:
+
+    ```less
+    .box-shadow(@x, @y, @blur, @color) {
+      box-shadow: @arguments;
+      -webkit-box-shadow: @arguments;
+      -moz-box-shadow: @arguments;
+    }
+    .menu {
+      .box-shadow(1px, 1px, 5px, #aaa);
+    }
+    ```
+
+In addition to the arguments passed to the mixin, `@arguments` will also include
+remaining default values assigned by the mixin:
+
+
+    ```less
+    .border-mixin(@width, @style: solid, @color: black) {
+      border: @arguments;
+    }
+
+    pre {
+      .border-mixin(4px, dotted);
+    }
+
+    ```
+
+
+#### Pattern Matching
+
+When you *mix in* a mixin, all the available mixins of that name in the current
+scope are checked to see if they match based on what was passed to the mixin
+and how it was declared.
+
+The simplest case is matching by number of arguments. Only the mixins that
+match the number of arguments passed in are used.
+
+    ```less
+    .simple() { // matches no arguments
+      height: 10px;
+    }
+
+    .simple(@a, @b) { // matches two arguments
+      color: red;
+    }
+
+    .simple(@a) { // matches one argument
+      color: blue;
+    }
+
+    div {
+      .simple(10);
+    }
+
+    span {
+      .simple(10, 20);
+    }
+    ```
+
+Whether an argument has default values is also taken into account when matching
+based on number of arguments:
+
+    ```less
+    // matches one or two arguments
+    .hello(@a, @b: blue) {
+      height: @a;
+      color: @b;
+    }
+
+    .hello(@a, @b) { // matches only two
+      width: @a;
+      border-color: @b;
+    }
+
+    .hello(@a) { // matches only one
+      padding: 1em;
+    }
+
+    div {
+      .hello(10px);
+    }
+
+    pre {
+      .hello(10px, yellow);
+    }
+    ```
+
+Additionally, a *vararg* value can be used to further control how things are
+matched.  A mixin's argument list can optionally end in the special argument
+named `...`.  The `...` may match any number of arguments, including 0.
+
+    ```less
+    // this will match any number of arguments
+    .first(...) {
+      color: blue;
+    }
+
+    // matches at least 1 argument
+    .second(@arg, ...) {
+      height: 200px + @arg;
+    }
+
+    div { .first("some", "args"); }
+    pre { .second(10px); }
+    ```
+
+If you want to capture the values that get captured by the *vararg* you can
+give it a variable name by putting it directly before the `...`. This variable
+must be the last argument defined. It's value is just like the special
+[`@arguments` variable](#arguments_variable), a space separated list.
+
+
+    ```less
+    .hello(@first, @rest...) {
+      color: @first;
+      text-shadow: @rest;
+    }
+
+    span {
+      .hello(red, 1px, 1px, 0px, white);
+    }
+
+    ```
+
+Another way of controlling whether a mixin matches is by specifying a value in
+place of an argument name when declaring the mixin:
+
+    ```less
+    .style(old, @size) {
+      font: @size serif;
+    }
+
+    .style(new, @size) {
+      font: @size sans-serif;
+    }
+
+    .style(@_, @size) {
+      letter-spacing: floor(@size / 6px);
+    }
+
+    em {
+      @switch: old;
+      .style(@switch, 15px);
+    }
+    ```
+
+Notice that two of the three mixins were matched. The mixin with a matching
+first argument, and the generic mixin that matches two arguments. It's common
+to use `@_` as the name of a variable we intend to not use. It has no special
+meaning to LESS, just to the reader of the code.
+
+#### Guards
+
+Another way of restricting when a mixin is mixed in is by using guards. A guard
+is a special expression that is associated with a mixin declaration that is
+evaluated during the mixin process. It must evaluate to true before the mixin
+can be used.
+
+We use the `when` keyword to begin describing a list of guard expressions.
+
+Here's a simple example:
+
+    ```less
+    .guarded(@arg) when (@arg = hello) {
+      color: blue;
+    }
+
+    div {
+      .guarded(hello); // match
+    }
+
+    span {
+      .guarded(world); // no match
+    }
+    ```
+Only the `div`'s mixin will match in this case, because the guard expression
+requires that `@arg` is equal to `hello`.
+
+We can include many different guard expressions by separating them by commas.
+Only one of them needs to match to trigger the mixin:
+
+    ```less
+    .x(@a, @b) when (@a = hello), (@b = world) {
+      width: 960px;
+    }
+
+    div {
+      .x(hello, bar); // match
+    }
+
+    span {
+      .x(foo, world); // match
+    }
+
+    pre {
+      .x(foo, bar); // no match
+    }
+    ```
+
+Instead of a comma, we can use `and` keyword to make it so all of the guards
+must match in order to trigger the mixin. `and` has higher precedence than the
+comma.
+
+    ```less
+    .y(@a, @b) when (@a = hello) and (@b = world) {
+      height: 600px;
+    }
+
+    div {
+      .y(hello, world); // match
+    }
+
+    span {
+      .y(hello, bar); // no match
+    }
+    ```
+
+Commas and `and`s can be mixed and matched.
+
+You can also negate a guard expression by using `not` in from of the parentheses:
+
+    ```less
+    .x(@a) when not (@a = hello) {
+      color: blue;
+    }
+
+    div {
+      .x(hello); // no match
+    }
+    ```
+
+The `=` operator is used to check equality between any two values. For numbers
+the following comparison operators are also defined:
+
+`<`, `>`, `=<`, `>=`
+
+There is also a collection of predicate functions that can be used to test the
+type of a value.
+
+These are `isnumber`, `iscolor`, `iskeyword`, `isstring`, `ispixel`,
+`ispercentage` and `isem`.
+
+    ```less
+    .mix(@a) when (ispercentage(@a)) {
+      height: 500px * @a;
+    }
+    .mix(@a) when (ispixel(@a)) {
+      height: @a;
+    }
+
+    div.a {
+      .mix(50%);
+    }
+
+    div.a {
+      .mix(350px);
+    }
+    ```
+
+#### !important
+
+If you want to apply the `!important` suffix to every property when mixing in a
+mixin, just append `!important` to the end of the call to the mixin:
+
+    ```less
+    .make_bright {
+      color: red;
+      font-weight: bold;
+    }
+
+    .color {
+      color: green;
+    }
+
+    body {
+      .make_bright() !important;
+      .color();
+    }
+
+    ```
+
+### Selector Expressions
+
+Sometimes we want to dynamically generate the selector of a block based on some
+variable or expression. We can do this by using *selector expressions*. Selector
+expressions are CSS selectors that are evaluated in the current scope before
+being written out.
+
+A simple example is a mixin that dynamically creates a selector named after the
+mixin's argument:
+
+    ```less
+    .create-selector(@name) {
+      @{name} {
+        color: red;
+      }
+    }
+
+    .create-selector(hello);
+    .create-selector(world);
+    ```
+
+The string interpolation syntax works inside of selectors, letting you insert varaibles.
+
+Here's an interesting example adapted from Twitter Bootstrap. A couple advanced
+things are going on. We are using [Guards](#guards) along with a recursive
+mixin to work like a loop to generate a series of CSS blocks.
+
+
+    ```less
+    // create our recursive mixin:
+    .spanX (@index) when (@index > 0) {
+      .span@{index} {
+        width: @index * 100px;
+      }
+      .spanX(@index - 1);
+    }
+    .spanX (0) {}
+
+    // mix it into the global scopee:
+    .spanX(4);
+    ```
+
+### Import
+
+Multiple LESS files can be compiled into a single CSS file by using the
+`@import` statement. Be careful, the LESS import statement shares syntax with
+the CSS import statement. If the file being imported ends in a `.less`
+extension, or no extension, then it is treated as a LESS import. Otherwise it
+is left alone and outputted directly:
+
+    ```lessbasic
+    // my_file.less
+    .some-mixin(@height) {
+      height: @height;
+    }
+
+    // main.less
+    @import "main.less" // will import the file if it can be found
+    @import "main.css" // will be left alone
+
+    body {
+      .some-mixin(400px);
+    }
+    ```
+
+All of the following lines are valid ways to import the same file:
+
+    ```lessbasic
+    @import "file";
+    @import 'file.less';
+    @import url("file");
+    @import url('file');
+    @import url(file);
+    ```
+
+When importing, the `importDir` is searched for files. This can be configured,
+see [PHP Interface](#php_interface).
+
+A file is only imported once. If you try to include the same file multiple
+times all the import statements after the first produce no output.
+
+### String Interpolation
+
+String interpolation is a convenient way to insert the value of a variable
+right into a string literal. Given some variable named `@var_name`, you just
+need to write it as `@{var_name}` from within the string to have its value
+inserted:
+
+    ```less
+    @symbol: ">";
+    h1:before {
+      content: "@{symbol}: ";
+    }
+
+    h2:before {
+      content: "@{symbol}@{symbol}: ";
+    }
+    ```
+
+There are two kinds of strings, implicit and explicit strings. Explicit strings
+are wrapped by double quotes, `"hello I am a string"`, or single quotes `'I am
+another string'`. Implicit strings only appear when using `url()`. The text
+between the parentheses is considered a string and thus string interpolation is
+possible:
+
+    ```less
+    @path: "files/";
+    body {
+      background: url(@{path}my_background.png);
+    }
+    ```
+
+### String Format Function
+
+The `%` function can be used to insert values into strings using a *format
+string*. It works similar to `printf` seen in other languages. It has the
+same purpose as string interpolation above, but gives explicit control over
+the output format.
+
+    ```less
+    @symbol: ">";
+    h1:before {
+      content: %("%s: ", @symbol);
+    }
+    ```
+
+The `%` function takes as its first argument the format string, following any
+number of addition arguments that are inserted in place of the format
+directives.
+
+A format directive starts with a `%` and is followed by a single character that
+is either `a`, `d`, or `s`:
+
+    ```less
+    strings: %("%a %d %s %a", hi, 1, 'ok', 'cool');
+    ```
+
+`%a` and `%d` format the value the same way: they compile the argument to its
+CSS value and insert it directly. When used with a string, the quotes are
+included in the output. This typically isn't what we want, so we have the `%s`
+format directive which strips quotes from strings before inserting them.
+
+The `%d` directive functions the same as `%a`, but is typically used for numbers
+assuming the output format of numbers might change in the future.
+
+### String Unquoting
+
+Sometimes you will need to write proprietary CSS syntax that is unable to be
+parsed. As a workaround you can place the code into a string and unquote it.
+Unquoting is the process of outputting a string without its surrounding quotes.
+There are two ways to unquote a string.
+
+The `~` operator in front of a string will unquote that string:
+
+    ```less
+    .class {
+      // a made up, but problematic vendor specific CSS
+      filter: ~"Microsoft.AlphaImage(src='image.png')";
+    }
+    ```
+
+If you are working with other types, such as variables, there is a built in
+function that let's you unquote any value. It is called `e`.
+
+    ```less
+    @color: "red";
+    .class {
+      color: e(@color);
+    }
+    ```
+
+### Built In Functions
+
+**lesserphp** has a collection of built in functions:
+
+* `e(str)` -- returns a string without the surrounding quotes.
+  See [String Unquoting](#string_unquoting)
+
+* `floor(number)` -- returns the floor of a numerical input
+* `round(number, [precision])` -- returns the rounded value of numerical input with optional precision
+
+* `lighten(color, percent)` -- lightens `color` by `percent` and returns it
+* `darken(color, percent)` -- darkens `color` by `percent` and returns it
+
+* `saturate(color, percent)` -- saturates `color` by `percent` and returns it
+* `desaturate(color, percent)` -- desaturates `color` by `percent` and returns it
+
+* `fadein(color, percent)` -- makes `color` less transparent by `percent` and returns it
+* `fadeout(color, percent)` -- makes `color` more transparent by `percent` and returns it
+
+* `spin(color, amount)` -- returns a color with `amount` degrees added to hue
+
+* `fade(color, amount)` -- returns a color with the alpha set to `amount`
+
+* `hue(color)` -- returns the hue of `color`
+
+* `saturation(color)` -- returns the saturation of `color`
+
+* `lightness(color)` -- returns the lightness of `color`
+
+* `alpha(color)` -- returns the alpha value of `color` or 1.0 if it doesn't have an alpha
+
+* `percentage(number)` -- converts a floating point number to a percentage, e.g. `0.65` -> `65%`
+
+* `mix(color1, color1, percent)` -- mixes two colors by percentage where 100%
+  keeps all of `color1`, and 0% keeps all of `color2`. Will take into account
+  the alpha of the colors if it exists. See
+  <http://sass-lang.com/docs/yardoc/Sass/Script/Functions.html#mix-instance_method>.
+
+* `contrast(color, dark, light)` -- if `color` has a lightness value greater
+  than 50% then `dark` is returned, otherwise return `light`.
+
+* `extract(list, index)` -- returns the `index`th item from `list`. The list is
+  `1` indexed, meaning the first item's index is 1, the second is 2, and etc.
+
+* `pow(base, exp)` -- returns `base` raised to the power of `exp`
+
+* `pi()` -- returns pi
+
+* `mod(a,b)` -- returns `a` modulus `b`
+
+* `tan(a)` -- returns tangent of `a` where `a` is in radians
+
+* `cos(a)` -- returns cosine of `a` where `a` is in radians
+
+* `sin(a)` -- returns sine of `a` where `a` is in radians
+
+* `atan(a)` -- returns arc tangent of `a`
+
+* `acos(a)` -- returns arc cosine of `a`
+
+* `asin(a)` -- returns arc sine of `a`
+
+* `sqrt(a)` -- returns square root of `a`
+
+* `rgbahex(color)` -- returns a string containing 4 part hex color.
+
+   This is used to convert a CSS color into the hex format that IE's filter
+   method expects when working with an alpha component.
+
+       ```less
+       .class {
+          @start: rgbahex(rgba(25, 34, 23, .5));
+          @end: rgbahex(rgba(85, 74, 103, .6));
+          // abridged example
+          -ms-filter:
+            e("gradient(start=@{start},end=@{end})");
+       }
+       ```
+
+## PHP Interface
+
+When working with **lesserphp** from PHP, the typical flow 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.
+
+Methods:
+
+* [`compile($string)`](#compiling[) -- Compile a string
+
+* [`compileFile($inFile, [$outFile])`](#compiling) -- Compile a file to another or return it
+
+* [`checkedCompile($inFile, $outFile)`](#compiling) -- Compile a file only if it's newer
+
+* [`cachedCompile($cacheOrFile, [$force])`](#compiling_automatically) -- Conditionally compile while tracking imports
+
+* [`setFormatter($formatterName)`](#output_formatting) -- Change how CSS output looks
+
+* [`setPreserveComments($keepComments)`](#preserving_comments) -- Change if comments are kept in output
+
+* [`registerFunction($name, $callable)`](#custom_functions) -- Add a custom function
+
+* [`unregisterFunction($name)`](#custom_functions) -- Remove a registered function
+
+* [`setVariables($vars)`](#setting_variables_from_php) -- Set a variable from PHP
+
+* [`unsetVariable($name)`](#setting_variables_from_php) -- Remove a PHP variable
+
+* [`setImportDir($dirs)`](#import_directory) -- Set the search path for imports
+
+* [`addImportDir($dir)`](#import_directory) -- Append directory to search path for imports
+
+
+### Compiling
+
+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
+    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
+    $less->checkedCompile("input.less", "output.css");
+    ```
+
+See [Compiling Automatically](#compiling_automatically) for a description of
+the more advanced `cachedCompile` method.
+
+### Output Formatting
+
+Output formatting controls the indentation of the output CSS. Besides the
+default formatter, two additional ones are included and it's also easy to make
+your own.
+
+To use a formatter, the method `setFormatter` is used. Just
+pass the name of the formatter:
+
+    ```php
+    $less = new lessc;
+
+    $less->setFormatter("compressed");
+    echo $less->compile("div { color: lighten(blue, 10%) }");
+    ```
+
+In this example, the `compressed` formatter is used. The formatters are:
+
+ * `lessjs` *(default)* -- Same style used in LESS for JavaScript
+
+ * `compressed` -- Compresses all the unrequired whitespace
+
+ * `classic` -- **lessphp**'s original formatter
+
+To revert to the default formatter, call `setFormatter` with a value of `null`.
+
+#### Custom Formatter
+
+The easiest way to customize the formatter is to create your own instance of an
+existing formatter and alter its public properties before passing it off to
+**lessphp**. The `setFormatter` method can also take an instance of a
+formatter.
+
+Each of the formatter names corresponds to a class with `lessc_formatter_`
+prepended in front of it. Here the classic formatter is customized to use tabs
+instead of spaces:
+
+
+    ```php
+    $formatter = new lessc_formatter_classic;
+    $formatter->indentChar = "\t";
+
+    $less = new lessc;
+    $less->setFormatter($formatter);
+    echo $less->compileFile("myfile.less");
+    ```
+
+For more information about what can be configured with the formatter consult
+the source code.
+
+### Preserving Comments
+
+By default, all comments in the source LESS file are stripped when compiling.
+You might want to keep the `/* */` comments in the output though. For
+example, bundling a license in the file.
+
+Enable or disable comment preservation by calling `setPreserveComments`:
+
+    ```php
+    $less = new lessc;
+    $less->setPreserveComments(true);
+    echo $less->compile("/* hello! */");
+    ```
+
+Comments are disabled by default because there is additional overhead, and more
+often than not they aren't needed.
+
+
+### Compiling Automatically
+
+Often, you want to only compile a LESS file only if it has been modified since
+last compile. This is very important because compiling is performance intensive
+and you should avoid a recompile if it possible.
+
+The `checkedCompile` compile method will do just that. It will check if the
+input file is newer than the output file, or if the output file doesn't exist
+yet, and compile only then.
+
+    ```php
+    $less->checkedCompile("input.less", "output.css");
+    ```
+
+There's a problem though. `checkedCompile` is very basic, it only checks the
+input file's modification time. It is unaware of any files from `@import`.
+
+
+For this reason we also have `cachedCompile`. It's slightly more complex, but
+gives us the ability to check changes to all files including those imported. It
+takes one argument, either the name of the file we want to compile, or an
+existing *cache object*. Its return value is an updated cache object.
+
+If we don't have a cache object, then we call the function with the name of the
+file to get the initial cache object. If we do have a cache object, then we
+call the function with it. In both cases, an updated cache object is returned.
+
+The cache object keeps track of all the files that must be checked in order to
+determine if a rebuild is required.
+
+The cache object is a plain PHP `array`. It stores the last time it compiled in
+`$cache["updated"]` and output of the compile in `$cache["compiled"]`.
+
+Here we demonstrate creating an new cache object, then using it to see if we
+have a recompiled version available to be written:
+
+
+    ```php
+    $inputFile = "myfile.less";
+    $outputFile = "myfile.css";
+
+    $less = new lessc;
+
+    // create a new cache object, and compile
+    $cache = $less->cachedCompile($inputFile);
+
+    file_put_contents($outputFile, $cache["compiled"]);
+
+    // the next time we run, write only if it has updated
+    $last_updated = $cache["updated"];
+    $cache = $less->cachedCompile($cache);
+    if ($cache["updated"] > $last_updated) {
+        file_put_contents($outputFile, $cache["compiled"]);
+    }
+
+    ```
+
+In order for the system to fully work, we must save cache object between
+requests. Because it's a plain PHP `array`, it's sufficient to
+[`serialize`](http://php.net/serialize) it and save it the string somewhere
+like a file or in persistent memory.
+
+An example with saving cache object to a file:
+
+    ```php
+    function autoCompileLess($inputFile, $outputFile) {
+      // load the cache
+      $cacheFile = $inputFile.".cache";
+
+      if (file_exists($cacheFile)) {
+        $cache = unserialize(file_get_contents($cacheFile));
+      } else {
+        $cache = $inputFile;
+      }
+
+      $less = new lessc;
+      $newCache = $less->cachedCompile($cache);
+
+      if (!is_array($cache) || $newCache["updated"] > $cache["updated"]) {
+        file_put_contents($cacheFile, serialize($newCache));
+        file_put_contents($outputFile, $newCache['compiled']);
+      }
+    }
+
+    autoCompileLess('myfile.less', 'myfile.css');
+    ```
+
+`cachedCompile` method takes an optional second argument, `$force`. Passing in
+true will cause the input to always be recompiled.
+
+### Error Handling
+
+All of the compile methods will throw an `Exception` if the parsing fails or
+there is a compile time error. Compile time errors include things like passing
+incorrectly typed values for functions that expect specific things, like the
+color manipulation functions.
+
+    ```php
+    $less = new lessc;
+    try {
+        $less->compile("} invalid LESS }}}");
+    } catch (Exception $ex) {
+        echo "lessphp fatal error: ".$ex->getMessage();
+    }
+    ```
+### Setting Variables From PHP
+
+Before compiling any code you can set initial LESS variables from PHP. The
+`setVariables` method lets us do this. It takes an associative array of names
+to values. The values must be strings, and will be parsed into correct CSS
+values.
+
+
+    ```php
+    $less = new lessc;
+
+    $less->setVariables(array(
+      "color" => "red",
+      "base" => "960px"
+    ));
+
+    echo $less->compile(".magic { color: @color;  width: @base - 200; }");
+    ```
+
+If you need to unset a variable, the `unsetVariable` method is available. It
+takes the name of the variable to unset.
+
+    ```php
+    $less->unsetVariable("color");
+    ```
+
+Be aware that the value of the variable is a string containing a CSS value. So
+if you want to pass a LESS string in, you're going to need two sets of quotes.
+One for PHP and one for LESS.
+
+
+    ```php
+    $less->setVariables(array(
+      "url" => "'http://example.com'"
+    ));
+
+    echo $less->compile("body { background: url("@{url}/bg.png"); }");
+    ```
+
+### Import Directory
+
+When running the `@import` directive, an array of directories called the import
+search path is searched through to find the file being asked for.
+
+By default, when using `compile`, the import search path just contains `""`,
+which is equivalent to the current directory of the script. If `compileFile` is
+used, then the directory of the file being compiled is used as the starting
+import search path.
+
+Two methods are available for configuring the search path.
+
+`setImportDir` will overwrite the search path with its argument. If the value
+isn't an array it will be converted to one.
+
+
+In this example, `@import "colors";` will look for either
+`assets/less/colors.less` or `assets/bootstrap/colors.less` in that order:
+
+    ```php
+    $less->setImportDir(array("assets/less/", "assets/bootstrap"));
+
+    echo $less->compile('@import "colors";');
+    ```
+
+`addImportDir` will append a single path to the import search path instead of
+overwriting the whole thing.
+
+    ```php
+    $less->addImportDir("public/stylesheets");
+    ```
+
+### Custom Functions
+
+**lesserphp** has a simple extension interface where you can implement user
+functions that will be exposed in LESS code during the compile. They can be a
+little tricky though because you need to work with the **lesserphp** type system.
+
+The two methods we are interested in are `registerFunction` and
+`unregisterFunction`. `registerFunction` takes two arguments, a name and a
+callable value. `unregisterFunction` just takes the name of an existing
+function to remove.
+
+Here's an example that adds a function called `double` that doubles any numeric
+argument:
+
+    ```php
+    <?php
+    include "lessc.inc.php";
+
+    function lessphp_double($arg) {
+        list($type, $value) = $arg;
+        return array($type, $value*2);
+    }
+
+    $less = new lessc;
+    $less->registerFunction("double", "lessphp_double");
+
+    // gives us a width of 800px
+    echo $less->compile("div { width: double(400px); }");
+    ```
+
+The second argument to `registerFunction` is any *callable value* that is
+understood by [`call_user_func`](http://php.net/call_user_func).
+
+If we are using PHP 5.3 or above then we are free to pass a function literal
+like so:
+
+    ```php
+    $less->registerFunction("double", function($arg) {
+        list($type, $value, $unit) = $arg;
+        return array($type, $value*2, $unit);
+    });
+    ```
+
+Now let's talk about the `double` function itself.
+
+Although a little verbose, the implementation gives us some insight on the type
+system. All values in **lesserphp** are stored in an array where the 0th element
+is a string representing the type, and the other elements make up the
+associated data for that value.
+
+The best way to get an understanding of the system is to register is dummy
+function which does a `var_dump` on the argument. Try passing the function
+different values from LESS and see what the results are.
+
+The return value of the registered function must also be a **lesserphp** type,
+but if it is a string or numeric value, it will automatically be coerced into
+an appropriate typed value. In our example, we reconstruct the value with our
+modifications while making sure that we preserve the original type.
+
+The instance of **lesserphp** itself is sent to the registered function as the
+second argument in addition to the arguments array.
+
+## Command Line Interface
+
+**lesserphp** comes with a command line script written in PHP that can be used to
+invoke the compiler from the terminal. On Linux and OSX, all you need to do is
+place `plessc` and `lessc.inc.php` somewhere in your PATH (or you can run it in
+the current directory as well). On windows you'll need a copy of `php.exe` to
+run the file. To compile a file, `input.less` to CSS, run:
+
+    ```bash
+    $ plessc input.less
+    ```
+
+To write to a file, redirect standard out:
+
+    ```bash
+    $ plessc input.less > output.css
+    ```
+
+To compile code directly on the command line:
+
+    ```bash
+    $ plessc -r "@color: red; body { color: @color; }"
+    ```
+
+To watch a file for changes, and compile it as needed, use the `-w` flag:
+
+    ```bash
+    $ plessc -w input-file output-file
+    ```
+
+Errors from watch mode are written to standard out.
+
+
+## License
+
+Copyright (c) 2012 Leaf Corcoran, <http://leafo.net/lessphp>
+
+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.
+
+
+*Also under GPL3 if required, see `LICENSE` file*
+
diff --git a/lesserphp/lessc.inc.php b/lesserphp/lessc.inc.php
new file mode 100644
index 0000000..4764b28
--- /dev/null
+++ b/lesserphp/lessc.inc.php
@@ -0,0 +1,4019 @@
+<?php
+
+/**
+ * lessphp v0.5.2
+ * 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.2";
+
+	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($vars, $imports, $vars), $other);
+		} else {
+			return array_merge($vars, $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 !== false && $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[1] / 255) + (0.7152 * $color[2] / 255) + (0.0722 * $color[3] / 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 = ",";
+}
+
+
diff --git a/lessphp/lessc.inc.php b/lessphp/lessc.inc.php
deleted file mode 100755
index 90fac1a..0000000
--- a/lessphp/lessc.inc.php
+++ /dev/null
@@ -1,3880 +0,0 @@
-<?php
-
-/**
- * lessphp v0.5.0
- * http://leafo.net/lessphp
- *
- * LESS CSS compiler, adapted from http://lesscss.org
- *
- * Copyright 2013, Leaf Corcoran <leafot@gmail.com>
- * 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.0";
-
-    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 = '&';
-
-    public $importDisabled = false;
-    public $importDir = '';
-
-    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);
-    }
-
-    public static function compressList($items, $delim) {
-        if (!isset($items[1]) && isset($items[0])) return $items[0];
-        else return array('list', $delim, $items);
-    }
-
-    public static 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:
-            $this->throwError("unknown block type: $block->type\n");
-        }
-    }
-
-    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 '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) {
-                $this->throwError("{$prop[1][0]} is undefined");
-            }
-
-            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:
-            $this->throwError("unknown op: {$prop[0]}\n");
-        }
-    }
-
-
-    /**
-     * 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 pow($this->assertNumber($base), $this->assertNumber($exp));
-    }
-
-    protected function lib_pi() {
-        return pi();
-    }
-
-    protected function lib_mod($args) {
-        list($a, $b) = $this->assertArgs($args, 2, "mod");
-        return $this->assertNumber($a) % $this->assertNumber($b);
-    }
-
-    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, "%");
-    }
-
-    /**
-     * Mix color with white in variable proportion.
-     *
-     * It is the same as calling `mix(#ffffff, @color, @weight)`.
-     *
-     *     tint(@color, [@weight: 50%]);
-     *
-     * http://lesscss.org/functions/#color-operations-tint
-     *
-     * @return array Color
-     */
-    protected function lib_tint($args) {
-        $white = ['color', 255, 255, 255];
-        if ($args[0] == 'color') {
-            return $this->lib_mix([ 'list', ',', [$white, $args] ]);
-        } elseif ($args[0] == "list" && count($args[2]) == 2) {
-            return $this->lib_mix([ $args[0], $args[1], [$white, $args[2][0], $args[2][1]] ]);
-        } else {
-            $this->throwError("tint expects (color, weight)");
-        }
-    }
-
-    /**
-     * Mix color with black in variable proportion.
-     *
-     * It is the same as calling `mix(#000000, @color, @weight)`
-     *
-     *     shade(@color, [@weight: 50%]);
-     *
-     * http://lesscss.org/functions/#color-operations-shade
-     *
-     * @return array Color
-     */
-    protected function lib_shade($args) {
-        $black = ['color', 0, 0, 0];
-        if ($args[0] == 'color') {
-            return $this->lib_mix([ 'list', ',', [$black, $args] ]);
-        } elseif ($args[0] == "list" && count($args[2]) == 2) {
-            return $this->lib_mix([ $args[0], $args[1], [$black, $args[2][0], $args[2][1]] ]);
-        } else {
-            $this->throwError("shade expects (color, weight)");
-        }
-    }
-
-    // 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;
-            $threshold  = ( isset($args[2][3]) ) ? $this->assertNumber($args[2][3]) : $threshold;
-        }
-        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->toLuma($darkColor) > $this->toLuma($lightColor) ) {
-            $t  = $lightColor;
-            $lightColor = $darkColor;
-            $darkColor  = $t;
-        }
-
-        $inputColor_alpha = $this->lib_alpha($inputColor);
-        if ( ( $this->toLuma($inputColor) * $inputColor_alpha) < $threshold) {
-            return $lightColor;
-        }
-        return $darkColor;
-    }
-
-    private function toLuma($color) {
-        list(, $r, $g, $b) = $this->coerceColor($color);
-
-        $r = $r / 255;
-        $g = $g / 255;
-        $b = $b / 255;
-
-        $r = ($r <= 0.03928) ? $r / 12.92 : pow((($r + 0.055) / 1.055), 2.4);
-        $g = ($g <= 0.03928) ? $g / 12.92 : pow((($g + 0.055) / 1.055), 2.4);
-        $b = ($b <= 0.03928) ? $b / 12.92 : pow((($b + 0.055) / 1.055), 2.4);
-
-        return (0.2126 * $r) + (0.7152 * $g) + (0.0722 * $b);
-    }
-
-    protected function lib_luma($color) {
-        return array("number", round($this->toLuma($color) * 100, 8), "%");
-    }
-
-
-    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;
-        }
-    }
-
-    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) {
-            // copy alpha
-            $out[] = $color[4];
-        }
-        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) {
-            // copy alpha
-            $out[] = $color[4];
-        }
-        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') {
-            // need a list of arguments
-            return false;
-        }
-        $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) {
-        return $a ? self::$TRUE : 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;
-        }
-    }
-
-
-    // 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);
-    }
-
-    public function lib_red($color){
-        $color = $this->coerceColor($color);
-        if (is_null($color)) {
-            $this->throwError('color expected for red()');
-        }
-
-        return $color[1];
-    }
-
-    public function lib_green($color){
-        $color = $this->coerceColor($color);
-        if (is_null($color)) {
-            $this->throwError('color expected for green()');
-        }
-
-        return $color[2];
-    }
-
-    public 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;
-
-        $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];
-            }
-
-            $current = isset($current->storeParent) ?
-                $current->storeParent :
-                $current->parent;
-        }
-
-        $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->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;
-    }
-
-    // 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) && isset($in['root'])) {
-            if ($force || !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']) && is_array($in['files'])) {
-                foreach ($in['files'] as $fname => $ftime) {
-                    if (!file_exists($fname) || 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;
-                    }
-                }
-            }
-
-            $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->string($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->string($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->string($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 string(&$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 (!$tags) {
-            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->string($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();
-
-        $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 = ",";
-}
diff --git a/locales/en.php b/locales/en.php
new file mode 100644
index 0000000..350860b
--- /dev/null
+++ b/locales/en.php
@@ -0,0 +1,47 @@
+<?php
+$loc = array(
+  'subtitle' => "QR codes generator",
+  'description' => "Generate QR codes freely. Choose content, size, colors...",
+
+  'label_content' => "Text to encode",
+  'label_redondancy' => "Redondancy rate",
+  'label_margin' => "Margin size",
+  'label_size' => "Image size",
+  'label_bgColor' => "Background color",
+  'label_mainColor' => "Foreground color",
+
+  'placeholder' => "Enter the text to encode in the QR code",
+
+  'value_default' => "default",
+
+  'help_content' => "
+    You can encode what you want as text.<br>
+    Softwares which decodes these QR codes could suggest to open them with dedicated software, depending on their <a href='https://en.wikipedia.org/wiki/List_of_URI_schemes'>URI scheme</a>.<br><br>
+    For instance, to open a webpage:<br>
+    https://www.domain.tld/<br><br>
+    To send an email:<br>
+    mailto:contact@domain.tld<br><br>
+    To share geographic coordinates:<br>
+    geo:48.867564,2.364057<br><br>
+    To call a phone number:<br>
+    tel:+33639981871
+  ",
+  'help_redondancy' => "Redundancy is the duplication of information in the QR code to correct errors during decoding. A higher rate will produce a bigger QR code, but will have a better chance of being decoded correctly.",
+  'help_margin' => "Number of pixels in the white bands around the QR code.",
+  'help_size' => "By how much will the dimensions of the image be multiplied?",
+
+  'button_create' => "Generate",
+  'button_download' => "Download this QR code",
+
+  'title_showOnlyQR' => "Show only this QR code",
+
+  'metaText_qr' => "
+    <h3>What's a QR code ?</h3>
+    A QR code is a 2 dimensions barcode in which is written in binary text. It can be decoded with a device equipped with a photo sensor and an adequate software.
+    <a href='https://en.wikipedia.org/wiki/QR_code'>QR code on Wikipedia</a>
+  ",
+  'metaText_legal' => "LibreQR 1.2.0 is a free software whose <a href='https://code.antopie.org/miraty/libreqr/''>source code</a>  is available under the terms of the <abbr title='GNU Affero General Public License version 3 ou toute version ultérieure'><a href='LICENSE.html'>AGPLv3</a>+</abbr>.",
+
+  'opensearch_description' => "Generate QR codes from your search or address bar",
+  'opensearch_actionName' => "Generate QR codes from your search or address bar",
+);
diff --git a/locales/fr.php b/locales/fr.php
new file mode 100644
index 0000000..bb04b5d
--- /dev/null
+++ b/locales/fr.php
@@ -0,0 +1,47 @@
+<?php
+$loc = array(
+  'subtitle' => "Générateur de codes QR",
+  'description' => "Générez des codes QR librement. Choisissez le contenu, la taille, les couleurs...",
+
+  'label_content' => "Texte à encoder",
+  'label_redondancy' => "Taux de redondance",
+  'label_margin' => "Taille de la marge",
+  'label_size' => "Taille de l'image",
+  'label_bgColor' => "Couleur de fond",
+  'label_mainColor' => "Couleur de premier plan",
+
+  'placeholder' => "Entrez le texte à encoder dans le code QR",
+
+  'value_default' => "par défaut",
+
+  'help_content' => "
+    Vous pouvez encoder ce que vous voulez sous forme de texte.<br>
+    Les logiciels qui décodent ces codes QR pourraient proposer de les ouvrir avec un logiciel dédié, en fonction de leur <a href='https://fr.wikipedia.org/wiki/Sch%C3%A9ma_d%27URI'>schéma d'URI</a>.<br><br>
+    Par exemple, pour ouvrir une page Web :<br>
+    https://www.domaine.tld/<br><br>
+    Pour envoyer un mail :<br>
+    mailto:contact@domaine.tld<br><br>
+    Pour partager des coordonnées géographique :<br>
+    geo:48.867564,2.364057<br><br>
+    Pour appeler un numéro de téléphone :<br>
+    tel:+33639981871
+  ",
+  'help_redondancy' => "La redondance est la duplication des informations dans le code QR afin de corriger les erreurs lors du décodage. Un taux plus élevé produira un code QR plus grand, mais aura plus de chance d'être décodé correctement.",
+  'help_margin' => "Nombre de pixels des bandes blanches autour du code QR.",
+  'help_size' => "Par combien les dimensions de l'image seront-elles multipliées ?",
+
+  'button_create' => "Générer",
+  'button_download' => "Télécharger ce code QR",
+
+  'title_showOnlyQR' => "Afficher uniquement ce code QR",
+
+  'metaText_qr' => "
+    <h3>Qu'est-ce qu'un code QR ?</h3>
+    Un code QR est un code-barres en 2 dimensions dans lequel est inscrit en binaire du texte. Il peut être décodé avec un appareil muni d'un capteur photo et d'un logiciel adéquat.
+    <a href='https://fr.wikipedia.org/wiki/Code_QR'>Code QR sur Wikipédia</a>
+  ",
+  'metaText_legal' => "LibreQR 1.2.0 est un logiciel libre dont le <a href='https://code.antopie.org/miraty/libreqr/''>code source</a> est disponible selon les termes de l'<abbr title='GNU Affero General Public License version 3 ou toute version ultérieure'><a href='LICENSE.html'>AGPLv3</a>+</abbr>.",
+
+  'opensearch_description' => "Générez des codes QR depuis votre barre de recherche ou d'adresse",
+  'opensearch_actionName' => "Generate QR codes from your search or address bar",
+);
diff --git a/locales/template.php b/locales/template.php
new file mode 100644
index 0000000..9082c92
--- /dev/null
+++ b/locales/template.php
@@ -0,0 +1,27 @@
+<?php
+$loc = array(
+  'subtitle' => "subtitle",
+  'label_content' => "label_content",
+  'label_redondancy' => "label_redondancy",
+  'label_margin' => "label_margin",
+  'label_size' => "label_size",
+  'label_bgColor' => "label_bgColor",
+  'label_mainColor' => "label_mainColor",
+
+  'placeholder' => "placeholder",
+
+  'value_default' => "value_default",
+
+  'help_content' => "help_content",
+  'help_redondancy' => "help_redondancy",
+  'help_margin' => "help_margin",
+  'help_size' => "help_size",
+
+  'button_create' => "button_create",
+  'button_download' => "button_download",
+
+  'title_showOnlyQR' => "title_showOnlyQR",
+
+  'metaText_qr' => "metaText_qr",
+  'metaText_legal' => "metaText_legal",
+);
diff --git a/manifest.php b/manifest.php
index d27a069..1e04f23 100755
--- a/manifest.php
+++ b/manifest.php
@@ -1,28 +1,28 @@
-<?php require "config.inc.php"; ?>
+<?php require "inc.php"; ?>
 {
 	"dir": "ltr",
-	"lang": "fr",
+	"lang": "<?= $locale ?>",
 	"name": "LibreQR",
 	"short_name": "LibreQR",
-	"description": "Générer un code QR",
-	"start_url": "<?php echo $instPath; ?>",
-	"scope": "<?php echo $instPath; ?>",
+	"description": "<?= $loc['subtitle'] ?>",
+	"start_url": "<?= $instPath; ?>",
+	"scope": "<?= $instPath; ?>",
 	"display": "standalone",
-	"theme_color": "<?php echo $variablesTheme["bg"]; ?>",
-	"background_color": "<?php echo $variablesTheme["bg"]; ?>",
-  "orientation": "portrait",
+	"theme_color": "<?= $variablesTheme["bg"]; ?>",
+	"background_color": "<?= $variablesTheme["bg"]; ?>",
+	"orientation": "portrait",
 	"icons":
 	[
 <?php for ($i = 0; $i < (count($themeDimensionsIcons) - 1); $i++) { ?>
 		{
-			"src": "themes/<?php echo $theme; ?>/icons/<?php echo $themeDimensionsIcons[$i]; ?>.png",
-			"sizes": "<?php echo $themeDimensionsIcons[$i]; ?>x<?php echo $themeDimensionsIcons[$i]; ?>",
+			"src": "themes/<?= $theme; ?>/icons/<?= $themeDimensionsIcons[$i]; ?>.png",
+			"sizes": "<?= $themeDimensionsIcons[$i]; ?>x<?= $themeDimensionsIcons[$i]; ?>",
 			"type": "image/png"
 		},
 <?php } ?>
 		{
-			"src": "themes/<?php echo $theme; ?>/icons/<?php echo $themeDimensionsIcons[$i]; ?>.png",
-			"sizes": "<?php echo $themeDimensionsIcons[$i]; ?>x<?php echo $themeDimensionsIcons[$i]; ?>",
+			"src": "themes/<?= $theme; ?>/icons/<?= $themeDimensionsIcons[$i]; ?>.png",
+			"sizes": "<?= $themeDimensionsIcons[$i]; ?>x<?= $themeDimensionsIcons[$i]; ?>",
 			"type": "image/png"
 		}
 	]
diff --git a/opensearch.php b/opensearch.php
index 26f93c0..b2b5182 100755
--- a/opensearch.php
+++ b/opensearch.php
@@ -1,8 +1,8 @@
-<?php require "config.inc.php"; ?>
+<?php require "inc.php"; ?>
 <?xml version="1.0" encoding="UTF-8" ?>
 <OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
-  <ShortName>Générer un code QR</ShortName>
-  <Description>Générez des codes QR depuis votre barre de recherche ou d'adresse</Description>
+  <ShortName>LibreQR</ShortName>
+  <Description><?= $loc['opensearch_actionName'] ?></Description>
 <?php
   foreach($themeDimensionsIcons as $dimIcon) {
     echo '  <Image height="' . $dimIcon . '" width="' . $dimIcon . '" type="image/png">' . $instPath . 'themes/' . $theme . '/icons/' . $dimIcon . '.png</Image>' . "\n";
diff --git a/style.less b/style.less
index 3460464..95524c9 100755
--- a/style.less
+++ b/style.less
@@ -33,6 +33,10 @@ a {
   }
 }
 
+p {
+  margin: 0px;
+}
+
 #firstWrapper {
   display: flex;
   flex-direction: row;
@@ -47,7 +51,7 @@ a {
   max-width: 480px;
 }
 
-.centrer {
+.centered {
   text-align: center;
 }
 
@@ -61,7 +65,7 @@ form {
   margin-bottom: 30px;
 }
 
-.center {
+main {
   display: flex;
   flex-direction: column;
   justify-content: center;
@@ -360,7 +364,7 @@ input[type=color] {
     margin-right: auto;
   }
 
-  .center {
+  main {
     width: auto;
   }
 
diff --git a/style.min.css b/style.min.css
index 3e6c230..75856e6 100644
--- a/style.min.css
+++ b/style.min.css
@@ -1 +1 @@
-*{font-family:"Ubuntu", sans-serif;scrollbar-color:white #2a2a2a;scrollbar-width:auto;}a{color:white;text-decoration:underline;}a:hover{text-decoration:none;}#firstWrapper{display:flex;flex-direction:row;}#menusDeroulants{text-align:center;margin-left:20px;}#qrCode{max-width:480px;}.centrer{text-align:center;}.bouton{padding:3px 10px 3px 10px;text-decoration:none;}form{display:block;margin-bottom:30px;}.center{display:flex;flex-direction:column;justify-content:center;margin-left:auto;margin-right:auto;width:814px;}body{margin:18px;background-color:#2a2a2a;color:white;font-weight:normal;font-size:20px;}body h1{color:white;text-decoration:none;}label{font-size:20px;}header{text-align:center;padding:0px;margin:0px;height:64px;}#logo{width:64px;height:64px;}#titres{margin-left:20px;}h1,h2,h3,h4,h5,h6{margin:0px;font-weight:normal;}h1{font-size:33px;}h2{font-size:22px;}#lienTitres{text-align:left;justify-content:center;text-decoration:none;display:flex;flex-direction:row;}#showOnlyQR{margin-top:30px;}#titre{text-align:center;justify-content:center;}.param{padding:10px;padding-left:0px;margin-left:0px;padding-right:0px;margin-right:0px;}.conteneurInputColor{display:flex;flex-direction:row;justify-content:center;}::selection{color:#2a2a2a;background-color:white;}label[for=txt]{padding-left:22px;}#colors{display:flex;flex-direction:row;justify-content:space-between;text-align:center;}#colors .param{text-align:center;display:flex;justify-content:center;flex-direction:column;width:100%;}.metaText{color:#868686;text-align:left;transition:color 0.12s cubic-bezier(0.42,0.0,1.0,1.0);position:fixed;width:400px;}.metaText a:link{transition:color 0.12s cubic-bezier(0.42,0.0,1.0,1.0);color:#868686;text-decoration:underline;}.metaText:hover,.metaText:hover a:link{color:white;}footer{font-size:14px;bottom:20px;left:20px;}#info{font-size:16px;bottom:20px;right:20px;margin:0px;}#info h3{font-size:20px;font-weight:normal;padding-bottom:10px;}#redondancy,#margin,#txt,#size,input[type=color],input[type=submit],.bouton{border:2px #5f5f5f solid;border-radius:10px;font-size:20px;padding-left:10px;font-weight:normal;color:white;transition:border 0.1s linear;background-color:#31363b;margin-top:8px;}#redondancy:hover,#margin:hover,#txt:hover,#size:hover,input[type=color]:hover,input[type=submit]:hover,.bouton:hover{border:2px #808080 solid;}#redondancy:focus,#margin:focus,#txt:focus,#size:focus,input[type=color]:focus,input[type=submit]:focus,.bouton:focus{border:2px white solid;outline:none;}#redondancy,#size,#margin{background-color:#31363b;width:250px;height:40px;}#txt{background-color:#232629;color:white;padding:10px;margin:10px;width:500px;scrollbar-color:white #232629;scrollbar-width:auto;}input[type=submit]{font-size:28px;padding:10px;padding-left:14px;padding-right:14px;}#txt::placeholder{color:#868686;opacity:1;font-family:"Ubuntu", sans-serif;font-weight:normal;font-size:1em;}input[type=color]{height:60px;width:84px;padding:5px;border:2px #5f5f5f solid;}#helpImg{width:20px;height:20px;margin-bottom:-3px;margin-left:5px;}.boutonAide{height:0px;width:0px;color:#868686;cursor:help;font-size:0.8em;}.conteneurAide .contenuAide{position:absolute;transform:scale(0) rotate(-12deg);color:white;background:#151616;padding:15px;border-radius:10px;box-shadow:0 0 10px rgba(0,0,0,0.5);margin-top:23px;margin-left:-35px;transition:all .25s;opacity:0;max-width:500px;font-size:20px;text-align:left;}@media (max-width: 500px){.conteneurAide .contenuAide{position:fixed;margin:5px;left:0px;top:0px;}}.conteneurAide:hover .contenuAide,.conteneurAide:focus-within .contenuAide{transform:scale(1) rotate(0);opacity:1;}@media (max-width: 1400px){.metaText{width:250px;}}@media (max-width: 1050px){#metaTexts{display:flex;flex-direction:row;}.metaText{width:100%;position:static;font-size:20px;}#info{color:white;margin-bottom:20px;padding-top:30px;font-size:20px;}#info a:link{color:white;}}@media (max-width: 850px){#metaTexts{flex-direction:column;width:480px;justify-content:center;margin-left:auto;margin-right:auto;}.center{width:auto;}#firstWrapper{flex-direction:column;}body{margin:10px;}#txt{width:92%;}}@media (max-width: 500px){#metaTexts{width:auto;}#colors{flex-direction:column;}h1{font-size:28px;padding-top:6px;}#txt{width:85%;}#qrCode{max-width:94%;}}@media (max-width: 415px){h1{padding:0px;}}
\ No newline at end of file
+*{font-family:"Ubuntu", sans-serif;scrollbar-color:white #2a2a2a;scrollbar-width:auto;}a{color:white;text-decoration:underline;}a:hover{text-decoration:none;}p{margin:0px;}#firstWrapper{display:flex;flex-direction:row;}#menusDeroulants{text-align:center;margin-left:20px;}#qrCode{max-width:480px;}.centered{text-align:center;}.bouton{padding:3px 10px 3px 10px;text-decoration:none;}form{display:block;margin-bottom:30px;}main{display:flex;flex-direction:column;justify-content:center;margin-left:auto;margin-right:auto;width:814px;}body{margin:18px;background-color:#2a2a2a;color:white;font-weight:normal;font-size:20px;}body h1{color:white;text-decoration:none;}label{font-size:20px;}header{text-align:center;padding:0px;margin:0px;height:64px;}#logo{width:64px;height:64px;}#titres{margin-left:20px;}h1,h2,h3,h4,h5,h6{margin:0px;font-weight:normal;}h1{font-size:33px;}h2{font-size:22px;}#lienTitres{text-align:left;justify-content:center;text-decoration:none;display:flex;flex-direction:row;}#showOnlyQR{margin-top:30px;}#titre{text-align:center;justify-content:center;}.param{padding:10px;padding-left:0px;margin-left:0px;padding-right:0px;margin-right:0px;}.conteneurInputColor{display:flex;flex-direction:row;justify-content:center;}::selection{color:#2a2a2a;background-color:white;}label[for=txt]{padding-left:22px;}#colors{display:flex;flex-direction:row;justify-content:space-between;text-align:center;}#colors .param{text-align:center;display:flex;justify-content:center;flex-direction:column;width:100%;}.metaText{color:#868686;text-align:left;transition:color 0.12s cubic-bezier(0.42,0.0,1.0,1.0);position:fixed;width:400px;}.metaText a:link{transition:color 0.12s cubic-bezier(0.42,0.0,1.0,1.0);color:#868686;text-decoration:underline;}.metaText:hover,.metaText:hover a:link{color:white;}footer{font-size:14px;bottom:20px;left:20px;}#info{font-size:16px;bottom:20px;right:20px;margin:0px;}#info h3{font-size:20px;font-weight:normal;padding-bottom:10px;}#redondancy,#margin,#txt,#size,input[type=color],input[type=submit],.bouton{border:2px #5f5f5f solid;border-radius:10px;font-size:20px;padding-left:10px;font-weight:normal;color:white;transition:border 0.1s linear;background-color:#31363b;margin-top:8px;}#redondancy:hover,#margin:hover,#txt:hover,#size:hover,input[type=color]:hover,input[type=submit]:hover,.bouton:hover{border:2px #808080 solid;}#redondancy:focus,#margin:focus,#txt:focus,#size:focus,input[type=color]:focus,input[type=submit]:focus,.bouton:focus{border:2px white solid;outline:none;}#redondancy,#size,#margin{background-color:#31363b;width:250px;height:40px;}#txt{background-color:#232629;color:white;padding:10px;margin:10px;width:500px;scrollbar-color:white #232629;scrollbar-width:auto;}input[type=submit]{font-size:28px;padding:10px;padding-left:14px;padding-right:14px;}#txt::placeholder{color:#868686;opacity:1;font-family:"Ubuntu", sans-serif;font-weight:normal;font-size:1em;}input[type=color]{height:60px;width:84px;padding:5px;border:2px #5f5f5f solid;}#helpImg{width:20px;height:20px;margin-bottom:-3px;margin-left:5px;}.boutonAide{height:0px;width:0px;color:#868686;cursor:help;font-size:0.8em;}.conteneurAide .contenuAide{position:absolute;transform:scale(0) rotate(-12deg);color:white;background:#151616;padding:15px;border-radius:10px;box-shadow:0 0 10px rgba(0,0,0,0.5);margin-top:23px;margin-left:-35px;transition:all .25s;opacity:0;max-width:500px;font-size:20px;text-align:left;}@media (max-width: 500px){.conteneurAide .contenuAide{position:fixed;margin:5px;left:0px;top:0px;}}.conteneurAide:hover .contenuAide,.conteneurAide:focus-within .contenuAide{transform:scale(1) rotate(0);opacity:1;}@media (max-width: 1400px){.metaText{width:250px;}}@media (max-width: 1050px){#metaTexts{display:flex;flex-direction:row;}.metaText{width:100%;position:static;font-size:20px;}#info{color:white;margin-bottom:20px;padding-top:30px;font-size:20px;}#info a:link{color:white;}}@media (max-width: 850px){#metaTexts{flex-direction:column;width:480px;justify-content:center;margin-left:auto;margin-right:auto;}main{width:auto;}#firstWrapper{flex-direction:column;}body{margin:10px;}#txt{width:92%;}}@media (max-width: 500px){#metaTexts{width:auto;}#colors{flex-direction:column;}h1{font-size:28px;padding-top:6px;}#txt{width:85%;}#qrCode{max-width:94%;}}@media (max-width: 415px){h1{padding:0px;}}
\ No newline at end of file