Force the compiler to regenerate the cached css file

@param array $less_files Array of .less files to compile
@param array $parser_options Array of compiler options
@param array $modify_vars Array of variables
@return string Name of the css file
194359
public static function Regen( $less_files, $parser_options = array(), $modify_vars = array() ){
		$parser_options['use_cache'] = false;
		return self::Get( $less_files, $parser_options, $modify_vars );
	}
694965
function compileCSS(style, parser, opts) {
    if (typeof parser === 'object') {
      opts = parser
      parser = ''
    }
    return _compileCSS(style, opts.tagName, parser, opts)
  }
464945
public static function compileSubExpression(&$context, $vars) {
        $ret = static::customHelper($context, $vars, true, true, true);

        if (($ret === null) && $context['flags']['lambda']) {
            $ret = static::compileVariable($context, $vars, true, true);
        }

        return array($ret ? $ret : '', 'FIXME: $subExpression');
    }
959229
function processCSSFiles(optionsIn = null, configFileLocationIn = '') {


		var continueCSSFilesProcess = function(optionsIn2){
			// console.log(optionsIn2)
				// console.log(optionsIn2.css)
			CPEVENTS.removeListener('CONFIG_READ_REDUCE_PROPS_END', continueCSSFilesProcess);

			var continueCSSFilesProcessAfterConfig = function(optionsIn3){

				
				CPEVENTS.removeListener('continueCSSFilesProcessAfterConfig', continueCSSFilesProcessAfterConfig);

				//config
				if (OPTIONS.css === undefined && CONFIG.options.css) {
					OPTIONS.css = CONFIG.options.css;
				}

				//Options
				if (optionsIn !== null && optionsIn !== undefined) {

					for (key in optionsIn) {

						OPTIONS[key] = optionsIn[key];	
						
					}
				}
				// console.log(CONFIG)
				// console.log(optionsIn.css)
				// console.log(optionsIn3)
				//CSS Files
				// var files = CONFIG.options.css;

				// if (optionsIn.css !== null && optionsIn.css !== undefined) {

				// files = optionsIn.css;
					
				// }

				files = OPTIONS.css;

				if (files !== undefined && files !== '') {
					tmpCSSPaths = [];

					//check for file or files
					switch (typeof files) {
						case 'object':
						case 'array':
								
							for (i = 0; i < files.length; ++i) {

								getFilePaths(files[i], ['.css']);
							}

							if (tmpCSSPaths.length) {
								files = tmpCSSPaths;
							}

							break;
						case 'string':
							//formats
							files = files.replace(/ /g, '');
							// comma delimited list - filename1.css, filename2.css
							if (files.indexOf(',') > -1) { 
								files = files.replace(/^\s+|\s+$/g,'').split(',');
								
								for (i = 0; i < files.length; ++i) {

									getFilePaths(files[i], ['.css']);

								}

								if (tmpCSSPaths.length) {
									files = tmpCSSPaths;
								}


							} else {

								//string path
								getFilePaths(files, ['.css']);

								if (tmpCSSPaths.length) {
									files = tmpCSSPaths;
								}

							}

							break;
					} //end of switch

					fileLocation = files.toString();

					CPEVENTS.on('CSS_READ_AGAIN', function(){

						readCSSFile(files);
					});
					CPEVENTS.on('CSS_READ_END', function(){
						// CPEVENTS.emit('CONFIG_READ_REDUCE_PROPS_END');
						processCSS(null,OPTIONS,function(){

						});	
						
					});

					readCSSFile(files);


				} else { //end of files nothing check

					//
				}




			};

			if (currentConfig != configFileLocationIn) { //don't read same config
				CPEVENTS.on('CONFIG_READ_END', continueCSSFilesProcessAfterConfig); //end of config read
			}

			currentConfig = configFileLocationIn;

			if (configFileLocationIn != 'cmd_default') {
				readConfig(configFileLocationIn);	
			} else if (configFileLocationIn == 'cmd_default') {
				readConfig(configFileLocationIn, optionsIn);	
			}
		};

		CPEVENTS.on('CONFIG_READ_REDUCE_PROPS_END', continueCSSFilesProcess); //end of reduce config read
		

		if (!hasReadReduceDeclarations && fs.existsSync(OPTIONS.reduce_declarations_file_location)) {
			
			readReduceDeclarations();
		}

		if (!hasReadReduceDeclarations && !fs.existsSync(OPTIONS.reduce_declarations_file_location)) {

			//default process settings
			var default_reduce_declarations_config = {
				"declaration_names" : [
					"font",
					"margin",
					"padding",
					"list-style",
					"outline",
					"border",
					"border-top",
					"border-right",
					"border-bottom",
					"border-left",
					"border-radius",
					"border-color",
					"border-top-color",
					"border-right-color",
					"border-bottom-color",
					"border-left-color",
					"color",
					"background-color",
					"font-color",
					"outline-color",
					"box-shadow",
					"text-shadow",
					"float",
					"font-family",
					"font-size",
					"font-weight",
					"font-style",
					"font-variant",
					"font-stretch"
				]
			};

			if (optionsIn !== null && (optionsIn['reduceConfig'] === undefined || optionsIn['reduceConfig'] === null)) {

				optionsIn['reduceConfig'] = default_reduce_declarations_config;
				readReduceDeclarations(optionsIn['reduceConfig']);
			} else {

				readReduceDeclarations();
			}
		}

	}
1359711
function compileSass(path, ext, file, callback) {
  let compiledCss = sass.renderSync({
    file: path,
    outputStyle: 'compressed',
  });
  callback(null, compiledCss.css);
}
428306
protected function arrayToLowercase($vars)
    {
        $result = array();

        foreach ($vars as $k => $v) {
            if (is_array($v)) {
                $result[strtolower($k)] = $this->arrayToLowercase($v);
            } else {
                $result[strtolower($k)] = strtolower($v);
            }
        }

        return $result;
    }
1362216
public function renderPartial($partialName, $sectionName, array $variables)
    {
        if (!isset($this->partialIdentifierCache[$partialName])) {
            $this->partialIdentifierCache[$partialName] = $this->getPartialIdentifier($partialName);
        }
        $partialIdentifier = $this->partialIdentifierCache[$partialName];

        if ($this->templateCompiler->has($partialIdentifier)) {
            $parsedPartial = $this->templateCompiler->get($partialIdentifier);
        } else {
            $this->templateParser->setConfiguration($this->buildParserConfiguration());
            $parsedPartial = $this->templateParser->parse($this->getPartialSource($partialName));
            if ($parsedPartial->isCompilable()) {
                $this->templateCompiler->store($partialIdentifier, $parsedPartial);
            }
        }

        /** @var $variableContainer TemplateVariableContainer **/
        $variableContainer = $this->objectManager->get(\TYPO3\Fluid\Core\ViewHelper\TemplateVariableContainer::class, $variables);
        $renderingContext = clone $this->getCurrentRenderingContext();
        $renderingContext->injectTemplateVariableContainer($variableContainer);

        $this->startRendering(self::RENDERING_PARTIAL, $parsedPartial, $renderingContext);
        if ($sectionName !== null) {
            $output = $this->renderSection($sectionName, $variables);
        } else {
            $output = $parsedPartial->render($renderingContext);
        }
        $this->stopRendering();

        return $output;
    }
706386
public function page($filename, array $vars = [], $return = false)
    {
        if ( ! is_file($filename)) {
            $pageDirectories = modules()->getResourcesDirs('pages');
            foreach ($pageDirectories as $pageDirectory) {
                if (is_file($pageFilePath = $pageDirectory . $filename . '.phtml')) {
                    $filename = $pageFilePath;
                    break;
                }
            }
        }

        if (count($vars)) {
            presenter()->merge($vars);
        }

        presenter()->merge(presenter()->page->getVars());

        if ($return === false) {
            if (presenter()->partials->hasPartial('content') === false) {
                presenter()->partials->addPartial('content', $filename);
            } else {
                presenter()->partials->addPartial(pathinfo($filename, PATHINFO_FILENAME), $filename);
            }
        } elseif (parser()->loadFile($filename)) {
            return parser()->parse(presenter()->getArrayCopy());
        }
    }
1318411
public static function css_files(array $files) {
        if (empty($files)) {
            return '';
        }

        $compressed = array();
        foreach ($files as $file) {
            $content = file_get_contents($file);
            if ($content === false) {
                $compressed[] = "\n\n/* Cannot read CSS file ".basename(dirname(dirname($file))).'/'.basename(dirname($file)).'/'.basename($file)."*/\n\n";
                continue;
            }
            $compressed[] = self::css($content);
        }

        return implode("\n", $compressed);
    }
330485
function compileJs(srcDir, srcFilename, destDir, options) {
  options = options || {};

  if (options.minify) {
    const startTime = Date.now();
    return closureCompile(
        srcDir + srcFilename + '.js', destDir, options.minifiedName, options)
        .then(function() {
          fs.writeFileSync(destDir + '/version.txt', internalRuntimeVersion);
          if (options.latestName) {
            fs.copySync(
                destDir + '/' + options.minifiedName,
                destDir + '/' + options.latestName);
          }
        })
        .then(() => {
          endBuildStep('Minified', srcFilename + '.js', startTime);
        });
  }

  var bundler = browserify(srcDir + srcFilename + '-babel.js', {debug: true})
      .transform(babel, {loose: 'all'});
  if (options.watch) {
    bundler = watchify(bundler);
  }

  var wrapper = options.wrapper || '<%= contents %>';

  var lazybuild = lazypipe()
      .pipe(source, srcFilename + '-babel.js')
      .pipe(buffer)
      .pipe($$.replace, /\$internalRuntimeVersion\$/g, internalRuntimeVersion)
      .pipe($$.wrap, wrapper)
      .pipe($$.sourcemaps.init.bind($$.sourcemaps), {loadMaps: true});

  var lazywrite = lazypipe()
      .pipe($$.sourcemaps.write.bind($$.sourcemaps), './')
      .pipe(gulp.dest.bind(gulp), destDir);

  var destFilename = options.toName || srcFilename + '.js';
  function rebundle() {
    const startTime = Date.now();
    return toPromise(bundler.bundle()
      .on('error', function(err) {
        if (err instanceof SyntaxError) {
          console.error($$.util.colors.red('Syntax error:', err.message));
        } else {
          console.error($$.util.colors.red(err.message));
        }
      })
      .pipe(lazybuild())
      .pipe($$.rename(destFilename))
      .pipe(lazywrite())
      .on('end', function() {
      })).then(() => {
        endBuildStep('Compiled', srcFilename, startTime);
      });
  }

  if (options.watch) {
    bundler.on('update', function() {
      rebundle();
      // Touch file in unit test set. This triggers rebundling of tests because
      // karma only considers changes to tests files themselves re-bundle
      // worthy.
      touch('test/_init_tests.js');
    });
  }

  if (options.watch === false) {
    // Due to the two step build process, compileJs() is called twice, once with
    // options.watch set to true and, once with it set to false. However, we do
    // not need to call rebundle() twice. This avoids the duplicate compile seen
    // when you run `gulp watch` and touch a file.
    return Promise.resolve();
  } else {
    // This is the default options.watch === true case, and also covers the
    // `gulp build` / `gulp dist` cases where options.watch is undefined.
    return rebundle();
  }
}
929012
function generateLoaders (loader, loaderOptions) {
    const loaders = options.usePostCSS ? [cssLoader, postcssLoader] : [cssLoader]
    if (loader) {
      loaders.push({
        loader: loader + '-loader',
        options: Object.assign({}, loaderOptions, {
          sourceMap: options.sourceMap
        })
      })
    }

    // Extract CSS when that option is specified
    // (which is the case during production build)
    if (options.extract) {
      return ExtractTextPlugin.extract({
        use: loaders,
        fallback: 'vue-style-loader'
      })
    } else {
      return ['vue-style-loader'].concat(loaders)
    }
  }
1262038
@Nonnull
  public static String getMinifiedCSSFilename (@Nonnull final String sCSSFilename)
  {
    if (!isCSSFilename (sCSSFilename))
      throw new IllegalArgumentException ("Passed file name '" + sCSSFilename + "' is not a CSS file name!");
    if (isMinifiedCSSFilename (sCSSFilename))
      return sCSSFilename;
    return StringHelper.trimEnd (sCSSFilename, CCSS.FILE_EXTENSION_CSS) + CCSS.FILE_EXTENSION_MIN_CSS;
  }
1345265
function _loadStyles() {
        var lessText = require("text!LiveDevelopment/main.less");

        less.render(lessText, function onParse(err, tree) {
            console.assert(!err, err);
            ExtensionUtils.addEmbeddedStyleSheet(tree.css);
        });
    }
1196657
protected function getScssVars() {

		$sass = '';

		// Required
		foreach ( $this->requiredSassVars as $var ) {
			$method = $this->varToGetter( $var );

			if ( ! method_exists( $this->input, $method ) ) {
				throw new \LogicException( "Input::{$method}() not found." );
			}
			if ( empty( $this->input->{$method}() ) ) {
				throw new \InvalidArgumentException( "Input::{$method}() cannot be empty." );
			}

			$sass .= "\${$var}: " . $this->input->{$method}() . ";\n";
		}

		// Optional
		foreach ( $this->optionalSassVars as $var ) {
			$method = $this->varToGetter( $var );

			if ( method_exists( $this->input, $method ) && ! empty( $this->input->{$method}() ) ) {
				$sass .= "\${$var}: " . $this->input->{$method}() . ";\n";
			}
		}

		return $sass;
	}
1068710
function parser(indexFilePath, options, done) {
	gdebug('Start');

	var modules      = []
	  , deep         = 0
	  , options      = _.extend({}, defaults, options)
	  , noparse      = options.noparse || []
	  , parsers      = [];
	;

	// try to resolve index filepath :
	indexFilePath = indexResolve(indexFilePath);
	if(!indexFilePath) {
		return done(new Error('Index not found for :' + indexFilePath));
	}

	// Prepare path subsitution by resolving all paths 
	// like we resolve the index :
	options.substitute = (function() {
		var substitute   = {};
		_.each(options.substitute, function(to, from) {
			debug('substitution prepare: %s to %s', from, to)
			var _to   = indexResolve(to);
			if(!_to) {
				debug('Module subsitution error this module can not be resolved (to):' + to)
				return done(new Error('Module subsitution error this module can not be resolved (to):' + to));
			}
			var _from = indexResolve(from);
			if(!_from) {
				debug('Module subsitution error this module can not be resolved (from):' + from)
				return done(new Error('Module subsitution error this module can not be resolved (from):' + from));
			}
			debug('    substitution result: %s to %s', _from, _to)
			substitute[_from] = _to;
		})
		return substitute;
	})();

	// Prepare the parser list, option parsers before default parsers :
	_.each(options.parsers, function(def) {
		parsers.push(def);
	});
	parsers.push({match: /\.coffee$/, parse: require('./parsers/coffee')});
	parsers.push({match: /\.css$/, parse: require('./parsers/css')});
	parsers.push({match: /\.html$/, parse: require('./parsers/html')});
	parsers.push({match: /\.jade$/, parse: require('./parsers/jade')});
	parsers.push({match: /\.json$/, parse: require('./parsers/json')});
	parsers.push({match: /\.sass$/, parse: require('./parsers/sass')});
	parsers.push({match: /\.styl$/, parse: require('./parsers/stylus')});
	parsers.push({match: /\.js$/,   parse: require('./parsers/javascript')});
	parsers.push({match: /\.(txt|html)$/,   parse: require('./parsers/txt')});

	// Parse a source an return a valid
	// javascript source injectable in an nway
	// define() template.
	// This method call the first valid parser
	// defined by user (options.parsers) or in
	// the default parsers
	function parse(src, module, makeModule, options) {
		// Find the first valid parser :
		debug('Find a parser for :', module.path)
		var result = _.find(parsers, function(def) {
			// debug('    Check parser match :', def.match)
			if(def.match instanceof RegExp) {
				return def.match.test(module.path);
			} else if ('string'   == typeof def.match) {
				return minimatch(module.path, def.match);
			} else if ('function' == typeof def.match) {
				return def.match(src, module, makeModule, options);
			} else {
				return false;
			}
		});
		if(!result) {
			debug('Warning: No valid parser found for %s. Json string is exported', module.path)
			return 'module.exports = ' + JSON.stringify(src);
		} else {
			debug('Ok parser match :', result.match);
			return result.parse(src, module, makeModule, options);
		}
	}

	// Create a module object for the index
	// receives an absolute filepath to parse, and return
	// a new Module object
	function makeModule(index) {

		var stored, src, srcPath, relpath;

		// Prepare module
		var module  = new Module({
			 uid:    index
			,req:    []
			,path:   index
			,relpath: null
			,isNodeModule: false
			,isAsyncModule: arequirePath === index
			,arequirePath:  arequirePath
			,index:  index
		});

		if(~module.path.indexOf('/node_modules/')) module.isNodeModule = true;

		relpath = path.relative(process.cwd(), module.path);
		relpath = !/^\./.test(relpath) ? './' + relpath : relpath;
		module.relpath = relpath;

		debug('makeModule for %s', relpath);

		// Check for stored version of this path
		stored = _.find(modules, function(p) {
			return module.path === p.path;
		});
		if(stored) {
			debug('allready stored : return (absolute path match)');
			return stored;
		}

		// Read source
		src           = fs.readFileSync(module.path, 'utf8');
		module.mtime  = fs.statSync(module.path).mtime;
		module.uid    = getUID({src: src, path:module.path, options: options});

		// Check for stored version with same uid
		stored = _.find(modules, function(p) {
			return module.uid  === p.uid;
		});
		if(stored) {
			debug('allready stored : return (md5 hash match)');
			return stored;
		}

		// Save module
		modules.push(module);

		// Do not parse ?
		module.notparsed = _.find(noparse, function(np) {
			if(np instanceof RegExp) {
				return np.test(module.path);
			} else if ('string'   == typeof np) {
				return minimatch(module.path, np);
			} else if ('function' == typeof np) {
				return np(module.path, module);
			} else {
				return false;
			}
		});

		// Parse
		if(module.notparsed) {
			debug('  no parse');
		} else {
			debug('  run parse');
			src = parse(src, module, makeModule, options);
		}

		// Store the module source :
		module.source = src;


		// Return the module object

		debug('end %s', relpath);
		return module;
	}

	var root = makeModule(indexFilePath);

	process.nextTick(function() {

		gdebug('End');
		done(null, modules);
	})
}
821102
public function renderString($input, array $vars = [], $filename = null)
    {
        $fallback = function () use ($input, $vars, $filename) {
            return $this->renderWithPhp($input, $vars, $filename);
        };

        if ($this->getDefaultOption('pugjs')) {
            return $this->renderWithJs($input, $filename, $vars, $fallback);
        }

        return call_user_func($fallback);
    }
1226391
function initCssLESS() {
  // Options for less-middleware.
  var opt = {
    debug: false,
    render: {
      compress: false
    }
  };
  var sm;
  if (build.engine.less.map.enabled === true) {
    // Less-middleware passes opt.render data to the less.render function.
    opt.render.sourceMap = sm = {
      sourceMapBasepath: build.sourceDir,
      sourceMapRootpath: '/'
    };
    if (build.engine.less.map.inline === true) {
      // BUG: External map files are still created, even when inline is enabled.
      sm.sourceMapFileInline = true;
      sm.sourceMapLessInline = true;
      sm.sourceMapMapInline = true;
      sm.outputSourceFiles = true;
    } else {
      // HACK: Specifying sourceMapFilename here causes less to put the same
      // sourceMappingURL in every css file, so instead we use a special token
      // and fix the situation during postprocess.css.
      sm.sourceMapFilename = initCssLESS.SOURCEMAP_FILENAME_TOKEN;
      opt.postprocess = {
        css: postprocessCss
      };
    }
  }
  app.use(lessMw(build.sourceDir, opt));
}