csso 0,3,0,0,2,0,3,1 editorconfig jscs travis-ci npm

CSS minifier with structural optimizations

NPM version Build Status Coverage Status NPM Downloads Twitter

CSSO (CSS Optimizer) is a CSS minifier. It performs three sort of transformations: cleaning (removing redundant), compression (replacement for shorter form) and restructuring (merge of declarations, rulesets and so on). As a result your CSS becomes much smaller.

Originated by Yandex Sponsored by Avito

Ready to use


npm install csso


Basic usage:

var csso = require('csso');

var minifiedCss = csso.minify('.test { color: #ff0000; }').css;

// .test{color:red}

CSSO is based on CSSTree to parse CSS into AST, AST traversal and to generate AST back to CSS. All CSSTree API is available behind syntax field. You may minify CSS step by step:

var csso = require('csso');
var ast = csso.syntax.parse('.test { color: #ff0000; }');
var compressedAst = csso.compress(ast).ast;
var minifiedCss = csso.syntax.translate(compressedAst);

// .test{color:red}

Warning: CSSO uses early versions of CSSTree that still in active development. CSSO doesn’t guarantee API behind syntax field or AST format will not change in future releases of CSSO, since it’s subject to change in CSSTree. Be carefull with CSSO updates if you use syntax API until this warning removal.

minify(source[, options])

Minify source CSS passed as String.

var result = csso.minify('.test { color: #ff0000; }', {
    restructure: false,   // don't change CSS structure, i.e. don't merge declarations, rulesets etc
    debug: true           // show additional debug information:
                          // true or number from 1 to 3 (greater number - more details)

// > .test{color:red}

Returns an object with properties:


  • sourceMap

Type: Boolean
Default: false

Generate a source map when true.

  • filename

Type: String
Default: '<unknown>'

Filename of input CSS, uses for source map generation.

  • debug

Type: Boolean
Default: false

Output debug information to stderr.

  • beforeCompress

Type: function(ast, options) or Array<function(ast, options)> or null
Default: null

Called right after parse is run.

  • afterCompress

Type: function(compressResult, options) or Array<function(compressResult, options)> or null
Default: null

Called right after compress() is run.

  • Other options are the same as for compress() function.

minifyBlock(source[, options])

The same as minify() but for list of declarations. Usually it’s a style attribute value.

var result = csso.minifyBlock('color: rgba(255, 0, 0, 1); color: #ff0000');

// > color:red

compress(ast[, options])

Does the main task – compress an AST.

NOTE: compress() performs AST compression by transforming input AST by default (since AST cloning is expensive and needed in rare cases). Use clone option with truthy value in case you want to keep input AST untouched.

Returns an object with properties:

  • ast Object – resulting AST


  • restructure

Type: Boolean
Default: true

Disable or enable a structure optimisations.

  • clone

Type: Boolean
Default: false

Transform a copy of input AST if true. Useful in case of AST reuse.

  • comments

Type: String or Boolean
Default: true

Specify what comments to left:

  • 'exclamation' or true – left all exclamation comments (i.e. /*! .. */)

  • 'first-exclamation' – remove every comments except first one

  • false – remove every comments

  • usage

Type: Object or null
Default: null

Usage data for advanced optimisations (see Usage data for details)

  • logger

Type: Function or null
Default: null

Function to track every step of transformation.

Source maps

To get a source map set true for sourceMap option. Additianaly filename option can be passed to specify source file. When sourceMap option is true, map field of result object will contain a SourceMapGenerator instance. This object can be mixed with another source map or translated to string.

var csso = require('csso');
var css = fs.readFileSync('path/to/my.css', 'utf8');
var result = csso.minify(css, {
  filename: 'path/to/my.css', // will be added to source map as reference to source file
  sourceMap: true             // generate source map

// { css: '...minified...', map: SourceMapGenerator {} }

// '{ .. source map content .. }'

Example of generating source map with respect of source map from input CSS:

var require('source-map');
var csso = require('csso');
var inputFile = 'path/to/my.css';
var input = fs.readFileSync(inputFile, 'utf8');
var inputMap = input.match(/\/\*# sourceMappingURL=(\S+)\s*\*\/\s*$/);
var output = csso.minify(input, {
  filename: inputFile,
  sourceMap: true

// apply input source map to output
if (inputMap) {
    new SourceMapConsumer(inputMap[1]),

// result CSS with source map
  output.css +
  '/*# sourceMappingURL=data:application/json;base64,' +
  new Buffer(output.map.toString()).toString('base64') +
  ' */'

Usage data

CSSO can use data about how CSS is used in a markup for better compression. File with this data (JSON) can be set using usage option. Usage data may contain following sections:

  • blacklist – a set of black lists (see Black list filtering)
  • tags – white list of tags
  • ids – white list of ids
  • classes – white list of classes
  • scopes – groups of classes which never used with classes from other groups on the same element

All sections are optional. Value of tags, ids and classes should be an array of a string, value of scopes should be an array of arrays of strings. Other values are ignoring.

White list filtering

tags, ids and classes are using on clean stage to filter selectors that contain something not in the lists. Selectors are filtering only by those kind of simple selector which white list is specified. For example, if only tags list is specified then type selectors are checking, and if all type selectors in selector present in list or selector has no any type selector it isn’t filter.

ids and classes are case sensitive, tags – is not.

Input CSS:

* { color: green; }
ul, ol, li { color: blue; }
UL.foo, span.bar { color: red; }

Usage data:

    "tags": ["ul", "LI"]

Resulting CSS:


Filtering performs for nested selectors too. :not() pseudos content is ignoring since the result of matching is unpredictable. Example for the same usage data as above:

:nth-child(2n of ul, ol) { color: red }
:nth-child(3n + 1 of img) { color: yellow }
:not(div, ol, ul) { color: green }
:has(:matches(ul, ol), ul, ol) { color: blue }

Turns into:

:nth-child(2n of ul){color:red}:not(div,ol,ul){color:green}:has(:matches(ul),ul){color:blue}

Black list filtering

Black list filtering performs the same as white list filtering, but filters things that mentioned in the lists. blacklist can contain the lists tags, ids and classes.

Black list has a higher priority, so when something mentioned in the white list and in the black list then white list occurrence is ignoring. The :not() pseudos content ignoring as well.

* { color: green; }
ul, ol, li { color: blue; }
UL.foo, li.bar { color: red; }

Usage data:

    "blacklist": {
        "tags": ["ul"]
    "tags": ["ul", "LI"]

Resulting CSS:



Scopes is designed for CSS scope isolation solutions such as css-modules. Scopes are similar to namespaces and define lists of class names that exclusively used on some markup. This information allows the optimizer to move rules more agressive. Since it assumes selectors from different scopes don’t match for the same element. This can improve rule merging.

Suppose we have a file:

.module1-foo { color: red; }
.module1-bar { font-size: 1.5em; background: yellow; }

.module2-baz { color: red; }
.module2-qux { font-size: 1.5em; background: yellow; width: 50px; }

It can be assumed that first two rules are never used with the second two on the same markup. But we can’t say that for sure without a markup review. The optimizer doesn’t know it either and will perform safe transformations only. The result will be the same as input but with no spaces and some semicolons:


With usage data CSSO can produce better output. If follow usage data is provided:

    "scopes": [
        ["module1-foo", "module1-bar"],
        ["module2-baz", "module2-qux"]

The result will be (29 bytes extra saving):


If class name isn’t mentioned in the scopes it belongs to default scope. scopes data doesn’t affect classes whitelist. If class name mentioned in scopes but missed in classes (both sections are specified) it will be filtered.

Note that class name can’t be set for several scopes. Also selector can’t has a class names from different scopes. In both cases an exception will thrown.

Currently the optimizer doesn’t care about changing order safety for out-of-bounds selectors (i.e. selectors that match to elements without class name, e.g. .scope div or .scope ~ :last-child). It assumes that scoped CSS modules doesn’t relay on it’s order. It may be fix in future if to be an issue.



Related Repositories



CSS minifier with structural optimizations ...



Light Node.js module that compress javascript and css files with Babili / Yui Compressor / Google Closure Compiler / UglifyJS / Clean-css / CSSO / Sqwish ...



Minify CSS files with CSSO. ...



Minify CSS with CSSO. ...



CSS Optimizer(csso) ruby wrapper for Rails Asset pipeline ...

Top Contributors

lahmatiy afelix anotherquiz tadatuta sergeche XhmikosR vithar ftonato Leonya t32k Bonga gela-d benurb lesanra Taritsyn ArturAralin 4exova denysdovhan sipayRT silentroach innabelaya johanneszorn joshbaumann julesanchez jk708 mathiasbynens angryobject MunGell spmason sokra


package version
css-tree csstree/csstree
dev browserify ^13.0.0
coveralls ^2.11.6
eslint ^2.2.0
istanbul ^0.4.2
jscs ~2.10.0
mocha ~2.4.2
package-json-versionify ^1.0.4
source-map ^0.5.6
uglify-js ^2.6.1


-   v2.2.1 zip tar
-   v2.2.0 zip tar
-   v2.1.1 zip tar
-   v2.1.0 zip tar
-   v2.0.0 zip tar
-   v1.8.2 zip tar
-   v1.8.1 zip tar
-   v1.8.0 zip tar
-   v1.7.1 zip tar
-   v1.7.0 zip tar
-   v1.6.4 zip tar
-   v1.6.3 zip tar
-   v1.6.2 zip tar
-   v1.6.1 zip tar
-   v1.6.0 zip tar
-   v1.5.4 zip tar
-   v1.5.3 zip tar
-   v1.5.2 zip tar
-   v1.5.1 zip tar
-   v1.5.0 zip tar
-   v1.4.4 zip tar
-   v1.4.3 zip tar
-   v1.4.2 zip tar
-   v1.4.1 zip tar
-   v1.4.0 zip tar
-   v1.3.12 zip tar
-   v1.3.11 zip tar
-   v1.3.10 zip tar
-   v1.3.9 zip tar