OwlCyberSecurity - MANAGER

Edit File: seedprod_lessc.inc.php

<?php

/**
 * lessphp v0.3.8
 * http://leafo.net/lessphp
 *
 * LESS css compiler, adapted from http://seedprod_lesscss.org
 *
 * Copyright 2012, Leaf Corcoran <leafot@gmail.com>
 * Licensed under MIT or GPLv3, see LICENSE
 */

/**
 * The less compiler and parser.
 *
 * Converting LESS to CSS is a three stage process. The incoming file is parsed
 * by `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  = 'v0.3.8';
	protected static $TRUE  = array( 'keyword', 'true' );
	protected static $FALSE = array( 'keyword', 'false' );

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

public $vPrefix        = '@'; // prefix of abstract properties
	public $mPrefix        = '$'; // prefix of abstract blocks
	public $parentSelector = '&';

public $importDisabled = false;
	public $importDir      = '';

protected $numberPrecision = null;

// 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( 'keyword', '' );

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->importDir as $dir ) {
			$full = $dir . ( substr( $dir, -1 ) != '/' ? '/' : '' ) . $url;
			if ( $this->fileExists( $file = $full . '.less' ) || $this->fileExists( $file = $full ) ) {
				return $file;
			}
		}

return null;
	}

protected function fileExists( $name ) {
		return is_file( $name );
	}

public static function compressList( $items, $delim ) {
		if ( ! isset( $items[1] ) && isset( $items[0] ) ) {
			return $items[0];
		} else {
			return array( 'list', $delim, $items );
		}
	}

public static function preg_quote( $what ) {
		return preg_quote( $what, '/' );
	}

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

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

$url = $this->compileValue( $this->lib_e( $str ) );

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

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

if ( $this->importDisabled ) {
			return array( false, '/* import disabled */' );
		}

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

// set the parents of all the block props
		foreach ( $root->props as $prop ) {
			if ( $prop[0] == 'block' ) {
				$prop[1]->parent = $parentBlock;
			}
		}

// copy mixins into scope, set their parents
		// bring blocks from import into current block
		// TODO: need to mark the source parser	these came from this file
		foreach ( $root->children as $childName => $child ) {
			if ( isset( $parentBlock->children[ $childName ] ) ) {
				$parentBlock->children[ $childName ] = array_merge(
					$parentBlock->children[ $childName ],
					$child
				);
			} else {
				$parentBlock->children[ $childName ] = $child;
			}
		}

$pi  = pathinfo( $realPath );
		$dir = $pi['dirname'];

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

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

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

$oldImport = $this->importDir;

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

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

$this->importDir    = $oldImport;
		$this->sourceParser = $oldSourceParser;
	}

/**
	 * Recursively compiles a block.
	 *
	 * A block is analogous to a CSS block in most cases. A single LESS document
	 * is encapsulated in a block when parsed, but it does not have parent tags
	 * so all of it's children appear on the root level when compiled.
	 *
	 * Blocks are made up of props and children.
	 *
	 * Props are property instructions, array tuples which describe an action
	 * to be taken, eg. write a property, set a variable, mixin a block.
	 *
	 * The children of a block are just all the blocks that are defined within.
	 * This is used to look up mixins when performing a mixin.
	 *
	 * Compiling the block involves pushing a fresh environment on the stack,
	 * and iterating through the props, compiling each one.
	 *
	 * See seedprod_lessc::compileProp()
	 *
	 */
	protected function compileBlock( $block ) {
		switch ( $block->type ) {
			case 'root':
				$this->compileRoot( $block );
				break;
			case null:
				$this->compileCSSBlock( $block );
				break;
			case 'media':
				$this->compileMedia( $block );
				break;
			case 'directive':
				$name = '@' . $block->name;
				if ( ! empty( $block->value ) ) {
					$name .= ' ' . $this->compileValue( $this->reduce( $block->value ) );
				}

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

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

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

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

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

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

$query = $this->compileMediaQuery( $this->multiplyMedia( $env ) );

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

$this->compileProps( $media, $this->scope );

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

$this->scope = $this->scope->parent;
		$this->popEnv();
	}

protected function mediaParent( $scope ) {
		while ( ! empty( $scope->parent ) ) {
			if ( ! empty( $scope->type ) && $scope->type != 'media' ) {
				break;
			}
			$scope = $scope->parent;
		}

return $scope;
	}

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

$this->compileProps( $block, $this->scope );

$this->scope = $this->scope->parent;
		$this->popEnv();
	}

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

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

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

foreach ( $props as $prop ) {
			switch ( $prop[0] ) {
				case 'assign':
					if ( isset( $prop[1][0] ) && $prop[1][0] == $this->vPrefix ) {
						$vars[] = $prop;
					} else {
						$other[] = $prop;
					}
					break;
				case 'import':
					$id        = self::$nextImportId++;
					$prop[]    = $id;
					$imports[] = $prop;
					$other[]   = array( 'import_mixin', $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 'mediaType':
						$parts[] = implode( ' ', array_slice( $q, 1 ) );
						break;
					case 'mediaExp':
						if ( isset( $q[2] ) ) {
							$parts[] = "($q[1]: " .
							$this->compileValue( $this->reduce( $q[2] ) ) . ')';
						} else {
							$parts[] = "($q[1])";
						}
						break;
				}
			}

if ( count( $parts ) > 0 ) {
				$compiledQueries[] = implode( ' and ', $parts );
			}
		}

$out = '@media';
		if ( ! empty( $parts ) ) {
			$out .= ' ' .
				implode( $this->formatter->selectorSeparator, $compiledQueries );
		}
		return $out;
	}

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

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

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

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

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

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

return $selectors;
	}

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

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

return $selectors;
		}

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

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

return $out;
	}

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

foreach ( $selectors as $s ) {
			if ( is_array( $s ) ) {
				list(, $value) = $s;
				$out[]         = $this->compileValue( $this->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->guards ) ) {
			$groupPassed = false;
			foreach ( $block->guards as $guardGroup ) {
				foreach ( $guardGroup as $guard ) {
					$this->pushEnv();
					$this->zipSetArgs( $block->args, $callingArgs );

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

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

$this->popEnv();

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

if ( $groupPassed ) {
					break;
				}
			}

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

$numCalling = count( $callingArgs );

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

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

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

protected function patternMatchAll( $blocks, $callingArgs ) {
		$matches = null;
		foreach ( $blocks as $block ) {
			if ( $this->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->id ] ) ) {
			return null;
		}
		$seen[ $searchIn->id ] = true;

$name = $path[0];

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

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

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

if ( $searchIn->parent === $searchIn ) {
			return null;
		}
		return $this->findBlocks( $searchIn->parent, $path, $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] == 'arg' ) {
				if ( $i < count( $values ) && ! is_null( $values[ $i ] ) ) {
					$value = $values[ $i ];
				} elseif ( isset( $a[2] ) ) {
					$value = $a[2];
				} else {
					$value = null;
				}

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

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

$this->env->arguments = $assignedValues;
	}

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

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

$args   = array_map( array( $this, 'reduce' ), (array) $args );
				$mixins = $this->findBlocks( $block, $path, $args );

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

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

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

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

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

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

$mixin->parent = $oldParent;

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

break;
			case 'raw':
				$out->lines[] = $prop[1];
				break;
			case 'directive':
				list(, $name, $value) = $prop;
				$out->lines[]         = "@$name " . $this->compileValue( $this->reduce( $value ) ) . ';';
				break;
			case 'comment':
				$out->lines[] = $prop[1];
				break;
			case 'import';
				list(, $importPath, $importId) = $prop;
				$importPath                    = $this->reduce( $importPath );

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

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

$this->env->imports[ $importId ] = $result === false ?
				array( false, '@import ' . $this->compileValue( $importPath ) . ';' ) :
				$result;

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

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

/**
	 * Compiles a primitive value into a CSS property value.
	 *
	 * Values in lessphp are typed by being wrapped in arrays, their format is
	 * typically:
	 *
	 *     array(type, contents [, additional_contents]*)
	 *
	 * The input is expected to be reduced. This function will not work on
	 * things like expressions and variables.
	 */
	protected function compileValue( $value ) {
		switch ( $value[0] ) {
			case 'list':
				// [1] - delimiter
				// [2] - array of values
				return implode( $value[1], array_map( array( $this, 'compileValue' ), $value[2] ) );
			case 'raw_color':
				if ( ! empty( $this->formatter->compressColors ) ) {
					return $this->compileValue( $this->coerceColor( $value ) );
				}
				return $value[1];
			case 'keyword':
				// [1] - the keyword
				return $value[1];
			case 'number':
				list(, $num, $unit) = $value;
				// [1] - the number
				// [2] - the unit
				if ( $this->numberPrecision !== null ) {
					$num = round( $num, $this->numberPrecision );
				}
				return $num . $unit;
			case 'string':
				// [1] - contents of string (includes quotes)
				list(, $delim, $content) = $value;
				foreach ( $content as &$part ) {
					if ( is_array( $part ) ) {
						$part = $this->compileValue( $part );
					}
				}
				return $delim . implode( $content ) . $delim;
			case 'color':
				// [1] - red component (either number or a %)
				// [2] - green component
				// [3] - blue component
				// [4] - optional alpha component
				list(, $r, $g, $b) = $value;
				$r                 = round( $r );
				$g                 = round( $g );
				$b                 = round( $b );

if ( count( $value ) == 5 && $value[4] != 1 ) { // rgba
					return 'rgba(' . $r . ',' . $g . ',' . $b . ',' . $value[4] . ')';
				}

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

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

return $h;

case 'function':
				list(, $name, $args) = $value;
				return $name . '(' . $this->compileValue( $args ) . ')';
			default: // assumed to be unit
				$this->throwError( "unknown value type: $value[0]" );
		}
	}

protected function lib_isnumber( $value ) {
		return $this->toBool( $value[0] == 'number' );
	}

protected function lib_isstring( $value ) {
		return $this->toBool( $value[0] == 'string' );
	}

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

protected function lib_iskeyword( $value ) {
		return $this->toBool( $value[0] == 'keyword' );
	}

protected function lib_ispixel( $value ) {
		return $this->toBool( $value[0] == 'number' && $value[2] == 'px' );
	}

protected function lib_ispercentage( $value ) {
		return $this->toBool( $value[0] == 'number' && $value[2] == '%' );
	}

protected function lib_isem( $value ) {
		return $this->toBool( $value[0] == 'number' && $value[2] == 'em' );
	}

protected function lib_rgbahex( $color ) {
		$color = $this->coerceColor( $color );
		if ( is_null( $color ) ) {
			$this->throwError( 'color expected for rgbahex' );
		}

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

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

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

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

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

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

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

$d = $string[0] == 'string' ? $string[1] : '"';
		return array( 'string', $d, array( $template ) );
	}

protected function lib_floor( $arg ) {
		$value = $this->assertNumber( $arg );
		return array( 'number', floor( $value ), $arg[2] );
	}

protected function lib_ceil( $arg ) {
		$value = $this->assertNumber( $arg );
		return array( 'number', ceil( $value ), $arg[2] );
	}

protected function lib_round( $arg ) {
		$value = $this->assertNumber( $arg );
		return array( 'number', 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] != 'list' || count( $args[2] ) < 2 ) {
			return array( array( 'color', 0, 0, 0 ), 0 );
		}
		list($color, $delta) = $args[2];
		$color               = $this->assertColor( $color );
		$delta               = floatval( $delta[1] );

return array( $color, $delta );
	}

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

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

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

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

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

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

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

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

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

$hsl = $this->toHSL( $color );

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

return $this->toRGB( $hsl );
	}

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

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

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

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

protected function lib_lightness( $color ) {
		$hsl = $this->toHSL( $this->assertColor( $color ) );
		return round( $hsl[3] );
	}

// get the alpha of a color
	// defaults to 1 for non-colors or colors without an alpha
	protected function lib_alpha( $value ) {
		if ( ! is_null( $color = $this->coerceColor( $value ) ) ) {
			return isset( $color[4] ) ? $color[4] : 1;
		}
	}

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

protected function lib_percentage( $arg ) {
		$num = $this->assertNumber( $arg );
		return array( 'number', $num * 100, '%' );
	}

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

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

$first_a  = $this->lib_alpha( $first );
		$second_a = $this->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(
			'color',
			$w1 * $first[1] + $w2 * $second[1],
			$w1 * $first[2] + $w2 * $second[2],
			$w1 * $first[3] + $w2 * $second[3],
		);

if ( $first_a != 1.0 || $second_a != 1.0 ) {
			$new[] = $first_a * $weight + $second_a * ( $weight - 1 );
		}

return $this->fixColor( $new );
	}

protected function assertColor( $value, $error = 'expected color value' ) {
		$color = $this->coerceColor( $value );
		if ( is_null( $color ) ) {
			$this->throwError( $error );
		}
		return $color;
	}

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

protected function toHSL( $color ) {
		if ( $color[0] == 'hsl' ) {
			return $color;
		}

$r = $color[1] / 255;
		$g = $color[2] / 255;
		$b = $color[3] / 255;

$min = min( $r, $g, $b );
		$max = max( $r, $g, $b );

$L = ( $min + $max ) / 2;
		if ( $min == $max ) {
			$S = $H = 0;
		} else {
			if ( $L < 0.5 ) {
				$S = ( $max - $min ) / ( $max + $min );
			} else {
				$S = ( $max - $min ) / ( 2.0 - $max - $min );
			}

if ( $r == $max ) {
				$H = ( $g - $b ) / ( $max - $min );
			} elseif ( $g == $max ) {
				$H = 2.0 + ( $b - $r ) / ( $max - $min );
			} elseif ( $b == $max ) {
				$H = 4.0 + ( $r - $g ) / ( $max - $min );
			}
		}

$out = array(
			'hsl',
			( $H < 0 ? $H + 6 : $H ) * 60,
			$S * 100,
			$L * 100,
		);

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

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

if ( 6 * $comp < 1 ) {
			return $temp1 + ( $temp2 - $temp1 ) * 6 * $comp;
		}
		if ( 2 * $comp < 1 ) {
			return $temp2;
		}
		if ( 3 * $comp < 2 ) {
			return $temp1 + ( $temp2 - $temp1 ) * ( ( 2 / 3 ) - $comp ) * 6;
		}

return $temp1;
	}

/**
	 * Converts a hsl array into a color value in rgb.
	 * Expects H to be in range of 0 to 360, S and L in 0 to 100
	 */
	protected function toRGB( $color ) {
		if ( $color == 'color' ) {
			return $color;
		}

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

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

$temp1 = 2.0 * $L - $temp2;

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

// $out = array('color', round($r*255), round($g*255), round($b*255));
		$out = array( 'color', $r * 255, $g * 255, $b * 255 );
		if ( count( $color ) > 4 ) {
			$out[] = $color[4]; // copy alpha
		}
		return $out;
	}

protected function clamp( $v, $max = 1, $min = 0 ) {
		return min( $max, max( $min, $v ) );
	}

/**
	 * Convert the rgb, rgba, hsl color literals of function type
	 * as returned by the parser into values of color type.
	 */
	protected function funcToColor( $func ) {
		$fname = $func[1];
		if ( $func[2][0] != 'list' ) {
			return false; // need a list of arguments
		}
		$rawComponents = $func[2][2];

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

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

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

while ( count( $hsl ) < 4 ) {
				$hsl[] = 0;
			}
			return $this->toRGB( $hsl );

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

$i++;
			}
			while ( count( $components ) < 3 ) {
				$components[] = 0;
			}
			array_unshift( $components, 'color' );
			return $this->fixColor( $components );
		}

return false;
	}

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

$seen =& $this->env->seenNames;

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

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

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

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

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

if ( is_null( $ret ) ) {
						return array(
							'string',
							'',
							array(
								$name,
								'(',
								$args,
								')',
							),
						);
					}

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

return $ret;
				}

// plain function, reduce args
				$value[2] = $this->reduce( $value[2] );
				return $value;
			case 'unary':
				list(, $op, $exp) = $value;
				$exp              = $this->reduce( $exp );

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

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

return $value;
	}

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

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

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

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

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

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

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

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

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

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

// operators that work on all types
		if ( $op == 'and' ) {
			return $this->toBool( $left == self::$TRUE && $right == self::$TRUE );
		}

if ( $op == '=' ) {
			return $this->toBool( $this->eq( $left, $right ) );
		}

if ( $op == '+' && ! is_null( $str = $this->stringConcatenate( $left, $right ) ) ) {
			return $str;
		}

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

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

return array( 'string', '', array( $left, $paddedOp, $right ) );
	}

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

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

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

return $c;
	}

protected function op_number_color( $op, $lft, $rgt ) {
		if ( $op == '+' || $op == '*' ) {
			return $this->op_color_number( $op, $rgt, $lft );
		}
	}

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

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

protected function op_color_color( $op, $left, $right ) {
		$out = array( 'color' );
		$max = count( $left ) > count( $right ) ? count( $left ) : count( $right );
		foreach ( range( 1, $max - 1 ) as $i ) {
			$lval = isset( $left[ $i ] ) ? $left[ $i ] : 0;
			$rval = isset( $right[ $i ] ) ? $right[ $i ] : 0;
			switch ( $op ) {
				case '+':
					$out[] = $lval + $rval;
					break;
				case '-':
					$out[] = $lval - $rval;
					break;
				case '*':
					$out[] = $lval * $rval;
					break;
				case '%':
					$out[] = $lval % $rval;
					break;
				case '/':
					if ( $rval == 0 ) {
						$this->throwError( "evaluate error: can't divide by zero" );
					}
					$out[] = $lval / $rval;
					break;
				default:
					$this->throwError( 'evaluate error: color op number failed on op ' . $op );
			}
		}
		return $this->fixColor( $out );
	}

// operator on two numbers
	protected function op_number_number( $op, $left, $right ) {
		$unit = empty( $left[2] ) ? $right[2] : $left[2];

$value = 0;
		switch ( $op ) {
			case '+':
				$value = $left[1] + $right[1];
				break;
			case '*':
				$value = $left[1] * $right[1];
				break;
			case '-':
				$value = $left[1] - $right[1];
				break;
			case '%':
				$value = $left[1] % $right[1];
				break;
			case '/':
				if ( $right[1] == 0 ) {
					$this->throwError( 'parse error: divide by zero' );
				}
				$value = $left[1] / $right[1];
				break;
			case '<':
				return $this->toBool( $left[1] < $right[1] );
			case '>':
				return $this->toBool( $left[1] > $right[1] );
			case '>=':
				return $this->toBool( $left[1] >= $right[1] );
			case '=<':
				return $this->toBool( $left[1] <= $right[1] );
			default:
				$this->throwError( 'parse error: unknown number operator: ' . $op );
		}

return array( 'number', $value, $unit );
	}

/* environment functions */

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

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

$this->env = $e;
		return $e;
	}

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

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

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

$isArguments = $name == $this->vPrefix . 'arguments';
		while ( $current ) {
			if ( $isArguments && isset( $current->arguments ) ) {
				return array( 'list', ' ', $current->arguments );
			}

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

return $default;
	}

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

$this->set( $name, $value );
		}
	}

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

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

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

$this->env   = null;
		$this->scope = null;

$this->formatter = $this->newFormatter();

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

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

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

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

$pi = pathinfo( $fname );

$oldImport = $this->importDir;

$this->importDir   = (array) $this->importDir;
		$this->importDir[] = $pi['dirname'] . '/';

$this->allParsedFiles = array();
		$this->addParsedFile( $fname );

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

$this->importDir = $oldImport;

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

return $out;
	}

// compile only if changed input has changed or output doesn't exist
	public function checkedCompile( $in, $out ) {
		if ( ! is_file( $out ) || filemtime( $in ) > filemtime( $out ) ) {
			$this->compileFile( $in, $out );
			return true;
		}
		return false;
	}

/**
	 * Execute lessphp on a .less file or a lessphp cache structure
	 *
	 * The lessphp cache structure contains information about a specific
	 * less file having been parsed. It can be used as a hint for future
	 * calls to determine whether or not a rebuild is required.
	 *
	 * The cache structure contains two important keys that may be used
	 * externally:
	 *
	 * compiled: The final compiled CSS
	 * updated: The time (in seconds) the CSS was last compiled
	 *
	 * The cache structure is a plain-ol' PHP associative array and can
	 * be serialized and unserialized without a hitch.
	 *
	 * @param mixed $in Input
	 * @param bool $force Force rebuild?
	 * @return array lessphp cache structure
	 */
	public function cachedCompile( $in, $force = false ) {
		// assume no root
		$root = null;

if ( is_string( $in ) ) {
			$root = $in;
		} elseif ( is_array( $in ) and isset( $in['root'] ) ) {
			if ( $force or ! isset( $in['files'] ) ) {
				// If we are forcing a recompile or if for some reason the
				// structure does not contain any file information we should
				// specify the root to trigger a rebuild.
				$root = $in['root'];
			} elseif ( isset( $in['files'] ) and is_array( $in['files'] ) ) {
				foreach ( $in['files'] as $fname => $ftime ) {
					if ( ! file_exists( $fname ) or filemtime( $fname ) > $ftime ) {
						// One of the files we knew about previously has changed
						// so we should look at our incoming root again.
						$root = $in['root'];
						break;
					}
				}
			}
		} else {
			// TODO: Throw an exception? We got neither a string nor something
			// that looks like a compatible lessphp cache structure.
			return null;
		}

if ( $root !== null ) {
			// If we have a root value which means we should rebuild.
			$out             = array();
			$out['root']     = $root;
			$out['compiled'] = $this->compileFile( $root );
			$out['files']    = $this->allParsedFiles();
			$out['updated']  = time();
			return $out;
		} else {
			// No changes, pass back the structure
			// we were given initially.
			return $in;
		}

}

// parse and compile buffer
	// This is deprecated
	public function parse( $str = null, $initialVariables = null ) {
		if ( is_array( $str ) ) {
			$initialVariables = $str;
			$str              = null;
		}

$oldVars = $this->registeredVars;
		if ( $initialVariables !== null ) {
			$this->setVariables( $initialVariables );
		}

if ( $str == null ) {
			if ( empty( $this->_parseFile ) ) {
				throw new exception( 'nothing to parse' );
			}

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

$this->registeredVars = $oldVars;
		return $out;
	}

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

return $parser;
	}

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

protected function newFormatter() {
		$className = 'seedprod_lessc_formatter_lessjs';
		if ( ! empty( $this->formatterName ) ) {
			if ( ! is_string( $this->formatterName ) ) {
				return $this->formatterName;
			}
			$className = "seedprod_lessc_formatter_$this->formatterName";
		}

return new $className();
	}

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

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

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

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

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

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

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

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

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

/**
	 * Uses the current value of $this->count to show line and line number
	 */
	protected function throwError( $msg = null ) {
		if ( $this->sourceLoc >= 0 ) {
			$this->sourceParser->throwError( $msg, $this->sourceLoc );
		}
		throw new exception( $msg );
	}

// compile file $in to file $out if $in is newer than $out
	// returns true when it compiles, false otherwise
	public static function ccompile( $in, $out, $less = null ) {
		if ( $less === null ) {
			$less = new self();
		}
		return $less->checkedCompile( $in, $out );
	}

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

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

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

protected static $precedence = array(
		'=<' => 0,
		'>=' => 0,
		'='  => 0,
		'<'  => 0,
		'>'  => 0,

'+'  => 1,
		'-'  => 1,
		'*'  => 2,
		'/'  => 2,
		'%'  => 2,
	);

protected static $whitePattern;
	protected static $commentMulti;

protected static $commentSingle     = '//';
	protected static $commentMultiLeft  = '/*';
	protected static $commentMultiRight = '*/';

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

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

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

/**
	 * if we are in parens we can be more liberal with whitespace around
	 * operators because it must evaluate to a single value and thus is less
	 * ambiguous.
	 *
	 * Consider:
	 *     property1: 10 -5; // is two numbers, 10 and -5
	 *     property2: (10 -5); // should evaluate to 5
	 */
	protected $inParens = false;

// caches preg escaped literals
	protected static $literalCache = array();

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

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

$this->writeComments = false;

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

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

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

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

$this->env    = null; // block stack
		$this->buffer = $this->writeComments ? $buffer : $this->removeComments( $buffer );
		$this->pushSpecialBlock( 'root' );
		$this->eatWhiteDefault = true;
		$this->seenComments    = array();

// trim whitespace on head
		// if (preg_match('/^\s+/', $this->buffer, $m)) {
		// 	$this->line += substr_count($m[0], "\n");
		// 	$this->buffer = ltrim($this->buffer);
		// }
		$this->whitespace();

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

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

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

return $this->env;
	}

/**
	 * Parse a single chunk off the head of the buffer and append it to the
	 * current parse environment.
	 * Returns false when the buffer is empty, or when there is an error.
	 *
	 * This function is called repeatedly until the entire document is
	 * parsed.
	 *
	 * This parser is most similar to a recursive descent parser. Single
	 * functions represent discrete grammatical rules for the language, and
	 * they are able to capture the text that represents those rules.
	 *
	 * Consider the function 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'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 &&.
	 *
	 * 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->seek() to remember the current
	 * position into $s. Then if a chain fails, use $this->seek($s) to
	 * go back where we started.
	 */
	protected function parseChunk() {
		if ( empty( $this->buffer ) ) {
			return false;
		}
		$s = $this->seek();

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

// look for special css blocks
		if ( $this->literal( '@', false ) ) {
			$this->count--;

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

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

$this->seek( $s );
		}

// setting a variable
		if ( $this->variable( $var ) && $this->assign() &&
			$this->propertyValue( $value ) && $this->end() ) {
			$this->append( array( 'assign', $var, $value ), $s );
			return true;
		} else {
			$this->seek( $s );
		}

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

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

// opening a simple block
		if ( $this->tags( $tags ) && $this->literal( '{' ) ) {
			$tags = $this->fixTags( $tags );
			$this->pushBlock( $tags );
			return true;
		} else {
			$this->seek( $s );
		}

// closing a block
		if ( $this->literal( '}', false ) ) {
			try {
				$block = $this->pop();
			} catch ( exception $e ) {
				$this->seek( $s );
				$this->throwError( $e->getMessage() );
			}

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

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

if ( ! $hidden ) {
				$this->append( array( 'block', $block ), $s );
			}

// this is done here so comments aren't bundled into he block that
			// was just closed
			$this->whitespace();
			return true;
		}

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

// spare ;
		if ( $this->literal( ';' ) ) {
			return true;
		}

return false; // got nothing, throw error
	}

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

return preg_match( $pattern, $dirname );
	}

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

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

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

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

$exps = seedprod_lessc::compressList( $values, ' ' );
		return true;
	}

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

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

return true;
		}
		return false;
	}

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

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

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

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

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

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

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

$lhs = array( 'expression', $m[1], $lhs, $rhs, $whiteBefore, $whiteAfter );
				$ss  = $this->seek();

continue;
			}

break;
		}

$this->seek( $ss );

return $lhs;
	}

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

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

$s = null;
		while ( $this->expressionList( $v ) ) {
			$values[] = $v;
			$s        = $this->seek();
			if ( ! $this->literal( ',' ) ) {
				break;
			}
		}

if ( $s ) {
			$this->seek( $s );
		}

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

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

$value = seedprod_lessc::compressList( $values, ', ' );
		return true;
	}

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

// speed shortcut
		if ( isset( $this->buffer[ $this->count ] ) && $this->buffer[ $this->count ] != '(' ) {
			return false;
		}

$inParens = $this->inParens;
		if ( $this->literal( '(' ) &&
			( $this->inParens = true ) && $this->expression( $exp ) &&
			$this->literal( ')' ) ) {
			$out            = $exp;
			$this->inParens = $inParens;
			return true;
		} else {
			$this->inParens = $inParens;
			$this->seek( $s );
		}

return false;
	}

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

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

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

if ( $this->keyword( $word ) ) {
			$value = array( 'keyword', $word );
			return true;
		}

// try a variable
		if ( $this->variable( $var ) ) {
			$value = array( 'variable', $var );
			return true;
		}

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

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

return false;
	}

// an import statement
	protected function import( &$out ) {
		$s = $this->seek();
		if ( ! $this->literal( '@import' ) ) {
			return false;
		}

// @import "something.css" media;
		// @import url("something.css") media;
		// @import url(something.css) media;

if ( $this->propertyValue( $value ) ) {
			$out = array( 'import', $value );
			return true;
		}
	}

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

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

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

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

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

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

$out = $parts;
		return true;
	}

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

$this->seek( $s );
		return false;
	}

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

$stop = array( "'", '"', '@{', $end );
		$stop = array_map( array( 'seedprod_lessc', 'preg_quote' ), $stop );
		// $stop[] = self::$commentMulti;

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

$patt = '(.*?)(' . implode( '|', $stop ) . ')';

$nestingLevel = 0;

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

$tok = $m[2];

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

if ( ( $tok == "'" || $tok == '"' ) && $this->lstring( $str ) ) {
				$content[] = $str;
				continue;
			}

if ( $tok == '@{' && $this->interpolation( $inter ) ) {
				$content[] = $inter;
				continue;
			}

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

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

$this->eatWhiteDefault = $oldWhite;

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

// trim the end
		if ( is_string( end( $content ) ) ) {
			$content[ count( $content ) - 1 ] = rtrim( end( $content ) );
		}

$out = array( 'string', '', $content );
		return true;
	}

protected function lstring( &$out ) {
		$s = $this->seek();
		if ( $this->literal( '"', false ) ) {
			$delim = '"';
		} elseif ( $this->literal( "'", false ) ) {
			$delim = "'";
		} else {
			return false;
		}

$content = array();

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

$oldWhite              = $this->eatWhiteDefault;
		$this->eatWhiteDefault = false;

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

$this->eatWhiteDefault = $oldWhite;

if ( $this->literal( $delim ) ) {
			$out = array( 'string', $delim, $content );
			return true;
		}

$this->seek( $s );
		return false;
	}

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

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

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

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

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

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

return false;
	}

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

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

if ( ! $this->literal( ')' ) ) {
			$this->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( &$args, &$isVararg, $delim = ',' ) {
		$s = $this->seek();
		if ( ! $this->literal( '(' ) ) {
			return false;
		}

$values = array();

$isVararg = false;
		while ( true ) {
			if ( $this->literal( '...' ) ) {
				$isVararg = true;
				break;
			}

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

if ( $this->value( $literal ) ) {
				$values[] = array( 'lit', $literal );
			}

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

if ( ! $this->literal( ')' ) ) {
			$this->seek( $s );
			return false;
		}

$args = $values;

return true;
	}

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

return true;
	}

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

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

return true;
	}

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

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

// escape parent selector, (yuck)
			$value = str_replace( $this->seedprod_lessc->parentSelector, '$&$', $value );
			return true;
		}

$this->seek( $s );
		return false;
	}

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

$this->seek( $s );
		return false;
	}

// a single tag
	protected function tag( &$tag, $simple = false ) {
		if ( $simple ) {
			$chars = '^,:;{}\][> "\'';
		} else {
			$chars = '^,;{}["\'';
		}

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

$tag = '';
		while ( $this->tagBracket( $first ) ) {
			$tag .= $first;
		}

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

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

$tag = trim( $tag );
		if ( $tag == '' ) {
			return false;
		}

return true;
	}

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

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

$sPreArgs = $this->seek();

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

if ( ! $this->literal( ',' ) ) {
					break;
				}
			}
			$args = array( 'list', ',', $args );

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

$this->seek( $s );
		return false;
	}

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

$name = null;
		$this->seek( $s );
		return false;
	}

/**
	 * Consume an assignment operator
	 * Can optionally take a name that will be set to the current property name
	 */
	protected function assign( $name = null ) {
		if ( $name ) {
			$this->currentProperty = $name;
		}
		return $this->literal( ':' ) || $this->literal( '=' );
	}

// consume a keyword
	protected function keyword( &$word ) {
		if ( $this->match( '([\w_\-\*!"][\w\-_"]*)', $m ) ) {
			$word = $m[1];
			return true;
		}
		return false;
	}

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

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

if ( ! $this->literal( 'when' ) ) {
			$this->seek( $s );
			return false;
		}

$guards = array();

while ( $this->guardGroup( $g ) ) {
			$guards[] = $g;
			if ( ! $this->literal( ',' ) ) {
				break;
			}
		}

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

return true;
	}

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

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

return true;
	}

protected function guard( &$guard ) {
		$s      = $this->seek();
		$negate = $this->literal( 'not' );

if ( $this->literal( '(' ) && $this->expression( $exp ) && $this->literal( ')' ) ) {
			$guard = $exp;
			if ( $negate ) {
				$guard = array( 'negate', $guard );
			}
			return true;
		}

$this->seek( $s );
		return false;
	}

/* raw parsing functions */

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

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

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

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

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

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

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

return true;
	}

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

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

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

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

// match something without consuming it
	protected function peek( $regex, &$out = null, $from = null ) {
		if ( is_null( $from ) ) {
			$from = $this->count;
		}
		$r      = '/' . $regex . '/Ais';
		$result = preg_match( $r, $this->buffer, $out, null, $from );

return $result;
	}

// seek to a spot in the buffer or return where we are on no argument
	protected function seek( $where = null ) {
		if ( $where === null ) {
			return $this->count;
		} else {
			$this->count = $where;
		}
		return true;
	}

/* misc functions */

public function throwError( $msg = 'parse error', $count = null ) {
		$count = is_null( $count ) ? $this->count : $count;

$line = $this->line +
			substr_count( substr( $this->buffer, 0, $count ), "\n" );

if ( ! empty( $this->sourceName ) ) {
			$loc = "$this->sourceName on line $line";
		} else {
			$loc = "line: $line";
		}

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

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

$b->type = $type;
		$b->id   = self::$nextBlockId++;

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

$b->props    = array();
		$b->children = array();

$this->env = $b;
		return $b;
	}

// push a block that doesn't multiply tags
	protected function pushSpecialBlock( $type ) {
		return $this->pushBlock( null, $type );
	}

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

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

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

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

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

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

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

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

$min = null;
		}

return $out . $text;
	}

}

class seedprod_lessc_formatter_classic {
	public $indentChar = '  ';

public $break             = "\n";
	public $open              = ' {';
	public $close             = '}';
	public $selectorSeparator = ', ';
	public $assignSeparator   = ':';

public $openSingle  = ' { ';
	public $closeSingle = ' }';

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

public $compressColors = false;

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

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

public function property( $name, $value ) {
		return $name . $this->assignSeparator . $value . ';';
	}

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

return true;
		}
		return false;
	}

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

$inner = $pre = $this->indentStr();

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

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

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

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

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

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

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

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

$this->indentLevel--;
		}
	}
}

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

public function indentStr( $n = 0 ) {
		return '';
	}
}

class seedprod_lessc_formatter_lessjs extends seedprod_lessc_formatter_classic {
	public $disableSingle     = true;
	public $breakSelectors    = true;
	public $assignSeparator   = ': ';
	public $selectorSeparator = ',';
}