csso

• Fixed CommonJS version bundling when browser field is used
• Added module field

• Extended Node.js support to include ^10
• Fixed main field in package.json to refer to CommonJS module
• Bumped css-tree to ~2.0.4 (fixed CSS serialization issue in IE11)

• Bumped css-tree to ~2.0.3 (various fixes on generate CSS)
• Added exports:
  • csso/syntax

• Added support for CSS Selectors Level 4 and legacy pseudos in specificity calculation, i.e. :has(), :not(<selector-list>), :is(), :matches(), :-moz-any(), :-webkit-any(), :where(), :nth-child(... of <selector-list>) and :nth-last-child(... of <selector-list>)
• Package
  • Changed supported versions of Node.js to ^12.20.0, ^14.13.0 and >=15.0.0
  • Converted to ES modules. However, CommonJS is supported as well (dual module)
  • Changed bundle set to provide dist/csso.js (an IIFE version with csso as a global name) and dist/csso.esm.js (as ES module). Both are minified
  • Bumped css-tree to 2.0

• Trim Custom Property values when possible (#393)
• Fixed removing unit for zero-length dimentions in min(), max() and clamp() functions (#426)
• Fixed crash on bad value in TRBL declaration value (#412)

• Fixed build setup to exclude full mdn/data that reduced the lib size:
  • dist/csso.js: 794.5Kb -> 255.2Kb
  • dist/csso.min.js: 394.4Kb -> 194.2Kb
  • package size: 237.8 kB -> 156.1 kB
  • package unpacked size: 1.3 MB -> 586.8 kB

• Bumped CSSTree to ^1.0.0
• Fixed wrongly merging of TRBL values when one of them contains var() (#420)
• Fixed wrongly merging of pseudo class and element with the same name, e.g. :-ms-input-placeholder and ::-ms-input-placeholder (#383, #416)
• Fixed wrongly merging of overflow fallback (#415)

• Prevented percent sign removal in flex/-ms-flex (#410)
• Fixed restructuring optimisation in some cases (thanks to @charlessuh & @chsuh, #358, #411)
• Bumped dependencies (thanks to @AviVahl, #409)

• Fixed clean stage to avoid exceptions when source has unparsed or bad parts (#369, #378, #380, #397)
• Fixed wrong percentage sign removal for zero values (#382, #395)

• Bumped CSSTree to 1.0.0-alpha.37 to avoid source map generation inconsistency across Node.js versions

• Dropped support for Node < 8
• Refreshed dev dependencies and scripts
• Bumped CSSTree to 1.0.0-alpha.36 (#399)
• Changed bundle files: dist/csso.js and dist/csso.min.js instead single dist/csso-browser.js (min version)
• Expose compress() as syntax.compress()

• Bumped CSSTree to 1.0.0-alpha.29 (fixes some issues)

• Migrated to CSSTree 1.0.0-alpha.27

WARN: Internal API (i.e. csso.syntax) was changed, see CSSTree's release notes for details

• Added percent sign removal for zero percentages for some properties that is safe (@RubaXa, #286)
• Removed unit removal for zero values in -ms-flex due it breaks flex in IE10/11 (#362)
• Improved performance of selectors comparison (@smelukov, #343)

• Fixed merge of position declarations when sticky fallback is using (thanks to @gruzzilkin, #356)

• Migrated to CSSTree 1.0.0-alpha25
  • Changed AST format (see CSSTree change log for details)
  • Fixed performance issue when generate CSS with source map (quadratic increase in time depending on the size of the CSS)

• Fixed named color compression to apply only when an identifier is guaranteed to be a color. Used CSSTree's feature to determine the meaning of a part of a value based on W3C specs. No more false positive matches like Arial Black, and with no hacks ;)
• Added lifting of @keyframes to the beginning of style sheet
• Added removal of @keyframes, @media and @supports with no prelude
• Added removal of duplicate @keyframes (#202)
• Added new option forceMediaMerge to force media rules merging. It's unsafe in general, but works fine in many cases. Use it on your own risk (#350)
• Bumped CSSTree to 1.0.0-alpha23

• Fixed crash on a number processing when it used not in a list (#335)

• Implemented optimisation for none keyword in border and outline properties (@zoobestik, #41)
• Implemented replacing rgba(x, x, x, 0) to transparent
• Fixed plus sign omitting for numbers following identifier, hex color, number or unicode range, since it can change the meaning of CSS (e.g. calc(1px+2px) has been optimized to calc(1px2px) before, now it stays the same)
• Improved usage filtering for nested selectors (i.e. for :nth-*(), :has(), :matches and other pseudos)
• Implemented blacklist filtering in usage (#334, see Black list filtering)
• Improved white space removing, now white spaces are removing in the beginning and at the ending of sequences, and between stylesheet and block nodes
• Bumped css-tree to 1.0.0-alpha19

• Fixed declaration merging when declaration contains an !important

New AST backend

Initially, CSSO used Gonzales for CSS parsing into AST, tree traversal and translating it back to a string. During last year numerous refactorings transformed it into something different. Eventually, AST backend became a brand new solution, too powerful to use it just for a single task like a CSS minification. Therefore it was extracted into a standalone project called CSSTree and developing as an independent.

CSSTree became stable enough. So it's a time bring it back to CSSO as dependency and get fast and efficient CSS parsing and other AST operations. At the same time, CSSTree is more specs compliant and works better for edge cases. Starting this release CSSO is based on CSSTree and gets great tools it provides.

Changes don't affect high-end users but those who're using internal API to deal with AST. The most significant change – every AST method is now behind syntax property of CSSO public API. Actually, the entire CSSTree syntax is behind syntax property. Worth noting that CSSTree that still in active development and syntax API shape may be changed in next CSSO releases while migration on new CSSTree versions. AST format was changed too, but it quite stable now so no surprises expected here.

CLI as standalone package

Command line interface was integrated into CSSO from its beginning. It was common for tools in time when CSSO were invented. Since than frontend developing has been changed, task runners and bundlers rule the world today. Most users use CSSO plugins for task runners and bundlers rather than CLI. That's why extracting it into a separate package (csso-cli) looks reasonable to reduce dependency count. With this release, CLI should be installed separately.

Changes

• Migrated to CSSTree as AST backend and exposed its API behind syntax property
• Extracted CLI into standalone package css/csso-cli

• Fixed infinite loop on value parse (#328)

• Added \0 IE hack support (#320)

• Added beforeCompress and afterCompress options support (#316)
• Fixed crash on empty argument in function (#317)

• Fixed shorthand optimisation issue when value has a color value or something unknown (#311)
• Fixed cursor broken fallback (#306)

• Implement AST cloning by adding clone() function and clone option for compress() function (#296)
• Fix parse and translate attribute selector with flags but with no operator (i.e. [attrName i])
• Don't merge rules with flagged attribute selectors with others (#291)
• Take in account functions when merge TRBL-properties (#297, thanks to @ArturAralin)
• Improve partial merge (#304)
• Tweak scanner, reduce code deoptimizations and other small improvements

• Fix wrong declaration with \9 hack merge (#295)

• New option comments to specify what comments to left: exclamation, first-exclamation and none
• Add offset to CSS parse error details
• Fix token offset computation

It has been almost six months since CSSO came back to active development. During this time, it has become much faster, reduce memory consumption and has got new cool features. It is time to discard the legacy API to keep moving forward. If you have used the CLI nothing has changed for you. Basically, the changes affect the internal API users and plugin authors. But the changes are not dramatic and aimed to provide a simple and consistent API. For example earlier minify() method returns a string or an object, depending on whether the source map is required or not. Now the method is less confusing and always returns an object.

var csso = require('csso');

// before
console.log(csso.minify(css));
console.log(csso.minify(css, { sourceMap: true }).css);

// now it's consistent
console.log(csso.minify(css).css);
console.log(csso.minify(css, { sourceMap: true }).css);

Most significant changes is about AST format. For long time, CSSO used gonzales parser and its AST format for CSS transformation. That format is good enough, but not so convenient to maintain and extend. Therefore in 1.5.0 internal AST format was introduced. Despite the fact that the internal format is better in many ways, it led to unnecessary overhead in time and memory, as required converting gonzales<->internal. In addition, it has led to the need for dual-API – one for gonzales AST and another for internal. Parser was reworked to build AST in "internal" format, that become single format is using by CSSO now. Gonzales format and related code was totally removed. The huge diff but it's worth it! This, as well as the introduction of a brand new dynamic scanner, made the parser faster by ~30%. And together with no extra converting compression accelerated at least by ~15% and reduced memory consumption by almost half.

These are important changes for the upcoming features! See current state of API in readme.

Changes

• No more gonzales AST format and related code
• minify() and minifyBlock() is always return an object as result now (i.e. { css: String, map: SourceMapGenerator or null })
• parse()
  • Returns AST in new format (so called internal)
  • Dynamic scanner implemented
  • New AST format + dynamic scanner = performance boost and less memory consumption
  • No more context argument, context should be specified via options
  • Supported contexts now: stylesheet, atrule, atruleExpression, ruleset, selector, simpleSelector, block, declaration and value
  • Drop needPositions option, positions option should be used instead
  • Drop needInfo option, info object is attaching to nodes when some information is requested by options
  • options should be an object, otherwise it treats as empty object
• compress()
  • No more AST converting (performance boost and less memory consumption)
  • Drop outputAst option
  • Returns an object as result instead of AST (i.e. { ast: Object })
• Drop methods: justDoIt(), stringify(), cleanInfo()

• Fix wrong declaration with \9 hack merge (#295)
• Take in account functions when merge TRBL-properties (#297)
• Improve partial merge (#304)

• Don't remove spaces after function/braces/urls since unsafe (#289)

The main feature of the release is usage data support. By default the optimizer doesn't know how CSS is using on markup and performs safe transformations only. But such knowledge allows to do much more. CSSO doesn't collect any information about CSS using (that's other tools task) but can use usage data to perform filtering and better compression. Data can be provided via --usage option for CLI or usage option for minify() and compress() methods.

Filtering

Usage data can be used to filter selectors that contains something not in a white list. You can provide lists for tag names, class names or ids.

> cat example.css
.with { color: red; }
.usage.data { color: green; }
.we.can.do.more, .data { color: blue; }
.not.only.usage { color: yellow; }

> csso example.css
.with{color:red}.usage.data{color:green}.data,.we.can.do.more{color:#00f}.not.only.usage{color:#ff0}

> cat usage.json
{
    "classes": ["usage", "data"]
}

> csso example.css --usage usage.json
.usage.data{color:green}.data{color:#00f}

Scopes

CSS scope isolation solutions such as css-modules are becoming popular today. Scopes are similar to namespaces and defines lists of class names that exclusively used on some markup. This information allows the optimizer to move rulesets more agressive. Since it assumes selectors from different scopes can't to be matched on the same element. That leads to better ruleset merging.

In example we get better compression using scopes information (29 bytes extra saving).

> cat example.css
.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; }

> csso example.css
.module1-foo{color:red}.module1-bar{font-size:1.5em;background:#ff0}.module2-baz{color:red}.module2-qux{font-size:1.5em;background:#ff0;width:50px}

> cat usage.json
{
    "scopes": [
        ["module1-foo", "module1-bar"],
        ["module2-baz", "module2-qux"]
    ]
}

> csso example.css --usage usage.json
.module1-foo,.module2-baz{color:red}.module1-bar,.module2-qux{font-size:1.5em;background:#ff0}.module2-qux{width:50px}

Compression improvement with this feature depends on project structure. For a project in which we tested the feature, it gives 25-38% CSS size reduction compared to result without using usage data (the project uses its own CSS module isolation solution).

See more detail about feature in readme.

minifyBlock()

Some tools are using CSSO not only for stylesheet compression but also for style attribute compression. If use minify() method for this task it raises a parse error. So tool's authors do something like that:

var csso = require('csso');

function compressStyleAttributeContent(options) {
    var tmp = '.dummy{' + style + '}';
    var compressed = csso.minify(tmp, options);

    return compressed.replace(/^\.dummy\{|\}$/);
}

compressStyleAttributeContent('color: rgba(255, 0, 0, 1); color: yellow', options);
// > 'color:#ff0'

Now it's all can be replaced for minifyBlock() function. No more hacks!

var csso = require('csso');

css.minifyBlock('color: rgba(255, 0, 0, 1); color: yellow', options);
// > 'color:#ff0'

Changes

• Usage data support:
  • Filter rulesets by tag names, class names and ids white lists.
  • More aggressive ruleset moving using class name scopes information.
  • New CLI option --usage to pass usage data file.
• Improve initial ruleset merge
  • Change order of ruleset processing, now it's left to right. Previously unmerged rulesets may prevent lookup and other rulesets merge.
  • Difference in pseudo signature just prevents ruleset merging, but don't stop lookup.
  • Simplify block comparison (performance).
• New method csso.minifyBlock() for css block compression (e.g. style attribute content).
• Ruleset merge improvement: at-rules with block (like @media or @supports) now can be skipped during ruleset merge lookup if doesn't contain something prevents it.
• FIX: Add negation (:not()) to pseudo signature to avoid unsafe merge (old browsers doesn't support it).
• FIX: Check nested parts of value when compute compatibility. It fixes unsafe property merging.

• pass block mode to tokenizer for correct parsing of declarations properties with // hack
• fix wrongly @import and @charset removal on double exclamation comment

• support for CSS Custom Properties (#279)
• rework RTBL properties merge – better merge for values with special units and don't merge values with CSS-wide keywords (#255)
• remove redundant universal selectors (#178)
• take in account !important when check for property overriding (#280)
• don't merge text-align declarations with some values (#281)
• add spaces around /deep/ combinator on translate, since it together with universal selector can produce a comment
• better keyword and property name resolving (tolerant to hacks and so on)
• integration improvements
  • compression log function could be customized by logger option for compress() and minify()
  • make possible to set initial line and column for parser

• npm publish issue (#276)

• add file to generated source map since other tools can relay on it in source map transform chain

• tweak some parse error messages and their positions
• fix :not() parsing and selector groups in :not() is supported now (#215)
• needPosition parser option is deprecated, positions option should be used instead (needPosition is used still if positions option omitted)
• expose internal AST API as csso.internal.*
• minify() adds sourcesContent by default when source map is generated
• bring back support for node.js 0.10 until major release (#275)

• fix exception on zero length dimension compress outside declaration (#273)

The main feature of this release is Source Maps support. To get a source map use --map CLI option. Source map can be inlined or saved to external file. For example:

$ echo '.example { color: #ff0000 }' | csso --map inline
.example{color:red}
/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjxzdGRpbj4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUSxDQUFXLFMiLCJzb3VyY2VzQ29udGVudCI6WyIuZXhhbXBsZSB7IGNvbG9yOiAjZmYwMDAwOyB9XG4iXX0= */

CSSO is trying to fetch input source map and use it for generating map (when --map option is used). More details and options see in readme.

Support of source maps needs the right positions in original CSS to be got on parsing and passed right to the end of optimisation till translation into string. This led to the need for a number of changes in the parser and ended by its full remake. Also compressor was reworked, its code simplified (for example, by using lists instead of arrays) and various optimisations were added. As the result CSSO became 2x faster:

It was hard before to realize where something is going wrong on CSS parsing and why. Here is the example:

$ echo '.test { color }' | csso
/usr/local/lib/node_modules/csso/lib/parser/index.js:115
    throw new Error('Please check the validity of the CSS block starting from the line #' + currentBlockLN);
    ^

Error: Please check the validity of the CSS block starting from the line #1
    at throwError (/usr/local/lib/node_modules/csso/lib/parser/index.js:115:11)
    at getBlock (/usr/local/lib/node_modules/csso/lib/parser/index.js:523:14)
    at getRuleset (/usr/local/lib/node_modules/csso/lib/parser/index.js:1585:18)
    at getStylesheet (/usr/local/lib/node_modules/csso/lib/parser/index.js:1783:52)
    at Object.CSSPRules.stylesheet (/usr/local/lib/node_modules/csso/lib/parser/index.js:80:65)
    at parse (/usr/local/lib/node_modules/csso/lib/parser/index.js:2094:30)
    at Object.minify (/usr/local/lib/node_modules/csso/lib/index.js:18:15)
    at /usr/local/lib/node_modules/csso/lib/cli.js:38:31
    at Socket.<anonymous> (/usr/local/lib/node_modules/csso/lib/cli.js:14:13)
    at emitNone (events.js:72:20)

Refactoring of the parser helped to fix it. Starting with this release CSS error output has more details and solving problems should be much easier:

$ echo '.test { color }' | csso

Parse error <stdin>: Colon is expected
    1 |.test { color }
---------------------^
    2 |

Code coverage was set up and it helped to fix a number issues. Currently 99% of code is covered by tests. But truly speaking it doesn't mean minification is always correct (mostly because of structural optimizations). Minification improvements and its correctness is being the focus for next releases.

Changes

• source maps support
• parser remake:
  • various parsing issues fixed
  • fix unicode sequence processing in ident (#191)
  • support for flags in attribute selector (#270)
  • position (line and column) of parse error (#109)
  • 4x performance boost, less memory consumption
• compressor refactoring
  • internal AST is using doubly linked lists (with safe transformation support during iteration) instead of arrays
  • rename restructuring to restructure option for minify()/compress() (restructuring is alias for restructure now, with lower priority)
  • unquote urls when possible (#141, #60)
• setup code coverage and a number of related fixes

• one more fix (in restructRuleset this time) with merge of rulesets when a ruleset with same specificity places between them (#264)
• disable partial merge of rulesets in @keyframes rulesets (until sure it's correct)

• don't override display values with different browser support (#259)
• fix publish issue (one of modules was published in development state)

• don't merge rulesets if between them a ruleset with same specificity (#264)

• ensure - is not used as an identifier in attribute selectors (thanks to @mathiasbynens)
• fix broken justDoIt() function
• various small fixes

The main changes of this release are about compressor. It significant refactored in two aspects: code simplicity and performance. Also a new AST format for compressor was introduced.

Let's start with clarification on the new AST format. As you may know csso uses gonzales to parse CSS to get AST. In the past it was one of fastest detailed CSS parsers written in JavaScript. But now gonzales isn't fast enough and hasn't support for some new things that were added to CSS last years. Further more gonzales uses arrays to describe AST nodes that isn't verbose, slow and expensive for memory. Also its format has several design mistakes and unsuitable for transformations as well.

Therefore, the replacement of the parser became obvious. But it isn't so easy since every single part of csso depends on AST format. Another problem is there is no suitable detailed CSS parser that can be a replacement for gonzales. So I have started working on this sort of parser a сouple of months ago. But still a lot of work to be done. Until that I decided to do first step for parser replacing by introducing new AST format (for now for internal usage only). Currently gonzales is used for getting initial AST which after that is converted into internal format. Theoretically it's possible to write AST convertors for other parsers too. Thus csso became less dependent on the parser.

Actually new format appeared in the middle of refactoring to simplify code and improve readability. But first tests showed performance boost too despite AST conversion overhead. That was the sign that we are on the right way.

Earlier source code of compressor was too complicated and was located in a single file. Now it is splitted into simple modules grouped by phase of processing: cleaning, compressing and restructuring. It makes dealing with compressor's source code much easier. Moreover, beside improved readability, the new AST format helped to simplify the source code since this format uses objects instead of arrays to describe AST nodes, has no redundant things and much more suitable for transformations.

Before we talk about performance, let's look at comparison table first (the table is based on css-minification-benchmark):

As you can see, csso 1.5 is about 1.2–3.4 times faster than previous version. Take in account that those numbers contain time of all operations, i.e. parsing, compression and translation. In 1.4 compression takes more than ¾ of total time, but the new version takes less than a half of it. In fact compression become much faster than changes in total time because parsing takes significant time (one more reason to change parser) and has not changed.

As was mentioned above, some part of the performance boost due new AST format. It's not the single optimisation. Restructuring algorithms were also improved, redundant calculations and actions were removed, creating and copying of data structures was reduced, various caches and indexes are using now, some heuristics based on CSS specifics were used. Also final restructuring steps perform without a loop now. This loop was very expensive because snapshots (AST translating to string) were made in the beginning and in the end of each iteration and compared to check that iteration has good progress. It led to a lot of memory consumption and , even to processing freeze on large files. For example test file (3.7Mb) in issue #201 was never processed whereas now it takes about 12 seconds to be done (not so good but better than infinity). It is also worth noting that memory consumption has also been reduced by more than a half.

It's not the end of the compressor refactoring. The restructuring algorithms still need to be replaced for better ones that produce better results. More optimisation could be done when the parser will provide more details about CSS structure. So new improvements are coming.

Change log

Parser

• attach minus to number

Compressor

• split code base into small modules and related refactoring
• introduce internal AST format for compressor (gonzales→internal and internal→gonzales convertors, walkers, translator)
• various optimizations: no snapshots, using caches and indexes
• sort selectors, merge selectors in alphabet order
• compute selector's specificity
• better ruleset restructuring, improve compression of partially equal blocks
• better ruleset merge – not only closest but also disjoined by other rulesets when safe
• join @media with same query
• outputAst – new option to specify output AST format (gonzales by default for backward compatibility)
• remove quotes surrounding attribute values in attribute selectors when possible (issue #73)
• replace from→0% and 100%→to at @keyframes (#205)
• prevent partial merge of rulesets at @keyframes (#80, #197)

API

• walker for gonzales AST was implemented

CLI

• new option --stat (output stat in stderr)
• new optional parameter level for --debug option

• prevent removal of spaces after braces that before identifier that breaking at-rules expressions (#258)

• fix unicode-range parsing that cause to wrong function detection (#250)

• allow spaces between progid: and rest part of value for IE's filter property as autoprefixer generates this kind of code (#249)
• fixes for Windows:
  • correct processing of new lines
  • normalize file content in test suite before comparing
• fixes to work in strict mode (#252)
• init compressor dictionaries for every css block (#248, #251)
• bump uglify-js version

• allow merge for display property (#167, #244)
• more accurate rect (clip property value) merge
• fix typo when specifying options in cli (thanks to @Taritsyn)
• fix safe unit values merge with keyword values (#244)
• fix wrong descendant combinator removal (#246)
• build browser version on prepublish (thanks to @silentroach)
• parser: store whitespaces as single token (performance and reduce memory consumption)

Back project to life. Changed files structure, cleaned up and refactored most of sources. Closed 60+ issues.

Common

• single code base (no more src folder)
• build browser version with browserify (no more make, and web folder), browser version is available at dist/csso-browser.js
• main file is lib/index.js now
• minimal node.js version is 0.12 now
• restrict file list to publish on npm (no more useless folders and files in package)
• add jscs to control code style
• automate gh-pages update
• util functions reworked
• translator reworked
• test suite reworked
• compressor refactored
• initial parser refactoring

API

• new method minify(src, options), options:
  • restructuring – if set to false, disable structure optimisations (true by default)
  • debug - outputs intermediate state of CSS during compression (false by default)
• deprecate justDoIt() method (use minify instead)
• rename treeToString() method to stringify()
• drop printTree() method
• AST node info
  • column and offset added
  • ln renamed to line
  • fix line counting across multiple files and input with CR LF (#147)

CLI

• completely reworked, use clap to parse argv
• add support for input from stdin (#128)
• drop undocumented and obsoleted options --rule and --parser (suppose nobody use it)
• drop -off alias for --restructure-off as incorrect (only one letter options should starts with single -)
• new option --debug that reflecting to options.debug for minify

Parsing and optimizations

• keep all exclamation comments (#194)
• add /deep/ combinator support (#209)
• attribute selector
  • allow colon in attribute name (#237)
  • support for namespaces (#233)
• color
  • support all css/html colors
  • convert hsla to rgba and hls to rgb
  • convert rgba with 1 as alpha value to rgb (#122)
  • interpolate rgb and rgba percentage values to absolute values
  • replace percentage values in rgba for normalized/interpolated values
  • lowercase hex colors and color names (#169)
  • fix color minification when hex value replaced for color name (#176)
  • fit rgb values to 0..255 range (#181)
• calc
  • remove spaces for multiple operator in calc
  • don't remove units inside calc (#222)
  • fix wrong white space removal around + and - (#228)
• don't remove units in flex property as it could change value meaning (#200)
• don't merge \9 hack values (#231)
• merge property values only if they have the same functions (#150, #227)
• don't merge property values with some sort of units (#140, #161)
• fix !important issue for top-right-bottom-left properties (#189)
• fix top-right-bottom-left properties merge (#139, #175)
• support for unicode-range (#148)
• don't crash on ruleset with no selector (#135)
• tolerant to class names that starts with digit (#99, #105)
• fix background compressing (#170)

Small personal sidenote

We have been using csso in our building process for years. Not only as CSS compress utility, but also as a parser to get AST, transform it and pass to csso for compression.

All those years it worked stable enough and various bugs usually were not an issue. I have even rewritten some util functions to use it instead of csso functions. But project has no maintainer for years. In spite of the opinion that csso is dead, it has its own audience and number of downloads continues to grow. It's sad that many issues were left with no attention. Moreover I wanted to improve it to make CSS compression results much better and predictable.

That's why I've decided to change the situation. I’m happy that project's owners gave me this opportunity. I became maintainer of csso and started bringing it back to life.

As a first steps I've changed files structure, cleaned up and refactored most of sources. Now it has single code base, with reworked test suite, jscs for code style check, browserify to build the bundle, automated gh-pages publishing etc. All aim to ensure that nothing prevents us to move forward.

After initial refactoring and a bunch of bug fixes, it's now clear to me that all parts of csso need to be reworked. First of all compressor's struсtural optimization algorithms should be replaced for others, that are safer, faster and more efficient. Parser should become compliant to standards, with support for new CSS features and more predictable. When this is done, we can try new structural optimizations, that no one has tried before. That is the main reason why I've decided to work on csso.

Stay tuned!

@lahmatiy

• Case insensitive check for !important (issue #187)
• Fix problems with using csso as cli command on Windows (issue #83, #136, #142 and others)
• Remove byte order marker (the UTF-8 BOM) from input
• Don't strip space between funktion-funktion and funktion-vhash (issue #134)
• Don't merge TRBL values having \9 (hack for IE8 in bootstrap) (issues #159, #214, #230, #231 and others)
• Don't strip units off dimensions of non-length (issues #226, #229 and others)

• Gonzales 1.0.7.

• Gonzales 1.0.6.

• Gonzales 1.0.5.
• Protecting copyright notices in CSS: https://github.com/css/csso/issues/92
• Zero CSS throws an error: https://github.com/css/csso/issues/96
• Don't minify the second 0s in Firefox for animations: https://github.com/css/csso/issues/100
• Japan manual
• BEM ready documentation

• @page inside @media Causes Error: https://github.com/css/csso/issues/90