function CssPreprocessor($content, $type)
{
    if ($type == 'css') {
    } else {
        if ($type == 'less') {
            try {
                $parser = new Less_Parser();
                $parser->parse($content);
                $content = $parser->getCss();
            } catch (Exception $e) {
                var_dump($e->getMessage());
            }
        } else {
            if ($type == 'sass') {
                $scss = new scssc();
                $content = $scss->compile($content);
            } else {
                if ($type == 'stylus') {
                    $stylus = new Stylus();
                    $content = $stylus->fromString($content)->toString();
                }
            }
        }
    }
    return $content;
}

/**
 * Compile SCSS
 * 
 * @return string
 */
function mob_admin_compile_scss($scss_folder, $css_folder, $format_style = "scss_formatter")
{
    // scssc will be loaded automatically via Composer
    $scss_compiler = new scssc();
    // set the path where your _mixins are
    $scss_compiler->setImportPaths($scss_folder);
    // set css formatting (normal, nested or minimized), @see http://leafo.net/scssphp/docs/#output_formatting
    $scss_compiler->setFormatter($format_style);
    // get all .scss files from scss folder
    $filelist = glob($scss_folder . "*.scss");
    try {
        // step through all .scss files in that folder
        foreach ($filelist as $file_path) {
            // get path elements from that file
            $file_path_elements = pathinfo($file_path);
            // get file's name without extension
            $file_name = $file_path_elements['filename'];
            // get .scss's content, put it into $string_sass
            $string_sass = mob_file_read($scss_folder . $file_name . ".scss");
            // compile this SASS code to CSS
            $string_css = $scss_compiler->compile($string_sass);
            // write CSS into file with the same filename, but .css extension
            mob_file_write($css_folder . $file_name . ".css", $string_css);
        }
    } catch (Exception $e) {
        return $e->getMessage();
    }
}

 /**
  * Compiles all .scss files in a given folder into .css files in a given folder
  *
  * @param string $scss_folder source folder where you have your .scss files
  * @param string $css_folder destination folder where you want your .css files
  * @param string $format_style CSS output format, see http://leafo.net/scssphp/docs/#output_formatting for more.
  */
 public static function run($scss_folder, $css_folder, $format_style = "scss_formatter", $file_append = false)
 {
     // scssc will be loaded automatically via Composer
     $scss_compiler = new scssc();
     // set the path where your _mixins are
     $scss_compiler->setImportPaths($scss_folder);
     // set css formatting (normal, nested or minimized), @see http://leafo.net/scssphp/docs/#output_formatting
     $scss_compiler->setFormatter($format_style);
     // create master css file
     if (!is_dir($css_folder) && $file_append == false) {
         file_put_contents($css_folder, "");
     }
     if (is_dir($scss_folder)) {
         $scan = scandir($scss_folder);
     } else {
         $scan = [$scss_folder];
     }
     if (!file_exists($scss_folder)) {
         throw new Exception("Arquivo inexistente: {$scss_folder}");
     }
     foreach ($scan as $file) {
         if (in_array($file, array(".", ".."))) {
             continue;
         }
         if (is_dir($scss_folder)) {
             if (!file_exists($css_folder . $file)) {
                 if (is_dir($css_folder)) {
                     if (!mkdir($css_folder . $file . "/")) {
                         throw new Exception("Falha ao compilar arquivo .scss. Não foi possível criar a pasta {$css_folder}{$file}/");
                     }
                     if (!chmod($css_folder . $file, 0755)) {
                         throw new Exception("Falha ao compilar arquivo .scss. Não foi possível mudar a permissão do arquivo {$css_folder}{$file}/ para 755 (rwxr-xr-x)");
                     }
                 }
             }
             if (is_dir($css_folder)) {
                 self::run($scss_folder . $file . "/", $css_folder . $file . "/", $format_style);
             } else {
                 self::run($scss_folder . $file, $css_folder, $format_style);
             }
         } else {
             if (preg_match('/(.*).scss$/', $file) and $file[0] != '.') {
                 // get path elements from that file
                 $file_path_elements = pathinfo($file);
                 // get file's name without extension
                 $file_name = $file_path_elements['filename'];
                 // get .scss's content, put it into $string_sass
                 $string_sass = file_get_contents($scss_folder);
                 // compile this SASS code to CSS
                 $string_css = $scss_compiler->compile($string_sass);
                 // write CSS into file with the same filename, but .css extension
                 if (is_dir($css_folder)) {
                     file_put_contents($css_folder . $file_name . ".css", $string_css);
                 } else {
                     file_put_contents($css_folder, $string_css, FILE_APPEND);
                 }
             }
         }
     }
 }

 public static function compile_sass($parent)
 {
     if (!empty(self::$path)) {
         require "scssphp/scss.inc.php";
         $scss = new scssc();
         $scss->setImportPaths(self::$path);
         if (!$parent->args['dev_mode']) {
             $scss->setFormatter("scss_formatter_compressed");
         }
         $new_css = '';
         foreach (self::$import as $import) {
             $new_css .= $scss->compile($import);
         }
         if ($new_css != '') {
             if ($parent->args['sass']['page_output']) {
                 echo '<style type="text/css" id="redux-' . $parent->args['opt_name'] . '">' . $new_css . '</style>';
             } else {
                 //Redux_Functions::initWpFilesystem();
                 //global $wp_filesystem;
                 $filesystem = $parent->filesystem;
                 $css_file = Redux_Helpers::cleanFilePath(ReduxFramework::$_upload_dir . $parent->args['opt_name'] . '-redux.css');
                 //$ret_val    = $wp_filesystem->put_contents($css_file, $new_css, FS_CHMOD_FILE);
                 $ret_val = $filesystem->execute('put_contents', $css_file, array('content' => $new_css));
             }
         }
     }
 }

 public static function compile_sass($parent)
 {
     if (!empty(self::$path)) {
         if (!class_exists('scssc') && !isset($GLOBALS['redux_scss_compiler'])) {
             $GLOBALS['redux_scss_compiler'] = true;
             require "scssphp/scss.inc.php";
         }
         $scss = new scssc();
         $scss->setImportPaths(self::$path);
         if (!$parent->args['dev_mode']) {
             $scss->setFormatter("scss_formatter_compressed");
         }
         $new_css = '';
         foreach (self::$import as $import) {
             $new_css .= $scss->compile($import);
         }
         if ($new_css != '') {
             if ($parent->args['sass']['page_output']) {
                 echo '<style type="text/css" id="redux-' . $parent->args['opt_name'] . '">' . $new_css . '</style>';
             } else {
                 $filesystem = $parent->filesystem;
                 $css_file = Redux_Helpers::cleanFilePath(ReduxFramework::$_upload_dir . $parent->args['opt_name'] . '-redux.css');
                 $ret_val = $filesystem->execute('put_contents', $css_file, array('content' => $new_css));
             }
         }
     }
 }

 /**
  * Compiles all .scss files in a given folder into .css files in a given folder
  *
  * @param string $scss_folder source folder where you have your .scss files
  * @param string $css_folder destination folder where you want your .css files
  * @param string $format_style CSS output format, see http://leafo.net/scssphp/docs/#output_formatting for more.
  */
 public static function run($scss_folder, $css_folder, $format_style = "scss_formatter")
 {
     // scssc will be loaded automatically via Composer
     $scss_compiler = new scssc();
     // set the path where your _mixins are
     $scss_compiler->setImportPaths($scss_folder);
     // set css formatting (normal, nested or minimized), @see http://leafo.net/scssphp/docs/#output_formatting
     $scss_compiler->setFormatter($format_style);
     // get all .scss files from scss folder
     $filelist = glob($scss_folder . "*.scss");
     // step through all .scss files in that folder
     foreach ($filelist as $file_path) {
         // get path elements from that file
         $file_path_elements = pathinfo($file_path);
         // get file's name without extension
         $file_name = $file_path_elements['filename'];
         // get .scss's content, put it into $string_sass
         $string_sass = file_get_contents($scss_folder . $file_name . ".scss");
         // compile this SASS code to CSS
         $string_css = $scss_compiler->compile($string_sass);
         // create target directory if doesn't exist
         if (!is_dir($css_folder)) {
             mkdir($css_folder, 0777, true);
         }
         // write CSS into file with the same filename, but .css extension
         file_put_contents($css_folder . $file_name . ".css", $string_css);
     }
 }

 /**
  * @see PreFileFilter::__invoke()
  */
 public function __invoke($code, \Lohini\WebLoader\WebLoader $loader, $file = NULL)
 {
     if ($file === NULL || strtolower(pathinfo($file, PATHINFO_EXTENSION)) != 'scss') {
         return $code;
     }
     $filter = new \scssc($file);
     return $filter->compile();
 }

 function compileScss()
 {
     require "scss.inc.php";
     $scss = new scssc();
     $scss->setImportPaths(get_stylesheet_directory() . '/assets/scss/');
     $scss->setFormatter('scss_formatter_compressed');
     file_put_contents(get_stylesheet_directory() . '/assets/css/global-gen.css', $scss->compile('@import "global.scss"'));
 }

 public function init($css = '')
 {
     require "compass/vendor/autoload.php";
     require "compass/compass.inc.php";
     $scss = new scssc();
     new scss_compass($scss);
     return $scss->compile('@import "compass";' . $css);
 }

 /** Default RudraX Plug
  *
  * @RequestMapping(url="scss/{mdfile}",type=css)
  *
  */
 function serveStyle($mdfile)
 {
     include_once LIB_PATH . "/leafo/scssphp/scss.inc.php";
     $scss = new scssc();
     $scss->setFormatter("scss_formatter_compressed");
     $server = new scss_server(get_include_path(), get_include_path() . BUILD_PATH . "/scss/", $scss);
     $server->serve();
 }

 public function filterLoad(AssetInterface $asset)
 {
     $root = $asset->getSourceRoot();
     $path = $asset->getSourcePath();
     $lc = new \scssc();
     if ($root && $path) {
         $lc->addImportPath(dirname($root . '/' . $path));
     }
     $asset->setContent($lc->compile($asset->getContent()));
 }

function jetpack_sass_css_preprocess($sass)
{
    require_once dirname(__FILE__) . '/preprocessors/scss.inc.php';
    $compiler = new scssc();
    try {
        return $compiler->compile($sass);
    } catch (Exception $e) {
        return $sass;
    }
}

 /**
  * Set values for Wp_Scss::properties
  *
  * @param string scss_dir - path to source directory for scss files
  * @param string css_dir - path to output directory for css files
  * @param string method - type of compile (compressed, expanded, etc)
  *
  * @var object scssc - instantiate the compiling object.
  *
  * @var array compile_errors - catches errors from compile
  */
 public function __construct($scss_dir, $css_dir, $compile_method)
 {
     $this->scss_dir = $scss_dir;
     $this->css_dir = $css_dir;
     $this->compile_method = $compile_method;
     global $scssc;
     $scssc = new scssc();
     $scssc->setFormatter($compile_method);
     $scssc->setImportPaths($scss_dir);
     $this->compile_errors = array();
 }

 /**
  * @return scssc
  */
 private function get_compiler()
 {
     if (is_null($this->compiler)) {
         if (!class_exists('scssc')) {
             require_once dirname(__FILE__) . '/Compiler/lib/scssphp/scss.inc.php';
         }
         $this->compiler = new scssc();
         $this->compiler->setImportPaths($this->get_import_paths());
         $this->compiler->setFormatter('scss_formatter_compressed');
     }
     return $this->compiler;
 }

 public static function parse($source, $isFile = true)
 {
     $parser = new scssc();
     if ($isFile) {
         $parser->setImportPaths(dirname($source));
     }
     try {
         return $isFile ? $parser->compile('@import "' . basename($source) . '"') : $parser->compile($source);
     } catch (Exception $e) {
         return '/** SASS PARSE ERROR: ' . $e->getMessage() . ' **/';
     }
 }

 /**
  * Runs `scssc` against any files that match the configured extension.
  *
  * @param string $filename The name of the input file.
  * @param string $input The content of the file.
  * @throws Exception
  * @return string
  */
 public function input($filename, $input)
 {
     if (substr($filename, strlen($this->_settings['ext']) * -1) !== $this->_settings['ext']) {
         return $input;
     }
     App::import('Vendor', 'scssc', array('file' => $this->_settings['path']));
     if (!class_exists('scssc')) {
         throw new Exception(sprintf('Cannot not load filter class "%s".', 'scssc'));
     }
     $sc = new scssc();
     $sc->addImportPath(dirname($filename));
     return $sc->compile($input);
 }

 public function filterLoad(AssetInterface $asset)
 {
     $lc = new \scssc();
     if ($this->compass) {
         new \scss_compass($lc);
     }
     if ($dir = $asset->getSourceDirectory()) {
         $lc->addImportPath($dir);
     }
     foreach ($this->importPaths as $path) {
         $lc->addImportPath($path);
     }
     $asset->setContent($lc->compile($asset->getContent()));
 }

 public function run_compiler($scss_dir, $sass_vars, $sass_import_file, $css_name, $compile_method = 'scss_formatter_nested')
 {
     require_once WPCSC_PLUGIN_DIR . '/scssphp/scss.inc.php';
     $scss = new scssc();
     $scss->setImportPaths($scss_dir);
     $scss->setFormatter($compile_method);
     $scss->setVariables($sass_vars);
     $new_css = $scss->compile($sass_import_file);
     /* Write the CSS to the Database */
     $wpcscOptions = get_option('wpcsc1208_option_settings');
     /* Sanitze the CSS before going into the Database
        Refer to this doc, http://wptavern.com/wordpress-theme-review-team-sets-new-guidelines-for-custom-css-boxes */
     $wpcscOptions['wpcsc_content'][$css_name] = wp_kses($new_css, array('\'', '\\"'));
     update_option('wpcsc1208_option_settings', $wpcscOptions);
 }

 /**
  * Compile the SCSS.
  *
  * @return string
  */
 protected function compile_scss()
 {
     if (!class_exists('scssc') && !class_exists('scss_formatter_nested')) {
         include_once 'libs/class-scss.php';
     }
     // Get options
     $colors = WC_Colors::get_options(get_option('woocommerce_colors'));
     ob_start();
     include 'views/scss.php';
     $scss = ob_get_clean();
     $compiler = new scssc();
     $compiler->setFormatter('scss_formatter_compressed');
     $compiled_css = $compiler->compile(trim($scss));
     return $compiled_css;
 }

 protected function compile($css)
 {
     $scss = new scssc();
     $scss->setImportPaths(maxButtons::get_plugin_path() . "assets/scss");
     //$scss->setFormatter('scss_formatter_compressed');
     $compile = " @import '_mixins.scss';  " . $css;
     maxButtonsUtils::addTime("CSSParser: Compile start ");
     try {
         $css = $scss->compile($compile);
     } catch (Exception $e) {
         $css = $this->output_css;
     }
     maxButtonsUtils::addTime("CSSParser: Compile end ");
     return $css;
 }