| Dir : /home/trave494/tiktechtok.org/wp-content/plugins/coming-soon/app/includes/ |
| Server: Linux ngx353.inmotionhosting.com 4.18.0-553.22.1.lve.1.el8.x86_64 #1 SMP Tue Oct 8 15:52:54 UTC 2024 x86_64 IP: 209.182.202.254 |
| Dir : //home/trave494/tiktechtok.org/wp-content/plugins/coming-soon/app/includes/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 = ',';
}