css-tree

What are css-tree's main functionalities?

const csstree = require('css-tree');
const ast = csstree.parse('.example { color: red; }');

csstree.walk(ast, function(node) {
  if (node.type === 'ClassSelector') {
    console.log(node.name);
  }
});

const modifiedAST = csstree.parse('.example { color: blue; }');
const css = csstree.generate(modifiedAST);

const compressedCSS = csstree.translate(csstree.parse('.example { color: red; }', { compress: true }));

CSSTree

CSSTree is a tool set to work with CSS, including fast detailed parser (string->AST), walker (AST traversal), generator (AST->string) and lexer (validation and matching) based on knowledge of spec and browser implementations. The main goal is to be efficient and W3C spec compliant, with focus on CSS analyzing and source-to-source transforming tasks.

NOTE: The project is in alpha stage since some parts need further improvements, AST format and API are subjects to change. However it's stable enough and used by packages like CSSO (CSS minifier) and SVGO (SVG optimizer) in production.

Features

• Detailed parsing with an adjustable level of detail

  By default CSSTree parses CSS as detailed as possible, i.e. each single logical part is representing with its own AST node (see AST format for all possible node types). The parsing detail level can be changed through parser options, for example, you can disable parsing of selectors or declarations for component parts.

• Tolerant to errors by design

  Parser behaves as spec says: "When errors occur in CSS, the parser attempts to recover gracefully, throwing away only the minimum amount of content before returning to parsing as normal". The only thing the parser departs from the specification is that it doesn't throw away bad content, but wraps it in the special nodes, which allows processing it later.

• Fast and efficient

  CSSTree is created with focus on performance and effective memory consumption. Therefore it's one of the fastest CSS parsers at the moment.

• Syntax validation

  The build-in lexer can test CSS against syntaxes defined by W3C. CSSTree uses mdn/data as a basis for lexer's dictionaries and extends them with vendor specific and legacy syntaxes. Lexer can only check the declaration values currently, but this feature will be extended to other parts of the CSS in the future.

Docs

• Parsing CSS into AST
• AST format
• Generate CSS from AST
• AST traversal
• Utils to work with AST

Tools

• AST Explorer – explore CSSTree AST format with zero setup
• CSS syntax reference
• CSS syntax validator

Related projects

• csstree-validator – NPM package to validate CSS
• stylelint-csstree-validator – plugin for stylelint to validate CSS
• Grunt plugin
• Gulp plugin
• Sublime plugin
• VS Code plugin
• Atom plugin

Usage

Install with npm:

> npm install css-tree

Use in your code:

var csstree = require('css-tree');
var ast = csstree.parse('.example { world: "!" }');

csstree.walk(ast, function(node) {
    if (node.type === 'ClassSelector' && node.name === 'example') {
        node.name = 'hello';
    }
});

console.log(csstree.generate(ast));
// .hello{world:"!"}

Top level API

License

MIT

1.0.0-alpha.29 (May 30, 2018)

• Lexer
  • Syntax matching was completely reworked. Now it's token-based and uses state machine. Public API has not changed. However, some internal data structures have changed. Most significal change in syntax match result tree structure, it's became token-based instead of node-based.
  • Grammar
    • Changed grammar tree format:
      • Added Token node type to represent a single code point (<delim-token>)
      • Added Multiplier that wraps a single node (term property)
      • Added AtKeyword to represent <at-keyword-token>
      • Removed Slash and Percent node types, they are replaced for a node with Token type
      • Changed Function to represent <function-token> with no children
      • Removed multiplier property from Group
    • Changed generate() method:
      • Method takes an options as second argument now (generate(node, forceBraces, decorator) -> generate(node, options)). Two options are supported: forceBraces and decorator
      • When a second parameter is a function it treats as decorate option value, i.e. generate(node, fn) -> generate(node, { decorate: fn })
      • Decorate function invokes with additional parameter – a reference to a node
• Tokenizer
  • Renamed Atrule const to AtKeyword