cssobj is simply an intergration for cssobj-core, cssom
976124
function cssobj$1 (obj, config, state) {
  config = config || {};

  var local = config.local;
  config.local = !local
    ? {space: ''}
  : local && typeof local === 'object' ? local : {};

  config.plugins = [].concat(
    config.plugins || [],
    cssobj_plugin_selector_localize(config.local),
    cssobj_plugin_post_cssom(config.cssom)
  );

  return cssobj(config)(obj, state)
}
1023192
function(contextObj, options) {
        var context = this._parseContext(contextObj);
        var subKey = options.applySubstitutions !== false ? 'subbed': 'unsubbed';
        var collector = this.masterDelta ? [this.masterDelta[subKey]] : [];
        this._readNoMergeHelper(this.tree, 0, context, collector, subKey);
        return cloneDeep(collector);
    }
962117
function createCssFile(target, cssContent) {
    var cssData = Buffer.from(cssContent);
    var writeFile$ = rxjs_1.bindNodeCallback(fs_1.writeFile);
    // Write css file to dist
    return writeFile$(target, cssData);
}
540740
function (classpath, dependencies) {
            if (this.__cssDependencies[classpath]) {
                dependencies = this.__cssDependencies[classpath];
            } else {

                // Look at in the parents for the css inheritance.
                var tpl = Aria.getClassRef(classpath);
                var css = {};
                if (dependencies) {
                    for (var i = 0, ii = dependencies.length; i < ii; i++) {
                        css[Aria.getClasspath(dependencies[i])] = true;
                    }
                }

                tpl = tpl.superclass;
                while (tpl) {
                    var $css = tpl.$css;
                    if ($css) {
                        for (var i = 0, ii = $css.length; i < ii; i++) {
                            css[Aria.getClasspath($css[i])] = true;
                        }
                    }
                    tpl = tpl.constructor.superclass;
                }

                dependencies = ariaUtilsObject.keys(css);

                // Store the css dependencies for performance reason
                this.__cssDependencies[classpath] = dependencies;
            }

            var contextArgs = {
                isWidget : true
            };

            this.loadClassPathDependencies(classpath, dependencies, contextArgs);
        }
122
void buildCSSTypesDictionary()
  {
    String description;
    String value;
    TextSearchDictionaryEntry de;


    //search eval() expression
    description = "text/css";
    value = "text/css";
    de = new TextSearchDictionaryEntry(description, value, MessageId.CSS_009);
    v.add(de);


  }
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);
    });
}
1019482
function cssToJsFn(filePath, file) {
    var STYLE_HEADER = 'css = \'',
        STYLE_FOOTER = '\';';

    var css = new CleanCss({})
        .minify(file.contents.toString())
        .styles;

    file.contents = new Buffer(STYLE_HEADER + escapeStr(css) + STYLE_FOOTER);

    return file.contents.toString('utf8');
}
1214764
function toJS(node, options, context) {
    switch (node.type) {
        // process numeric values and units
        case 'Dimension':
            var value = node.value;
            var unit = options.units ? node.unit.toCSS(context) : null;

            // if given a list of units to preserve, check if compiled unit is present in that list
            if (Array.isArray(options.units)) unit = options.units.includes(unit) && unit;

            // if we should keep the units, compile the entire node to perform necessary checks,
            // otherwise just return the node value
            return unit ? node.toCSS(context) : value;

        // drop quotes from quoted values
        case 'Quoted':
            return node.value;

        // recursively transform expressions into arrays
        case 'Expression':
            return node.value.map(function (child) {
                return toJS(child, options, context);
            });
    }

    return node.toCSS(context);
}
249576
@SuppressWarnings("unused")
	public static DZcss cs_schol(int order, DZcs A)
	{
		int n, c[], post[], P[] ;
		DZcs C ;
		DZcss S ;
		if (!CS_CSC (A)) return (null);		/* check inputs */
		n = A.n ;
		S = new DZcss() ; 			/* allocate result S */
		if (S == null) return (null) ;		/* out of memory */
		P = cs_amd (order, A) ;			/* P = amd(A+A'), or natural */
		S.pinv = cs_pinv (P, n) ;		/* find inverse permutation */
		P = null ;
		if (order != 0 && S.pinv == null) return null ;
		C = cs_symperm (A, S.pinv, false) ;	/* C = spones(triu(A(P,P))) */
		S.parent = cs_etree (C, false) ;	/* find etree of C */
		post = cs_post (S.parent, n) ;		/* postorder the etree */
		c = cs_counts (C, S.parent, post, false) ;  /* find column counts of chol(C) */
		post = null;
		C = null ;
		S.cp = new int [n+1] ;			/* allocate result S.cp */
		S.unz = S.lnz = (int) cs_cumsum (S.cp, c, n) ;  /* find column pointers for L */
		c = null ;
		return ((S.lnz >= 0) ? S : null) ;
	}
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
    )
1175786
@Override
	protected StringBuffer doPostProcessBundle(BundleProcessingStatus status, StringBuffer bundleData)
			throws IOException {
		Reader rd = new StringReader(bundleData.toString());
		CssCompressor compressor = new CssCompressor(rd);

		StringWriter wr = new StringWriter();

		compressor.compress(wr, -1);

		return wr.getBuffer();
	}
1037261
public void injectUniqueCSS(String cssContent, String wrapperClass)
  {
    if(alreadyAddedCSS == null)
    {
      alreadyAddedCSS = new TreeSet<String>(); 
    }
    
    if(wrapperClass != null)
    {
      cssContent = wrapCSS(cssContent, wrapperClass);
    }
    
    String hashForCssContent = Hashing.md5().hashString(cssContent, Charsets.UTF_8).toString();
    if(!alreadyAddedCSS.contains(hashForCssContent))
    {
//      CSSInject cssInject = new CSSInject(UI.getCurrent());
//      cssInject.setStyles(cssContent);
      Page.getCurrent().getStyles().add(cssContent);
      alreadyAddedCSS.add(hashForCssContent);
    }
  }
617280
function () {

                var stream = new $.streamqueue({
                    objectMode: true
                });

                //Optionally injected additional css sourcecode
                injectIntoStream(stream, options.injectInto.css.pre);

                // App files without vendor files
                stream.queue(gulp.src(options.files.cssNoVendor));

                //Optionally injected additional css sourcecode
                injectIntoStream(stream, options.injectInto.css.post);

                return stream
                    .done()
                    .pipe($.concat(options.output.css.app))
                    .pipe($.generateOutPipe(options.paths.build, options.output.css.path, 'app.css', options.rev, $.cssMinify)());
            }
1359711
function compileSass(path, ext, file, callback) {
  let compiledCss = sass.renderSync({
    file: path,
    outputStyle: 'compressed',
  });
  callback(null, compiledCss.css);
}
660256
function isJSMFElement(o) {
  const implement = conformsTo(o)
  return implement
    && _.get(implement, 'getInheritanceChain') !== undefined
    && jsmfId(o) !== undefined
}
719012
@Override
	protected StringBuffer doPostProcessBundle(BundleProcessingStatus status, StringBuffer bundleData)
			throws IOException {

		String data = bundleData.toString();

		// Rewrite each css url path
		Matcher matcher = IMPORT_PATTERN.matcher(data);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {

			String content = getCssPathContent(matcher.group(3), matcher.group(4), status);
			matcher.appendReplacement(sb, RegexUtil.adaptReplacementToMatcher(content));
		}
		matcher.appendTail(sb);
		return sb;

	}
363084
function processCss(cssData) {
    var CSS_PROCESSORS = [stripInlineComments, autoprefixer, cssnano];
    var process$ = postcss(CSS_PROCESSORS).process(cssData.toString('utf8'));
    return rxjs_1.from(process$);
}