<h2>File Contents: /home/planet5/public_html/wp-content/plugins/coming-soon/app/includes/seedprod_lessc.inc.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/coming-soon/app/includes/seedprod_lessc.inc.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
// phpcs:disable WordPress.Security.EscapeOutput -- Third-party LESS compiler library (lessphp v0.3.8).

/**
 * lessphp v0.3.8
 * http://leafo.net/lessphp
 *
 * LESS css compiler, adapted from http://seedprod_lesscss.org
 *
 * Copyright 2012, Leaf Corcoran &lt;leafot@gmail.com&gt;
 * 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 `seedprod_lessc_parser` into a syntax tree, then it is compiled into another tree
 * representing the CSS structure by `seedprod_lessc`. The CSS tree is fed into a
 * formatter, like `seedprod_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 `seedprod_lessc` is the entry point.
 *
 * In summary:
 *
 * The `seedprod_lessc` class creates an intstance 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 `seedprod_lessc_parser` class is only concerned with parsing its input.
 *
 * The `seedprod_lessc_formatter` takes a CSS tree, and dumps it to a formatted string,
 * handling things like indentation.
 */
class seedprod_lessc {
	public static $VERSION  = &#039;v0.3.8&#039;;
	protected static $TRUE  = array( &#039;keyword&#039;, &#039;true&#039; );
	protected static $FALSE = array( &#039;keyword&#039;, &#039;false&#039; );

	protected $libFunctions     = array();
	protected $registeredVars   = array();
	protected $preserveComments = false;

	public $vPrefix        = &#039;@&#039;; // prefix of abstract properties
	public $mPrefix        = &#039;$&#039;; // prefix of abstract blocks
	public $parentSelector = &#039;&amp;&#039;;

	public $importDisabled = false;
	public $importDir      = &#039;&#039;;

	protected $numberPrecision = null;

	// 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;

	public static $defaultValue = array( &#039;keyword&#039;, &#039;&#039; );

	protected static $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-&gt;importDir as $dir ) {
			$full = $dir . ( substr( $dir, -1 ) != &#039;/&#039; ? &#039;/&#039; : &#039;&#039; ) . $url;
			if ( $this-&gt;fileExists( $file = $full . &#039;.less&#039; ) || $this-&gt;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] ) &amp;&amp; isset( $items[0] ) ) {
			return $items[0];
		} else {
			return array( &#039;list&#039;, $delim, $items );
		}
	}

	public static function preg_quote( $what ) {
		return preg_quote( $what, &#039;/&#039; );
	}

	protected function tryImport( $importPath, $parentBlock, $out ) {
		if ( $importPath[0] == &#039;function&#039; &amp;&amp; $importPath[1] == &#039;url&#039; ) {
			$importPath = $this-&gt;flattenList( $importPath[2] );
		}

		$str = $this-&gt;coerceString( $importPath );
		if ( $str === null ) {
			return false;
		}

		$url = $this-&gt;compileValue( $this-&gt;lib_e( $str ) );

		// don&#039;t import if it ends in css.
		if ( substr_compare( $url, &#039;.css&#039;, -4, 4 ) === 0 ) {
			return false;
		}

		$realPath = $this-&gt;findImport( $url );
		if ( $realPath === null ) {
			return false;
		}

		if ( $this-&gt;importDisabled ) {
			return array( false, &#039;/* import disabled */&#039; );
		}

		$this-&gt;addParsedFile( $realPath );
		$parser = $this-&gt;makeParser( $realPath );
		$root   = $parser-&gt;parse( file_get_contents( $realPath ) );

		// set the parents of all the block props.
		foreach ( $root-&gt;props as $prop ) {
			if ( $prop[0] == &#039;block&#039; ) {
				$prop[1]-&gt;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-&gt;children as $childName =&gt; $child ) {
			if ( isset( $parentBlock-&gt;children[ $childName ] ) ) {
				$parentBlock-&gt;children[ $childName ] = array_merge(
					$parentBlock-&gt;children[ $childName ],
					$child
				);
			} else {
				$parentBlock-&gt;children[ $childName ] = $child;
			}
		}

		$pi  = pathinfo( $realPath );
		$dir = $pi[&#039;dirname&#039;];

		list($top, $bottom) = $this-&gt;sortProps( $root-&gt;props, true );
		$this-&gt;compileImportedProps( $top, $parentBlock, $out, $parser, $dir );

		return array( true, $bottom, $parser, $dir );
	}

	protected function compileImportedProps( $props, $block, $out, $sourceParser, $importDir ) {
		$oldSourceParser = $this-&gt;sourceParser;

		$oldImport = $this-&gt;importDir;

		// TODO: this is because the importDir api is stupid.
		$this-&gt;importDir = (array) $this-&gt;importDir;
		array_unshift( $this-&gt;importDir, $importDir );

		foreach ( $props as $prop ) {
			$this-&gt;compileProp( $prop, $block, $out );
		}

		$this-&gt;importDir    = $oldImport;
		$this-&gt;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&#039;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 seedprod_lessc::compileProp()
	 */
	protected function compileBlock( $block ) {
		switch ( $block-&gt;type ) {
			case &#039;root&#039;:
				$this-&gt;compileRoot( $block );
				break;
			case null:
				$this-&gt;compileCSSBlock( $block );
				break;
			case &#039;media&#039;:
				$this-&gt;compileMedia( $block );
				break;
			case &#039;directive&#039;:
				$name = &#039;@&#039; . $block-&gt;name;
				if ( ! empty( $block-&gt;value ) ) {
					$name .= &#039; &#039; . $this-&gt;compileValue( $this-&gt;reduce( $block-&gt;value ) );
				}

				$this-&gt;compileNestedBlock( $block, array( $name ) );
				break;
			default:
				$this-&gt;throwError( &quot;unknown block type: $block-&gt;type\n&quot; );
		}
	}

	protected function compileCSSBlock( $block ) {
		$env = $this-&gt;pushEnv();

		$selectors      = $this-&gt;compileSelectors( $block-&gt;tags );
		$env-&gt;selectors = $this-&gt;multiplySelectors( $selectors );
		$out            = $this-&gt;makeOutputBlock( null, $env-&gt;selectors );

		$this-&gt;scope-&gt;children[] = $out;
		$this-&gt;compileProps( $block, $out );

		$block-&gt;scope = $env; // mixins carry scope with them!
		$this-&gt;popEnv();
	}

	protected function compileMedia( $media ) {
		$env         = $this-&gt;pushEnv( $media );
		$parentScope = $this-&gt;mediaParent( $this-&gt;scope );

		$query = $this-&gt;compileMediaQuery( $this-&gt;multiplyMedia( $env ) );

		$this-&gt;scope             = $this-&gt;makeOutputBlock( $media-&gt;type, array( $query ) );
		$parentScope-&gt;children[] = $this-&gt;scope;

		$this-&gt;compileProps( $media, $this-&gt;scope );

		if ( count( $this-&gt;scope-&gt;lines ) &gt; 0 ) {
			$orphanSelelectors = $this-&gt;findClosestSelectors();
			if ( ! is_null( $orphanSelelectors ) ) {
				$orphan        = $this-&gt;makeOutputBlock( null, $orphanSelelectors );
				$orphan-&gt;lines = $this-&gt;scope-&gt;lines;
				array_unshift( $this-&gt;scope-&gt;children, $orphan );
				$this-&gt;scope-&gt;lines = array();
			}
		}

		$this-&gt;scope = $this-&gt;scope-&gt;parent;
		$this-&gt;popEnv();
	}

	protected function mediaParent( $scope ) {
		while ( ! empty( $scope-&gt;parent ) ) {
			if ( ! empty( $scope-&gt;type ) &amp;&amp; $scope-&gt;type != &#039;media&#039; ) {
				break;
			}
			$scope = $scope-&gt;parent;
		}

		return $scope;
	}

	protected function compileNestedBlock( $block, $selectors ) {
		$this-&gt;pushEnv( $block );
		$this-&gt;scope                     = $this-&gt;makeOutputBlock( $block-&gt;type, $selectors );
		$this-&gt;scope-&gt;parent-&gt;children[] = $this-&gt;scope;

		$this-&gt;compileProps( $block, $this-&gt;scope );

		$this-&gt;scope = $this-&gt;scope-&gt;parent;
		$this-&gt;popEnv();
	}

	protected function compileRoot( $root ) {
		$this-&gt;pushEnv();
		$this-&gt;scope = $this-&gt;makeOutputBlock( $root-&gt;type );
		$this-&gt;compileProps( $root, $this-&gt;scope );
		$this-&gt;popEnv();
	}

	protected function compileProps( $block, $out ) {
		foreach ( $this-&gt;sortProps( $block-&gt;props ) as $prop ) {
			$this-&gt;compileProp( $prop, $block, $out );
		}
	}

	protected function sortProps( $props, $split = false ) {
		$vars    = array();
		$imports = array();
		$other   = array();

		foreach ( $props as $prop ) {
			switch ( $prop[0] ) {
				case &#039;assign&#039;:
					if ( isset( $prop[1][0] ) &amp;&amp; $prop[1][0] == $this-&gt;vPrefix ) {
						$vars[] = $prop;
					} else {
						$other[] = $prop;
					}
					break;
				case &#039;import&#039;:
					$id        = self::$nextImportId++;
					$prop[]    = $id;
					$imports[] = $prop;
					$other[]   = array( &#039;import_mixin&#039;, $id );
					break;
				default:
					$other[] = $prop;
			}
		}

		if ( $split ) {
			return array( array_merge( $vars, $imports ), $other );
		} else {
			return array_merge( $vars, $imports, $other );
		}
	}

	protected function compileMediaQuery( $queries ) {
		$compiledQueries = array();
		foreach ( $queries as $query ) {
			$parts = array();
			foreach ( $query as $q ) {
				switch ( $q[0] ) {
					case &#039;mediaType&#039;:
						$parts[] = implode( &#039; &#039;, array_slice( $q, 1 ) );
						break;
					case &#039;mediaExp&#039;:
						if ( isset( $q[2] ) ) {
							$parts[] = &quot;($q[1]: &quot; .
							$this-&gt;compileValue( $this-&gt;reduce( $q[2] ) ) . &#039;)&#039;;
						} else {
							$parts[] = &quot;($q[1])&quot;;
						}
						break;
				}
			}

			if ( count( $parts ) &gt; 0 ) {
				$compiledQueries[] = implode( &#039; and &#039;, $parts );
			}
		}

		$out = &#039;@media&#039;;
		if ( ! empty( $parts ) ) {
			$out .= &#039; &#039; .
				implode( $this-&gt;formatter-&gt;selectorSeparator, $compiledQueries );
		}
		return $out;
	}

	protected function multiplyMedia( $env, $childQueries = null ) {
		if ( is_null( $env ) ||
			! empty( $env-&gt;block-&gt;type ) &amp;&amp; $env-&gt;block-&gt;type != &#039;media&#039; ) {
			return $childQueries;
		}

		// plain old block, skip.
		if ( empty( $env-&gt;block-&gt;type ) ) {
			return $this-&gt;multiplyMedia( $env-&gt;parent, $childQueries );
		}

		$out     = array();
		$queries = $env-&gt;block-&gt;queries;
		if ( is_null( $childQueries ) ) {
			$out = $queries;
		} else {
			foreach ( $queries as $parent ) {
				foreach ( $childQueries as $child ) {
					$out[] = array_merge( $parent, $child );
				}
			}
		}

		return $this-&gt;multiplyMedia( $env-&gt;parent, $out );
	}

	protected function expandParentSelectors( &amp;$tag, $replace ) {
		$parts = explode( &#039;$&amp;$&#039;, $tag );
		$count = 0;
		foreach ( $parts as &amp;$part ) {
			$part   = str_replace( $this-&gt;parentSelector, $replace, $part, $c );
			$count += $c;
		}
		$tag = implode( $this-&gt;parentSelector, $parts );
		return $count;
	}

	protected function findClosestSelectors() {
		$env       = $this-&gt;env;
		$selectors = null;
		while ( $env !== null ) {
			if ( isset( $env-&gt;selectors ) ) {
				$selectors = $env-&gt;selectors;
				break;
			}
			$env = $env-&gt;parent;
		}

		return $selectors;
	}


	// multiply $selectors against the nearest selectors in env.
	protected function multiplySelectors( $selectors ) {
		// find parent selectors.

		$parentSelectors = $this-&gt;findClosestSelectors();
		if ( is_null( $parentSelectors ) ) {
			// kill parent reference in top level selector.
			foreach ( $selectors as &amp;$s ) {
				$this-&gt;expandParentSelectors( $s, &#039;&#039; );
			}

			return $selectors;
		}

		$out = array();
		foreach ( $parentSelectors as $parent ) {
			foreach ( $selectors as $child ) {
				$count = $this-&gt;expandParentSelectors( $child, $parent );

				// don&#039;t prepend the parent tag if &amp; was used.
				if ( $count &gt; 0 ) {
					$out[] = trim( $child );
				} else {
					$out[] = trim( $parent . &#039; &#039; . $child );
				}
			}
		}

		return $out;
	}

	// reduces selector expressions.
	protected function compileSelectors( $selectors ) {
		$out = array();

		foreach ( $selectors as $s ) {
			if ( is_array( $s ) ) {
				list(, $value) = $s;
				$out[]         = $this-&gt;compileValue( $this-&gt;reduce( $value ) );
			} else {
				$out[] = $s;
			}
		}

		return $out;
	}

	protected function eq( $left, $right ) {
		return $left == $right;
	}

	protected function patternMatch( $block, $callingArgs ) {
		// match the guards if it has them.
		// any one of the groups must have all its guards pass for a match.
		if ( ! empty( $block-&gt;guards ) ) {
			$groupPassed = false;
			foreach ( $block-&gt;guards as $guardGroup ) {
				foreach ( $guardGroup as $guard ) {
					$this-&gt;pushEnv();
					$this-&gt;zipSetArgs( $block-&gt;args, $callingArgs );

					$negate = false;
					if ( $guard[0] == &#039;negate&#039; ) {
						$guard  = $guard[1];
						$negate = true;
					}

					$passed = $this-&gt;reduce( $guard ) == self::$TRUE;
					if ( $negate ) {
						$passed = ! $passed;
					}

					$this-&gt;popEnv();

					if ( $passed ) {
						$groupPassed = true;
					} else {
						$groupPassed = false;
						break;
					}
				}

				if ( $groupPassed ) {
					break;
				}
			}

			if ( ! $groupPassed ) {
				return false;
			}
		}

		$numCalling = count( $callingArgs );

		if ( empty( $block-&gt;args ) ) {
			return $block-&gt;isVararg || $numCalling == 0;
		}

		$i = -1; // no args
		// try to match by arity or by argument literal.
		foreach ( $block-&gt;args as $i =&gt; $arg ) {
			switch ( $arg[0] ) {
				case &#039;lit&#039;:
					if ( empty( $callingArgs[ $i ] ) || ! $this-&gt;eq( $arg[1], $callingArgs[ $i ] ) ) {
						return false;
					}
					break;
				case &#039;arg&#039;:
					// no arg and no default value.
					if ( ! isset( $callingArgs[ $i ] ) &amp;&amp; ! isset( $arg[2] ) ) {
						return false;
					}
					break;
				case &#039;rest&#039;:
					--$i; // rest can be empty
					break 2;
			}
		}

		if ( $block-&gt;isVararg ) {
			return true; // not having enough is handled above
		} else {
			$numMatched = $i + 1;
			// greater than becuase default values always match.
			return $numMatched &gt;= $numCalling;
		}
	}

	protected function patternMatchAll( $blocks, $callingArgs ) {
		$matches = null;
		foreach ( $blocks as $block ) {
			if ( $this-&gt;patternMatch( $block, $callingArgs ) ) {
				$matches[] = $block;
			}
		}

		return $matches;
	}

	// attempt to find blocks matched by path and args.
	protected function findBlocks( $searchIn, $path, $args, $seen = array() ) {
		if ( $searchIn == null ) {
			return null;
		}
		if ( isset( $seen[ $searchIn-&gt;id ] ) ) {
			return null;
		}
		$seen[ $searchIn-&gt;id ] = true;

		$name = $path[0];

		if ( isset( $searchIn-&gt;children[ $name ] ) ) {
			$blocks = $searchIn-&gt;children[ $name ];
			if ( count( $path ) == 1 ) {
				$matches = $this-&gt;patternMatchAll( $blocks, $args );
				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-&gt;findBlocks(
						$subBlock,
						array_slice( $path, 1 ),
						$args,
						$seen
					);

					if ( ! is_null( $subMatches ) ) {
						foreach ( $subMatches as $sm ) {
							$matches[] = $sm;
						}
					}
				}

				return count( $matches ) &gt; 0 ? $matches : null;
			}
		}

		if ( $searchIn-&gt;parent === $searchIn ) {
			return null;
		}
		return $this-&gt;findBlocks( $searchIn-&gt;parent, $path, $args, $seen );
	}

	// sets all argument names in $args to either the default value.
	// or the one passed in through $values.
	protected function zipSetArgs( $args, $values ) {
		$i              = 0;
		$assignedValues = array();
		foreach ( $args as $a ) {
			if ( $a[0] == &#039;arg&#039; ) {
				if ( $i &lt; count( $values ) &amp;&amp; ! is_null( $values[ $i ] ) ) {
					$value = $values[ $i ];
				} elseif ( isset( $a[2] ) ) {
					$value = $a[2];
				} else {
					$value = null;
				}

				$value = $this-&gt;reduce( $value );
				$this-&gt;set( $a[1], $value );
				$assignedValues[] = $value;
			}
			++$i;
		}

		// check for a rest.
		$last = end( $args );
		if ( is_array( $last ) &amp;&amp; $last[0] == &#039;rest&#039; ) {
			$rest = array_slice( $values, count( $args ) - 1 );
			$this-&gt;set( $last[1], $this-&gt;reduce( array( &#039;list&#039;, &#039; &#039;, $rest ) ) );
		}

		$this-&gt;env-&gt;arguments = $assignedValues;
	}

	// compile a prop and update $lines or $blocks appropriately.
	protected function compileProp( $prop, $block, $out ) {
		// set error position context.
		$this-&gt;sourceLoc = isset( $prop[-1] ) ? $prop[-1] : -1;

		switch ( $prop[0] ) {
			case &#039;assign&#039;:
				list(, $name, $value) = $prop;
				if ( $name[0] == $this-&gt;vPrefix ) {
					$this-&gt;set( $name, $value );
				} else {
					$out-&gt;lines[] = $this-&gt;formatter-&gt;property(
						$name,
						$this-&gt;compileValue( $this-&gt;reduce( $value ) )
					);
				}
				break;
			case &#039;block&#039;:
				list(, $child) = $prop;
				$this-&gt;compileBlock( $child );
				break;
			case &#039;mixin&#039;:
				list(, $path, $args, $suffix) = $prop;

				$args   = array_map( array( $this, &#039;reduce&#039; ), (array) $args );
				$mixins = $this-&gt;findBlocks( $block, $path, $args );

				if ( $mixins === null ) {
					// fwrite(STDERR,&quot;failed to find block: &quot;.implode(&quot; &gt; &quot;, $path).&quot;\n&quot;);
					break; // throw error here??
				}

				foreach ( $mixins as $mixin ) {
					$haveScope = false;
					if ( isset( $mixin-&gt;parent-&gt;scope ) ) {
						$haveScope                   = true;
						$mixinParentEnv              = $this-&gt;pushEnv();
						$mixinParentEnv-&gt;storeParent = $mixin-&gt;parent-&gt;scope;
					}

					$haveArgs = false;
					if ( isset( $mixin-&gt;args ) ) {
						$haveArgs = true;
						$this-&gt;pushEnv();
						$this-&gt;zipSetArgs( $mixin-&gt;args, $args );
					}

					$oldParent = $mixin-&gt;parent;
					if ( $mixin != $block ) {
						$mixin-&gt;parent = $block;
					}

					foreach ( $this-&gt;sortProps( $mixin-&gt;props ) as $subProp ) {
						if ( $suffix !== null &amp;&amp;
						$subProp[0] == &#039;assign&#039; &amp;&amp;
						is_string( $subProp[1] ) &amp;&amp;
						$subProp[1][0] != $this-&gt;vPrefix ) {
							$subProp[2] = array(
								&#039;list&#039;,
								&#039; &#039;,
								array( $subProp[2], array( &#039;keyword&#039;, $suffix ) ),
							);
						}

						$this-&gt;compileProp( $subProp, $mixin, $out );
					}

					$mixin-&gt;parent = $oldParent;

					if ( $haveArgs ) {
						$this-&gt;popEnv();
					}
					if ( $haveScope ) {
						$this-&gt;popEnv();
					}
				}

				break;
			case &#039;raw&#039;:
				$out-&gt;lines[] = $prop[1];
				break;
			case &#039;directive&#039;:
				list(, $name, $value) = $prop;
				$out-&gt;lines[]         = &quot;@$name &quot; . $this-&gt;compileValue( $this-&gt;reduce( $value ) ) . &#039;;&#039;;
				break;
			case &#039;comment&#039;:
				$out-&gt;lines[] = $prop[1];
				break;
			case &#039;import&#039;;
				list(, $importPath, $importId) = $prop;
				$importPath                    = $this-&gt;reduce( $importPath );

				if ( ! isset( $this-&gt;env-&gt;imports ) ) {
					$this-&gt;env-&gt;imports = array();
				}

				$result = $this-&gt;tryImport( $importPath, $block, $out );

				$this-&gt;env-&gt;imports[ $importId ] = $result === false ?
				array( false, &#039;@import &#039; . $this-&gt;compileValue( $importPath ) . &#039;;&#039; ) :
				$result;

			break;
			case &#039;import_mixin&#039;:
				list(, $importId) = $prop;
				$import           = $this-&gt;env-&gt;imports[ $importId ];
				if ( $import[0] === false ) {
					$out-&gt;lines[] = $import[1];
				} else {
					list(, $bottom, $parser, $importDir) = $import;
					$this-&gt;compileImportedProps( $bottom, $block, $out, $parser, $importDir );
				}

				break;
			default:
				$this-&gt;throwError( &quot;unknown op: {$prop[0]}\n&quot; );
		}
	}


	/**
	 * 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.
	 */
	protected function compileValue( $value ) {
		switch ( $value[0] ) {
			case &#039;list&#039;:
				// [1] - delimiter.
				// [2] - array of values.
				return implode( $value[1], array_map( array( $this, &#039;compileValue&#039; ), $value[2] ) );
			case &#039;raw_color&#039;:
				if ( ! empty( $this-&gt;formatter-&gt;compressColors ) ) {
					return $this-&gt;compileValue( $this-&gt;coerceColor( $value ) );
				}
				return $value[1];
			case &#039;keyword&#039;:
				// [1] - the keyword.
				return $value[1];
			case &#039;number&#039;:
				list(, $num, $unit) = $value;
				// [1] - the number.
				// [2] - the unit.
				if ( $this-&gt;numberPrecision !== null ) {
					$num = round( $num, $this-&gt;numberPrecision );
				}
				return $num . $unit;
			case &#039;string&#039;:
				// [1] - contents of string (includes quotes)
				list(, $delim, $content) = $value;
				foreach ( $content as &amp;$part ) {
					if ( is_array( $part ) ) {
						$part = $this-&gt;compileValue( $part );
					}
				}
				return $delim . implode( $content ) . $delim;
			case &#039;color&#039;:
				// [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 &amp;&amp; $value[4] != 1 ) { // rgba
					return &#039;rgba(&#039; . $r . &#039;,&#039; . $g . &#039;,&#039; . $b . &#039;,&#039; . $value[4] . &#039;)&#039;;
				}

				$h = sprintf( &#039;#%02x%02x%02x&#039;, $r, $g, $b );

				if ( ! empty( $this-&gt;formatter-&gt;compressColors ) ) {
					// Converting hex color to short notation (e.g. #003399 to #039)
					if ( $h[1] === $h[2] &amp;&amp; $h[3] === $h[4] &amp;&amp; $h[5] === $h[6] ) {
						$h = &#039;#&#039; . $h[1] . $h[3] . $h[5];
					}
				}

				return $h;

			case &#039;function&#039;:
				list(, $name, $args) = $value;
				return $name . &#039;(&#039; . $this-&gt;compileValue( $args ) . &#039;)&#039;;
			default: // assumed to be unit
				$this-&gt;throwError( &quot;unknown value type: $value[0]&quot; );
		}
	}

	protected function lib_isnumber( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;number&#039; );
	}

	protected function lib_isstring( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;string&#039; );
	}

	protected function lib_iscolor( $value ) {
		return $this-&gt;toBool( $this-&gt;coerceColor( $value ) );
	}

	protected function lib_iskeyword( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;keyword&#039; );
	}

	protected function lib_ispixel( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;number&#039; &amp;&amp; $value[2] == &#039;px&#039; );
	}

	protected function lib_ispercentage( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;number&#039; &amp;&amp; $value[2] == &#039;%&#039; );
	}

	protected function lib_isem( $value ) {
		return $this-&gt;toBool( $value[0] == &#039;number&#039; &amp;&amp; $value[2] == &#039;em&#039; );
	}

	protected function lib_rgbahex( $color ) {
		$color = $this-&gt;coerceColor( $color );
		if ( is_null( $color ) ) {
			$this-&gt;throwError( &#039;color expected for rgbahex&#039; );
		}

		return sprintf(
			&#039;#%02x%02x%02x%02x&#039;,
			isset( $color[4] ) ? $color[4] * 255 : 255,
			$color[1],
			$color[2],
			$color[3]
		);
	}

	protected function lib_argb( $color ) {
		return $this-&gt;lib_rgbahex( $color );
	}

	// utility func to unquote a string.
	protected function lib_e( $arg ) {
		switch ( $arg[0] ) {
			case &#039;list&#039;:
				$items = $arg[2];
				if ( isset( $items[0] ) ) {
					return $this-&gt;lib_e( $items[0] );
				}
				return self::$defaultValue;
			case &#039;string&#039;:
				$arg[1] = &#039;&#039;;
				return $arg;
			case &#039;keyword&#039;:
				return $arg;
			default:
				return array( &#039;keyword&#039;, $this-&gt;compileValue( $arg ) );
		}
	}

	protected function lib__sprintf( $args ) {
		if ( $args[0] != &#039;list&#039; ) {
			return $args;
		}
		$values   = $args[2];
		$string   = array_shift( $values );
		$template = $this-&gt;compileValue( $this-&gt;lib_e( $string ) );

		$i = 0;
		if ( preg_match_all( &#039;/%[dsa]/&#039;, $template, $m ) ) {
			foreach ( $m[0] as $match ) {
				$val = isset( $values[ $i ] ) ?
					$this-&gt;reduce( $values[ $i ] ) : array( &#039;keyword&#039;, &#039;&#039; );

				// lessjs compat, renders fully expanded color, not raw color.
				if ( $color = $this-&gt;coerceColor( $val ) ) {
					$val = $color;
				}

				++$i;
				$rep      = $this-&gt;compileValue( $this-&gt;lib_e( $val ) );
				$template = preg_replace(
					&#039;/&#039; . self::preg_quote( $match ) . &#039;/&#039;,
					$rep,
					$template,
					1
				);
			}
		}

		$d = $string[0] == &#039;string&#039; ? $string[1] : &#039;&quot;&#039;;
		return array( &#039;string&#039;, $d, array( $template ) );
	}

	protected function lib_floor( $arg ) {
		$value = $this-&gt;assertNumber( $arg );
		return array( &#039;number&#039;, floor( $value ), $arg[2] );
	}

	protected function lib_ceil( $arg ) {
		$value = $this-&gt;assertNumber( $arg );
		return array( &#039;number&#039;, ceil( $value ), $arg[2] );
	}

	protected function lib_round( $arg ) {
		$value = $this-&gt;assertNumber( $arg );
		return array( &#039;number&#039;, round( $value ), $arg[2] );
	}

	/**
	 * Helper function to get arguments for color manipulation functions.
	 * takes a list that contains a color like thing and a percentage
	 */
	protected function colorArgs( $args ) {
		if ( $args[0] != &#039;list&#039; || count( $args[2] ) &lt; 2 ) {
			return array( array( &#039;color&#039;, 0, 0, 0 ), 0 );
		}
		list($color, $delta) = $args[2];
		$color               = $this-&gt;assertColor( $color );
		$delta               = floatval( $delta[1] );

		return array( $color, $delta );
	}

	protected function lib_darken( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );

		$hsl    = $this-&gt;toHSL( $color );
		$hsl[3] = $this-&gt;clamp( $hsl[3] - $delta, 100 );
		return $this-&gt;toRGB( $hsl );
	}

	protected function lib_lighten( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );

		$hsl    = $this-&gt;toHSL( $color );
		$hsl[3] = $this-&gt;clamp( $hsl[3] + $delta, 100 );
		return $this-&gt;toRGB( $hsl );
	}

	protected function lib_saturate( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );

		$hsl    = $this-&gt;toHSL( $color );
		$hsl[2] = $this-&gt;clamp( $hsl[2] + $delta, 100 );
		return $this-&gt;toRGB( $hsl );
	}

	protected function lib_desaturate( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );

		$hsl    = $this-&gt;toHSL( $color );
		$hsl[2] = $this-&gt;clamp( $hsl[2] - $delta, 100 );
		return $this-&gt;toRGB( $hsl );
	}

	protected function lib_spin( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );

		$hsl = $this-&gt;toHSL( $color );

		$hsl[1] = $hsl[1] + $delta % 360;
		if ( $hsl[1] &lt; 0 ) {
			$hsl[1] += 360;
		}

		return $this-&gt;toRGB( $hsl );
	}

	protected function lib_fadeout( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );
		$color[4]            = $this-&gt;clamp( ( isset( $color[4] ) ? $color[4] : 1 ) - $delta / 100 );
		return $color;
	}

	protected function lib_fadein( $args ) {
		list($color, $delta) = $this-&gt;colorArgs( $args );
		$color[4]            = $this-&gt;clamp( ( isset( $color[4] ) ? $color[4] : 1 ) + $delta / 100 );
		return $color;
	}

	protected function lib_hue( $color ) {
		$hsl = $this-&gt;toHSL( $this-&gt;assertColor( $color ) );
		return round( $hsl[1] );
	}

	protected function lib_saturation( $color ) {
		$hsl = $this-&gt;toHSL( $this-&gt;assertColor( $color ) );
		return round( $hsl[2] );
	}

	protected function lib_lightness( $color ) {
		$hsl = $this-&gt;toHSL( $this-&gt;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-&gt;coerceColor( $value ) ) ) {
			return isset( $color[4] ) ? $color[4] : 1;
		}
	}

	// set the alpha of the color.
	protected function lib_fade( $args ) {
		list($color, $alpha) = $this-&gt;colorArgs( $args );
		$color[4]            = $this-&gt;clamp( $alpha / 100.0 );
		return $color;
	}

	protected function lib_percentage( $arg ) {
		$num = $this-&gt;assertNumber( $arg );
		return array( &#039;number&#039;, $num * 100, &#039;%&#039; );
	}

	// mixes two colors by weight.
	// mix(@color1, @color2, @weight);
	// http://sass-lang.com/docs/yardoc/Sass/Script/Functions.html#mix-instance_method
	protected function lib_mix( $args ) {
		if ( $args[0] != &#039;list&#039; || count( $args[2] ) &lt; 3 ) {
			$this-&gt;throwError( &#039;mix expects (color1, color2, weight)&#039; );
		}

		list($first, $second, $weight) = $args[2];
		$first                         = $this-&gt;assertColor( $first );
		$second                        = $this-&gt;assertColor( $second );

		$first_a  = $this-&gt;lib_alpha( $first );
		$second_a = $this-&gt;lib_alpha( $second );
		$weight   = $weight[1] / 100.0;

		$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(
			&#039;color&#039;,
			$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-&gt;fixColor( $new );
	}

	protected function assertColor( $value, $error = &#039;expected color value&#039; ) {
		$color = $this-&gt;coerceColor( $value );
		if ( is_null( $color ) ) {
			$this-&gt;throwError( $error );
		}
		return $color;
	}

	protected function assertNumber( $value, $error = &#039;expecting number&#039; ) {
		if ( $value[0] == &#039;number&#039; ) {
			return $value[1];
		}
		$this-&gt;throwError( $error );
	}

	protected function toHSL( $color ) {
		if ( $color[0] == &#039;hsl&#039; ) {
			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 &lt; 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(
			&#039;hsl&#039;,
			( $H &lt; 0 ? $H + 6 : $H ) * 60,
			$S * 100,
			$L * 100,
		);

		if ( count( $color ) &gt; 4 ) {
			$out[] = $color[4]; // copy alpha
		}
		return $out;
	}

	protected function toRGB_helper( $comp, $temp1, $temp2 ) {
		if ( $comp &lt; 0 ) {
			$comp += 1.0;
		} elseif ( $comp &gt; 1 ) {
			$comp -= 1.0;
		}

		if ( 6 * $comp &lt; 1 ) {
			return $temp1 + ( $temp2 - $temp1 ) * 6 * $comp;
		}
		if ( 2 * $comp &lt; 1 ) {
			return $temp2;
		}
		if ( 3 * $comp &lt; 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 == &#039;color&#039; ) {
			return $color;
		}

		$H = $color[1] / 360;
		$S = $color[2] / 100;
		$L = $color[3] / 100;

		if ( $S == 0 ) {
			$r = $g = $b = $L;
		} else {
			$temp2 = $L &lt; 0.5 ?
				$L * ( 1.0 + $S ) :
				$L + $S - $L * $S;

			$temp1 = 2.0 * $L - $temp2;

			$r = $this-&gt;toRGB_helper( $H + 1 / 3, $temp1, $temp2 );
			$g = $this-&gt;toRGB_helper( $H, $temp1, $temp2 );
			$b = $this-&gt;toRGB_helper( $H - 1 / 3, $temp1, $temp2 );
		}

		// $out = array(&#039;color&#039;, round($r*255), round($g*255), round($b*255));
		$out = array( &#039;color&#039;, $r * 255, $g * 255, $b * 255 );
		if ( count( $color ) &gt; 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] != &#039;list&#039; ) {
			return false; // need a list of arguments
		}
		$rawComponents = $func[2][2];

		if ( $fname == &#039;hsl&#039; || $fname == &#039;hsla&#039; ) {
			$hsl = array( &#039;hsl&#039; );
			$i   = 0;
			foreach ( $rawComponents as $c ) {
				$val = $this-&gt;reduce( $c );
				$val = isset( $val[1] ) ? floatval( $val[1] ) : 0;

				if ( $i == 0 ) {
					$clamp = 360;
				} elseif ( $i &lt; 3 ) {
					$clamp = 100;
				} else {
					$clamp = 1;
				}

				$hsl[] = $this-&gt;clamp( $val, $clamp );
				++$i;
			}

			while ( count( $hsl ) &lt; 4 ) {
				$hsl[] = 0;
			}
			return $this-&gt;toRGB( $hsl );

		} elseif ( $fname == &#039;rgb&#039; || $fname == &#039;rgba&#039; ) {
			$components = array();
			$i          = 1;
			foreach ( $rawComponents as $c ) {
				$c = $this-&gt;reduce( $c );
				if ( $i &lt; 4 ) {
					if ( $c[0] == &#039;number&#039; &amp;&amp; $c[2] == &#039;%&#039; ) {
						$components[] = 255 * ( $c[1] / 100 );
					} else {
						$components[] = floatval( $c[1] );
					}
				} elseif ( $i == 4 ) {
					if ( $c[0] == &#039;number&#039; &amp;&amp; $c[2] == &#039;%&#039; ) {
						$components[] = 1.0 * ( $c[1] / 100 );
					} else {
						$components[] = floatval( $c[1] );
					}
				} else {
					break;
				}

				++$i;
			}
			while ( count( $components ) &lt; 3 ) {
				$components[] = 0;
			}
			array_unshift( $components, &#039;color&#039; );
			return $this-&gt;fixColor( $components );
		}

		return false;
	}

	protected function reduce( $value, $forExpression = false ) {
		switch ( $value[0] ) {
			case &#039;variable&#039;:
				$key = $value[1];
				if ( is_array( $key ) ) {
					$key = $this-&gt;reduce( $key );
					$key = $this-&gt;vPrefix . $this-&gt;compileValue( $this-&gt;lib_e( $key ) );
				}

				$seen =&amp; $this-&gt;env-&gt;seenNames;

				if ( ! empty( $seen[ $key ] ) ) {
					$this-&gt;throwError( &quot;infinite loop detected: $key&quot; );
				}

				$seen[ $key ] = true;
				$out          = $this-&gt;reduce( $this-&gt;get( $key, self::$defaultValue ) );
				$seen[ $key ] = false;
				return $out;
			case &#039;list&#039;:
				foreach ( $value[2] as &amp;$item ) {
					$item = $this-&gt;reduce( $item, $forExpression );
				}
				return $value;
			case &#039;expression&#039;:
				return $this-&gt;evaluate( $value );
			case &#039;string&#039;:
				foreach ( $value[2] as &amp;$part ) {
					if ( is_array( $part ) ) {
						$strip = $part[0] == &#039;variable&#039;;
						$part  = $this-&gt;reduce( $part );
						if ( $strip ) {
							$part = $this-&gt;lib_e( $part );
						}
					}
				}
				return $value;
			case &#039;escape&#039;:
				list(, $inner) = $value;
				return $this-&gt;lib_e( $this-&gt;reduce( $inner ) );
			case &#039;function&#039;:
				$color = $this-&gt;funcToColor( $value );
				if ( $color ) {
					return $color;
				}

				list(, $name, $args) = $value;
				if ( $name == &#039;%&#039; ) {
					$name = &#039;_sprintf&#039;;
				}
				$f = isset( $this-&gt;libFunctions[ $name ] ) ?
				$this-&gt;libFunctions[ $name ] : array( $this, &#039;lib_&#039; . $name );

				if ( is_callable( $f ) ) {
					if ( $args[0] == &#039;list&#039; ) {
						$args = self::compressList( $args[2], $args[1] );
					}

					$ret = call_user_func( $f, $this-&gt;reduce( $args, true ), $this );

					if ( is_null( $ret ) ) {
						return array(
							&#039;string&#039;,
							&#039;&#039;,
							array(
								$name,
								&#039;(&#039;,
								$args,
								&#039;)&#039;,
							),
						);
					}

					// convert to a typed value if the result is a php primitive.
					if ( is_numeric( $ret ) ) {
						$ret = array( &#039;number&#039;, $ret, &#039;&#039; );
					} elseif ( ! is_array( $ret ) ) {
						$ret = array( &#039;keyword&#039;, $ret );
					}

					return $ret;
				}

				// plain function, reduce args.
				$value[2] = $this-&gt;reduce( $value[2] );
				return $value;
			case &#039;unary&#039;:
				list(, $op, $exp) = $value;
				$exp              = $this-&gt;reduce( $exp );

				if ( $exp[0] == &#039;number&#039; ) {
					switch ( $op ) {
						case &#039;+&#039;:
							return $exp;
						case &#039;-&#039;:
							$exp[1] *= -1;
							return $exp;
					}
				}
				return array( &#039;string&#039;, &#039;&#039;, array( $op, $exp ) );
		}

		if ( $forExpression ) {
			switch ( $value[0] ) {
				case &#039;keyword&#039;:
					if ( $color = $this-&gt;coerceColor( $value ) ) {
						return $color;
					}
					break;
				case &#039;raw_color&#039;:
					return $this-&gt;coerceColor( $value );
			}
		}

		return $value;
	}


	// coerce a value for use in color operation.
	protected function coerceColor( $value ) {
		switch ( $value[0] ) {
			case &#039;color&#039;:
				return $value;
			case &#039;raw_color&#039;:
				$c        = array( &#039;color&#039;, 0, 0, 0 );
				$colorStr = substr( $value[1], 1 );
				$num      = hexdec( $colorStr );
				$width    = strlen( $colorStr ) == 3 ? 16 : 256;

				for ( $i = 3; $i &gt; 0; $i-- ) { // 3 2 1
					$t    = $num % $width;
					$num /= $width;

					$c[ $i ] = $t * ( 256 / $width ) + $t * floor( 16 / $width );
				}

				return $c;
			case &#039;keyword&#039;:
				$name = $value[1];
				if ( isset( self::$cssColors[ $name ] ) ) {
					list($r, $g, $b) = explode( &#039;,&#039;, self::$cssColors[ $name ] );
					return array( &#039;color&#039;, $r, $g, $b );
				}
				return null;
		}
	}

	// make something string like into a string.
	protected function coerceString( $value ) {
		switch ( $value[0] ) {
			case &#039;string&#039;:
				return $value;
			case &#039;keyword&#039;:
				return array( &#039;string&#039;, &#039;&#039;, array( $value[1] ) );
		}
		return null;
	}

	// turn list of length 1 into value type.
	protected function flattenList( $value ) {
		if ( $value[0] == &#039;list&#039; &amp;&amp; count( $value[2] ) == 1 ) {
			return $this-&gt;flattenList( $value[2][0] );
		}
		return $value;
	}

	protected 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-&gt;reduce( $left, true );
		$right = $this-&gt;reduce( $right, true );

		if ( $leftColor = $this-&gt;coerceColor( $left ) ) {
			$left = $leftColor;
		}

		if ( $rightColor = $this-&gt;coerceColor( $right ) ) {
			$right = $rightColor;
		}

		$ltype = $left[0];
		$rtype = $right[0];

		// operators that work on all types.
		if ( $op == &#039;and&#039; ) {
			return $this-&gt;toBool( $left == self::$TRUE &amp;&amp; $right == self::$TRUE );
		}

		if ( $op == &#039;=&#039; ) {
			return $this-&gt;toBool( $this-&gt;eq( $left, $right ) );
		}

		if ( $op == &#039;+&#039; &amp;&amp; ! is_null( $str = $this-&gt;stringConcatenate( $left, $right ) ) ) {
			return $str;
		}

		// type based operators.
		$fname = &quot;op_${ltype}_${rtype}&quot;;
		if ( is_callable( array( $this, $fname ) ) ) {
			$out = $this-&gt;$fname( $op, $left, $right );
			if ( ! is_null( $out ) ) {
				return $out;
			}
		}

		// make the expression look it did before being parsed.
		$paddedOp = $op;
		if ( $whiteBefore ) {
			$paddedOp = &#039; &#039; . $paddedOp;
		}
		if ( $whiteAfter ) {
			$paddedOp .= &#039; &#039;;
		}

		return array( &#039;string&#039;, &#039;&#039;, array( $left, $paddedOp, $right ) );
	}

	protected function stringConcatenate( $left, $right ) {
		if ( $strLeft = $this-&gt;coerceString( $left ) ) {
			if ( $right[0] == &#039;string&#039; ) {
				$right[1] = &#039;&#039;;
			}
			$strLeft[2][] = $right;
			return $strLeft;
		}

		if ( $strRight = $this-&gt;coerceString( $right ) ) {
			array_unshift( $strRight[2], $left );
			return $strRight;
		}
	}


	// make sure a color&#039;s components don&#039;t go out of bounds.
	protected function fixColor( $c ) {
		foreach ( range( 1, 3 ) as $i ) {
			if ( $c[ $i ] &lt; 0 ) {
				$c[ $i ] = 0;
			}
			if ( $c[ $i ] &gt; 255 ) {
				$c[ $i ] = 255;
			}
		}

		return $c;
	}

	protected function op_number_color( $op, $lft, $rgt ) {
		if ( $op == &#039;+&#039; || $op == &#039;*&#039; ) {
			return $this-&gt;op_color_number( $op, $rgt, $lft );
		}
	}

	protected function op_color_number( $op, $lft, $rgt ) {
		if ( $rgt[0] == &#039;%&#039; ) {
			$rgt[1] /= 100;
		}

		return $this-&gt;op_color_color(
			$op,
			$lft,
			array_fill( 1, count( $lft ) - 1, $rgt[1] )
		);
	}

	protected function op_color_color( $op, $left, $right ) {
		$out = array( &#039;color&#039; );
		$max = count( $left ) &gt; 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 &#039;+&#039;:
					$out[] = $lval + $rval;
					break;
				case &#039;-&#039;:
					$out[] = $lval - $rval;
					break;
				case &#039;*&#039;:
					$out[] = $lval * $rval;
					break;
				case &#039;%&#039;:
					$out[] = $lval % $rval;
					break;
				case &#039;/&#039;:
					if ( $rval == 0 ) {
						$this-&gt;throwError( &quot;evaluate error: can&#039;t divide by zero&quot; );
					}
					$out[] = $lval / $rval;
					break;
				default:
					$this-&gt;throwError( &#039;evaluate error: color op number failed on op &#039; . $op );
			}
		}
		return $this-&gt;fixColor( $out );
	}

	// 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 &#039;+&#039;:
				$value = $left[1] + $right[1];
				break;
			case &#039;*&#039;:
				$value = $left[1] * $right[1];
				break;
			case &#039;-&#039;:
				$value = $left[1] - $right[1];
				break;
			case &#039;%&#039;:
				$value = $left[1] % $right[1];
				break;
			case &#039;/&#039;:
				if ( $right[1] == 0 ) {
					$this-&gt;throwError( &#039;parse error: divide by zero&#039; );
				}
				$value = $left[1] / $right[1];
				break;
			case &#039;&lt;&#039;:
				return $this-&gt;toBool( $left[1] &lt; $right[1] );
			case &#039;&gt;&#039;:
				return $this-&gt;toBool( $left[1] &gt; $right[1] );
			case &#039;&gt;=&#039;:
				return $this-&gt;toBool( $left[1] &gt;= $right[1] );
			case &#039;=&lt;&#039;:
				return $this-&gt;toBool( $left[1] &lt;= $right[1] );
			default:
				$this-&gt;throwError( &#039;parse error: unknown number operator: &#039; . $op );
		}

		return array( &#039;number&#039;, $value, $unit );
	}


	/* environment functions */

	protected function makeOutputBlock( $type, $selectors = null ) {
		$b            = new stdclass();
		$b-&gt;lines     = array();
		$b-&gt;children  = array();
		$b-&gt;selectors = $selectors;
		$b-&gt;type      = $type;
		$b-&gt;parent    = $this-&gt;scope;
		return $b;
	}

	// the state of execution.
	protected function pushEnv( $block = null ) {
		$e         = new stdclass();
		$e-&gt;parent = $this-&gt;env;
		$e-&gt;store  = array();
		$e-&gt;block  = $block;

		$this-&gt;env = $e;
		return $e;
	}

	// pop something off the stack.
	protected function popEnv() {
		$old       = $this-&gt;env;
		$this-&gt;env = $this-&gt;env-&gt;parent;
		return $old;
	}

	// set something in the current env.
	protected function set( $name, $value ) {
		$this-&gt;env-&gt;store[ $name ] = $value;
	}


	// get the highest occurrence entry for a name.
	protected function get( $name, $default = null ) {
		$current = $this-&gt;env;

		$isArguments = $name == $this-&gt;vPrefix . &#039;arguments&#039;;
		while ( $current ) {
			if ( $isArguments &amp;&amp; isset( $current-&gt;arguments ) ) {
				return array( &#039;list&#039;, &#039; &#039;, $current-&gt;arguments );
			}

			if ( isset( $current-&gt;store[ $name ] ) ) {
				return $current-&gt;store[ $name ];
			} else {
				$current = isset( $current-&gt;storeParent ) ?
					$current-&gt;storeParent : $current-&gt;parent;
			}
		}

		return $default;
	}

	// inject array of unparsed strings into environment as variables.
	protected function injectVariables( $args ) {
		$this-&gt;pushEnv();
		$parser = new seedprod_lessc_parser( $this, __METHOD__ );
		foreach ( $args as $name =&gt; $strValue ) {
			if ( $name[0] != &#039;@&#039; ) {
				$name = &#039;@&#039; . $name;
			}
			$parser-&gt;count  = 0;
			$parser-&gt;buffer = (string) $strValue;
			if ( ! $parser-&gt;propertyValue( $value ) ) {
				throw new Exception( &quot;failed to parse passed in variable $name: $strValue&quot; );
			}

			$this-&gt;set( $name, $value );
		}
	}

	/**
	 * Initialize any static state, can initialize parser for a file
	 * $opts isn&#039;t used yet
	 */
	public function __construct( $fname = null ) {
		if ( $fname !== null ) {
			// used for deprecated parse method.
			$this-&gt;_parseFile = $fname;
		}
	}

	public function compile( $string, $name = null ) {
		$locale = setlocale( LC_NUMERIC, 0 );
		setlocale( LC_NUMERIC, &#039;C&#039; );

		$this-&gt;parser = $this-&gt;makeParser( $name );
		$root         = $this-&gt;parser-&gt;parse( $string );

		$this-&gt;env   = null;
		$this-&gt;scope = null;

		$this-&gt;formatter = $this-&gt;newFormatter();

		if ( ! empty( $this-&gt;registeredVars ) ) {
			$this-&gt;injectVariables( $this-&gt;registeredVars );
		}

		$this-&gt;sourceParser = $this-&gt;parser; // used for error messages
		$this-&gt;compileBlock( $root );

		ob_start();
		$this-&gt;formatter-&gt;block( $this-&gt;scope );
		$out = ob_get_clean();
		setlocale( LC_NUMERIC, $locale );
		return $out;
	}

	public function compileFile( $fname, $outFname = null ) {
		if ( ! is_readable( $fname ) ) {
			throw new Exception( &#039;load error: failed to find &#039; . $fname );
		}

		$pi = pathinfo( $fname );

		$oldImport = $this-&gt;importDir;

		$this-&gt;importDir   = (array) $this-&gt;importDir;
		$this-&gt;importDir[] = $pi[&#039;dirname&#039;] . &#039;/&#039;;

		$this-&gt;allParsedFiles = array();
		$this-&gt;addParsedFile( $fname );

		$out = $this-&gt;compile( file_get_contents( $fname ), $fname );

		$this-&gt;importDir = $oldImport;

		if ( $outFname !== null ) {
			return file_put_contents( $outFname, $out );
		}

		return $out;
	}

	// compile only if changed input has changed or output doesn&#039;t exist.
	public function checkedCompile( $in, $out ) {
		if ( ! is_file( $out ) || filemtime( $in ) &gt; filemtime( $out ) ) {
			$this-&gt;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&#039; 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[&#039;root&#039;] ) ) {
			if ( $force or ! isset( $in[&#039;files&#039;] ) ) {
				// 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[&#039;root&#039;];
			} elseif ( isset( $in[&#039;files&#039;] ) and is_array( $in[&#039;files&#039;] ) ) {
				foreach ( $in[&#039;files&#039;] as $fname =&gt; $ftime ) {
					if ( ! file_exists( $fname ) or filemtime( $fname ) &gt; $ftime ) {
						// One of the files we knew about previously has changed.
						// so we should look at our incoming root again.
						$root = $in[&#039;root&#039;];
						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[&#039;root&#039;]     = $root;
			$out[&#039;compiled&#039;] = $this-&gt;compileFile( $root );
			$out[&#039;files&#039;]    = $this-&gt;allParsedFiles();
			$out[&#039;updated&#039;]  = 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-&gt;registeredVars;
		if ( $initialVariables !== null ) {
			$this-&gt;setVariables( $initialVariables );
		}

		if ( $str == null ) {
			if ( empty( $this-&gt;_parseFile ) ) {
				throw new exception( &#039;nothing to parse&#039; );
			}

			$out = $this-&gt;compileFile( $this-&gt;_parseFile );
		} else {
			$out = $this-&gt;compile( $str );
		}

		$this-&gt;registeredVars = $oldVars;
		return $out;
	}

	protected function makeParser( $name ) {
		$parser                = new seedprod_lessc_parser( $this, $name );
		$parser-&gt;writeComments = $this-&gt;preserveComments;

		return $parser;
	}

	public function setFormatter( $name ) {
		$this-&gt;formatterName = $name;
	}

	protected function newFormatter() {
		$className = &#039;seedprod_lessc_formatter_lessjs&#039;;
		if ( ! empty( $this-&gt;formatterName ) ) {
			if ( ! is_string( $this-&gt;formatterName ) ) {
				return $this-&gt;formatterName;
			}
			$className = &quot;seedprod_lessc_formatter_$this-&gt;formatterName&quot;;
		}

		return new $className();
	}

	public function setPreserveComments( $preserve ) {
		$this-&gt;preserveComments = $preserve;
	}

	public function registerFunction( $name, $func ) {
		$this-&gt;libFunctions[ $name ] = $func;
	}

	public function unregisterFunction( $name ) {
		unset( $this-&gt;libFunctions[ $name ] );
	}

	public function setVariables( $variables ) {
		$this-&gt;registeredVars = array_merge( $this-&gt;registeredVars, $variables );
	}

	public function unsetVariable( $name ) {
		unset( $this-&gt;registeredVars[ $name ] );
	}

	public function setImportDir( $dirs ) {
		$this-&gt;importDir = (array) $dirs;
	}

	public function addImportDir( $dir ) {
		$this-&gt;importDir   = (array) $this-&gt;importDir;
		$this-&gt;importDir[] = $dir;
	}

	public function allParsedFiles() {
		return $this-&gt;allParsedFiles;
	}

	protected function addParsedFile( $file ) {
		$this-&gt;allParsedFiles[ realpath( $file ) ] = filemtime( $file );
	}

	/**
	 * Uses the current value of $this-&gt;count to show line and line number
	 */
	protected function throwError( $msg = null ) {
		if ( $this-&gt;sourceLoc &gt;= 0 ) {
			$this-&gt;sourceParser-&gt;throwError( $msg, $this-&gt;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-&gt;checkedCompile( $in, $out );
	}

	public static function cexecute( $in, $force = false, $less = null ) {
		if ( $less === null ) {
			$less = new self();
		}
		return $less-&gt;cachedCompile( $in, $force );
	}

	protected static $cssColors = array(
		&#039;aliceblue&#039;            =&gt; &#039;240,248,255&#039;,
		&#039;antiquewhite&#039;         =&gt; &#039;250,235,215&#039;,
		&#039;aqua&#039;                 =&gt; &#039;0,255,255&#039;,
		&#039;aquamarine&#039;           =&gt; &#039;127,255,212&#039;,
		&#039;azure&#039;                =&gt; &#039;240,255,255&#039;,
		&#039;beige&#039;                =&gt; &#039;245,245,220&#039;,
		&#039;bisque&#039;               =&gt; &#039;255,228,196&#039;,
		&#039;black&#039;                =&gt; &#039;0,0,0&#039;,
		&#039;blanchedalmond&#039;       =&gt; &#039;255,235,205&#039;,
		&#039;blue&#039;                 =&gt; &#039;0,0,255&#039;,
		&#039;blueviolet&#039;           =&gt; &#039;138,43,226&#039;,
		&#039;brown&#039;                =&gt; &#039;165,42,42&#039;,
		&#039;burlywood&#039;            =&gt; &#039;222,184,135&#039;,
		&#039;cadetblue&#039;            =&gt; &#039;95,158,160&#039;,
		&#039;chartreuse&#039;           =&gt; &#039;127,255,0&#039;,
		&#039;chocolate&#039;            =&gt; &#039;210,105,30&#039;,
		&#039;coral&#039;                =&gt; &#039;255,127,80&#039;,
		&#039;cornflowerblue&#039;       =&gt; &#039;100,149,237&#039;,
		&#039;cornsilk&#039;             =&gt; &#039;255,248,220&#039;,
		&#039;crimson&#039;              =&gt; &#039;220,20,60&#039;,
		&#039;cyan&#039;                 =&gt; &#039;0,255,255&#039;,
		&#039;darkblue&#039;             =&gt; &#039;0,0,139&#039;,
		&#039;darkcyan&#039;             =&gt; &#039;0,139,139&#039;,
		&#039;darkgoldenrod&#039;        =&gt; &#039;184,134,11&#039;,
		&#039;darkgray&#039;             =&gt; &#039;169,169,169&#039;,
		&#039;darkgreen&#039;            =&gt; &#039;0,100,0&#039;,
		&#039;darkgrey&#039;             =&gt; &#039;169,169,169&#039;,
		&#039;darkkhaki&#039;            =&gt; &#039;189,183,107&#039;,
		&#039;darkmagenta&#039;          =&gt; &#039;139,0,139&#039;,
		&#039;darkolivegreen&#039;       =&gt; &#039;85,107,47&#039;,
		&#039;darkorange&#039;           =&gt; &#039;255,140,0&#039;,
		&#039;darkorchid&#039;           =&gt; &#039;153,50,204&#039;,
		&#039;darkred&#039;              =&gt; &#039;139,0,0&#039;,
		&#039;darksalmon&#039;           =&gt; &#039;233,150,122&#039;,
		&#039;darkseagreen&#039;         =&gt; &#039;143,188,143&#039;,
		&#039;darkslateblue&#039;        =&gt; &#039;72,61,139&#039;,
		&#039;darkslategray&#039;        =&gt; &#039;47,79,79&#039;,
		&#039;darkslategrey&#039;        =&gt; &#039;47,79,79&#039;,
		&#039;darkturquoise&#039;        =&gt; &#039;0,206,209&#039;,
		&#039;darkviolet&#039;           =&gt; &#039;148,0,211&#039;,
		&#039;deeppink&#039;             =&gt; &#039;255,20,147&#039;,
		&#039;deepskyblue&#039;          =&gt; &#039;0,191,255&#039;,
		&#039;dimgray&#039;              =&gt; &#039;105,105,105&#039;,
		&#039;dimgrey&#039;              =&gt; &#039;105,105,105&#039;,
		&#039;dodgerblue&#039;           =&gt; &#039;30,144,255&#039;,
		&#039;firebrick&#039;            =&gt; &#039;178,34,34&#039;,
		&#039;floralwhite&#039;          =&gt; &#039;255,250,240&#039;,
		&#039;forestgreen&#039;          =&gt; &#039;34,139,34&#039;,
		&#039;fuchsia&#039;              =&gt; &#039;255,0,255&#039;,
		&#039;gainsboro&#039;            =&gt; &#039;220,220,220&#039;,
		&#039;ghostwhite&#039;           =&gt; &#039;248,248,255&#039;,
		&#039;gold&#039;                 =&gt; &#039;255,215,0&#039;,
		&#039;goldenrod&#039;            =&gt; &#039;218,165,32&#039;,
		&#039;gray&#039;                 =&gt; &#039;128,128,128&#039;,
		&#039;green&#039;                =&gt; &#039;0,128,0&#039;,
		&#039;greenyellow&#039;          =&gt; &#039;173,255,47&#039;,
		&#039;grey&#039;                 =&gt; &#039;128,128,128&#039;,
		&#039;honeydew&#039;             =&gt; &#039;240,255,240&#039;,
		&#039;hotpink&#039;              =&gt; &#039;255,105,180&#039;,
		&#039;indianred&#039;            =&gt; &#039;205,92,92&#039;,
		&#039;indigo&#039;               =&gt; &#039;75,0,130&#039;,
		&#039;ivory&#039;                =&gt; &#039;255,255,240&#039;,
		&#039;khaki&#039;                =&gt; &#039;240,230,140&#039;,
		&#039;lavender&#039;             =&gt; &#039;230,230,250&#039;,
		&#039;lavenderblush&#039;        =&gt; &#039;255,240,245&#039;,
		&#039;lawngreen&#039;            =&gt; &#039;124,252,0&#039;,
		&#039;lemonchiffon&#039;         =&gt; &#039;255,250,205&#039;,
		&#039;lightblue&#039;            =&gt; &#039;173,216,230&#039;,
		&#039;lightcoral&#039;           =&gt; &#039;240,128,128&#039;,
		&#039;lightcyan&#039;            =&gt; &#039;224,255,255&#039;,
		&#039;lightgoldenrodyellow&#039; =&gt; &#039;250,250,210&#039;,
		&#039;lightgray&#039;            =&gt; &#039;211,211,211&#039;,
		&#039;lightgreen&#039;           =&gt; &#039;144,238,144&#039;,
		&#039;lightgrey&#039;            =&gt; &#039;211,211,211&#039;,
		&#039;lightpink&#039;            =&gt; &#039;255,182,193&#039;,
		&#039;lightsalmon&#039;          =&gt; &#039;255,160,122&#039;,
		&#039;lightseagreen&#039;        =&gt; &#039;32,178,170&#039;,
		&#039;lightskyblue&#039;         =&gt; &#039;135,206,250&#039;,
		&#039;lightslategray&#039;       =&gt; &#039;119,136,153&#039;,
		&#039;lightslategrey&#039;       =&gt; &#039;119,136,153&#039;,
		&#039;lightsteelblue&#039;       =&gt; &#039;176,196,222&#039;,
		&#039;lightyellow&#039;          =&gt; &#039;255,255,224&#039;,
		&#039;lime&#039;                 =&gt; &#039;0,255,0&#039;,
		&#039;limegreen&#039;            =&gt; &#039;50,205,50&#039;,
		&#039;linen&#039;                =&gt; &#039;250,240,230&#039;,
		&#039;magenta&#039;              =&gt; &#039;255,0,255&#039;,
		&#039;maroon&#039;               =&gt; &#039;128,0,0&#039;,
		&#039;mediumaquamarine&#039;     =&gt; &#039;102,205,170&#039;,
		&#039;mediumblue&#039;           =&gt; &#039;0,0,205&#039;,
		&#039;mediumorchid&#039;         =&gt; &#039;186,85,211&#039;,
		&#039;mediumpurple&#039;         =&gt; &#039;147,112,219&#039;,
		&#039;mediumseagreen&#039;       =&gt; &#039;60,179,113&#039;,
		&#039;mediumslateblue&#039;      =&gt; &#039;123,104,238&#039;,
		&#039;mediumspringgreen&#039;    =&gt; &#039;0,250,154&#039;,
		&#039;mediumturquoise&#039;      =&gt; &#039;72,209,204&#039;,
		&#039;mediumvioletred&#039;      =&gt; &#039;199,21,133&#039;,
		&#039;midnightblue&#039;         =&gt; &#039;25,25,112&#039;,
		&#039;mintcream&#039;            =&gt; &#039;245,255,250&#039;,
		&#039;mistyrose&#039;            =&gt; &#039;255,228,225&#039;,
		&#039;moccasin&#039;             =&gt; &#039;255,228,181&#039;,
		&#039;navajowhite&#039;          =&gt; &#039;255,222,173&#039;,
		&#039;navy&#039;                 =&gt; &#039;0,0,128&#039;,
		&#039;oldlace&#039;              =&gt; &#039;253,245,230&#039;,
		&#039;olive&#039;                =&gt; &#039;128,128,0&#039;,
		&#039;olivedrab&#039;            =&gt; &#039;107,142,35&#039;,
		&#039;orange&#039;               =&gt; &#039;255,165,0&#039;,
		&#039;orangered&#039;            =&gt; &#039;255,69,0&#039;,
		&#039;orchid&#039;               =&gt; &#039;218,112,214&#039;,
		&#039;palegoldenrod&#039;        =&gt; &#039;238,232,170&#039;,
		&#039;palegreen&#039;            =&gt; &#039;152,251,152&#039;,
		&#039;paleturquoise&#039;        =&gt; &#039;175,238,238&#039;,
		&#039;palevioletred&#039;        =&gt; &#039;219,112,147&#039;,
		&#039;papayawhip&#039;           =&gt; &#039;255,239,213&#039;,
		&#039;peachpuff&#039;            =&gt; &#039;255,218,185&#039;,
		&#039;peru&#039;                 =&gt; &#039;205,133,63&#039;,
		&#039;pink&#039;                 =&gt; &#039;255,192,203&#039;,
		&#039;plum&#039;                 =&gt; &#039;221,160,221&#039;,
		&#039;powderblue&#039;           =&gt; &#039;176,224,230&#039;,
		&#039;purple&#039;               =&gt; &#039;128,0,128&#039;,
		&#039;red&#039;                  =&gt; &#039;255,0,0&#039;,
		&#039;rosybrown&#039;            =&gt; &#039;188,143,143&#039;,
		&#039;royalblue&#039;            =&gt; &#039;65,105,225&#039;,
		&#039;saddlebrown&#039;          =&gt; &#039;139,69,19&#039;,
		&#039;salmon&#039;               =&gt; &#039;250,128,114&#039;,
		&#039;sandybrown&#039;           =&gt; &#039;244,164,96&#039;,
		&#039;seagreen&#039;             =&gt; &#039;46,139,87&#039;,
		&#039;seashell&#039;             =&gt; &#039;255,245,238&#039;,
		&#039;sienna&#039;               =&gt; &#039;160,82,45&#039;,
		&#039;silver&#039;               =&gt; &#039;192,192,192&#039;,
		&#039;skyblue&#039;              =&gt; &#039;135,206,235&#039;,
		&#039;slateblue&#039;            =&gt; &#039;106,90,205&#039;,
		&#039;slategray&#039;            =&gt; &#039;112,128,144&#039;,
		&#039;slategrey&#039;            =&gt; &#039;112,128,144&#039;,
		&#039;snow&#039;                 =&gt; &#039;255,250,250&#039;,
		&#039;springgreen&#039;          =&gt; &#039;0,255,127&#039;,
		&#039;steelblue&#039;            =&gt; &#039;70,130,180&#039;,
		&#039;tan&#039;                  =&gt; &#039;210,180,140&#039;,
		&#039;teal&#039;                 =&gt; &#039;0,128,128&#039;,
		&#039;thistle&#039;              =&gt; &#039;216,191,216&#039;,
		&#039;tomato&#039;               =&gt; &#039;255,99,71&#039;,
		&#039;turquoise&#039;            =&gt; &#039;64,224,208&#039;,
		&#039;violet&#039;               =&gt; &#039;238,130,238&#039;,
		&#039;wheat&#039;                =&gt; &#039;245,222,179&#039;,
		&#039;white&#039;                =&gt; &#039;255,255,255&#039;,
		&#039;whitesmoke&#039;           =&gt; &#039;245,245,245&#039;,
		&#039;yellow&#039;               =&gt; &#039;255,255,0&#039;,
		&#039;yellowgreen&#039;          =&gt; &#039;154,205,50&#039;,
	);
}

// responsible for taking a string of LESS code and converting it into a.
// syntax tree.
class seedprod_lessc_parser {
	protected static $nextBlockId = 0; // used to uniquely identify blocks

	protected static $precedence = array(
		&#039;=&lt;&#039; =&gt; 0,
		&#039;&gt;=&#039; =&gt; 0,
		&#039;=&#039;  =&gt; 0,
		&#039;&lt;&#039;  =&gt; 0,
		&#039;&gt;&#039;  =&gt; 0,

		&#039;+&#039;  =&gt; 1,
		&#039;-&#039;  =&gt; 1,
		&#039;*&#039;  =&gt; 2,
		&#039;/&#039;  =&gt; 2,
		&#039;%&#039;  =&gt; 2,
	);

	protected static $whitePattern;
	protected static $commentMulti;

	protected static $commentSingle     = &#039;//&#039;;
	protected static $commentMultiLeft  = &#039;/*&#039;;
	protected static $commentMultiRight = &#039;*/&#039;;

	// regex string to match any of the operators.
	protected static $operatorString;

	// these properties will supress division unless it&#039;s inside parenthases.
	protected static $supressDivisionProps =
		array( &#039;/border-radius$/i&#039;, &#039;/^font$/i&#039; );

	protected $blockDirectives = array( &#039;font-face&#039;, &#039;keyframes&#039;, &#039;page&#039;, &#039;-moz-document&#039; );
	protected $lineDirectives  = array( &#039;charset&#039; );

	/**
	 * 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.
	protected static $literalCache = array();

	public function __construct( $seedprod_lessc, $sourceName = null ) {
		$this-&gt;eatWhiteDefault = true;
		// reference to less needed for vPrefix, mPrefix, and parentSelector.
		$this-&gt;seedprod_lessc = $seedprod_lessc;

		$this-&gt;sourceName = $sourceName; // name used for error messages

		$this-&gt;writeComments = false;

		if ( ! self::$operatorString ) {
			self::$operatorString =
				&#039;(&#039; . implode(
					&#039;|&#039;,
					array_map(
						array( &#039;seedprod_lessc&#039;, &#039;preg_quote&#039; ),
						array_keys( self::$precedence )
					)
				) . &#039;)&#039;;

			$commentSingle     = seedprod_lessc::preg_quote( self::$commentSingle );
			$commentMultiLeft  = seedprod_lessc::preg_quote( self::$commentMultiLeft );
			$commentMultiRight = seedprod_lessc::preg_quote( self::$commentMultiRight );

			self::$commentMulti = $commentMultiLeft . &#039;.*?&#039; . $commentMultiRight;
			self::$whitePattern = &#039;/&#039; . $commentSingle . &#039;[^\n]*\s*|(&#039; . self::$commentMulti . &#039;)\s*|\s+/Ais&#039;;
		}
	}

	public function parse( $buffer ) {
		$this-&gt;count = 0;
		$this-&gt;line  = 1;

		$this-&gt;env    = null; // block stack
		$this-&gt;buffer = $this-&gt;writeComments ? $buffer : $this-&gt;removeComments( $buffer );
		$this-&gt;pushSpecialBlock( &#039;root&#039; );
		$this-&gt;eatWhiteDefault = true;
		$this-&gt;seenComments    = array();

		// trim whitespace on head.
		// if (preg_match(&#039;/^\s+/&#039;, $this-&gt;buffer, $m)) {
		// $this-&gt;line += substr_count($m[0], &quot;\n&quot;);
		// $this-&gt;buffer = ltrim($this-&gt;buffer);
		// }
		$this-&gt;whitespace();

		// parse the entire file.
		$lastCount = $this-&gt;count;
		while ( false !== $this-&gt;parseChunk() );

		if ( $this-&gt;count != strlen( $this-&gt;buffer ) ) {
			$this-&gt;throwError();
		}

		// TODO report where the block was opened.
		if ( ! is_null( $this-&gt;env-&gt;parent ) ) {
			throw new exception( &#039;parse error: unclosed block&#039; );
		}

		return $this-&gt;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 seedprod_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&#039;t advance the buffer and it will return false.
	 *
	 * All of these parse functions are powered by seedprod_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 &amp;&amp;.
	 *
	 * 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, seedprod_lessc::seek() is used to remember and set buffer positions.
	 *
	 * Before parsing a chain, use $s = $this-&gt;seek() to remember the current
	 * position into $s. Then if a chain fails, use $this-&gt;seek($s) to
	 * go back where we started.
	 */
	protected function parseChunk() {
		if ( empty( $this-&gt;buffer ) ) {
			return false;
		}
		$s = $this-&gt;seek();

		// setting a property.
		if ( $this-&gt;keyword( $key ) &amp;&amp; $this-&gt;assign() &amp;&amp;
			$this-&gt;propertyValue( $value, $key ) &amp;&amp; $this-&gt;end() ) {
			$this-&gt;append( array( &#039;assign&#039;, $key, $value ), $s );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		// look for special css blocks.
		if ( $this-&gt;literal( &#039;@&#039;, false ) ) {
			--$this-&gt;count;

			// media.
			if ( $this-&gt;literal( &#039;@media&#039; ) ) {
				if ( ( $this-&gt;mediaQueryList( $mediaQueries ) || true )
					&amp;&amp; $this-&gt;literal( &#039;{&#039; ) ) {
					$media          = $this-&gt;pushSpecialBlock( &#039;media&#039; );
					$media-&gt;queries = is_null( $mediaQueries ) ? array() : $mediaQueries;
					return true;
				} else {
					$this-&gt;seek( $s );
					return false;
				}
			}

			if ( $this-&gt;literal( &#039;@&#039;, false ) &amp;&amp; $this-&gt;keyword( $dirName ) ) {
				if ( $this-&gt;isDirective( $dirName, $this-&gt;blockDirectives ) ) {
					if ( ( $this-&gt;openString( &#039;{&#039;, $dirValue, null, array( &#039;;&#039; ) ) || true ) &amp;&amp;
						$this-&gt;literal( &#039;{&#039; ) ) {
						$dir       = $this-&gt;pushSpecialBlock( &#039;directive&#039; );
						$dir-&gt;name = $dirName;
						if ( isset( $dirValue ) ) {
							$dir-&gt;value = $dirValue;
						}
						return true;
					}
				} elseif ( $this-&gt;isDirective( $dirName, $this-&gt;lineDirectives ) ) {
					if ( $this-&gt;propertyValue( $dirValue ) &amp;&amp; $this-&gt;end() ) {
						$this-&gt;append( array( &#039;directive&#039;, $dirName, $dirValue ) );
						return true;
					}
				}
			}

			$this-&gt;seek( $s );
		}

		// setting a variable.
		if ( $this-&gt;variable( $var ) &amp;&amp; $this-&gt;assign() &amp;&amp;
			$this-&gt;propertyValue( $value ) &amp;&amp; $this-&gt;end() ) {
			$this-&gt;append( array( &#039;assign&#039;, $var, $value ), $s );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		if ( $this-&gt;import( $importValue ) ) {
			$this-&gt;append( $importValue, $s );
			return true;
		}

		// opening parametric mixin.
		if ( $this-&gt;tag( $tag, true ) &amp;&amp; $this-&gt;argumentDef( $args, $isVararg ) &amp;&amp;
			( $this-&gt;guards( $guards ) || true ) &amp;&amp;
			$this-&gt;literal( &#039;{&#039; ) ) {
			$block           = $this-&gt;pushBlock( $this-&gt;fixTags( array( $tag ) ) );
			$block-&gt;args     = $args;
			$block-&gt;isVararg = $isVararg;
			if ( ! empty( $guards ) ) {
				$block-&gt;guards = $guards;
			}
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		// opening a simple block.
		if ( $this-&gt;tags( $tags ) &amp;&amp; $this-&gt;literal( &#039;{&#039; ) ) {
			$tags = $this-&gt;fixTags( $tags );
			$this-&gt;pushBlock( $tags );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		// closing a block.
		if ( $this-&gt;literal( &#039;}&#039;, false ) ) {
			try {
				$block = $this-&gt;pop();
			} catch ( exception $e ) {
				$this-&gt;seek( $s );
				$this-&gt;throwError( $e-&gt;getMessage() );
			}

			$hidden = false;
			if ( is_null( $block-&gt;type ) ) {
				$hidden = true;
				if ( ! isset( $block-&gt;args ) ) {
					foreach ( $block-&gt;tags as $tag ) {
						if ( ! is_string( $tag ) || $tag[0] != $this-&gt;seedprod_lessc-&gt;mPrefix ) {
							$hidden = false;
							break;
						}
					}
				}

				foreach ( $block-&gt;tags as $tag ) {
					if ( is_string( $tag ) ) {
						$this-&gt;env-&gt;children[ $tag ][] = $block;
					}
				}
			}

			if ( ! $hidden ) {
				$this-&gt;append( array( &#039;block&#039;, $block ), $s );
			}

			// this is done here so comments aren&#039;t bundled into he block that.
			// was just closed.
			$this-&gt;whitespace();
			return true;
		}

		// mixin.
		if ( $this-&gt;mixinTags( $tags ) &amp;&amp;
			( $this-&gt;argumentValues( $argv ) || true ) &amp;&amp;
			( $this-&gt;keyword( $suffix ) || true ) &amp;&amp; $this-&gt;end() ) {
			$tags = $this-&gt;fixTags( $tags );
			$this-&gt;append( array( &#039;mixin&#039;, $tags, $argv, $suffix ), $s );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		// spare ;
		if ( $this-&gt;literal( &#039;;&#039; ) ) {
			return true;
		}

		return false; // got nothing, throw error
	}

	protected function isDirective( $dirname, $directives ) {
		// TODO: cache pattern in parser.
		$pattern = implode(
			&#039;|&#039;,
			array_map( array( &#039;seedprod_lessc&#039;, &#039;preg_quote&#039; ), $directives )
		);
		$pattern = &#039;/^(-[a-z-]+-)?(&#039; . $pattern . &#039;)$/i&#039;;

		return preg_match( $pattern, $dirname );
	}

	protected function fixTags( $tags ) {
		// move @ tags out of variable namespace.
		foreach ( $tags as &amp;$tag ) {
			if ( $tag[0] == $this-&gt;seedprod_lessc-&gt;vPrefix ) {
				$tag[0] = $this-&gt;seedprod_lessc-&gt;mPrefix;
			}
		}
		return $tags;
	}

	// a list of expressions.
	protected function expressionList( &amp;$exps ) {
		$values = array();

		while ( $this-&gt;expression( $exp ) ) {
			$values[] = $exp;
		}

		if ( count( $values ) == 0 ) {
			return false;
		}

		$exps = seedprod_lessc::compressList( $values, &#039; &#039; );
		return true;
	}

	/**
	 * Attempt to consume an expression.
	 *
	 * @link http://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudo-code
	 */
	protected function expression( &amp;$out ) {
		if ( $this-&gt;value( $lhs ) ) {
			$out = $this-&gt;expHelper( $lhs, 0 );

			// look for / shorthand.
			if ( ! empty( $this-&gt;env-&gt;supressedDivision ) ) {
				unset( $this-&gt;env-&gt;supressedDivision );
				$s = $this-&gt;seek();
				if ( $this-&gt;literal( &#039;/&#039; ) &amp;&amp; $this-&gt;value( $rhs ) ) {
					$out = array(
						&#039;list&#039;,
						&#039;&#039;,
						array( $out, array( &#039;keyword&#039;, &#039;/&#039; ), $rhs ),
					);
				} else {
					$this-&gt;seek( $s );
				}
			}

			return true;
		}
		return false;
	}

	/**
	 * recursively parse infix equation with $lhs at precedence $minP
	 */
	protected function expHelper( $lhs, $minP ) {
		$this-&gt;inExp = true;
		$ss          = $this-&gt;seek();

		while ( true ) {
			$whiteBefore = isset( $this-&gt;buffer[ $this-&gt;count - 1 ] ) &amp;&amp;
				ctype_space( $this-&gt;buffer[ $this-&gt;count - 1 ] );

			// If there is whitespace before the operator, then we require.
			// whitespace after the operator for it to be an expression.
			$needWhite = $whiteBefore &amp;&amp; ! $this-&gt;inParens;

			if ( $this-&gt;match( self::$operatorString . ( $needWhite ? &#039;\s&#039; : &#039;&#039; ), $m ) &amp;&amp; self::$precedence[ $m[1] ] &gt;= $minP ) {
				if ( ! $this-&gt;inParens &amp;&amp; isset( $this-&gt;env-&gt;currentProperty ) &amp;&amp; $m[1] == &#039;/&#039; &amp;&amp; empty( $this-&gt;env-&gt;supressedDivision ) ) {
					foreach ( self::$supressDivisionProps as $pattern ) {
						if ( preg_match( $pattern, $this-&gt;env-&gt;currentProperty ) ) {
							$this-&gt;env-&gt;supressedDivision = true;
							break 2;
						}
					}
				}

				$whiteAfter = isset( $this-&gt;buffer[ $this-&gt;count - 1 ] ) &amp;&amp;
					ctype_space( $this-&gt;buffer[ $this-&gt;count - 1 ] );

				if ( ! $this-&gt;value( $rhs ) ) {
					break;
				}

				// peek for next operator to see what to do with rhs.
				if ( $this-&gt;peek( self::$operatorString, $next ) &amp;&amp; self::$precedence[ $next[1] ] &gt; self::$precedence[ $m[1] ] ) {
					$rhs = $this-&gt;expHelper( $rhs, self::$precedence[ $next[1] ] );
				}

				$lhs = array( &#039;expression&#039;, $m[1], $lhs, $rhs, $whiteBefore, $whiteAfter );
				$ss  = $this-&gt;seek();

				continue;
			}

			break;
		}

		$this-&gt;seek( $ss );

		return $lhs;
	}

	// consume a list of values for a property.
	public function propertyValue( &amp;$value, $keyName = null ) {
		$values = array();

		if ( $keyName !== null ) {
			$this-&gt;env-&gt;currentProperty = $keyName;
		}

		$s = null;
		while ( $this-&gt;expressionList( $v ) ) {
			$values[] = $v;
			$s        = $this-&gt;seek();
			if ( ! $this-&gt;literal( &#039;,&#039; ) ) {
				break;
			}
		}

		if ( $s ) {
			$this-&gt;seek( $s );
		}

		if ( $keyName !== null ) {
			unset( $this-&gt;env-&gt;currentProperty );
		}

		if ( count( $values ) == 0 ) {
			return false;
		}

		$value = seedprod_lessc::compressList( $values, &#039;, &#039; );
		return true;
	}

	protected function parenValue( &amp;$out ) {
		$s = $this-&gt;seek();

		// speed shortcut.
		if ( isset( $this-&gt;buffer[ $this-&gt;count ] ) &amp;&amp; $this-&gt;buffer[ $this-&gt;count ] != &#039;(&#039; ) {
			return false;
		}

		$inParens = $this-&gt;inParens;
		if ( $this-&gt;literal( &#039;(&#039; ) &amp;&amp;
			( $this-&gt;inParens = true ) &amp;&amp; $this-&gt;expression( $exp ) &amp;&amp;
			$this-&gt;literal( &#039;)&#039; ) ) {
			$out            = $exp;
			$this-&gt;inParens = $inParens;
			return true;
		} else {
			$this-&gt;inParens = $inParens;
			$this-&gt;seek( $s );
		}

		return false;
	}

	// a single value.
	protected function value( &amp;$value ) {
		$s = $this-&gt;seek();

		// speed shortcut.
		if ( isset( $this-&gt;buffer[ $this-&gt;count ] ) &amp;&amp; $this-&gt;buffer[ $this-&gt;count ] == &#039;-&#039; ) {
			// negation.
			if ( $this-&gt;literal( &#039;-&#039;, false ) &amp;&amp;
				( ( $this-&gt;variable( $inner ) &amp;&amp; $inner = array( &#039;variable&#039;, $inner ) ) ||
				$this-&gt;unit( $inner ) ||
				$this-&gt;parenValue( $inner ) ) ) {
				$value = array( &#039;unary&#039;, &#039;-&#039;, $inner );
				return true;
			} else {
				$this-&gt;seek( $s );
			}
		}

		if ( $this-&gt;parenValue( $value ) ) {
			return true;
		}
		if ( $this-&gt;unit( $value ) ) {
			return true;
		}
		if ( $this-&gt;color( $value ) ) {
			return true;
		}
		if ( $this-&gt;func( $value ) ) {
			return true;
		}
		if ( $this-&gt;lstring( $value ) ) {
			return true;
		}

		if ( $this-&gt;keyword( $word ) ) {
			$value = array( &#039;keyword&#039;, $word );
			return true;
		}

		// try a variable.
		if ( $this-&gt;variable( $var ) ) {
			$value = array( &#039;variable&#039;, $var );
			return true;
		}

		// unquote string (should this work on any type?
		if ( $this-&gt;literal( &#039;~&#039; ) &amp;&amp; $this-&gt;lstring( $str ) ) {
			$value = array( &#039;escape&#039;, $str );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		// css hack: \0.
		if ( $this-&gt;literal( &#039;\\&#039; ) &amp;&amp; $this-&gt;match( &#039;([0-9]+)&#039;, $m ) ) {
			$value = array( &#039;keyword&#039;, &#039;\\&#039; . $m[1] );
			return true;
		} else {
			$this-&gt;seek( $s );
		}

		return false;
	}

	// an import statement.
	protected function import( &amp;$out ) {
		$s = $this-&gt;seek();
		if ( ! $this-&gt;literal( &#039;@import&#039; ) ) {
			return false;
		}

		// @import &quot;something.css&quot; media;
		// @import url(&quot;something.css&quot;) media;
		// @import url(something.css) media;

		if ( $this-&gt;propertyValue( $value ) ) {
			$out = array( &#039;import&#039;, $value );
			return true;
		}
	}

	protected function mediaQueryList( &amp;$out ) {
		if ( $this-&gt;genericList( $list, &#039;mediaQuery&#039;, &#039;,&#039;, false ) ) {
			$out = $list[2];
			return true;
		}
		return false;
	}

	protected function mediaQuery( &amp;$out ) {
		$s = $this-&gt;seek();

		$expressions = null;
		$parts       = array();

		if ( ( $this-&gt;literal( &#039;only&#039; ) &amp;&amp; ( $only = true ) || $this-&gt;literal( &#039;not&#039; ) &amp;&amp; ( $not = true ) || true ) &amp;&amp; $this-&gt;keyword( $mediaType ) ) {
			$prop = array( &#039;mediaType&#039; );
			if ( isset( $only ) ) {
				$prop[] = &#039;only&#039;;
			}
			if ( isset( $not ) ) {
				$prop[] = &#039;not&#039;;
			}
			$prop[]  = $mediaType;
			$parts[] = $prop;
		} else {
			$this-&gt;seek( $s );
		}

		if ( ! empty( $mediaType ) &amp;&amp; ! $this-&gt;literal( &#039;and&#039; ) ) {
			// ~.
		} else {
			$this-&gt;genericList( $expressions, &#039;mediaExpression&#039;, &#039;and&#039;, false );
			if ( is_array( $expressions ) ) {
				$parts = array_merge( $parts, $expressions[2] );
			}
		}

		if ( count( $parts ) == 0 ) {
			$this-&gt;seek( $s );
			return false;
		}

		$out = $parts;
		return true;
	}

	protected function mediaExpression( &amp;$out ) {
		$s     = $this-&gt;seek();
		$value = null;
		if ( $this-&gt;literal( &#039;(&#039; ) &amp;&amp;
			$this-&gt;keyword( $feature ) &amp;&amp;
			( $this-&gt;literal( &#039;:&#039; ) &amp;&amp; $this-&gt;expression( $value ) || true ) &amp;&amp;
			$this-&gt;literal( &#039;)&#039; ) ) {
			$out = array( &#039;mediaExp&#039;, $feature );
			if ( $value ) {
				$out[] = $value;
			}
			return true;
		}

		$this-&gt;seek( $s );
		return false;
	}

	// an unbounded string stopped by $end.
	protected function openString( $end, &amp;$out, $nestingOpen = null, $rejectStrs = null ) {
		$oldWhite              = $this-&gt;eatWhiteDefault;
		$this-&gt;eatWhiteDefault = false;

		$stop = array( &quot;&#039;&quot;, &#039;&quot;&#039;, &#039;@{&#039;, $end );
		$stop = array_map( array( &#039;seedprod_lessc&#039;, &#039;preg_quote&#039; ), $stop );
		// $stop[] = self::$commentMulti;

		if ( ! is_null( $rejectStrs ) ) {
			$stop = array_merge( $stop, $rejectStrs );
		}

		$patt = &#039;(.*?)(&#039; . implode( &#039;|&#039;, $stop ) . &#039;)&#039;;

		$nestingLevel = 0;

		$content = array();
		while ( $this-&gt;match( $patt, $m, false ) ) {
			if ( ! empty( $m[1] ) ) {
				$content[] = $m[1];
				if ( $nestingOpen ) {
					$nestingLevel += substr_count( $m[1], $nestingOpen );
				}
			}

			$tok = $m[2];

			$this-&gt;count -= strlen( $tok );
			if ( $tok == $end ) {
				if ( $nestingLevel == 0 ) {
					break;
				} else {
					--$nestingLevel;
				}
			}

			if ( ( $tok == &quot;&#039;&quot; || $tok == &#039;&quot;&#039; ) &amp;&amp; $this-&gt;lstring( $str ) ) {
				$content[] = $str;
				continue;
			}

			if ( $tok == &#039;@{&#039; &amp;&amp; $this-&gt;interpolation( $inter ) ) {
				$content[] = $inter;
				continue;
			}

			if ( in_array( $tok, $rejectStrs ) ) {
				$count = null;
				break;
			}

			$content[]    = $tok;
			$this-&gt;count += strlen( $tok );
		}

		$this-&gt;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( &#039;string&#039;, &#039;&#039;, $content );
		return true;
	}

	protected function lstring( &amp;$out ) {
		$s = $this-&gt;seek();
		if ( $this-&gt;literal( &#039;&quot;&#039;, false ) ) {
			$delim = &#039;&quot;&#039;;
		} elseif ( $this-&gt;literal( &quot;&#039;&quot;, false ) ) {
			$delim = &quot;&#039;&quot;;
		} else {
			return false;
		}

		$content = array();

		// look for either ending delim , escape, or string interpolation.
		$patt = &#039;([^\n]*?)(@\{|\\\\|&#039; .
			seedprod_lessc::preg_quote( $delim ) . &#039;)&#039;;

		$oldWhite              = $this-&gt;eatWhiteDefault;
		$this-&gt;eatWhiteDefault = false;

		while ( $this-&gt;match( $patt, $m, false ) ) {
			$content[] = $m[1];
			if ( $m[2] == &#039;@{&#039; ) {
				$this-&gt;count -= strlen( $m[2] );
				if ( $this-&gt;interpolation( $inter, false ) ) {
					$content[] = $inter;
				} else {
					$this-&gt;count += strlen( $m[2] );
					$content[]    = &#039;@{&#039;; // ignore it
				}
			} elseif ( $m[2] == &#039;\\&#039; ) {
				$content[] = $m[2];
				if ( $this-&gt;literal( $delim, false ) ) {
					$content[] = $delim;
				}
			} else {
				$this-&gt;count -= strlen( $delim );
				break; // delim
			}
		}

		$this-&gt;eatWhiteDefault = $oldWhite;

		if ( $this-&gt;literal( $delim ) ) {
			$out = array( &#039;string&#039;, $delim, $content );
			return true;
		}

		$this-&gt;seek( $s );
		return false;
	}

	protected function interpolation( &amp;$out ) {
		$oldWhite              = $this-&gt;eatWhiteDefault;
		$this-&gt;eatWhiteDefault = true;

		$s = $this-&gt;seek();
		if ( $this-&gt;literal( &#039;@{&#039; ) &amp;&amp;
			$this-&gt;keyword( $var ) &amp;&amp;
			$this-&gt;literal( &#039;}&#039;, false ) ) {
			$out                   = array( &#039;variable&#039;, $this-&gt;seedprod_lessc-&gt;vPrefix . $var );
			$this-&gt;eatWhiteDefault = $oldWhite;
			if ( $this-&gt;eatWhiteDefault ) {
				$this-&gt;whitespace();
			}
			return true;
		}

		$this-&gt;eatWhiteDefault = $oldWhite;
		$this-&gt;seek( $s );
		return false;
	}

	protected function unit( &amp;$unit ) {
		// speed shortcut.
		if ( isset( $this-&gt;buffer[ $this-&gt;count ] ) ) {
			$char = $this-&gt;buffer[ $this-&gt;count ];
			if ( ! ctype_digit( $char ) &amp;&amp; $char != &#039;.&#039; ) {
				return false;
			}
		}

		if ( $this-&gt;match( &#039;([0-9]+(?:\.[0-9]*)?|\.[0-9]+)([%a-zA-Z]+)?&#039;, $m ) ) {
			$unit = array( &#039;number&#039;, $m[1], empty( $m[2] ) ? &#039;&#039; : $m[2] );
			return true;
		}
		return false;
	}

	// a # color.
	protected function color( &amp;$out ) {
		if ( $this-&gt;match( &#039;(#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3}))&#039;, $m ) ) {
			if ( strlen( $m[1] ) &gt; 7 ) {
				$out = array( &#039;string&#039;, &#039;&#039;, array( $m[1] ) );
			} else {
				$out = array( &#039;raw_color&#039;, $m[1] );
			}
			return true;
		}

		return false;
	}

	// consume a list of property values delimited by ; and wrapped in ()
	protected function argumentValues( &amp;$args, $delim = &#039;,&#039; ) {
		$s = $this-&gt;seek();
		if ( ! $this-&gt;literal( &#039;(&#039; ) ) {
			return false;
		}

		$values = array();
		while ( true ) {
			if ( $this-&gt;expressionList( $value ) ) {
				$values[] = $value;
			}
			if ( ! $this-&gt;literal( $delim ) ) {
				break;
			} else {
				if ( $value == null ) {
					$values[] = null;
				}
				$value = null;
			}
		}

		if ( ! $this-&gt;literal( &#039;)&#039; ) ) {
			$this-&gt;seek( $s );
			return false;
		}

		$args = $values;
		return true;
	}

	// 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 ...
	protected function argumentDef( &amp;$args, &amp;$isVararg, $delim = &#039;,&#039; ) {
		$s = $this-&gt;seek();
		if ( ! $this-&gt;literal( &#039;(&#039; ) ) {
			return false;
		}

		$values = array();

		$isVararg = false;
		while ( true ) {
			if ( $this-&gt;literal( &#039;...&#039; ) ) {
				$isVararg = true;
				break;
			}

			if ( $this-&gt;variable( $vname ) ) {
				$arg = array( &#039;arg&#039;, $vname );
				$ss  = $this-&gt;seek();
				if ( $this-&gt;assign() &amp;&amp; $this-&gt;expressionList( $value ) ) {
					$arg[] = $value;
				} else {
					$this-&gt;seek( $ss );
					if ( $this-&gt;literal( &#039;...&#039; ) ) {
						$arg[0]   = &#039;rest&#039;;
						$isVararg = true;
					}
				}
				$values[] = $arg;
				if ( $isVararg ) {
					break;
				}
				continue;
			}

			if ( $this-&gt;value( $literal ) ) {
				$values[] = array( &#039;lit&#039;, $literal );
			}

			if ( ! $this-&gt;literal( $delim ) ) {
				break;
			}
		}

		if ( ! $this-&gt;literal( &#039;)&#039; ) ) {
			$this-&gt;seek( $s );
			return false;
		}

		$args = $values;

		return true;
	}

	// consume a list of tags.
	// this accepts a hanging delimiter.
	protected function tags( &amp;$tags, $simple = false, $delim = &#039;,&#039; ) {
		$tags = array();
		while ( $this-&gt;tag( $tt, $simple ) ) {
			$tags[] = $tt;
			if ( ! $this-&gt;literal( $delim ) ) {
				break;
			}
		}
		if ( count( $tags ) == 0 ) {
			return false;
		}

		return true;
	}

	// list of tags of specifying mixin path.
	// optionally separated by &gt; (lazy, accepts extra &gt;)
	protected function mixinTags( &amp;$tags ) {
		$s    = $this-&gt;seek();
		$tags = array();
		while ( $this-&gt;tag( $tt, true ) ) {
			$tags[] = $tt;
			$this-&gt;literal( &#039;&gt;&#039; );
		}

		if ( count( $tags ) == 0 ) {
			return false;
		}

		return true;
	}

	// a bracketed value (contained within in a tag definition)
	protected function tagBracket( &amp;$value ) {
		// speed shortcut.
		if ( isset( $this-&gt;buffer[ $this-&gt;count ] ) &amp;&amp; $this-&gt;buffer[ $this-&gt;count ] != &#039;[&#039; ) {
			return false;
		}

		$s = $this-&gt;seek();
		if ( $this-&gt;literal( &#039;[&#039; ) &amp;&amp; $this-&gt;to( &#039;]&#039;, $c, true ) &amp;&amp; $this-&gt;literal( &#039;]&#039;, false ) ) {
			$value = &#039;[&#039; . $c . &#039;]&#039;;
			// whitespace?
			if ( $this-&gt;whitespace() ) {
				$value .= &#039; &#039;;
			}

			// escape parent selector, (yuck)
			$value = str_replace( $this-&gt;seedprod_lessc-&gt;parentSelector, &#039;$&amp;$&#039;, $value );
			return true;
		}

		$this-&gt;seek( $s );
		return false;
	}

	protected function tagExpression( &amp;$value ) {
		$s = $this-&gt;seek();
		if ( $this-&gt;literal( &#039;(&#039; ) &amp;&amp; $this-&gt;expression( $exp ) &amp;&amp; $this-&gt;literal( &#039;)&#039; ) ) {
			$value = array( &#039;exp&#039;, $exp );
			return true;
		}

		$this-&gt;seek( $s );
		return false;
	}

	// a single tag.
	protected function tag( &amp;$tag, $simple = false ) {
		if ( $simple ) {
			$chars = &#039;^,:;{}\][&gt;\(\) &quot;\&#039;&#039;;
		} else {
			$chars = &#039;^,;{}[&quot;\&#039;&#039;;
		}

		if ( ! $simple &amp;&amp; $this-&gt;tagExpression( $tag ) ) {
			return true;
		}

		$tag = &#039;&#039;;
		while ( $this-&gt;tagBracket( $first ) ) {
			$tag .= $first;
		}

		while ( true ) {
			if ( $this-&gt;match( &#039;([&#039; . $chars . &#039;0-9][&#039; . $chars . &#039;]*)&#039;, $m ) ) {
				$tag .= $m[1];
				if ( $simple ) {
					break;
				}

				while ( $this-&gt;tagBracket( $brack ) ) {
					$tag .= $brack;
				}
				continue;
			} elseif ( $this-&gt;unit( $unit ) ) { // for keyframes
				$tag .= $unit[1] . $unit[2];
				continue;
			}
			break;
		}

		$tag = trim( $tag );
		if ( $tag == &#039;&#039; ) {
			return false;
		}

		return true;
	}

	// a css function.
	protected function func( &amp;$func ) {
		$s = $this-&gt;seek();

		if ( $this-&gt;match( &#039;(%|[\w\-_][\w\-_:\.]+|[\w_])&#039;, $m ) &amp;&amp; $this-&gt;literal( &#039;(&#039; ) ) {
			$fname = $m[1];

			$sPreArgs = $this-&gt;seek();

			$args = array();
			while ( true ) {
				$ss = $this-&gt;seek();
				// this ugly nonsense is for ie filter properties.
				if ( $this-&gt;keyword( $name ) &amp;&amp; $this-&gt;literal( &#039;=&#039; ) &amp;&amp; $this-&gt;expressionList( $value ) ) {
					$args[] = array( &#039;string&#039;, &#039;&#039;, array( $name, &#039;=&#039;, $value ) );
				} else {
					$this-&gt;seek( $ss );
					if ( $this-&gt;expressionList( $value ) ) {
						$args[] = $value;
					}
				}

				if ( ! $this-&gt;literal( &#039;,&#039; ) ) {
					break;
				}
			}
			$args = array( &#039;list&#039;, &#039;,&#039;, $args );

			if ( $this-&gt;literal( &#039;)&#039; ) ) {
				$func = array( &#039;function&#039;, $fname, $args );
				return true;
			} elseif ( $fname == &#039;url&#039; ) {
				// couldn&#039;t parse and in url? treat as string.
				$this-&gt;seek( $sPreArgs );
				if ( $this-&gt;openString( &#039;)&#039;, $string ) &amp;&amp; $this-&gt;literal( &#039;)&#039; ) ) {
					$func = array( &#039;function&#039;, $fname, $string );
					return true;
				}
			}
		}

		$this-&gt;seek( $s );
		return false;
	}

	// consume a less variable.
	protected function variable( &amp;$name ) {
		$s = $this-&gt;seek();
		if ( $this-&gt;literal( $this-&gt;seedprod_lessc-&gt;vPrefix, false ) &amp;&amp;
			( $this-&gt;variable( $sub ) || $this-&gt;keyword( $name ) ) ) {
			if ( ! empty( $sub ) ) {
				$name = array( &#039;variable&#039;, $sub );
			} else {
				$name = $this-&gt;seedprod_lessc-&gt;vPrefix . $name;
			}
			return true;
		}

		$name = null;
		$this-&gt;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-&gt;currentProperty = $name;
		}
		return $this-&gt;literal( &#039;:&#039; ) || $this-&gt;literal( &#039;=&#039; );
	}

	// consume a keyword.
	protected function keyword( &amp;$word ) {
		if ( $this-&gt;match( &#039;([\w_\-\*!&quot;][\w\-_&quot;]*)&#039;, $m ) ) {
			$word = $m[1];
			return true;
		}
		return false;
	}

	// consume an end of statement delimiter.
	protected function end() {
		if ( $this-&gt;literal( &#039;;&#039; ) ) {
			return true;
		} elseif ( $this-&gt;count == strlen( $this-&gt;buffer ) || $this-&gt;buffer[ $this-&gt;count ] == &#039;}&#039; ) {
			// if there is end of file or a closing block next then we don&#039;t need a ;
			return true;
		}
		return false;
	}

	protected function guards( &amp;$guards ) {
		$s = $this-&gt;seek();

		if ( ! $this-&gt;literal( &#039;when&#039; ) ) {
			$this-&gt;seek( $s );
			return false;
		}

		$guards = array();

		while ( $this-&gt;guardGroup( $g ) ) {
			$guards[] = $g;
			if ( ! $this-&gt;literal( &#039;,&#039; ) ) {
				break;
			}
		}

		if ( count( $guards ) == 0 ) {
			$guards = null;
			$this-&gt;seek( $s );
			return false;
		}

		return true;
	}

	// a bunch of guards that are and&#039;d together.
	// TODO rename to guardGroup.
	protected function guardGroup( &amp;$guardGroup ) {
		$s          = $this-&gt;seek();
		$guardGroup = array();
		while ( $this-&gt;guard( $guard ) ) {
			$guardGroup[] = $guard;
			if ( ! $this-&gt;literal( &#039;and&#039; ) ) {
				break;
			}
		}

		if ( count( $guardGroup ) == 0 ) {
			$guardGroup = null;
			$this-&gt;seek( $s );
			return false;
		}

		return true;
	}

	protected function guard( &amp;$guard ) {
		$s      = $this-&gt;seek();
		$negate = $this-&gt;literal( &#039;not&#039; );

		if ( $this-&gt;literal( &#039;(&#039; ) &amp;&amp; $this-&gt;expression( $exp ) &amp;&amp; $this-&gt;literal( &#039;)&#039; ) ) {
			$guard = $exp;
			if ( $negate ) {
				$guard = array( &#039;negate&#039;, $guard );
			}
			return true;
		}

		$this-&gt;seek( $s );
		return false;
	}

	/* raw parsing functions */

	protected function literal( $what, $eatWhitespace = null ) {
		if ( $eatWhitespace === null ) {
			$eatWhitespace = $this-&gt;eatWhiteDefault;
		}

		// shortcut on single letter.
		if ( ! isset( $what[1] ) &amp;&amp; isset( $this-&gt;buffer[ $this-&gt;count ] ) ) {
			if ( $this-&gt;buffer[ $this-&gt;count ] == $what ) {
				if ( ! $eatWhitespace ) {
					++$this-&gt;count;
					return true;
				}
				// goes below...
			} else {
				return false;
			}
		}

		if ( ! isset( self::$literalCache[ $what ] ) ) {
			self::$literalCache[ $what ] = seedprod_lessc::preg_quote( $what );
		}

		return $this-&gt;match( self::$literalCache[ $what ], $m, $eatWhitespace );
	}

	protected function genericList( &amp;$out, $parseItem, $delim = &#039;&#039;, $flatten = true ) {
		$s     = $this-&gt;seek();
		$items = array();
		while ( $this-&gt;$parseItem( $value ) ) {
			$items[] = $value;
			if ( $delim ) {
				if ( ! $this-&gt;literal( $delim ) ) {
					break;
				}
			}
		}

		if ( count( $items ) == 0 ) {
			$this-&gt;seek( $s );
			return false;
		}

		if ( $flatten &amp;&amp; count( $items ) == 1 ) {
			$out = $items[0];
		} else {
			$out = array( &#039;list&#039;, $delim, $items );
		}

		return true;
	}


	// advance counter to next occurrence of $what.
	// $until - don&#039;t include $what in advance.
	// $allowNewline, if string, will be used as valid char set.
	protected function to( $what, &amp;$out, $until = false, $allowNewline = false ) {
		if ( is_string( $allowNewline ) ) {
			$validChars = $allowNewline;
		} else {
			$validChars = $allowNewline ? &#039;.&#039; : &quot;[^\n]&quot;;
		}
		if ( ! $this-&gt;match( &#039;(&#039; . $validChars . &#039;*?)&#039; . seedprod_lessc::preg_quote( $what ), $m, ! $until ) ) {
			return false;
		}
		if ( $until ) {
			$this-&gt;count -= strlen( $what ); // give back $what
		}
		$out = $m[1];
		return true;
	}

	// try to match something on head of buffer.
	protected function match( $regex, &amp;$out, $eatWhitespace = null ) {
		if ( $eatWhitespace === null ) {
			$eatWhitespace = $this-&gt;eatWhiteDefault;
		}

		$r = &#039;/&#039; . $regex . ( $eatWhitespace &amp;&amp; ! $this-&gt;writeComments ? &#039;\s*&#039; : &#039;&#039; ) . &#039;/Ais&#039;;
		if ( preg_match( $r, $this-&gt;buffer, $out, null, $this-&gt;count ) ) {
			$this-&gt;count += strlen( $out[0] );
			if ( $eatWhitespace &amp;&amp; $this-&gt;writeComments ) {
				$this-&gt;whitespace();
			}
			return true;
		}
		return false;
	}

	// match some whitespace.
	protected function whitespace() {
		if ( $this-&gt;writeComments ) {
			$gotWhite = false;
			while ( preg_match( self::$whitePattern, $this-&gt;buffer, $m, null, $this-&gt;count ) ) {
				if ( isset( $m[1] ) &amp;&amp; empty( $this-&gt;commentsSeen[ $this-&gt;count ] ) ) {
					$this-&gt;append( array( &#039;comment&#039;, $m[1] ) );
					$this-&gt;commentsSeen[ $this-&gt;count ] = true;
				}
				$this-&gt;count += strlen( $m[0] );
				$gotWhite     = true;
			}
			return $gotWhite;
		} else {
			$this-&gt;match( &#039;&#039;, $m );
			return strlen( $m[0] ) &gt; 0;
		}
	}

	// match something without consuming it.
	protected function peek( $regex, &amp;$out = null, $from = null ) {
		if ( is_null( $from ) ) {
			$from = $this-&gt;count;
		}
		$r      = &#039;/&#039; . $regex . &#039;/Ais&#039;;
		$result = preg_match( $r, $this-&gt;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-&gt;count;
		} else {
			$this-&gt;count = $where;
		}
		return true;
	}

	/* misc functions */

	public function throwError( $msg = &#039;parse error&#039;, $count = null ) {
		$count = is_null( $count ) ? $this-&gt;count : $count;

		$line = $this-&gt;line +
			substr_count( substr( $this-&gt;buffer, 0, $count ), &quot;\n&quot; );

		if ( ! empty( $this-&gt;sourceName ) ) {
			$loc = &quot;$this-&gt;sourceName on line $line&quot;;
		} else {
			$loc = &quot;line: $line&quot;;
		}

		// TODO this depends on $this-&gt;count.
		if ( $this-&gt;peek( &quot;(.*?)(\n|$)&quot;, $m, $count ) ) {
			throw new exception( &quot;$msg: failed at `$m[1]` $loc&quot; );
		} else {
			throw new exception( &quot;$msg: $loc&quot; );
		}
	}

	protected function pushBlock( $selectors = null, $type = null ) {
		$b         = new stdclass();
		$b-&gt;parent = $this-&gt;env;

		$b-&gt;type = $type;
		$b-&gt;id   = self::$nextBlockId++;

		$b-&gt;isVararg = false; // TODO: kill me from here
		$b-&gt;tags     = $selectors;

		$b-&gt;props    = array();
		$b-&gt;children = array();

		$this-&gt;env = $b;
		return $b;
	}

	// push a block that doesn&#039;t multiply tags.
	protected function pushSpecialBlock( $type ) {
		return $this-&gt;pushBlock( null, $type );
	}

	// append a property to the current block.
	protected function append( $prop, $pos = null ) {
		if ( $pos !== null ) {
			$prop[-1] = $pos;
		}
		$this-&gt;env-&gt;props[] = $prop;
	}

	// pop something off the stack.
	protected function pop() {
		$old       = $this-&gt;env;
		$this-&gt;env = $this-&gt;env-&gt;parent;
		return $old;
	}

	// remove comments from $text.
	// todo: make it work for all functions, not just url.
	protected function removeComments( $text ) {
		$look = array(
			&#039;url(&#039;,
			&#039;//&#039;,
			&#039;/*&#039;,
			&#039;&quot;&#039;,
			&quot;&#039;&quot;,
		);

		$out = &#039;&#039;;
		$min = null;
		while ( true ) {
			// find the next item.
			foreach ( $look as $token ) {
				$pos = strpos( $text, $token );
				if ( $pos !== false ) {
					if ( ! isset( $min ) || $pos &lt; $min[1] ) {
						$min = array( $token, $pos );
					}
				}
			}

			if ( is_null( $min ) ) {
				break;
			}

			$count    = $min[1];
			$skip     = 0;
			$newlines = 0;
			switch ( $min[0] ) {
				case &#039;url(&#039;:
					if ( preg_match( &#039;/url\(.*?\)/&#039;, $text, $m, 0, $count ) ) {
						$count += strlen( $m[0] ) - strlen( $min[0] );
					}
					break;
				case &#039;&quot;&#039;:
				case &quot;&#039;&quot;:
					if ( preg_match( &#039;/&#039; . $min[0] . &#039;.*?&#039; . $min[0] . &#039;/&#039;, $text, $m, 0, $count ) ) {
						$count += strlen( $m[0] ) - 1;
					}
					break;
				case &#039;//&#039;:
					$skip = strpos( $text, &quot;\n&quot;, $count );
					if ( $skip === false ) {
						$skip = strlen( $text ) - $count;
					} else {
						$skip -= $count;
					}
					break;
				case &#039;/*&#039;:
					if ( preg_match( &#039;/\/\*.*?\*\//s&#039;, $text, $m, 0, $count ) ) {
						$skip     = strlen( $m[0] );
						$newlines = substr_count( $m[0], &quot;\n&quot; );
					}
					break;
			}

			if ( $skip == 0 ) {
				$count += strlen( $min[0] );
			}

			$out .= substr( $text, 0, $count ) . str_repeat( &quot;\n&quot;, $newlines );
			$text = substr( $text, $count + $skip );

			$min = null;
		}

		return $out . $text;
	}
}

class seedprod_lessc_formatter_classic {
	public $indentChar = &#039;  &#039;;

	public $break             = &quot;\n&quot;;
	public $open              = &#039; {&#039;;
	public $close             = &#039;}&#039;;
	public $selectorSeparator = &#039;, &#039;;
	public $assignSeparator   = &#039;:&#039;;

	public $openSingle  = &#039; { &#039;;
	public $closeSingle = &#039; }&#039;;

	public $disableSingle  = false;
	public $breakSelectors = false;

	public $compressColors = false;

	public function __construct() {
		$this-&gt;indentLevel = 0;
	}

	public function indentStr( $n = 0 ) {
		return str_repeat( $this-&gt;indentChar, max( $this-&gt;indentLevel + $n, 0 ) );
	}

	public function property( $name, $value ) {
		return $name . $this-&gt;assignSeparator . $value . &#039;;&#039;;
	}

	protected function isEmpty( $block ) {
		if ( empty( $block-&gt;lines ) ) {
			foreach ( $block-&gt;children as $child ) {
				if ( ! $this-&gt;isEmpty( $child ) ) {
					return false;
				}
			}

			return true;
		}
		return false;
	}

	public function block( $block ) {
		if ( $this-&gt;isEmpty( $block ) ) {
			return;
		}

		$inner = $pre = $this-&gt;indentStr();

		$isSingle = ! $this-&gt;disableSingle &amp;&amp;
			is_null( $block-&gt;type ) &amp;&amp; count( $block-&gt;lines ) == 1;

		if ( ! empty( $block-&gt;selectors ) ) {
			++$this-&gt;indentLevel;

			if ( $this-&gt;breakSelectors ) {
				$selectorSeparator = $this-&gt;selectorSeparator . $this-&gt;break . $pre;
			} else {
				$selectorSeparator = $this-&gt;selectorSeparator;
			}

			echo $pre .
				implode( $selectorSeparator, $block-&gt;selectors );
			if ( $isSingle ) {
				echo $this-&gt;openSingle;
				$inner = &#039;&#039;;
			} else {
				echo $this-&gt;open . $this-&gt;break;
				$inner = $this-&gt;indentStr();
			}
		}

		if ( ! empty( $block-&gt;lines ) ) {
			$glue = $this-&gt;break . $inner;
			echo $inner . implode( $glue, $block-&gt;lines );
			if ( ! $isSingle &amp;&amp; ! empty( $block-&gt;children ) ) {
				echo $this-&gt;break;
			}
		}

		foreach ( $block-&gt;children as $child ) {
			$this-&gt;block( $child );
		}

		if ( ! empty( $block-&gt;selectors ) ) {
			if ( ! $isSingle &amp;&amp; empty( $block-&gt;children ) ) {
				echo $this-&gt;break;
			}

			if ( $isSingle ) {
				echo $this-&gt;closeSingle . $this-&gt;break;
			} else {
				echo $pre . $this-&gt;close . $this-&gt;break;
			}

			--$this-&gt;indentLevel;
		}
	}
}

class seedprod_lessc_formatter_compressed extends seedprod_lessc_formatter_classic {
	public $disableSingle     = true;
	public $open              = &#039;{&#039;;
	public $selectorSeparator = &#039;,&#039;;
	public $assignSeparator   = &#039;:&#039;;
	public $break             = &#039;&#039;;
	public $compressColors    = true;

	public function indentStr( $n = 0 ) {
		return &#039;&#039;;
	}
}

class seedprod_lessc_formatter_lessjs extends seedprod_lessc_formatter_classic {
	public $disableSingle     = true;
	public $breakSelectors    = true;
	public $assignSeparator   = &#039;: &#039;;
	public $selectorSeparator = &#039;,&#039;;
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fcoming-soon%2Fapp%2Fincludes'>⬅ Back to Directory</a>