@applitools/css-tree/CHANGELOG.md

A temporary custom copy of https://github.com/csstree/csstree

## next

- Added support for the [`@container`](https://drafts.csswg.org/css-contain-3/#container-rule) at-rule
- Added support for the [`@starting-style`](https://drafts.csswg.org/css-transitions-2/#defining-before-change-style) at-rule
- Added support for the [`@scope`](https://drafts.csswg.org/css-cascade-6/#scoped-styles) at-rule
- Added support for the [`@layer`](https://drafts.csswg.org/css-cascade-5/#at-layer) at-rule
- Added support for `layer`, `layer()` and `supports()` in the `@media` at-rule (according to [the @import rule](https://drafts.csswg.org/css-cascade-5/#at-import) in Cascading and Inheritance 5)
- Added `Layer` and `LayerList` node types
- Bumped `mdn/data` to `2.1.0`
- Added `<dashed-ident>` to generic types
- Added `TokenStream#lookupTypeNonSC()` method
- Fixed initialization when `Object.prototype` is extended or polluted (#262)
- Fixed `speak` syntax patch (#241)
- Fixed crash on parse error when custom `line` or `offset` is specified via options (#251)
- Changed `parseWithFallback()` to rollback `tokenIndex` before calling a fallback
- Changed `Block` to not include `{` and `}`
- Changed `Atrule` and `Rule` to include `{` and `}` for a block
- Changed `Ratio` parsing:
    - Left and right parts contain nodes instead of strings
    - Both left and right parts of a ratio can now be any number; validation of number range is no longer within the parser's scope.
    - Both parts can now be functions. Although not explicitly mentioned in the specification, mathematical functions can replace numbers, addressing potential use cases (#162).
    - As per the [CSS Values and Units Level 4](https://drafts.csswg.org/css-values-4/#ratios) specification, the right part of `Ratio` can be omitted. While this can't be a parser output (which would produce a `Number` node), it's feasible during `Ratio` node construction or transformation.
- Changes to query-related at-rules:
    - Added new node types:
        - [`Feature`](./docs/ast.md#feature): represents features like `(feature)` and `(feature: value)`, fundamental for both `@media` and `@container` at-rules
        - [`FeatureRange`](./docs/ast.md#featurerange): represents [features in a range context](https://www.w3.org/TR/mediaqueries-4/#mq-range-context)
        - [`FeatureFunction`](./docs/ast.md#featurefunction): represents functional features such as `@supports`'s `selector()` or `@container`'s `style()`
        - [`Condition`](./docs/ast.md#condition): used across all query-like at-rules, encapsulating queries with features and the `not`, `and`, and `or` operators
        - [`GeneralEnclosure`](./docs/ast.md#condition): represents the [`<general-enclosed>`](https://www.w3.org/TR/mediaqueries-4/#typedef-general-enclosed) production, which caters to unparsed parentheses or functional expressions
        > Note: All new nodes include a `kind` property to define the at-rule type. Supported kinds are `media`, `supports`, and `container`.

    - Added support for functions for features and features in a range context, e.g. `(width: calc(100cm / 6))`
    - Added a `condition` value for the parser's context option to parse queries. Use the `kind` option to specify the condition type, e.g., `parse('...', { context: 'condition', kind: 'media' })`.
    - Introduced a `features` section in the syntax configuration for defining functional features of at-rules. Expand definitions using the `fork()` method. The current definition is as follows:
        ```js
        features: {
            supports: { selector() { /* ... */ } },
            container: { style() { /* ... */ } }
        }
        ```
    - Changes for `@media` at-rule:
        - Enhanced prelude parsing for complex queries. Parentheses with errors will be parsed as `GeneralEnclosed`.
        - Added support for features in a range context, e.g. `(width > 100px)` or `(100px < height < 400px)`
        - Transitioned from `MediaFeature` node type to the `Feature` node type with `kind: "media"`.
        - Changed `MediaQuery` node structure into the following form:
            ```ts
            type MediaQuery = {
                type: "MediaQuery";
                modifier: string | null; // e.g. "not", "only", etc.
                mediaType: string | null; // e.g. "all", "screen", etc.
                condition: Condition | null;
            }
            ```
    - Changes for `@supports` at-rule:
        - Enhanced prelude parsing for complex queries. Parentheses with errors will be parsed as `GeneralEnclosed`.
        - Added support for features in a range context, e.g. `(width > 100px)` or `(100px < height < 400px)`
        - Added `SupportsDeclaration` node type to encapsulate a declaration in a query, replacing `Parentheses`.
        - Parsing now employs `Condition` or `SupportsDeclaration` nodes of kind `supports` instead of `Parentheses`.
        - Added support for the [`selector()`](https://drafts.csswg.org/css-conditional-4/#at-supports-ext) feature via the `FeatureFunction` node (configured in `features.supports.selector`).

## [1.2.0](https://github.com/Applitools-Dev/sdk/compare/js/css-tree@1.1.4...js/css-tree@1.2.0) (2025-07-30)


### Features

* release java ([7bc39e6](https://github.com/Applitools-Dev/sdk/commit/7bc39e679eab27a19322ca4b121177da7437c106))

## [1.1.4](https://github.com/Applitools-Dev/sdk/compare/js/css-tree@1.1.3...js/css-tree@1.1.4) (2024-06-26)


### Bug Fixes

* tunnel client ([670b184](https://github.com/Applitools-Dev/sdk/commit/670b1843ce43347d97e19fa02f8bc630332ff414))

## [1.1.3](https://github.com/Applitools-Dev/sdk/compare/js/css-tree@1.1.2...js/css-tree@1.1.3) (2024-05-28)


### Bug Fixes

* trigger release ([88c4f81](https://github.com/Applitools-Dev/sdk/commit/88c4f812bd92eae61ee8ebbee5da0d64ad8c8859))

## [1.1.2](https://github.com/Applitools-Dev/sdk/compare/js/css-tree@1.1.1...js/css-tree@1.1.2) (2024-03-18)


### Bug Fixes

* trigger js release again ([1695f3d](https://github.com/Applitools-Dev/sdk/commit/1695f3d9967c7ab7b5d8c8637e86faa935a9047f))

## [1.1.1](https://github.com/Applitools-Dev/sdk/compare/js/css-tree@1.1.0...js/css-tree@1.1.1) (2024-03-18)


### Bug Fixes

* trigger js release ([dbc9bf8](https://github.com/Applitools-Dev/sdk/commit/dbc9bf8da3ab5d93e570881ba2c61efa47a1b342))

## [1.1.0](https://github.com/Applitools-Dev/sdk/compare/js/css-tree-v1.0.0...js/css-tree@1.1.0) (2024-03-17)


### Features

* support [@container](https://github.com/container) and [@layer](https://github.com/layer) cssom rules ([#2209](https://github.com/Applitools-Dev/sdk/issues/2209)) ([7da07c4](https://github.com/Applitools-Dev/sdk/commit/7da07c4f5b7f338fb5944ce244af8f2de928cab6))

## 2.3.1 (December 14, 2022)

- Added `:host`, `:host()` and `:host-context()` pseudo class support (#216)
- Fixed `generator`, `parse` and `parse-selector` entry points by adding missed `NestedSelector` node type
- Removed npm > 7 version requirement (#218)

## 2.3.0 (November 30, 2022)

- Added [CSS Nesting](https://www.w3.org/TR/css-nesting-1/) support:
    - Added `NestingSelector` node type for `&` (a nesting selector) in selectors
    - Added `@nest` at-rule
    - Changed behaviour for `@media` inside a `Rule` to parse its block content as a `Declaration` first
    - Changed `DeclarationList` behaviour to follow the rules for `Rule`'s block
- Added the dimension units introspection & customisation:
    - Added `Lexer#units` dictionary to provide unit groups (`length`, `angle`, etc.) used for matching
    - Changed Lexer's constructor to take into consideration `config.units` to override default units
    - Extended lexer's dump to contain a units dictionary
- Bumped `mdn-data` to `2.0.30`

## 2.2.1 (August 14, 2022)

- Fixed a regression added in `2.2.0` for at-rule syntax matching when at-rule has no prelude

## 2.2.0 (August 10, 2022)

- Bumped `mdn-data` to `2.0.28`
- Added support for CSS wide keywords `revert` and `revert-layer`
- Dropped support for `expression()` the same way as CSS wide keywords
- Patched `background-clip` property definition to match [Backgrounds and Borders 4](https://drafts.csswg.org/css-backgrounds-4/#background-clip) (#190)
- Patched `content` property definition to allow `attr()` (#201)
- Fixed definition syntax matching when a comma is expected before a `<delim-token>`
- Fixed at-rule validation fail when no prelude is specified and its syntax allows an empty prelude, that's the case for `@page` at-rule (#191)
- Added new units according to current state of [CSS Values and Units 4](https://drafts.csswg.org/css-values-4/): `rex`, `cap`, `rcap`, `rch`, `ic`, `ric`, `lh`, `rlh`, `vi`, `vb`, `sv*`, `lv*`, `dv*`
- Added container relative length units from [CSS Containment 3](https://drafts.csswg.org/css-contain-3/#container-lengths): `cqw`, `cqh`, `cqi`, `cqb`, `cqmin`, `cqmax`
- Removed `vm` unit (supposed to be an old IE versions supported this unit instead of `vmax`)
- Value definition syntax:
    - Added support for stacked multipliers `+#` and `#?` according to spec (#199)
    - Added parsing of a dimension in range definition notations, however, a validation for such ranges is not supported yet (#192)
    - Changed parsing of range definition notation to not omitting `[-∞,∞]` ranges

## 2.1.0 (February 17, 2022)

- Bumped `mdn-data` to `2.0.27`
- Added `module` field to `package.json`
- Fixed minor issues in CommonJS version
- Fixed `css-tree/utils` export (#181)
- Added `css-tree/convertor` export
- Added `css-tree/selector-parser` export (~27kb when bundled, #183)
- Reduced bundle size:
    - `css-tree/parser` 50kb -> 41kb
    - `css-tree/generator` 46kb -> 23kb
- Renamed `syntaxes` into `types` in `css-tree/definition-syntax-data-patch`
- Added parsing support for `:is()`, `:-moz-any()`, `:-webkit-any()` and `:where()` (#182, #184)

## 2.0.4 (December 17, 2021)

- Extended Node.js support to include `^10`
- Fixed `generate()` in safe mode to add a whitespace between `<dimension-token>` and `<hash-token>`, otherwise some values are broken in IE11, e.g. `border` properties (#173)
- Removed allowance for `:` for an attribute name on `AttributeSelector` parsing as it does not meet the CSS specs ([details](https://github.com/csstree/csstree/discussions/149))

## 2.0.3 (December 14, 2021)

- Fixed unintended whitespace on `generate()` in `safe` mode between `type-selector` and `id-selector` (e.g. `a#id`). A regression was introduces in `2.0.2` since IE11 fails on values when `<hash-token>` goes after `<ident-token>` without a whitespace in the middle, e.g. `1px solid#000`. Thus, in one case, a space between the `<ident-token>` and the `<hash-token>` is required, and in the other, vice versa. Until a better solution found, a workaround is used on `id-selector` generation by producing a `<delim-token>` instead of `<hash-token>`.

## 2.0.2 (December 10, 2021)

- Updated `width`, `min-width` and `max-width` syntax definitions
- Patched counter related syntaxes to match specs until updated in `mdn-data`
- Replaced `source-map` with `source-map-js` which reduce install size by ~700KB
- Fixed `calc()` function consumption on definition syntax matching
- Fixed `generate()` auto emitting a whitespace edge cases when next token starts with a dash (minus)
- Fixed `generate()` safe mode to cover more cases for IE11
- Fixed CommonJS bundling by adding browser files `dist/data.cjs` and `dist/version.cjs`
- Added exports:
    - `css-tree/definition-syntax-data`
    - `css-tree/definition-syntax-data-patch`

## 2.0.1 (December 4, 2021)

- Extended Node.js support to include `^12.20.0` and `^14.13.0` versions

## 2.0.0 (December 3, 2021)

- Package
    - Dropped support for Node.js prior 14.16 (following patch versions changed it to `^10 || ^12.20.0 || ^14.13.0 || >=15.0.0`)
    - Converted to ES modules. However, CommonJS is supported as well (dual module)
    - Added exports for standalone parts instead of internal paths usage (use as `import * as parser from "css-tree/parser"` or `require("css-tree/parser")`):
        - `css-tree/tokenizer`
        - `css-tree/parser`
        - `css-tree/walker`
        - `css-tree/generator`
        - `css-tree/lexer`
        - `css-tree/definition-syntax`
        - `css-tree/utils`
    - Changed bundle set to provide `dist/csstree.js` (an IIFE version with `csstree` as a global name) and `dist/csstree.esm.js` (as ES module). Both are minified
    - Bumped `mdn-data` to `2.0.23`
- Tokenizer
    - Changed `tokenize()` to take a function as second argument, which will be called for every token. No stream instance is creating when second argument is ommited.
    - Changed `TokenStream#getRawLength()` to take second parameter as a function (rule) that check a char code to stop a scanning
    - Added `TokenStream#forEachToken(fn)` method
    - Removed `TokenStream#skipWS()` method
    - Removed `TokenStream#getTokenLength()` method
- Parser
    - Moved `SyntaxError` (custom parser's error class) from root of public API to parser via `parse.SyntaxError`
    - Removed `parseError` field in parser's `SyntaxError`
    - Changed selector parsing to produce `{ type: 'Combinator', name: ' ' }` node instead of `WhiteSpace` node
    - Removed producing of `WhiteSpace` nodes with the single exception for a custom property declaration with a single white space token as a value
    - Parser adds a whitespace to `+` and `-` operators, when a whitespace is before and/or after an operator
    - Exposed parser's inner configuration as `parse.config`
    - Added `consumeUntilBalanceEnd()`, `consumeUntilLeftCurlyBracket()`, `consumeUntilLeftCurlyBracketOrSemicolon()`, `consumeUntilExclamationMarkOrSemicolon()` and `consumeUntilSemicolonIncluded()` methods to parser's inner API to use with `Raw` instead of `Raw.mode`
    - Changed `Nth` to always consume `of` clause when presented, so it became more general and moves validation to lexer
    - Changed `String` node type to store decoded string value, i.e. with no quotes and escape sequences
    - Changed `Url` node type to store decoded url value as a string instead of `String` or `Raw` node, i.e. with no quotes, escape sequences and `url()` wrapper
- Generator
    - Generator is now determines itself when a white space required between emitting tokens
    - Changed `chunk()` handler to `token()` (output a single token) and `tokenize()` (split a string into tokens and output each of them)
    - Added `mode` option for `generate()` to specify a mode of token separation: `spec` or `safe` (by default)
    - Added `emit(token, type, auto)` handler as implementation specific token processor
    - Changed `Nth` to serialize `+n` as `n`
    - Added auto-encoding for a `string` and `url` tokens on serialization
- Lexer
    - Removed `Lexer#matchDeclaration()` method
- Utils
    - Added `ident`, `string` and `url` helpers to decode/encode corresponding values, e.g. `url.decode('url("image.jpg")')` === `'image.jpg'`
    - List
        - Changed `List` to be iterable (iterates data)
        - Changed `List#first`, `List#last` and `List#isEmpty` to getters
        - Changed `List#getSize()` method to `List#size` getter
        - Removed `List#each()` and `List#eachRight()` methods, `List#forEach()` and `List#forEachRight()` should be used instead

## 1.1.3 (March 31, 2021)

- Fixed matching on CSS wide keywords for at-rule's prelude and descriptors
- Added `fit-content` to `width` property patch as browsers are supported it as a keyword (nonstandard), but spec defines it as a function
- Fixed parsing a value contains parentheses or brackets and `parseValue` option is set to `false`, in that case `!important` was included into a value but must not (#155)

## 1.1.2 (November 26, 2020)

- Rolled back to use spread syntax in object literals since it not supported by nodejs < 8.3 (#145)

## 1.1.1 (November 18, 2020)

- Fixed edge cases in mismatch location computation for `SyntaxMatchError`

## 1.1.0 (November 17, 2020)

- Bumped `mdn-data` to 2.0.14
- Extended `fork()` method to allow append syntax instead of overriding for `types`, `properties` and `atrules`, e.g. `csstree.fork({ types: { color: '| foo | bar' } })`
- Extended lexer API for validation
    - Added `Lexer#checkAtruleName(atruleName)`, `Lexer#checkAtrulePrelude(atruleName, prelude)`, `Lexer#checkAtruleDescriptorName(atruleName, descriptorName)` and `Lexer#checkPropertyName(propertyName)`
    - Added `Lexer#getAtrule(atruleName, fallbackBasename)` method
    - Extended `Lexer#getAtrulePrelude()` and `Lexer#getProperty()` methods to take `fallbackBasename` parameter
    - Improved `SyntaxMatchError` location details
    - Changed error messages

## 1.0.1 (November 11, 2020)

- Fixed edge cases for parsing of custom property value with a single whitespace when `parseCustomProperty:true`

## 1.0.0 (October 27, 2020)

- Added `onComment` option to parser config
- Added support for `break` and `skip` values in `walk()` to control traversal
- Added `List#reduce()` and `List#reduceRight()` methods
- Bumped `mdn-data` to 2.0.12
- Exposed version of the lib (i.e. `import { version } from 'css-tree'`)
- Fixed `Lexer#dump()` to dump atrules syntaxes as well
- Fixed matching comma separated `<urange>` list (#135)
- Renamed `HexColor` node type into `Hash`
- Removed `element()` specific parsing rules
- Removed `dist/default-syntax.json` from package

## 1.0.0-alpha.39 (December 5, 2019)

- Fixed walker with `visit: "Declaration"` to iterate `DeclarationList` (#114)

## 1.0.0-alpha.38 (November 25, 2019)

- Bumped `mdn-data` to `2.0.6`
- Added initial implmentation for at-rule matching via `Lexer#matchAtrulePrelude()` and `Lexer#matchAtruleDescriptor()` methods
- Added `-moz-control-character-visibility`, `-ms-grid-columns`, `-ms-grid-rows` and `-ms-hyphenate-limit-last` properties to patch (#111)
- Added `flow`, `flow-root` and `table-caption` values to patched `display` (#112)

## 1.0.0-alpha.37 (October 22, 2019)

- Bumped `source-map` version to `^0.6.1` to fix source map generation inconsistency across node.js versions due to mappings sorting bug and v8 moving to [a stable Array#sort](https://v8.dev/blog/array-sort) ([fix commit](https://github.com/mozilla/source-map/commit/f35a2e4212dd025cb5e1fc219e7ac8a4b96c2cc9) in `source-map`)

## 1.0.0-alpha.36 (October 13, 2019)

- Dropped support for Node < 8
- Updated dev deps (fixed `npm audit` issues)
- Reworked build pipeline
    - Package provides `dist/csstree.js` and `dist/csstree.min.js` now (instead of single `dist/csstree.js` that was a min version)
    - Bundle size (min version) reduced from 191Kb to 158Kb due to some optimisations
- Definition syntax
    - Renamed `grammar` into `definitionSyntax` (named per spec)
    - Added `compact` option to `generate()` method to avoid formatting (spaces) when possible
- Lexer
    - Changed `dump()` method to produce syntaxes in compact form by default

## 1.0.0-alpha.35 (October 7, 2019)

- Walker
    - Changed implementation to avoid runtime compilation due to CSP issues (see #91, #109)
    - Added `find()`, `findLast()` and `findAll()` methods (e.g. `csstree.find(ast, node => node.type === 'ClassSelector')`)

## 1.0.0-alpha.34 (July 27, 2019)

- Tokenizer
    - Added `isBOM()` function
    - Added `charCodeCategory()` function
    - Removed `firstCharOffset()` function (use `isBOM()` instead)
    - Removed `CHARCODE` dictionary
    - Removed `INPUT_STREAM_CODE*` dictionaries
- Lexer
    - Allowed comments in matching value (just ignore them like whitespaces)
    - Increased iteration count in value matching from 10k up to 15k
    - Fixed missed `debugger` (#104)

## 1.0.0-alpha.33 (July 11, 2019)

- Lexer
    - Fixed low priority productions matching by changing an approach for robust one (#103)

## 1.0.0-alpha.32 (July 11, 2019)

- Lexer
    - Fixed low priority productions matching in long `||-` and `&&-` groups (#103)

## 1.0.0-alpha.31 (July 11, 2019)

- Bumped `mdn/data` to `2.0.4` (#99)
- Lexer
    - Added [bracketed range notation](https://drafts.csswg.org/css-values-4/#numeric-ranges) support and related refactoring
    - Removed `<number-zero-one>`, `<number-one-or-greater>` and `<positive-integer>` from generic types. In fact, types moved to patch, because those types can be expressed in a regular grammar due to bracketed range notation implemented
    - Added support for multiple token string matching
    - Improved `<custom-ident>` production matching to claim the keyword only if no other unfulfilled production can claim it (#101)
    - Improved `<length>` production matching to claim "unitless zero" only if no other unfulfilled production can claim it
    - Changed lexer's constructor to prevent generic types override when used
    - Fixed large `||`- and `&&`-group matching, matching continues from the beginning on term match (#85)
    - Fixed checking that value has `var()` occurrences when value is a string (such values can't be matched on syntax currently and fail with specific error that can be used for ignorance in validation tools)
    - Fixed `<declaration-value>` and `<any-value>` matching when a value contains a function, parentheses or braces

## 1.0.0-alpha.30 (July 3, 2019)

- Bumped `mdn/data` to `~2.0.3`
    - Removed type removals from `mdn/data` due to lack of some generic types and specific lexer restictions (since lexer was reworked, see below)
    - Reduced and updated patches
- Tokenizer
    - Reworked tokenizer itself to compliment [CSS Syntax Module Level 3](https://drafts.csswg.org/css-syntax/#tokenization)
    - `Tokenizer` class splitted into several abstractions:
        - Added `TokenStream` class
        - Added `OffsetToLocation` class
        - Added `tokenize()` function that creates `TokenStream` instance for given string or updates a `TokenStream` instance passed as second parameter
        - Removed `Tokenizer` class
    - Removed `Raw` token type
    - Renamed `Identifier` token type to `Ident`
    - Added token types: `Hash`, `BadString`, `BadUrl`, `Delim`, `Percentage`, `Dimension`, `Colon`, `Semicolon`, `Comma`, `LeftSquareBracket`, `RightSquareBracket`, `LeftParenthesis`, `RightParenthesis`, `LeftCurlyBracket`, `RightCurlyBracket`
    - Replaced `Punctuator` with `Delim` token type, that excludes specific characters with its own token type like `Colon`, `Semicolon` etc
    - Removed `findCommentEnd`, `findStringEnd`, `findDecimalNumberEnd`, `findNumberEnd`, `findEscapeEnd`, `findIdentifierEnd` and `findUrlRawEnd` helper function
    - Removed `SYMBOL_TYPE`, `PUNCTUATION` and `STOP_URL_RAW` dictionaries
    - Added `isDigit`, `isHexDigit`, `isUppercaseLetter`, `isLowercaseLetter`, `isLetter`, `isNonAscii`, `isNameStart`, `isName`, `isNonPrintable`, `isNewline`, `isWhiteSpace`, `isValidEscape`, `isIdentifierStart`, `isNumberStart`, `consumeEscaped`, `consumeName`, `consumeNumber` and `consumeBadUrlRemnants` helper functions
- Parser
    - Changed parsing algorithms to work with new token type set
    - Changed `HexColor` consumption in way to relax checking a value, i.e. now `value` is a sequence of one or more name chars
    - Added `&` as a property hack
    - Relaxed `var()` parsing to only check that a first arguments is an identifier (not a custom property name as before)
- Lexer
    - Reworked syntax matching to relay on token set only (having AST is optional now)
    - Extended `Lexer#match()`, `Lexer#matchType()` and `Lexer#matchProperty()` methods to take a string as value, beside AST as a value
    - Extended `Lexer#match()` method to take a string as a syntax, beside of syntax descriptor
    - Reworked generic types:
        - Removed `<attr()>`, `<url>` (moved to patch) and `<progid>` types
        - Added types:
            - Related to token types: `<ident-token>`, `<function-token>`, `<at-keyword-token>`, `<hash-token>`, `<string-token>`, `<bad-string-token>`, `<url-token>`, `<bad-url-token>`, `<delim-token>`, `<number-token>`, `<percentage-token>`, `<dimension-token>`, `<whitespace-token>`, `<CDO-token>`, `<CDC-token>`, `<colon-token>`, `<semicolon-token>`, `<comma-token>`, `<[-token>`, `<]-token>`, `<(-token>`, `<)-token>`, `<{-token>` and `<}-token>`
            - Complex types: `<an-plus-b>`, `<urange>`, `<custom-property-name>`, `<declaration-value>`, `<any-value>` and `<zero>`
        - Renamed `<unicode-range>` to `<urange>` as per spec
        - Renamed `<expression>` (IE legacy extension) to `<-ms-legacy-expression>` and may to be removed in next releases

## 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`

## 1.0.0-alpha.28 (February 19, 2018)

- Renamed `lexer.grammar.translate()` method into `generate()`
- Fixed `<'-webkit-font-smoothing'>` and `<'-moz-osx-font-smoothing'>` syntaxes (#75)
- Added vendor keywords for `<'overflow'>` property syntax (#76)
- Pinned `mdn-data` to `~1.1.0` and fixed issues with some updated property syntaxes

## 1.0.0-alpha.27 (January 14, 2018)

- Generator
    - Changed node's `generate()` methods invocation, methods now take a node as a single argument and context (i.e. `this`) that have methods: `chunk()`, `node()` and `children()`
    - Renamed `translate()` to `generate()` and changed to take `options` argument
    - Removed `translateMarkup(ast, enter, leave)` method, use `generate(ast, { decorator: (handlers) => { ... }})` instead
    - Removed `translateWithSourceMap(ast)`, use `generate(ast, { sourceMap: true })` instead
    - Changed to support for children as an array
- Walker
    - Changed `walk()` to take an `options` argument instead of handler, with `enter`, `leave`, `visit` and `reverse` options (`walk(ast, fn)` is still works and equivalent to `walk(ast, { enter: fn })`)
    - Removed `walkUp(ast, fn)`, use `walk(ast, { leave: fn })`
    - Removed `walkRules(ast, fn)`, use `walk(ast, { visit: 'Rule', enter: fn })` instead
    - Removed `walkRulesRight(ast, fn)`, use `walk(ast, { visit: 'Rule', reverse: true, enter: fn })` instead
    - Removed `walkDeclarations(ast, fn)`, use `walk(ast, { visit: 'Declaration', enter: fn })` instead
    - Changed to support for children as array in most cases (`reverse: true` will fail on arrays since they have no `forEachRight()` method)
- Misc
    - List
        - Added `List#forEach()` method
        - Added `List#forEachRight()` method
        - Added `List#filter()` method
        - Changed `List#map()` method to return a `List` instance instead of `Array`
        - Added `List#push()` method, similar to `List#appendData()` but returns nothing
        - Added `List#pop()` method
        - Added `List#unshift()` method, similar to `List#prependData()` but returns nothing
        - Added `List#shift()` method
        - Added `List#prependList()` method
        - Changed `List#insert()`, `List#insertData()`, `List#appendList()` and `List#insertList()` methods to return a list that performed an operation
    - Changed `keyword()` method
        - Changed `name` field to include a vendor prefix
        - Added `basename` field to contain a name without a vendor prefix
        - Added `custom` field that contain a `true` when keyword is a custom property reference
    - Changed `property()` method
        - Changed `name` field to include a vendor prefix
        - Added `basename` field to contain a name without any prefixes, i.e. a hack and a vendor prefix
    - Added `vendorPrefix()` method
    - Added `isCustomProperty()` method

## 1.0.0-alpha.26 (November 9, 2017)

- Tokenizer
    - Added `Tokenizer#isBalanceEdge()` method
    - Removed `Tokenizer.endsWith()` method
- Parser
    - Made the parser tolerant to errors by default
    - Removed `tolerant` parser option (no parsing modes anymore)
    - Removed `property` parser option (a value parsing does not depend on property name anymore)
    - Canceled error for a handing semicolon in a block
    - Canceled error for unclosed `Brackets`, `Function` and `Parentheses` when EOF is reached
    - Fixed error when prelude ends with a comment for at-rules with custom prelude consumer
    - Relaxed at-rule parsing:
        - Canceled error when EOF is reached after a prelude
        - Canceled error for an at-rule with custom block consumer when at-rule has no block (just don't apply consumer in that case)
        - Canceled error on at-rule parsing when it occurs outside prelude or block (at-rule is converting to `Raw` node)
        - Allowed for any at-rule to have a prelude and a block, even if it's invalid per at-rule syntax (the responsibility for this check is moved to lexer, since it's possible to construct a AST with such errors)
    - Made a declaration value a safe parsing point (i.e. error on value parsing lead to a value is turning into `Raw` node, not a declaration as before)
    - Excluded surrounding white spaces and comments from a `Raw` node that represents a declaration value
    - Changed `Value` parse handler to return a node only with type `Value` (previously it returned a `Raw` node in some cases)
    - Fixed issue with `onParseError()` is not invoked for errors occured on selector or declaration value parsing in some cases
    - Changed using of `onParseError()` to stop parsing if handler throws an exception
- Lexer
    - Changed `grammar.walk()` to invoke passed handler on entering to node rather than on leaving the node
    - Improved `grammar.walk()` to take a walk handler pair as an object, i.e. `walk(node, { enter: fn, leave: fn })`
    - Changed `Lexer#match*()` methods to take a node of any type, but with a `children` field
    - Added `Lexer#match(syntax, node)` method
    - Fixed `Lexer#matchType()` method to stop return a positive result for the CSS wide keywords

## 1.0.0-alpha25 (October 9, 2017)

- Parser
    - Added fallback node as argument to `onParseError()` handler
    - Fixed raw consuming in tolerant mode when selector is invalid (greedy consuming and redundant warnings)
    - Fixed exception in tolerant mode caused by unknown at-rule with unclosed block
    - Changed handling of semicolons:
        - Hanging semicolon inside declaration blocks raise an error or turns into a `Raw` node in tolerant mode instead of being ignored
        - Semicolon outside of declaration blocks opens a `Rule` node as part of selector instead of being ignored
    - Aligned `parseAtrulePrelude` behaviour to `parseRulePrelude`
        - Removed `Raw` node wraping into `AtrulePrelude` when `parseAtrulePrelude` is disabled
        - Removed error emitting when at-rule has a custom prelude customer but no prelude is found (it should be validated by a lexer later)
- Generator
    - Fixed performance issue with `translateWithSourceMap()`, flattening the string (because of mixing building string and indexing into it) turned it into a quadratic algorithm (approximate numbers can be found in [the quiz created by this case](https://gist.github.com/lahmatiy/ea25d0e623d88ca9848384b5707d52d9))
- Added support for a single solidus hack for `property()`
- Minor fixes for custom errors

## 1.0.0-alpha24 (September 14, 2017)

- Improved CSSTree to be stable for standart build-in objects extension (#58)
- Parser
    - Renamed rule's `selector` to `prelude`. The reasons: [spec names this part so](https://www.w3.org/TR/css-syntax-3/#qualified-rule), and this branch can contain not only a selector (`SelectorList`) but also a raw payload (`Raw`). What's changed:
        - Renamed `Rule.selector` to `Rule.prelude`
        - Renamed `parseSelector` parser option to `parseRulePrelude`
        - Removed option for selector parse in `SelectorList`
- Lexer
    - Fixed undefined positions in a error when match a syntax to empty or white space only value
    - Improved `Lexer#checkStructure()`
        - Return a warning as an object with node reference and message
        - No exception on unknown node type, return a warning instead

## 1.0.0-alpha23 (September 10, 2017)

- Fixed `Tokenizer#getRawLength()`'s false positive balance match to the end of input in some cases (#56)
- Rename walker's entry point methods to be the same as CSSTree exposed methods (i.e. `walk()`, `walkUp()` etc)
- Rename at-rule's `expression` to `prelude` (since [spec names it so](https://www.w3.org/TR/css-syntax-3/#at-rule))
    - `AtruleExpression` node type → `AtrulePrelude`
    - `Atrule.expression` field → `Atrule.prelude`
    - `parseAtruleExpression` parser's option → `parseAtrulePrelude`
    - `atruleExpression` parse context → `atrulePrelude`
    - `atruleExpression` walk context reference → `atrulePrelude`

## 1.0.0-alpha22 (September 8, 2017)

- Parser
    - Fixed exception on parsing of unclosed `{}-block` in tolerant mode
    - Added tolerant mode support for `DeclarationList`
    - Added standalone entry point, i.e. default parser can be used via `require('css-tree/lib/parser')` (#47)
- Generator
    - Changed generator to produce `+n` when `AnPlusB.a` is `+1` to be "round-trip" with parser
    - Added standalone entry point, i.e. default generators can be used via `require('css-tree/lib/generator')`
- Walker
    - Added standalone entry point, i.e. default walkers can be used via `require('css-tree/lib/walker')` (#47)
- Lexer
    - Added `default` keyword to the list of invalid values for `<custom-ident>` (since it reversed per [spec](https://www.w3.org/TR/css-values/#custom-idents))
- Convertors (`toPlainObject()` and `fromPlainObject()`) moved to `lib/convertor` (entry point is `require('css-tree/lib/convertor')`)

## 1.0.0-alpha21 (September 5, 2017)

- Tokenizer
    - Added `Raw` token type
    - Improved tokenization of `url()` with raw as url to be more spec complient
    - Added `Tokenizer#balance` array computation on token layout
    - Added `Tokenizer#getRawLength()` to compute a raw length with respect of block balance
    - Added `Tokenizer#getTokenStart(offset)` method to get token start offset by token index
    - Added `idx` and `balance` fields to each token of `Tokenizer#dump()` method result
- Parser
    - Added `onParseError` option
    - Reworked node parsers that consume a `Raw` node to use a new approach. Since now a `Raw` node builds in `parser#Raw()` function only
    - Changed semantic of `parser#Raw()`, it takes 5 parameters now (it might to be changed in future)
    - Changed `parser#tolerantParse()` to pass a start token index to fallback function instead of source offset
    - Fixed `AtruleExpression` consuming in tolerant mode
    - Atrule handler to convert an empty `AtruleExpression` node into `null`
    - Changed `AtruleExpression` handler to always return a node (before it could return a `null` in some cases)
- Lexer
    - Fixed comma match node for `#` multiplier
    - Added reference name to `SyntaxReferenceError`
- Additional fixes on custom errors
- Reduced possible corruption of base config by `syntax.fork()`

## 1.0.0-alpha20 (August 28, 2017)

- Tokenizer
    - Added `Atrule` token type (`<at-rule-token>` per spec)
    - Added `Function` token type (`<function-token>` per spec)
    - Added `Url` token type
    - Replaced `Tokenizer#getTypes()` method with `Tokenizer#dump()` to get all tokens as an array
    - Renamed `Tokenizer.TYPE.Whitespace` to `Tokenizer.TYPE.WhiteSpace`
    - Renamed `Tokenizer.findWhitespaceEnd()` to `Tokenizer.findWhiteSpaceEnd()`
- Parser
    - Added initial implementation of tollerant mode (turn on by passing `tolerant: true` option). In this mode parse errors are never occour and any invalid part of CSS turns into a `Raw` node. Current safe points: `Atrule`, `AtruleExpression`, `Rule`, `Selector` and `Declaration`. Feature is experimental and further improvements are planned.
    - Changed `Atrule.expression` to contain a `AtruleExpression` node or `null` only (other node types is wrapping into a `AtruleExpression` node)
    - Renamed `AttributeSelector.operator` to `AttributeSelector.matcher`
- Generator
    - `translate()` method is now can take a function as second argument, that recieves every generated chunk. When no function is passed, default handler is used, it concats all the chunks and method returns a string.
- Lexer
    - Used [mdn/data](https://github.com/mdn/data) package as source of lexer's grammar instead of local dictionaries
    - Added `x` unit to `<resolution>` generic type
    - Improved match tree:
        - Omited Group (sequences) match nodes
        - Omited empty match nodes (for terms with `zero or more` multipliers)
        - Added `ASTNode` node type to contain a reference to AST node
        - Fixed node duplication (uncompleted match were added to tree)
        - Added AST node reference in match nodes
        - Added comma match node by `#` multiplier
    - Grammar
        - Changed `translate()` function to get a handler as third argument (optional). That handler recieves result of node traslation and can be used for decoration purposes. See [example](https://github.com/csstree/docs/blob/04c65af44477b5ea05feb373482898122b2a4528/docs/syntax.html#L619-L627)
        - Added `SyntaxParseError` to grammar export
        - Reworked group and multipliers representation in syntax tree:
            - Replaced `Sequence` for `Group` node type (`Sequence` node type removed)
            - Added `explicit` boolean property for `Group`
            - Only groups can have a multiplier now (other node types is wrapping into a single term implicit group when multiplier is applied)
            - Renamed `nonEmpty` Group's property to `disallowEmpty`
            - Added optimisation for syntax tree by dropping redundant root `Group` when it contains a single `Group` term (return this `Group` as a result)
    - Changed lexer's match functionality
        - Changed `Lexer#matchProperty()` and `Lexer#matchType()` to return an object instead of match tree. A match tree stores in `matched` field when AST is matched to grammar successfully, otherwise an error in `error` field. The result object also has some methods to test AST node against a match tree: `getTrace()`, `isType()`, `isProperty()` and `isKeyword()`
        - Added `Lexer#matchDeclaration()` method
        - Removed `Lexer#lastMatchError` (error stores in match result object in `error` field)
    - Added initial implementation of search for AST segments (new lexer methods: `Lexer#findValueSegments()`, `Lexer#findDeclarationValueSegments()` and `Lexer#findAllSegments`)
    - Implemented `SyntaxReferenceError` for unknown property and type references
- Renamed field in resulting object of `property()` function: `variable` → `custom`
- Fixed issue with readonly properties (e.g. `line` and `column`) of `Error` and exception on attempt to write in iOS Safari

## 1.0.0-alpha19 (April 24, 2017)

- Extended `List` class with new methods:
    - `List#prepend(item)`
    - `List#prependData(data)`
    - `List#insertData(data)`
    - `List#insertList(list)`
    - `List#replace(item, itemOrList)`

## 1.0.0-alpha18 (April 3, 2017)

- Added `atrule` walk context (#39)
- Changed a result of generate method for `AnPlusB`, `AttributeSelector`, `Function`, `MediaFeature` and `Ratio` ([1e95877](https://github.com/csstree/csstree/commit/1e9587710efa8e9338bcf0bc794b4b45f286231d))
- Fixed typo in `List` exception messages (@strarsis, #42)
- Improved tokenizer to convert an input to a string

## 1.0.0-alpha17 (March 13, 2017)

- Implemented new concept of `syntax`
    - Changed main `exports` to expose a default syntax
    - Defined initial [CSS syntax](lib/syntax/default.js)
    - Implemented `createSyntax()` method to create a new syntax from scratch
    - Implemented `fork()` method to create a new syntax based on given via extension
- Parser
    - Implemented `mediaQueryList` and `mediaQuery` parsing contexts
    - Implemented `CDO` and `CDC` node types
    - Implemented additional declaration property prefix hacks (`#` and `+`)
    - Added support for UTF-16LE BOM
    - Added support for `@font-face` at-rule
    - Added `chroma()` to legacy IE filter functions
    - Improved `HexColor` to consume hex only
    - Improved support for `\0` and `\9` hacks (#2)
    - Relaxed number check for `Ratio` terms
        - Allowed fractal values as a `Ratio` term
        - Disallowed zero number as a `Ratio` term
    - Changed important clause parsing
        - Allowed any identifier for important (to support hacks like `!ie`)
        - Store `true` for `important` field in case identifier equals to `important` and string otherwise
    - Fixed parse error formatted message rendering to take into account tabs
    - Removed exposing of `Parser` class
    - Removed `readSelectorSequence()`, `readSequenceFallback()` and `readSelectorSequenceFallback` methods
    - Used single universal sequence consumer for `AtruleExpression`, `Selector` and `Value`
- Generator
    - Reworked generator to use auto-generated functions based on syntax definition (additional work to be done in next releases)
    - Implemented `translateMarkup(ast, before, after)` method for complex cases
    - Reworked `translateWithSourceMap` to be more flexible (based on `translateMarkup`, additional work to be done in next releases)
- Walker
    - Reworked walker to use auto-generated function based on syntax definition (additional work to be done in next releases)
- Lexer
    - Prepared for better extensibility (additional work to be done in next releases)
    - Implemented `checkStructure(ast)` method to check AST structure based on syntax definition
    - Update syntax dictionaries to latest `mdn/data`
        - Add missing `<'offset-position'>` syntax
        - Extended `<position>` property with `-webkit-sticky` (@sergejmueller, #37)
    - Improved mismatch error position
- Implemented script (`gen:syntax`) to generate AST format reference page (`docs/ast.md`) using syntax definition

## 1.0.0-alpha16 (February 12, 2017)

- Exposed `Parser` class
- Added `startOffset` option to `Tokenizer` (constructor and `setSource()` method)
- Added fallback functions for default (`readSequenceFallback`) and selector (`readSelectorSequenceFallback`) sequence readers
- Fixed edge cases for `AnPlusB`
- Fixed wrong whitespace ignoring in `Selector` consumer

## 1.0.0-alpha15 (February 8, 2017)

- Fixed broken `atruleExpression` context
- Fixed vendor prefix detection in `keyword()` and `property()`
- Fixed `property()` to not lowercase custom property names
- Added `variable` boolean flag in `property()` result
- Renamed `scanner` into `tokenizer`
- Ranamed `syntax` into `lexer`
- Moved `docs/*.html` files to [csstree/docs](https://github.com/csstree/docs) repo
- Added `element()` function for `Value` context (`-moz-element()` supported as well)
- Merged `Universal` node type into `Type`
- Renamed node types:
    - `Id` -> `IdSelector`
    - `Class` -> `ClassSelector`
    - `Type` -> `TypeSelector`
    - `Attribute` -> `AttributeSelector`
    - `PseudoClass` -> `PseudoClassSelector`
    - `PseudoElement` -> `PseudoElementSelector`
    - `Hash` -> `HexColor`
    - `Space` -> `WhiteSpace`
    - `An+B` -> `AnPlusB`
- Removed `Progid` node type
- Relaxed `MediaQuery` consumer to not validate syntax on parse and to include whitespaces in children sequence as is
- Added `WhiteSpace.value` property to store whitespace sequence
- Implemented parser options to specify what should be parsed in details (when option is `false` some part of CSS represents as balanced `Raw`):
    - `parseAtruleExpression` – to parse at-rule expressions (`true` by default)
    - `parseSelector` – to parse rule's selector (`true` by default)
    - `parseValue` - to parse declaration's value (`true` by default)
    - `parseCustomProperty` – to parse value and fallback of custom property (`false` by default)
- Changed tokenization to stick leading hyphen minus to identifier token
- Changed selector parsing:
    - Don't convert spaces into descendant combinator
    - Don't validate selector structure on parsing (selectors may be checked by lexer later)
- Initial refactoring of [docs](https://github.com/csstree/csstree/blob/master/docs)
- Various improvements and fixes

## 1.0.0-alpha14 (February 3, 2017)

- Implemented `DeclarationList`, `MediaQueryList`, `MediaQuery`, `MediaFeature` and `Ratio` node types
- Implemented `declarationList` context (useful to parse HTML `style` attribute content)
- Implemented custom consumers for `@import`, `@media`, `@page` and `@supports` at-rules
- Implemented `atrule` option for `parse()` config, is used for `atruleExpession` context to specify custom consumer for at-rule if any
- Added `Scanner#skipWS()`, `Scanner#eatNonWS()`, `Scanner#consume()` and `Scanner#consumeNonWS()` helper methods
- Added custom consumers for known functional-pseudos, consume unknown functional-pseudo content as balanced `Raw`
- Allowed any `PseudoElement` to be a functional-pseudo (#33)
- Improved walker implementations to reduce GC thrashing by reusing cursors
- Changed `Atrule.block` to contain a `Block` node type only if any
- Changed `Block.loc` positions to include curly brackets
- Changed `Atrule.expression` to store a `null` if no expression
- Changed parser to use `StyleSheet` node type only for top level node (when context is `stylesheet`, that's by default)
- Changed `Parentheses`, `Brackets` and `Function` consumers to use passed sequence reader instead of its own
- Changed `Value` and `AtruleExpression` consumers to use common sequence reader (that reader was used by `Value` consumer before)
- Changed default sequence reader to exclude storage of spaces around `Comma`
- Changed processing of custom properties:
    - Consume declaration value as balanced `Raw`
    - Consume `var()` fallback value as balanced `Raw`
    - Validate first argument of `var()` starts with double dash
    - Custom property's value and fallback includes spaces around
- Fixed `Nth` to have a `loc` property
- Fixed `SelectorList.loc` and `Selector.loc` positions to exclude spaces
- Fixed issue Browserify build fail with `default-syntax.json` is not found error (#32, @philschatz)
- Disallowed `Type` selector starting with dash (parser throws an error in this case now)
- Disallowed empty selectors for `Rule` (not sure if it's correct but looks reasonable)
- Removed `>>` combinator support until any browser support (no signals about that yet)
- Removed `PseudoElement.legacy` property
- Removed special case for `:before`, `:after`, `:first-letter` and `:first-line` to represent them as `PseudoElement`, now those pseudos are represented as `PseudoClass` nodes
- Removed deprecated `Syntax#match()` method
- Parser was splitted into modules and related changes, one step closer to an extensible parser
- Various fixes and improvements, all changes have negligible impact on performance

## 1.0.0-alpha13 (January 19, 2017)

- Changed location storing in `SyntaxMatchError`
    - Changed property to store mismatch offset to `mismatchOffset`
    - Changed `offset` property to store bad node offset in source CSS if any
    - Added `loc` property that stores bad node `loc` if any

## 1.0.0-alpha12 (January 19, 2017)

- Fixed `Syntax#matchProperty()` method to always return a positive result for custom properties since syntax is never defined for them (#31)
- Implemented `fromPlainObject()` and `toPlainObject()` to convert plain object to AST or AST to plain object (currently converts `List` <-> `Array`)

## 1.0.0-alpha11 (January 18, 2017)

- Added support for `:matches(<selector-list>)` (#28)
- Added support for `:has(<relative-selector-list>)`
- Added support for `::slotted(<compound-selector>)`
- Implemented `Brackets` node type
- Implemented basic support for at-rule inside rule block (#24)
- Renamed `Selector` node type to `SelectorList`
- Renamed `SimpleSelector` node type to `Selector`
- Renamed `UnicodeRange.name` property to `UnicodeRange.value`
- Replaced `Negation` node type for regular `PseudoClass`
- Unified name of node property to store nested nodes, it always `children` now:
    - `StyleSheet.rules` -> `StyleSheet.children`
    - `SelectorList.selectors` -> `SelectorList.children`
    - `Block.declarations` -> `Block.children`
    - `*.sequence` -> `*.children`
- Fixed edge cases in parsing `Hex` and `UnicodeRange` when number not an integer
- Changed `nth-` pseudos parsing
    - Implemented `An+B` node type to represent expressions like `2n + 1` or `-3n`
    - Fixed edge cases when `a` or `b` is not an integer
    - Changed `odd` and `even` keywords processing, keywords are storing as `Identifier` node type now
    - Changed `Nth` node type format to store a `nth`-query and an optional `selector`
    - Implemented `of` clause for `nth-` pseudos (a.e. `:nth-child(2n + 1 of li, img)`)
    - Limited `Nth` parsing rules to `:nth-child()`, `:nth-last-child()`, `:nth-of-type(