Install extracted files and builded css
194316
def install(self, tmp_container, font_tmpdir, css_content):
        
        # Write builded css file to its destination
        with open(self.webfont_settings['csspart_path'], 'w') as css_file:
            css_file.write(css_content)

        # Clean previous font dir
        if os.path.exists(self.webfont_settings['fontdir_path']):
            shutil.rmtree(self.webfont_settings['fontdir_path'])
        font_srcdir = os.path.join(tmp_container, font_tmpdir)
        self._debug("* Installing font")
        self._debug("  - From: {}", font_srcdir)
        self._debug("  - To: {}", self.webfont_settings['fontdir_path'])

        shutil.copytree(font_srcdir, self.webfont_settings['fontdir_path'])

        # Copy new manifest into font dir
        manifest_src = os.path.join(tmp_container,
                                    settings.ICOMOON_MANIFEST_FILENAME)
        self._debug("* Installing manifest")
        self._debug("  - From: {}", manifest_src)
        self._debug("  - To: {}", self.webfont_settings['fontdir_path'])
        shutil.copy(manifest_src, self.webfont_settings['fontdir_path'])

        # Remove temp directory when all is done
        self._debug("* Removing temporary dir")
        shutil.rmtree(tmp_container)
201509
function generate_extract_css_loaders(after_style_loader, development, extract_css_plugin, useMiniCssExtractPlugin)
{
	let extract_css_loaders

	if (useMiniCssExtractPlugin)
	{
		const MiniCssExtractPlugin = require('mini-css-extract-plugin')

		return [{
			loader: MiniCssExtractPlugin.loader
		},
		...after_style_loader]
	}

	// The first argument to the .extract() function is the name of the loader
	// ("style-loader" in this case) to be applied to non-top-level-chunks in case of "allChunks: false" option.
	// since in this configuration "allChunks: true" option is used, this first argument is irrelevant.
	//
	// `remove: false` ensures that the styles being extracted
	// aren't erased from the chunk javascript file.
	//
	const extract_css_loader = extract_css_plugin.extract
	({
		remove    : development ? false : true,
		// `fallback` option is not really being used
		// because `allChunks: true` option is used.
		// fallback  : before_style_loader,
		use       : after_style_loader
	})

	// Workaround for an old bug, may be obsolete now.
	// https://github.com/webpack-contrib/extract-text-webpack-plugin/issues/368
	if (Array.isArray(extract_css_loader))
	{
		extract_css_loaders = extract_css_loader
	}
	else
	{
		extract_css_loaders =
		[{
			loader: extract_css_loader
		}]
	}

	// I'm also prepending another `style-loader` here
	// to re-enable adding these styles to the <head/> of the page on-the-fly.
	if (development)
	{
		return [{
			loader: 'style-loader'
		},
		...extract_css_loaders]
	}

	return extract_css_loaders
}
204890
async function importCustomSelectorsFromCSSFile(from) {
	const css = await readFile(path.resolve(from));
	const root = postcss.parse(css, { from: path.resolve(from) });

	return importCustomSelectorsFromCSSAST(root);
}
1309788
def _cached_css_compile(pattern, namespaces, custom, flags):
    """"""

    custom_selectors = process_custom(custom)
    return cm.SoupSieve(
        pattern,
        CSSParser(pattern, custom=custom_selectors, flags=flags).process_selectors(),
        namespaces,
        custom,
        flags
    )
1359711
function compileSass(path, ext, file, callback) {
  let compiledCss = sass.renderSync({
    file: path,
    outputStyle: 'compressed',
  });
  callback(null, compiledCss.css);
}
1356894
function compileCss(src, dest) {
  gulp
    .src(src)
    .pipe(plumber(config.plumberOptions))
    .pipe(gulpif(!config.production, sourcemaps.init()))
    .pipe(sass({
      outputStyle: config.production ? 'compressed' : 'expanded',
      precision: 5
    }))
    .pipe(postcss(processors))
    .pipe(gulpif(config.production, rename({
      suffix: '.min',
      extname: '.css'
    })))
    .pipe(gulpif(!config.production, sourcemaps.write()))
    .pipe(gulp.dest(dest));
}
459706
def css_files(self):
        ''' 

        '''
        bokehjsdir = self.bokehjsdir()
        js_files = []
        for root, dirnames, files in os.walk(bokehjsdir):
            for fname in files:
                if fname.endswith(".css"):
                    js_files.append(join(root, fname))
        return js_files
1296210
protected function gatherCSSFiles() {
		$this->output->writeln('Scanning theme "'.$this->theme.'" for CSS files');

		$this->finder
			 	->files()
			 	->in($this->themeDir)
			 	->name('*.css')
			 	->notName('*.blubber.css')
			 	->notName('*.lean.css');
		
		foreach($this->finder as $file) {
			$filename = basename($file->getRealPath());
			if($this->output->ask("Include the file <caution>$filename</caution>?")) {
				$this->cssFiles[] = $file->getRealPath();
			}
		}
	}
806357
function readCss () {
  return new Promise(function(resolve, reject){
    readFile(SRC, {encoding: 'utf8'}, function(err, str){
      if (err) { return reject(err); }
      resolve(str)
    });
  });
}
1304121
function (context) {
		var file = context.file;

		try {
			file.data = cleanCSS.process(file.data);
		} catch (err) {
			context.error('CSS syntax error: "%s"',
				file.pathname);
		}
	}
1011879
function add_css()
    {
        if ($this->css_loaded) {
            return;
        }

        $skin_path = $this->enigma->local_skin_path();
        $this->enigma->include_stylesheet("$skin_path/enigma.css");
        $this->css_loaded = true;
    }
628284
function buildStyles(conf, undertaker) {

    // Config that gets passed to node-sass.
    const sassConfig = conf.themeConfig.sass.nodeSassConf || {};

    // If we're in production mode, then compress the output CSS.
    if (conf.productionMode) {
      sassConfig.outputStyle = 'compressed';
    }

    // Any PostCSS conf and settings.
    const postCSSConf = [
      autoprefixer({
        browsers: conf.themeConfig.sass.browserSupport || 'last 2 versions'
      })
    ];

    const sassSrc = path.join(conf.themeConfig.root, conf.themeConfig.sass.src, '**', '*.scss');
    const sassDest = path.join(conf.themeConfig.root, conf.themeConfig.sass.dest);

    // The task itself.
    return undertaker.src(sassSrc)
      .pipe(gulpIf(!conf.productionMode, sourcemaps.init()))
      .pipe(sass(sassConfig).on('error', sass.logError))
      .pipe(postcss(postCSSConf))
      .pipe(gulpIf(!conf.productionMode, sourcemaps.write('.')))
      .pipe(undertaker.dest(sassDest));

}
156798
def remove_custom_css(destdir, resource=PKGNAME ):
    

    # Remove the inclusion in the main CSS
    if not os.path.isdir( destdir ):
        return False
    custom = os.path.join( destdir, 'custom.css' )
    copy = True
    found = False
    prefix = css_frame_prefix(resource)
    with io.open(custom + '-new', 'wt') as fout:
        with io.open(custom) as fin:
            for line in fin:
                if line.startswith( prefix + 'START' ):
                    copy = False
                    found = True
                elif line.startswith( prefix + 'END' ):
                    copy = True
                elif copy:
                    fout.write( line )

    if found:
        os.rename( custom+'-new',custom)
    else:
        os.unlink( custom+'-new')

    return found
1029765
function insertCss(styles, { replace = false, prepend = false, prefix = 's' } = {}) {
  const ids = []
  for (let i = 0; i < styles.length; i++) {
    const [moduleId, css, media, sourceMap] = styles[i]
    const id = `${prefix}${moduleId}-${i}`

    ids.push(id)

    if (inserted[id]) {
      if (!replace) {
        inserted[id]++
        continue
      }
    }

    inserted[id] = 1

    let elem = document.getElementById(id)
    let create = false

    if (!elem) {
      create = true

      elem = document.createElement('style')
      elem.setAttribute('type', 'text/css')
      elem.id = id

      if (media) {
        elem.setAttribute('media', media)
      }
    }

    let cssText = css
    if (sourceMap && typeof btoa === 'function') {
      // skip IE9 and below, see http://caniuse.com/atob-btoa
      cssText += `\n/*# sourceMappingURL=data:application/json;base64,${b64EncodeUnicode(
        JSON.stringify(sourceMap),
      )}*/`
      cssText += `\n/*# sourceURL=${sourceMap.file}?${id}*/`
    }

    if ('textContent' in elem) {
      elem.textContent = cssText
    } else {
      elem.styleSheet.cssText = cssText
    }

    if (create) {
      if (prepend) {
        document.head.insertBefore(elem, document.head.childNodes[0])
      } else {
        document.head.appendChild(elem)
      }
    }
  }

  return removeCss.bind(null, ids)
}
1310140
function injectCss(cssList, content) {
        var css = cssList.reduce(function (prev, now) {
            var uri = now.uri;
            return prev + '<link rel="stylesheet" type="text/css" href="' + uri + '">\r\n';
        }, '');
        if (content.indexOf(settings.styleTag) !== -1) {
            content = content.replace(settings.styleTag, css);
        }
        else {
            content = content.replace(/<\/head>/, css + '\n$&');
        }
        return content;
    }
821054
function prepareCssModulesInfo(docDom) {
        var cssModule = { name: '' },
            cssModulesInfo = [];
        $(docDom).find('link[rel="stylesheet"]')
            .filter(function () {
                if (grunt.config.get('lib_kind_fileter_enable')) {
                    var type = path.join(grunt.config.get('lib_kind'), grunt.config.get('stylesheets'));
                    var regexp = new RegExp('^' + type + '\/', 'i');
                    return $(this).attr('href').match(regexp) ? true : false;
                } else {
                    return true;
                }
            })
            .each(function () {
                var href = $(this).attr('href');
                var name = href.slice(href.lastIndexOf('/') + 1, href.length).replace(/\.css$/i, '');
                cssModule = {
                    name: name,
                    version: $(this).attr('data-version'),
                };
                cssModulesInfo.push(cssModule);
            });
        // set lib_css_modules_info
        grunt.config.set('lib_css_modules_info', cssModulesInfo);
    }
408265
function bundleCSS() {
    const glob      = require('glob');
    const srcmap    = require('./srcmap');
    const BUILT_PATH = path.join(__dirname, '..', config.dir.built);

    glob.sync('**/*.css', {
        cwd: BUILT_PATH
    }).forEach((file) => {
        const src = fs.readFileSync(path.join(BUILT_PATH, file)).toString()
            .replace(/^\ufeff/gm, '')
            .replace(/\r\n/gm, '\n')
        ;
        const node = srcmap.getNodeFromCode(src);
        node.prepend(banner('.css', path.basename(file, '.css')));
        const bundleSrc = '\ufeff' + srcmap.getCodeFromNode(node, (srcPath) => {
            const regex_src = new RegExp(`${config.dir.src}\\/${config.dir.stylesheet}\\/`);
            return srcPath
                .replace(/\.\.\//g, '')
                .replace(regex_src, SOURCE_MAP_NAMESPACE)
            ;
        }, { multiline: true });
        fs.writeFileSync(path.join(BUILT_PATH, file), bundleSrc);
        fs.writeFileSync(path.join(DST_PATH, file), bundleSrc);
    });
}