diff --git a/CHANGELOG.md b/CHANGELOG.md index 811c6f239..71b11283c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,67 @@ # Changelog +# 2.0.0 (unreleased) + +breaking changes + +see the [migration guide](./files/migration.md) + +- [x] removed the deprecated commonjs build (`dist/index.cjs`, export `@tbela99/css-parser/cjs`): the package is an ES module +- [x] `EnumToken.CommentTokenType` is 1: the value 0 is reserved for the null node, the `EnumToken` values are renumbered +- [x] the arena is never compacted nor trimmed by the library: detached nodes and the tokens allocated while rendering stay allocated. call `arena.compact()` to reclaim the memory +- [x] the initial arena capacity is computed from the input length: the arena seldom grows +- [x] `render()` renders copies (`withParents`, `expandNestingRules`) in the same arena, under a temporary stylesheet node +- [x] memory is reclaimed on demand only: `arena.mark(...nodes)` marks nodes, `arena.release()` releases the marked nodes, `arena.trim()` releases them and compacts the arena. `arena.rewind()` is removed +- [x] removed the deprecated `ValidationLevel` enum: the `validation` option is a boolean +- [x] removed the deprecated `parseFile()` and `transformFile()` functions: use `parse({file})` and `transform({file})` +- [x] removed the deprecated node types `EnumToken.InvalidRuleNodeType`, `EnumToken.InvalidAtRuleNodeType` and `EnumToken.InvalidDeclarationNodeType` (they were no longer produced: invalid nodes keep their type and get the `EnumAstNodeStatus.Invalid` state) and the deprecated `AstInvalidRule`, `AstInvalidAtRule` and `AstInvalidDeclaration` types. the `EnumToken` values that followed them are renumbered: use the `EnumToken` names, not their values +- [x] removed `EnumToken.InvalidClassSelectorTokenType`, `EnumToken.InvalidAttrTokenType` and `EnumToken.InvalidMediaQueryTokenType` (not produced by the parser) and `EnumToken.InvalidCommentTokenType`: a CDO / CDC comment outside of the stylesheet is a `EnumToken.BadCdoTokenType` token, reported and rendered as an empty string as before. the `InvalidClassSelectorToken`, `InvalidAttrToken` and `InvalidMediaQueryToken` types are removed. `EnumToken` starts at 1 +- [x] the arrays returned by the object views (`chi`, `val`, `tokens`, fields), their locations (`loc`) and their error lists (`errors`) are frozen: assign the property to modify the arena +- [x] the traversal and search functions are methods of the arena: `walk()`, `walkValues()`, `find()`, `findAll()`, `findLast()`, `findByValue()` and `findValue()` are removed, use `arena.walk(node, filter?, reverse?)`, `arena.walkValues(tokens, filter?, reverse?)`, `arena.find(node, matcher)`, `arena.findAll(node, matcher)`, `arena.findLast(node, matcher)`, `arena.findByValue(node, matcher)` and `arena.findValue(node, matcher)` +- [x] `arena.walk()` and `arena.walkValues()` return node ids instead of result objects (`{node, parent, root, arena, parents}`, `{value, parent, previousValue, nextValue, root, parents}`): the parent is `arena.getParent(node)`, the parent of a value token `arena.getValueParent(token)` (the field list token of a structured token is skipped) and the node that owns it `arena.getValueOwner(token)`. `walkValues()` has no `root` argument, it accepts an array of token ids or a node id (its value tokens are walked). `findByValue()` returns `{node, value}` (ids), `findValue()` returns the token id. the `WalkResult`, `WalkAttributesResult` and `TokenSearchResult` types are removed +- [x] the callbacks are called with the arena and the node id, the arguments that can be read from the arena are removed: walk filters `(arena, node)`, walkValues filters `(arena, token, event)` and type filters `(arena, token)`, matchers `(arena, node)` / `(arena, token)`, `arena.findToken()`, `arena.tokens()`, `arena.children()` and `arena.siblings()` filters `(arena, id)` +- [x] visitors are called with the arena and the node id: `handler(arena, id)` instead of `handler(node, arena, parent, root)`. they return nothing to keep the node, or an object (an object view or a plain object) or a node id, or an array of objects and node ids, to replace it +- [x] `arena.toObject(id)` returns an object view of the node (`AstArenaNode`) instead of a plain copy: its properties (`typ`, `nam`, `sel`, `val`, `chi`, `tokens`, `unit`, `kin`, `l`, `r`, `op`, `loc`, `state`, `errors`, `parent`, ...) are getters and setters that read and write the arena, the view only holds the arena (`ARENA`) and the node id (`ARENAID`, keyed symbols). `arena.toPlainObject(id)` (and `view.toJSON()`, `JSON.stringify(view)`) returns the plain copy. `arena.fromObject()` imports views: importing a view of the same arena is a noop, the views of another arena are copied +- [x] the css module variables (`result.cssModuleVariables`) are object views of the variable nodes +- [x] removed `replaceNodeOrValue()`; use `arena.replaceToken(id, ...tokens)` for value token replacement +- [x] removed `replaceNode()`; use `arena.replaceChild(id, ...nodes)` to replace AST nodes +- [x] removed `cloneNode()` and `cloneValue()`: use `arena.clone(id, deep?, cloneMap?)` +- [x] removed `expand()`: use `arena.expand(node)` +- [x] removed `getNodeProperty()` and `setNodeProperty()`: use the arena methods (`arena.getState()`, `arena.setState()`, `arena.getErrors()`, ...) or the object view properties (`arena.toObject(id).state = ...`) +- [x] `WalkerEvent` and `WalkerOptionEnum` are declared with the other enums (they are still exported by the package) + +performance + +- [x] the parser recycles the tokens that are not attached to the tree (whitespace, `:`, `;`, `{`, `}`, ...): the arena allocates about half the nodes. `arena.recycle(id)` reuses the id of a detached leaf node +- [x] the initial arena capacity is one node for every 4 bytes of css +- [x] the validations of declaration values are cached per arena: a value is validated once per property syntax. the failed validations are cached too: their errors are rebuilt with the node and the location of each declaration. the cache is keyed by the string table of the arena: compacting the arena does not reuse stale results +- [x] validation allocates less: the validation context is a class, the options are not copied, `matchAllSyntaxes()` passes its result object to the matching functions +- [x] the syntax definitions are tokenized by character code (no per character strings, regular expressions or position copies) +- [x] tokenizer: symbols, units and function names are looked up in hash tables by source range (no string per lookup), the characters are read by code (no single character strings), numbers are parsed without a string when the result is exact, the whitespace text is not kept +- [x] `arena.walk()` and `arena.walkValues()` return iterator objects instead of generators: one small object per walk, the iteration result object is reused, no closure, no result object or array per visited node. the children are read when the next node is requested. the iteration protocol (`next()`, `return()`, `for ... of`) is unchanged +- [x] parser: the declaration colors are parsed without an iterator, the selector string is built without intermediate arrays, maps or closures, `toLowerCase()` is not called on lowercase strings +- [x] renderer: `renderValue()` creates no options / cache object and no closure per call, token lists are rendered from the linked lists, `render()` copies the options with a fast clone and does not flatten the rendered children to remove the last semicolon +- [x] renderer: identical declarations (same name and value tokens) are rendered once per render: `.s{width:10px} .g{width:10px}` renders `width:10px` once. colors and constructs (functions, parentheses, binary expressions, ...) are memoized too, the individual tokens are not (`convertColor()` is called once per distinct color, fewer tokens are allocated while rendering). the source map locations are still computed for every node +- [x] renderer: numbers are minified once, the last semicolon of a block is known from the type of the last child (the rendered child is not read) +- [x] renderer: the memo keys are serialized compactly (most tokens take 1 or 2 values) directly in the key pool, the memos are reused by the next renders +- [x] minifier: the rule / at-rule preludes are not parsed again after the selectors are rewritten (at-rules used to get their name parsed as prelude tokens), the default values of the shorthand properties are parsed once +- [x] minifier: the rule sizes are compared with a renderer that resolves the options once and shares the rendered values, tokens are compared and deduplicated by structure instead of signature strings +- [x] parser: small inputs of known length do not allocate 4096 nodes +- [x] the single line methods (arena accessors and setters, tokenizer, line map and source file accessors, validation context, memo lookups) are inlined at their call sites inside the library. each inlined line is preceded by a `// inlined: ` comment. the public methods are unchanged + +features + +- [x] `AstArenaNode`: lightweight object view of an arena node, see `arena.toObject()` +- [x] `arena.getValueParent(token)`, `arena.getValueOwner(token)`, `arena.toPlainObject(id)` +- [x] arena accessors: `arena.getNextSibling(id)`, `arena.getPreviousSibling(id)`, `arena.getFirstToken(id)`, `arena.getLastToken(id)`, `arena.getCapacity()`, `arena.getLastId()` and `arena.getStringCount()` + +documentation + +- [x] [Arena Memory](./files/arena.md): memory used by the arena, capacity and growth, what allocates nodes, reclaiming memory with `mark()`, `release()`, `compact()`, `trim()` +- [x] the traversal, the visitors and the object views are documented with the new signatures ([Ast Manipulation](./files/ast.md), [Custom Transform](./files/transform.md), [Validation](./files/validation.md), [Plugins](./files/plugins.md), [Utility Functions](./files/utilities.md)) +- [x] [Migration](./files/migration.md): the breaking changes of 2.0 and how to update the code +- [x] the documentation, the README and the examples read and write the arena with its methods (`arena.getType(n)`, `arena.getName(n)`, `arena.getFirstChild(n)`, `arena.setType(n, type)`, ...) instead of accessing the columns + # 1.8.2 remove left over console debug diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 25264593d..3dbd16ecc 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -29,7 +29,7 @@ Use a current Node.js release compatible with the project dependencies. ## Update generated configuration -The repository includes scripts for refreshing generated CSS property and syntax data. Run them from the project root: +The repository includes scripts for refreshing generated CSS shorthand properties and syntax data. Run them from the project root: ```sh npm run config-update diff --git a/README.md b/README.md index 7917af421..1539abe2f 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,13 @@ # css-parser -An all-in-one CSS parsing solution for Node.js and the browser, covering parsing, validation, transformation, minification, and AST-based tooling. +A zero-allocation, high-performance CSS processing engine for Node.js and the browser, combining parsing, validation, transformation, minification, and AST-based tooling in a single solution. -The library always fully parses the stylesheet into a structured AST, and token values are exposed as typed data so custom transforms, plugins, and analysis can work with reliable, semantic input instead of raw strings. +Every stylesheet is fully parsed into a structured AST, with token values represented as typed data. This provides a reliable semantic foundation for custom transformations, plugin development, and advanced stylesheet analysis without relying on raw string manipulation. + +> [!NOTE] +> Version 2.0 has been rewritten to use arena memory for AST nodes and tokens, improving memory usage and performance. On the Tailwind CSS parsing and validation workload, runtime is 42% faster than v1.8.2 while using 60% less memory.
+This major release also introduces breaking changes and removes deprecated features. See the [migration guide](https://tbela99.github.io/css-parser/docs/documents/Guide.Migration.html) for details. ## Installation @@ -108,8 +112,8 @@ Performance vs execution speed comparison | File: tailwind.css | Speed optimization | Minification optimization | | --------------------- | ------------------ | ------------------------- | -| Size: 2,380,419 bytes | 1,890,728 bytes | 1,633,188 bytes | -| Time | 205.91 ms | 471.89 ms | +| Size: 2,380,419 bytes | 1,890,835 bytes | 1,633,188 bytes | +| Time | 128.67 ms | 268.86 ms | | Size reduction | -20.6% | -31.4% | ## Playground @@ -134,51 +138,145 @@ Try it [online](https://tbela99.github.io/css-parser/playground/) - [Syntax Lowering](https://tbela99.github.io/css-parser/docs/documents/Guide.Syntax_Lowering.html) - [Prefix Removal](https://tbela99.github.io/css-parser/docs/documents/Guide.Prefix_Removal.html) - [Ast Manipulation](https://tbela99.github.io/css-parser/docs/documents/Guide.Ast_Manipulation.html) +- [Arena Memory](https://tbela99.github.io/css-parser/docs/documents/Guide.Arena_Memory.html) - [Utility Functions](https://tbela99.github.io/css-parser/docs/documents/Guide.Utility_Functions.html) +- [Migration to 2.0](https://tbela99.github.io/css-parser/docs/documents/Guide.Migration.html) ## AST +Ast nodes and value tokens are allocated in an arena (`AstArena`) and referenced by their id (a number). The node data is stored +column-wise in typed arrays (structure of arrays) and is read / written through the arena. The parser does not allocate +node or token objects: + +```ts +import {parse, render, EnumToken} from '@tbela99/css-parser'; + +const {arena, ast} = await parse(`.foo { color: red }`); +const rule = arena.getFirstChild(ast); +const declaration = arena.getFirstChild(rule); + +console.log(arena.getType(rule) == EnumToken.RuleNodeType, arena.getSelector(rule)); // true '.foo' +console.log(arena.getName(declaration)); // 'color' +console.log(arena.tokens(declaration).map((token) => [EnumToken[arena.getType(token)], arena.str(token)])); // [['Color', 'red']] +console.log(render(arena, ast).code); // .foo{color:red} +``` + ### Comment -- typ: number -- val: string, the comment +- `arena.getType(n)`: EnumToken.CommentNodeType +- `arena.getValue(n)`: string, the comment -### AtRuleStyleSheet +### StyleSheet -- typ: number -- chi: array of children +- `arena.getType(n)`: EnumToken.StyleSheetNodeType +- `arena.children(n)`: array of children ids ### Declaration -- typ: number -- nam: string, declaration name -- val: array of tokens -- state: EnumAstNodeStatus, validation state -- errors: ErrorDescription[], validation errors +- `arena.getType(n)`: EnumToken.DeclarationNodeType +- `arena.getName(n)`: string, declaration name +- `arena.tokens(n)`: array of token ids, the declaration value +- `arena.getState(n)`: EnumAstNodeStatus, validation state +- `arena.getErrors(n)`: ErrorDescription[], validation errors -### Rule +### Rule and KeyframesRule -- typ: number -- sel: string, css selector -- chi: array of children -- state: EnumAstNodeStatus, validation state -- errors: ErrorDescription[], validation errors +- `arena.getType(n)`: EnumToken.RuleNodeType or EnumToken.KeyframesRuleNodeType +- `arena.getSelector(n)`: string, css selector +- `arena.tokens(n)`: array of token ids, the parsed selector +- `arena.children(n)`: array of children ids +- `arena.getState(n)`: EnumAstNodeStatus, validation state +- `arena.getErrors(n)`: ErrorDescription[], validation errors ### AtRule and KeyframesAtRule -- typ: number -- nam: string. AtRule name -- val: rule prelude -- state: EnumAstNodeStatus, validation state -- errors: ErrorDescription[], validation errors +- `arena.getType(n)`: EnumToken.AtRuleNodeType or EnumToken.KeyframesAtRuleNodeType +- `arena.getName(n)`: string. AtRule name +- `arena.getValue(n)`: rule prelude +- `arena.tokens(n)`: array of token ids, the parsed prelude +- `arena.children(n)`: array of children ids (at-rules with a block) +- `arena.getState(n)`: EnumAstNodeStatus, validation state +- `arena.getErrors(n)`: ErrorDescription[], validation errors + +### Object views + +`arena.toObject(id)` returns an object view of a node or a token (`AstArenaNode`): its properties (`typ`, `nam`, `sel`, +`val`, `chi`, `tokens`, `loc`, `state`, `errors`, `parent`, ...) are getters and setters that read and write the arena. +The view only holds the arena and the node id (`view[ARENAID]`). Importing a view of the same arena is a noop: + +```ts +const rule = arena.toObject(arena.getFirstChild(ast)); + +rule.sel = '.bar'; +rule.chi[0].nam = 'background-color'; + +// the returned arrays are frozen: assign the property to modify the arena +rule.chi = [...rule.chi, {typ: EnumToken.DeclarationNodeType, nam: 'width', val: [{typ: EnumToken.LengthTokenType, val: 3, unit: 'px'}]}]; + +console.log(arena.fromObject(rule) == rule[ARENAID]); // true: nothing is copied +console.log(JSON.stringify(rule)); // deep plain copy +``` + +### Traversal and visitors + +The traversal and search functions are methods of the arena: `arena.walk()`, `arena.walkValues()`, `arena.find()`, +`arena.findAll()`, `arena.findLast()`, `arena.findByValue()`, `arena.findValue()`. They return node ids. Their callbacks, +like the visitors, are called with the arena and the node id: everything else is read from the arena. + +```ts +for (const node of arena.walk(ast)) { + + console.log(EnumToken[arena.getType(node)], arena.getParent(node)); +} -### KeyframesRule +const result = await transform(css, { + visitor: { + + Declaration(arena: AstArena, id: number) { + + const node = arena.toObject(id); + + if (node.nam == 'height') { + + node.nam = 'width'; + } + } + } +}); +``` + +A visitor returns nothing to keep the node, or an object or a node id (or an array of objects and node ids) to replace it. + +### Arena memory + +The arena never frees memory by itself: detached nodes keep their memory and their ids stay valid. A long-lived arena +can be compacted. `compact()` and `trim()` renumber the nodes and return the mapping of the old ids to the new ids: + +```ts +console.log(arena.getCapacity(), arena.getLastId(), arena.getStringCount()); // capacity, last allocated id, interned strings + +arena.mark(node); // mark a node to be released later +const mapping = arena.trim(result.errors); // release the marked nodes, drop the unreachable nodes, shrink the columns +const newId = mapping[oldId]; // 0 when the node has been dropped +``` + +See [Arena Memory](https://tbela99.github.io/css-parser/docs/documents/Guide.Arena_Memory.html). + +### Workers + +The arena can be moved to a worker (and back) without copying the node data: + +```ts +// main thread +const [properties, transferables] = AstArena.toTransferableArenaObject(result.arena); +worker.postMessage({ast: result.ast, properties, transferables}, transferables); + +// worker +const arena = AstArena.fromTransferableArenaObjects(event.data.properties, event.data.transferables); +console.log(render(arena, event.data.ast).code); +``` -- typ: number -- sel: string, css selector -- chi: array of children -- state: EnumAstNodeStatus, validation state -- errors: ErrorDescription[], validation errors +See [Ast Manipulation](https://tbela99.github.io/css-parser/docs/documents/Guide.Ast_Manipulation.html). ## Sourcemap diff --git a/benchmark/package.json b/benchmark/package.json index eea24d298..93fdb1cb8 100644 --- a/benchmark/package.json +++ b/benchmark/package.json @@ -10,8 +10,8 @@ "all": "npm run sizes && npm run bench; npm run report" }, "dependencies": { - "@tbela99/css-parser": "^1.7.0", - "@tbela99/css-parser2": "github:tbela99/css-parser#293f2dc", + "@tbela99/css-parser": "github:tbela99/css-parser#007a292", + "@tbela99/css-parser2": "github:tbela99/css-parser#007a292", "clean-css": "^5.3.3", "css-tree": "^3.2.1", "cssnano": "^9.9.0", @@ -19,7 +19,7 @@ "esbuild": "^0.28.2", "lightningcss": "^1.33.0", "postcss": "^8.5.32", - "vitest": "^5.0.5", + "vitest": "^5.1.0", "yuku-css": "^0.2.0" } } \ No newline at end of file diff --git a/benchmark/src/minifiers.js b/benchmark/src/minifiers.js index a28e56ed9..dcc5048fb 100644 --- a/benchmark/src/minifiers.js +++ b/benchmark/src/minifiers.js @@ -147,5 +147,5 @@ export const minifiers = [ url: versions["css-parser-dev"].url, label: `@tbela99/css-parser-dev (default) - ${versions["css-parser-dev"].version}`, minify: async (css) => tbelaDevTransform({ input: css }).code, - }, + } ]; diff --git a/dist/index-umd-web.js b/dist/index-umd-web.js index eb06b7e78..7230d5217 100644 --- a/dist/index-umd-web.js +++ b/dist/index-umd-web.js @@ -2,7 +2,7 @@ CSS parser, minifier and validator for node and the browser Author(s): Thierry Bela - Version: 1.8.2 + Version: 2.0.0-alpha.1 License: MIT */ (function (global, factory) { @@ -68,748 +68,713 @@ * Color component without unit */ EnumAstNodeStatus[EnumAstNodeStatus["PowerlessColorComponent"] = 512] = "PowerlessColorComponent"; - })(exports.EnumAstNodeStatus || (exports.EnumAstNodeStatus = {})); - /** - * Enum of validation levels - * @deprecated - */ - exports.ValidationLevel = void 0; - (function (ValidationLevel) { - /** - * disable validation - */ - ValidationLevel[ValidationLevel["None"] = 0] = "None"; + /* node flags stored in the arena `flags` column next to the validation state */ /** - * validate selectors + * mask of the validation state bits */ - ValidationLevel[ValidationLevel["Selector"] = 1] = "Selector"; + EnumAstNodeStatus[EnumAstNodeStatus["StateMask"] = 65535] = "StateMask"; /** - * validate at-rules + * the node has a children list (stylesheet, rule, at-rule with a block) */ - ValidationLevel[ValidationLevel["AtRule"] = 2] = "AtRule"; + EnumAstNodeStatus[EnumAstNodeStatus["HasChildren"] = 65536] = "HasChildren"; /** - * validate declarations + * the node has value tokens (declaration) */ - ValidationLevel[ValidationLevel["Declaration"] = 4] = "Declaration"; + EnumAstNodeStatus[EnumAstNodeStatus["HasValues"] = 131072] = "HasValues"; /** - * validate selectors and at-rules + * the node has a source location */ - ValidationLevel[ValidationLevel["Default"] = 3] = "Default"; + EnumAstNodeStatus[EnumAstNodeStatus["HasLocation"] = 262144] = "HasLocation"; /** - * validate selectors, at-rules and declarations + * the node is marked to be released or trimmed. see `arena.mark()`, `arena.release()` and `arena.trim()` */ - ValidationLevel[ValidationLevel["All"] = 7] = "All"; + EnumAstNodeStatus[EnumAstNodeStatus["Marked"] = 524288] = "Marked"; /** - * Report only. Apply validation and report nodes that are marked as invalid + * transient flag used while comparing the declarations of two rules + * @private */ - ValidationLevel[ValidationLevel["ReportOnly"] = 8] = "ReportOnly"; - })(exports.ValidationLevel || (exports.ValidationLevel = {})); + EnumAstNodeStatus[EnumAstNodeStatus["Matched"] = 1048576] = "Matched"; + })(exports.EnumAstNodeStatus || (exports.EnumAstNodeStatus = {})); /** * Enum of all token types */ exports.EnumToken = void 0; (function (EnumToken) { /** - * comment token + * comment token. the value 0 is reserved: it is the type of the null node (id 0) and of unset nodes, + * so that reading the type of a missing node never matches a real token type */ - EnumToken[EnumToken["CommentTokenType"] = 0] = "CommentTokenType"; + EnumToken[EnumToken["CommentTokenType"] = 1] = "CommentTokenType"; /** * cdata section token */ - EnumToken[EnumToken["CDOCOMMTokenType"] = 1] = "CDOCOMMTokenType"; + EnumToken[EnumToken["CDOCOMMTokenType"] = 2] = "CDOCOMMTokenType"; /** * style sheet node type */ - EnumToken[EnumToken["StyleSheetNodeType"] = 2] = "StyleSheetNodeType"; + EnumToken[EnumToken["StyleSheetNodeType"] = 3] = "StyleSheetNodeType"; /** * at-rule node type */ - EnumToken[EnumToken["AtRuleNodeType"] = 3] = "AtRuleNodeType"; + EnumToken[EnumToken["AtRuleNodeType"] = 4] = "AtRuleNodeType"; /** * rule node type */ - EnumToken[EnumToken["RuleNodeType"] = 4] = "RuleNodeType"; + EnumToken[EnumToken["RuleNodeType"] = 5] = "RuleNodeType"; /** * declaration node type */ - EnumToken[EnumToken["DeclarationNodeType"] = 5] = "DeclarationNodeType"; + EnumToken[EnumToken["DeclarationNodeType"] = 6] = "DeclarationNodeType"; /** * literal token type */ - EnumToken[EnumToken["LiteralTokenType"] = 6] = "LiteralTokenType"; + EnumToken[EnumToken["LiteralTokenType"] = 7] = "LiteralTokenType"; /** * identifier token type */ - EnumToken[EnumToken["IdenTokenType"] = 7] = "IdenTokenType"; + EnumToken[EnumToken["IdenTokenType"] = 8] = "IdenTokenType"; /** * dashed identifier token type */ - EnumToken[EnumToken["DashedIdenTokenType"] = 8] = "DashedIdenTokenType"; + EnumToken[EnumToken["DashedIdenTokenType"] = 9] = "DashedIdenTokenType"; /** * comma token type */ - EnumToken[EnumToken["CommaTokenType"] = 9] = "CommaTokenType"; + EnumToken[EnumToken["CommaTokenType"] = 10] = "CommaTokenType"; /** * colon token type */ - EnumToken[EnumToken["ColonTokenType"] = 10] = "ColonTokenType"; + EnumToken[EnumToken["ColonTokenType"] = 11] = "ColonTokenType"; /** * semicolon token type */ - EnumToken[EnumToken["SemiColonTokenType"] = 11] = "SemiColonTokenType"; + EnumToken[EnumToken["SemiColonTokenType"] = 12] = "SemiColonTokenType"; /** * number token type */ - EnumToken[EnumToken["NumberTokenType"] = 12] = "NumberTokenType"; + EnumToken[EnumToken["NumberTokenType"] = 13] = "NumberTokenType"; /** * at-rule token type */ - EnumToken[EnumToken["AtRuleTokenType"] = 13] = "AtRuleTokenType"; + EnumToken[EnumToken["AtRuleTokenType"] = 14] = "AtRuleTokenType"; /** * percentage token type */ - EnumToken[EnumToken["PercentageTokenType"] = 14] = "PercentageTokenType"; + EnumToken[EnumToken["PercentageTokenType"] = 15] = "PercentageTokenType"; /** * function token type */ - EnumToken[EnumToken["FunctionTokenType"] = 15] = "FunctionTokenType"; + EnumToken[EnumToken["FunctionTokenType"] = 16] = "FunctionTokenType"; /** * timeline function token type */ - EnumToken[EnumToken["TimelineFunctionTokenType"] = 16] = "TimelineFunctionTokenType"; + EnumToken[EnumToken["TimelineFunctionTokenType"] = 17] = "TimelineFunctionTokenType"; /** * timing function token type */ - EnumToken[EnumToken["TimingFunctionTokenType"] = 17] = "TimingFunctionTokenType"; + EnumToken[EnumToken["TimingFunctionTokenType"] = 18] = "TimingFunctionTokenType"; /** * url function token type */ - EnumToken[EnumToken["UrlFunctionTokenType"] = 18] = "UrlFunctionTokenType"; + EnumToken[EnumToken["UrlFunctionTokenType"] = 19] = "UrlFunctionTokenType"; /** * image function token type */ - EnumToken[EnumToken["ImageFunctionTokenType"] = 19] = "ImageFunctionTokenType"; + EnumToken[EnumToken["ImageFunctionTokenType"] = 20] = "ImageFunctionTokenType"; /** * string token type */ - EnumToken[EnumToken["StringTokenType"] = 20] = "StringTokenType"; + EnumToken[EnumToken["StringTokenType"] = 21] = "StringTokenType"; /** * unclosed string token type */ - EnumToken[EnumToken["UnclosedStringTokenType"] = 21] = "UnclosedStringTokenType"; + EnumToken[EnumToken["UnclosedStringTokenType"] = 22] = "UnclosedStringTokenType"; /** * dimension token type */ - EnumToken[EnumToken["DimensionTokenType"] = 22] = "DimensionTokenType"; + EnumToken[EnumToken["DimensionTokenType"] = 23] = "DimensionTokenType"; /** * length token type */ - EnumToken[EnumToken["LengthTokenType"] = 23] = "LengthTokenType"; + EnumToken[EnumToken["LengthTokenType"] = 24] = "LengthTokenType"; /** * angle token type */ - EnumToken[EnumToken["AngleTokenType"] = 24] = "AngleTokenType"; + EnumToken[EnumToken["AngleTokenType"] = 25] = "AngleTokenType"; /** * time token type */ - EnumToken[EnumToken["TimeTokenType"] = 25] = "TimeTokenType"; + EnumToken[EnumToken["TimeTokenType"] = 26] = "TimeTokenType"; /** * frequency token type */ - EnumToken[EnumToken["FrequencyTokenType"] = 26] = "FrequencyTokenType"; + EnumToken[EnumToken["FrequencyTokenType"] = 27] = "FrequencyTokenType"; /** * resolution token type */ - EnumToken[EnumToken["ResolutionTokenType"] = 27] = "ResolutionTokenType"; + EnumToken[EnumToken["ResolutionTokenType"] = 28] = "ResolutionTokenType"; /** * hash token type */ - EnumToken[EnumToken["HashTokenType"] = 28] = "HashTokenType"; + EnumToken[EnumToken["HashTokenType"] = 29] = "HashTokenType"; /** * block start token type */ - EnumToken[EnumToken["BlockStartTokenType"] = 29] = "BlockStartTokenType"; + EnumToken[EnumToken["BlockStartTokenType"] = 30] = "BlockStartTokenType"; /** * block end token type */ - EnumToken[EnumToken["BlockEndTokenType"] = 30] = "BlockEndTokenType"; + EnumToken[EnumToken["BlockEndTokenType"] = 31] = "BlockEndTokenType"; /** * attribute start token type */ - EnumToken[EnumToken["AttrStartTokenType"] = 31] = "AttrStartTokenType"; + EnumToken[EnumToken["AttrStartTokenType"] = 32] = "AttrStartTokenType"; /** * attribute end token type */ - EnumToken[EnumToken["AttrEndTokenType"] = 32] = "AttrEndTokenType"; + EnumToken[EnumToken["AttrEndTokenType"] = 33] = "AttrEndTokenType"; /** * start parentheses token type */ - EnumToken[EnumToken["StartParensTokenType"] = 33] = "StartParensTokenType"; + EnumToken[EnumToken["StartParensTokenType"] = 34] = "StartParensTokenType"; /** * end parentheses token type */ - EnumToken[EnumToken["EndParensTokenType"] = 34] = "EndParensTokenType"; + EnumToken[EnumToken["EndParensTokenType"] = 35] = "EndParensTokenType"; /** * parentheses token type */ - EnumToken[EnumToken["ParensTokenType"] = 35] = "ParensTokenType"; + EnumToken[EnumToken["ParensTokenType"] = 36] = "ParensTokenType"; /** * whitespace token type */ - EnumToken[EnumToken["WhitespaceTokenType"] = 36] = "WhitespaceTokenType"; + EnumToken[EnumToken["WhitespaceTokenType"] = 37] = "WhitespaceTokenType"; /** * include match token type */ - EnumToken[EnumToken["IncludeMatchTokenType"] = 37] = "IncludeMatchTokenType"; + EnumToken[EnumToken["IncludeMatchTokenType"] = 38] = "IncludeMatchTokenType"; /** * dash match token type */ - EnumToken[EnumToken["DashMatchTokenType"] = 38] = "DashMatchTokenType"; + EnumToken[EnumToken["DashMatchTokenType"] = 39] = "DashMatchTokenType"; /** * equal match token type */ - EnumToken[EnumToken["EqualMatchTokenType"] = 39] = "EqualMatchTokenType"; + EnumToken[EnumToken["EqualMatchTokenType"] = 40] = "EqualMatchTokenType"; /** * less than token type */ - EnumToken[EnumToken["LtTokenType"] = 40] = "LtTokenType"; + EnumToken[EnumToken["LtTokenType"] = 41] = "LtTokenType"; /** * less than or equal to token type */ - EnumToken[EnumToken["LteTokenType"] = 41] = "LteTokenType"; + EnumToken[EnumToken["LteTokenType"] = 42] = "LteTokenType"; /** * greater than token type */ - EnumToken[EnumToken["GtTokenType"] = 42] = "GtTokenType"; + EnumToken[EnumToken["GtTokenType"] = 43] = "GtTokenType"; /** * greater than or equal to token type */ - EnumToken[EnumToken["GteTokenType"] = 43] = "GteTokenType"; + EnumToken[EnumToken["GteTokenType"] = 44] = "GteTokenType"; /** * pseudo-class token type */ - EnumToken[EnumToken["PseudoClassTokenType"] = 44] = "PseudoClassTokenType"; + EnumToken[EnumToken["PseudoClassTokenType"] = 45] = "PseudoClassTokenType"; /** * pseudo-class function token type */ - EnumToken[EnumToken["PseudoClassFuncTokenType"] = 45] = "PseudoClassFuncTokenType"; + EnumToken[EnumToken["PseudoClassFuncTokenType"] = 46] = "PseudoClassFuncTokenType"; /** * delimiter token type */ - EnumToken[EnumToken["DelimTokenType"] = 46] = "DelimTokenType"; + EnumToken[EnumToken["DelimTokenType"] = 47] = "DelimTokenType"; /** * URL token type */ - EnumToken[EnumToken["UrlTokenTokenType"] = 47] = "UrlTokenTokenType"; + EnumToken[EnumToken["UrlTokenTokenType"] = 48] = "UrlTokenTokenType"; /** * end of file token type */ - EnumToken[EnumToken["EOFTokenType"] = 48] = "EOFTokenType"; + EnumToken[EnumToken["EOFTokenType"] = 49] = "EOFTokenType"; /** * important token type */ - EnumToken[EnumToken["ImportantTokenType"] = 49] = "ImportantTokenType"; + EnumToken[EnumToken["ImportantTokenType"] = 50] = "ImportantTokenType"; /** * color token type */ - EnumToken[EnumToken["ColorTokenType"] = 50] = "ColorTokenType"; + EnumToken[EnumToken["ColorTokenType"] = 51] = "ColorTokenType"; /** * attribute token type */ - EnumToken[EnumToken["AttrTokenType"] = 51] = "AttrTokenType"; + EnumToken[EnumToken["AttrTokenType"] = 52] = "AttrTokenType"; /** * bad comment token type */ - EnumToken[EnumToken["BadCommentTokenType"] = 52] = "BadCommentTokenType"; + EnumToken[EnumToken["BadCommentTokenType"] = 53] = "BadCommentTokenType"; /** * bad cdo token type */ - EnumToken[EnumToken["BadCdoTokenType"] = 53] = "BadCdoTokenType"; + EnumToken[EnumToken["BadCdoTokenType"] = 54] = "BadCdoTokenType"; /** * bad URL token type */ - EnumToken[EnumToken["BadUrlTokenType"] = 54] = "BadUrlTokenType"; + EnumToken[EnumToken["BadUrlTokenType"] = 55] = "BadUrlTokenType"; /** * bad string token type */ - EnumToken[EnumToken["BadStringTokenType"] = 55] = "BadStringTokenType"; + EnumToken[EnumToken["BadStringTokenType"] = 56] = "BadStringTokenType"; /** * binary expression token type */ - EnumToken[EnumToken["BinaryExpressionTokenType"] = 56] = "BinaryExpressionTokenType"; + EnumToken[EnumToken["BinaryExpressionTokenType"] = 57] = "BinaryExpressionTokenType"; /** * unary expression token type */ - EnumToken[EnumToken["UnaryExpressionTokenType"] = 57] = "UnaryExpressionTokenType"; + EnumToken[EnumToken["UnaryExpressionTokenType"] = 58] = "UnaryExpressionTokenType"; /** * flex token type */ - EnumToken[EnumToken["FlexTokenType"] = 58] = "FlexTokenType"; + EnumToken[EnumToken["FlexTokenType"] = 59] = "FlexTokenType"; /** * token list token type */ - EnumToken[EnumToken["ListToken"] = 59] = "ListToken"; + EnumToken[EnumToken["ListToken"] = 60] = "ListToken"; /* arithmetic tokens */ /** * addition token type */ - EnumToken[EnumToken["Add"] = 60] = "Add"; + EnumToken[EnumToken["Add"] = 61] = "Add"; /** * multiplication token type */ - EnumToken[EnumToken["Mul"] = 61] = "Mul"; + EnumToken[EnumToken["Mul"] = 62] = "Mul"; /** * division token type */ - EnumToken[EnumToken["Div"] = 62] = "Div"; + EnumToken[EnumToken["Div"] = 63] = "Div"; /** * subtraction token type */ - EnumToken[EnumToken["Sub"] = 63] = "Sub"; + EnumToken[EnumToken["Sub"] = 64] = "Sub"; /* new tokens */ /** * column combinator token type */ - EnumToken[EnumToken["ColumnCombinatorTokenType"] = 64] = "ColumnCombinatorTokenType"; + EnumToken[EnumToken["ColumnCombinatorTokenType"] = 65] = "ColumnCombinatorTokenType"; /** * contain match token type */ - EnumToken[EnumToken["ContainMatchTokenType"] = 65] = "ContainMatchTokenType"; + EnumToken[EnumToken["ContainMatchTokenType"] = 66] = "ContainMatchTokenType"; /** * start match token type */ - EnumToken[EnumToken["StartMatchTokenType"] = 66] = "StartMatchTokenType"; + EnumToken[EnumToken["StartMatchTokenType"] = 67] = "StartMatchTokenType"; /** * end match token type */ - EnumToken[EnumToken["EndMatchTokenType"] = 67] = "EndMatchTokenType"; + EnumToken[EnumToken["EndMatchTokenType"] = 68] = "EndMatchTokenType"; /** * match expression token type */ - EnumToken[EnumToken["MatchExpressionTokenType"] = 68] = "MatchExpressionTokenType"; + EnumToken[EnumToken["MatchExpressionTokenType"] = 69] = "MatchExpressionTokenType"; /** * namespace attribute token type */ - EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 69] = "NameSpaceAttributeTokenType"; + EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 70] = "NameSpaceAttributeTokenType"; /** * fraction token type */ - EnumToken[EnumToken["FractionTokenType"] = 70] = "FractionTokenType"; + EnumToken[EnumToken["FractionTokenType"] = 71] = "FractionTokenType"; /** * identifier list token type */ - EnumToken[EnumToken["IdenListTokenType"] = 71] = "IdenListTokenType"; + EnumToken[EnumToken["IdenListTokenType"] = 72] = "IdenListTokenType"; /** * grid template function token type */ - EnumToken[EnumToken["GridTemplateFuncTokenType"] = 72] = "GridTemplateFuncTokenType"; + EnumToken[EnumToken["GridTemplateFuncTokenType"] = 73] = "GridTemplateFuncTokenType"; /** * keyframe rule node type */ - EnumToken[EnumToken["KeyframesRuleNodeType"] = 73] = "KeyframesRuleNodeType"; + EnumToken[EnumToken["KeyframesRuleNodeType"] = 74] = "KeyframesRuleNodeType"; /** * class selector token type */ - EnumToken[EnumToken["ClassSelectorTokenType"] = 74] = "ClassSelectorTokenType"; + EnumToken[EnumToken["ClassSelectorTokenType"] = 75] = "ClassSelectorTokenType"; /** * universal selector token type */ - EnumToken[EnumToken["UniversalSelectorTokenType"] = 75] = "UniversalSelectorTokenType"; + EnumToken[EnumToken["UniversalSelectorTokenType"] = 76] = "UniversalSelectorTokenType"; /** * child combinator token type */ - EnumToken[EnumToken["ChildCombinatorTokenType"] = 76] = "ChildCombinatorTokenType"; + EnumToken[EnumToken["ChildCombinatorTokenType"] = 77] = "ChildCombinatorTokenType"; /** * descendant combinator token type */ - EnumToken[EnumToken["DescendantCombinatorTokenType"] = 77] = "DescendantCombinatorTokenType"; + EnumToken[EnumToken["DescendantCombinatorTokenType"] = 78] = "DescendantCombinatorTokenType"; /** * next sibling combinator token type */ - EnumToken[EnumToken["NextSiblingCombinatorTokenType"] = 78] = "NextSiblingCombinatorTokenType"; + EnumToken[EnumToken["NextSiblingCombinatorTokenType"] = 79] = "NextSiblingCombinatorTokenType"; /** * subsequent sibling combinator token type */ - EnumToken[EnumToken["SubsequentSiblingCombinatorTokenType"] = 79] = "SubsequentSiblingCombinatorTokenType"; + EnumToken[EnumToken["SubsequentSiblingCombinatorTokenType"] = 80] = "SubsequentSiblingCombinatorTokenType"; /** * nesting selector token type */ - EnumToken[EnumToken["NestingSelectorTokenType"] = 80] = "NestingSelectorTokenType"; - /** - * Invalid rule token type - * @deprecated - */ - EnumToken[EnumToken["InvalidRuleNodeType"] = 81] = "InvalidRuleNodeType"; - /** - * invalid class selector token type - */ - EnumToken[EnumToken["InvalidClassSelectorTokenType"] = 82] = "InvalidClassSelectorTokenType"; - /** - * invalid attribute token type - */ - EnumToken[EnumToken["InvalidAttrTokenType"] = 83] = "InvalidAttrTokenType"; - /** - * Invalid at rule token type - * @deprecated - */ - EnumToken[EnumToken["InvalidAtRuleNodeType"] = 84] = "InvalidAtRuleNodeType"; + EnumToken[EnumToken["NestingSelectorTokenType"] = 81] = "NestingSelectorTokenType"; /** * media query condition token type */ - EnumToken[EnumToken["MediaQueryConditionTokenType"] = 85] = "MediaQueryConditionTokenType"; + EnumToken[EnumToken["MediaQueryConditionTokenType"] = 82] = "MediaQueryConditionTokenType"; /** * media feature token type */ - EnumToken[EnumToken["MediaFeatureTokenType"] = 86] = "MediaFeatureTokenType"; + EnumToken[EnumToken["MediaFeatureTokenType"] = 83] = "MediaFeatureTokenType"; /** * media feature only token type */ - EnumToken[EnumToken["OnlyTokenType"] = 87] = "OnlyTokenType"; + EnumToken[EnumToken["OnlyTokenType"] = 84] = "OnlyTokenType"; /** * media feature not token type */ - EnumToken[EnumToken["NotTokenType"] = 88] = "NotTokenType"; + EnumToken[EnumToken["NotTokenType"] = 85] = "NotTokenType"; /** * media feature and token type */ - EnumToken[EnumToken["AndTokenType"] = 89] = "AndTokenType"; + EnumToken[EnumToken["AndTokenType"] = 86] = "AndTokenType"; /** * media feature or token type */ - EnumToken[EnumToken["OrTokenType"] = 90] = "OrTokenType"; + EnumToken[EnumToken["OrTokenType"] = 87] = "OrTokenType"; /** * pseudo page token type */ - EnumToken[EnumToken["PseudoPageTokenType"] = 91] = "PseudoPageTokenType"; + EnumToken[EnumToken["PseudoPageTokenType"] = 88] = "PseudoPageTokenType"; /** * pseudo element token type */ - EnumToken[EnumToken["PseudoElementTokenType"] = 92] = "PseudoElementTokenType"; + EnumToken[EnumToken["PseudoElementTokenType"] = 89] = "PseudoElementTokenType"; /** * keyframe at rule node type */ - EnumToken[EnumToken["KeyframesAtRuleNodeType"] = 93] = "KeyframesAtRuleNodeType"; - /** - * invalid declaration node type. - * @deprecated - */ - EnumToken[EnumToken["InvalidDeclarationNodeType"] = 94] = "InvalidDeclarationNodeType"; + EnumToken[EnumToken["KeyframesAtRuleNodeType"] = 90] = "KeyframesAtRuleNodeType"; /* css module nodes */ /** * composes token node type */ - EnumToken[EnumToken["ComposesSelectorNodeType"] = 95] = "ComposesSelectorNodeType"; + EnumToken[EnumToken["ComposesSelectorNodeType"] = 91] = "ComposesSelectorNodeType"; /** * css variable token type */ - EnumToken[EnumToken["CssVariableTokenType"] = 96] = "CssVariableTokenType"; + EnumToken[EnumToken["CssVariableTokenType"] = 92] = "CssVariableTokenType"; /** * css variable import token type */ - EnumToken[EnumToken["CssVariableImportTokenType"] = 97] = "CssVariableImportTokenType"; + EnumToken[EnumToken["CssVariableImportTokenType"] = 93] = "CssVariableImportTokenType"; /** * css variable declaration map token type */ - EnumToken[EnumToken["CssVariableDeclarationMapTokenType"] = 98] = "CssVariableDeclarationMapTokenType"; + EnumToken[EnumToken["CssVariableDeclarationMapTokenType"] = 94] = "CssVariableDeclarationMapTokenType"; /** * media range query token type */ - EnumToken[EnumToken["MediaRangeQueryTokenType"] = 99] = "MediaRangeQueryTokenType"; - /** - * invalid media query token type - */ - EnumToken[EnumToken["InvalidMediaQueryTokenType"] = 100] = "InvalidMediaQueryTokenType"; + EnumToken[EnumToken["MediaRangeQueryTokenType"] = 95] = "MediaRangeQueryTokenType"; /** * supports query condition token type */ - EnumToken[EnumToken["SupportsQueryConditionTokenType"] = 101] = "SupportsQueryConditionTokenType"; + EnumToken[EnumToken["SupportsQueryConditionTokenType"] = 96] = "SupportsQueryConditionTokenType"; /** * supports query unary condition token type */ - EnumToken[EnumToken["SupportsQueryUnaryConditionTokenType"] = 102] = "SupportsQueryUnaryConditionTokenType"; + EnumToken[EnumToken["SupportsQueryUnaryConditionTokenType"] = 97] = "SupportsQueryUnaryConditionTokenType"; /** * when else query condition token type */ - EnumToken[EnumToken["WhenElseQueryConditionTokenType"] = 103] = "WhenElseQueryConditionTokenType"; + EnumToken[EnumToken["WhenElseQueryConditionTokenType"] = 98] = "WhenElseQueryConditionTokenType"; /** * when else query unary condition token type */ - EnumToken[EnumToken["WhenElseUnaryConditionTokenType"] = 104] = "WhenElseUnaryConditionTokenType"; + EnumToken[EnumToken["WhenElseUnaryConditionTokenType"] = 99] = "WhenElseUnaryConditionTokenType"; /** * container style range token type */ - EnumToken[EnumToken["ContainerStyleRangeTokenType"] = 105] = "ContainerStyleRangeTokenType"; + EnumToken[EnumToken["ContainerStyleRangeTokenType"] = 100] = "ContainerStyleRangeTokenType"; /** * '*' */ - EnumToken[EnumToken["Star"] = 106] = "Star"; + EnumToken[EnumToken["Star"] = 101] = "Star"; /** * '+' */ - EnumToken[EnumToken["Plus"] = 107] = "Plus"; + EnumToken[EnumToken["Plus"] = 102] = "Plus"; /** * '~' */ - EnumToken[EnumToken["Tilda"] = 108] = "Tilda"; + EnumToken[EnumToken["Tilda"] = 103] = "Tilda"; /** * '|' */ - EnumToken[EnumToken["PipeTokenType"] = 109] = "PipeTokenType"; + EnumToken[EnumToken["PipeTokenType"] = 104] = "PipeTokenType"; /** * '::' */ - EnumToken[EnumToken["DoubleColonTokenType"] = 110] = "DoubleColonTokenType"; + EnumToken[EnumToken["DoubleColonTokenType"] = 105] = "DoubleColonTokenType"; /** * math function token type such as'calc(' etc. */ - EnumToken[EnumToken["MathFunctionTokenType"] = 111] = "MathFunctionTokenType"; + EnumToken[EnumToken["MathFunctionTokenType"] = 106] = "MathFunctionTokenType"; /** * transform function token type such as 'translate(' etc. */ - EnumToken[EnumToken["TransformFunctionTokenType"] = 112] = "TransformFunctionTokenType"; + EnumToken[EnumToken["TransformFunctionTokenType"] = 107] = "TransformFunctionTokenType"; /** * when function token type such as 'supports(' etc. */ - EnumToken[EnumToken["WhenElseFunctionTokenType"] = 113] = "WhenElseFunctionTokenType"; + EnumToken[EnumToken["WhenElseFunctionTokenType"] = 108] = "WhenElseFunctionTokenType"; /** * general enclosed function token type 'font-tech(' etc. */ - EnumToken[EnumToken["GeneralEnclosedFunctionTokenType"] = 114] = "GeneralEnclosedFunctionTokenType"; + EnumToken[EnumToken["GeneralEnclosedFunctionTokenType"] = 109] = "GeneralEnclosedFunctionTokenType"; /** * supports function token type such as 'at-rule(' */ - EnumToken[EnumToken["SupportsFunctionTokenType"] = 115] = "SupportsFunctionTokenType"; + EnumToken[EnumToken["SupportsFunctionTokenType"] = 110] = "SupportsFunctionTokenType"; /** * container function token type such as 'style(' or 'scroll-state(' */ - EnumToken[EnumToken["ContainerFunctionTokenType"] = 116] = "ContainerFunctionTokenType"; + EnumToken[EnumToken["ContainerFunctionTokenType"] = 111] = "ContainerFunctionTokenType"; /** * unrecognized node token type */ - EnumToken[EnumToken["RawNodeTokenType"] = 117] = "RawNodeTokenType"; + EnumToken[EnumToken["RawNodeTokenType"] = 112] = "RawNodeTokenType"; /** * media query boolean token type * at-rule media not () * at-rule media only () */ - EnumToken[EnumToken["MediaQueryUnaryFeatureTokenType"] = 118] = "MediaQueryUnaryFeatureTokenType"; + EnumToken[EnumToken["MediaQueryUnaryFeatureTokenType"] = 113] = "MediaQueryUnaryFeatureTokenType"; /** * grid template function token type such as 'minmax(' */ - EnumToken[EnumToken["GridTemplateFuncTokenDefType"] = 119] = "GridTemplateFuncTokenDefType"; + EnumToken[EnumToken["GridTemplateFuncTokenDefType"] = 114] = "GridTemplateFuncTokenDefType"; /** * image function token type such as 'image(' etc. */ - EnumToken[EnumToken["ImageFunctionTokenDefType"] = 120] = "ImageFunctionTokenDefType"; + EnumToken[EnumToken["ImageFunctionTokenDefType"] = 115] = "ImageFunctionTokenDefType"; /** * function token type such as 'view(' etc. */ - EnumToken[EnumToken["TimelineFunctionTokenDefType"] = 121] = "TimelineFunctionTokenDefType"; + EnumToken[EnumToken["TimelineFunctionTokenDefType"] = 116] = "TimelineFunctionTokenDefType"; /** * function token type */ - EnumToken[EnumToken["FunctionTokenDefType"] = 122] = "FunctionTokenDefType"; + EnumToken[EnumToken["FunctionTokenDefType"] = 117] = "FunctionTokenDefType"; /** * timing function token type such as 'linear(' etc. */ - EnumToken[EnumToken["TimingFunctionTokenDefType"] = 123] = "TimingFunctionTokenDefType"; + EnumToken[EnumToken["TimingFunctionTokenDefType"] = 118] = "TimingFunctionTokenDefType"; /** * color function token type such as 'rgb(' etc. */ - EnumToken[EnumToken["ColorFunctionTokenDefType"] = 124] = "ColorFunctionTokenDefType"; + EnumToken[EnumToken["ColorFunctionTokenDefType"] = 119] = "ColorFunctionTokenDefType"; /** * math function token type such as 'calc(' etc. */ - EnumToken[EnumToken["MathFunctionTokenDefType"] = 125] = "MathFunctionTokenDefType"; + EnumToken[EnumToken["MathFunctionTokenDefType"] = 120] = "MathFunctionTokenDefType"; /** * container function token type such as 'style(' or 'scroll-state(' */ - EnumToken[EnumToken["ContainerFunctionTokenDefType"] = 126] = "ContainerFunctionTokenDefType"; + EnumToken[EnumToken["ContainerFunctionTokenDefType"] = 121] = "ContainerFunctionTokenDefType"; /** * url function token type 'url(' */ - EnumToken[EnumToken["UrlFunctionTokenDefType"] = 127] = "UrlFunctionTokenDefType"; + EnumToken[EnumToken["UrlFunctionTokenDefType"] = 122] = "UrlFunctionTokenDefType"; /** * pseudo-class function token type */ - EnumToken[EnumToken["PseudoClassFunctionTokenDefType"] = 128] = "PseudoClassFunctionTokenDefType"; + EnumToken[EnumToken["PseudoClassFunctionTokenDefType"] = 123] = "PseudoClassFunctionTokenDefType"; /** * transform function token type such as 'translate(' etc. */ - EnumToken[EnumToken["TransformFunctionTokenDefType"] = 129] = "TransformFunctionTokenDefType"; + EnumToken[EnumToken["TransformFunctionTokenDefType"] = 124] = "TransformFunctionTokenDefType"; /** * when function token type such as 'supports(' or 'media(' */ - EnumToken[EnumToken["WhenElseFunctionTokenDefType"] = 130] = "WhenElseFunctionTokenDefType"; + EnumToken[EnumToken["WhenElseFunctionTokenDefType"] = 125] = "WhenElseFunctionTokenDefType"; /** * general enclosed function token type 'font-tech(' etc. */ - EnumToken[EnumToken["GeneralEnclosedFunctionTokenDefType"] = 131] = "GeneralEnclosedFunctionTokenDefType"; + EnumToken[EnumToken["GeneralEnclosedFunctionTokenDefType"] = 126] = "GeneralEnclosedFunctionTokenDefType"; /** * supports function token type 'font-tech(' */ - EnumToken[EnumToken["SupportsFunctionTokenDefType"] = 132] = "SupportsFunctionTokenDefType"; - /** - * CDOCOMMTokenType not allowed in this context - */ - EnumToken[EnumToken["InvalidCommentTokenType"] = 133] = "InvalidCommentTokenType"; + EnumToken[EnumToken["SupportsFunctionTokenDefType"] = 127] = "SupportsFunctionTokenDefType"; /** * custom function token type '--function-name(' */ - EnumToken[EnumToken["CustomFunctionTokenDefType"] = 134] = "CustomFunctionTokenDefType"; + EnumToken[EnumToken["CustomFunctionTokenDefType"] = 128] = "CustomFunctionTokenDefType"; /** * custom function token type */ - EnumToken[EnumToken["CustomFunctionTokenType"] = 135] = "CustomFunctionTokenType"; + EnumToken[EnumToken["CustomFunctionTokenType"] = 129] = "CustomFunctionTokenType"; /** * function tokens such as 'var(', 'env(', 'if(') */ - EnumToken[EnumToken["WildCardFunctionTokenDefType"] = 136] = "WildCardFunctionTokenDefType"; + EnumToken[EnumToken["WildCardFunctionTokenDefType"] = 130] = "WildCardFunctionTokenDefType"; /** * function such as 'var()', 'env()', 'if()' */ - EnumToken[EnumToken["WildCardFunctionTokenType"] = 137] = "WildCardFunctionTokenType"; + EnumToken[EnumToken["WildCardFunctionTokenType"] = 131] = "WildCardFunctionTokenType"; /** * if condition token */ - EnumToken[EnumToken["IfConditionTokenType"] = 138] = "IfConditionTokenType"; + EnumToken[EnumToken["IfConditionTokenType"] = 132] = "IfConditionTokenType"; /** * if-Else condition token */ - EnumToken[EnumToken["IfElseConditionTokenType"] = 139] = "IfElseConditionTokenType"; + EnumToken[EnumToken["IfElseConditionTokenType"] = 133] = "IfElseConditionTokenType"; /** * wrapped values token type like {Arial, sans-serif} */ - EnumToken[EnumToken["WrappedValuesTokenType"] = 140] = "WrappedValuesTokenType"; + EnumToken[EnumToken["WrappedValuesTokenType"] = 134] = "WrappedValuesTokenType"; + /** + * list of arena tokens (binary expression operands) + */ + EnumToken[EnumToken["ListTokenType"] = 135] = "ListTokenType"; /** * infinity token */ - EnumToken[EnumToken["NaNTokenType"] = 141] = "NaNTokenType"; + EnumToken[EnumToken["NaNTokenType"] = 136] = "NaNTokenType"; /** * infinity token */ - EnumToken[EnumToken["InfinityTokenType"] = 142] = "InfinityTokenType"; + EnumToken[EnumToken["InfinityTokenType"] = 137] = "InfinityTokenType"; /** * negative infinity token */ - EnumToken[EnumToken["NegativeInfinityTokenType"] = 143] = "NegativeInfinityTokenType"; + EnumToken[EnumToken["NegativeInfinityTokenType"] = 138] = "NegativeInfinityTokenType"; /** * CSS type token */ - EnumToken[EnumToken["CssTypeTokenType"] = 144] = "CssTypeTokenType"; + EnumToken[EnumToken["CssTypeTokenType"] = 139] = "CssTypeTokenType"; /** * user defined dimension token type */ - EnumToken[EnumToken["UserDefinedDimensionTokenType"] = 145] = "UserDefinedDimensionTokenType"; + EnumToken[EnumToken["UserDefinedDimensionTokenType"] = 140] = "UserDefinedDimensionTokenType"; /* aliases */ /** * alias for time token type */ - EnumToken[EnumToken["Time"] = 25] = "Time"; + EnumToken[EnumToken["Time"] = 26] = "Time"; /** * alias for identifier token type */ - EnumToken[EnumToken["Iden"] = 7] = "Iden"; + EnumToken[EnumToken["Iden"] = 8] = "Iden"; /** * alias for end of file token type */ - EnumToken[EnumToken["EOF"] = 48] = "EOF"; + EnumToken[EnumToken["EOF"] = 49] = "EOF"; /** * alias for hash token type */ - EnumToken[EnumToken["Hash"] = 28] = "Hash"; + EnumToken[EnumToken["Hash"] = 29] = "Hash"; /** * alias for flex token type */ - EnumToken[EnumToken["Flex"] = 58] = "Flex"; + EnumToken[EnumToken["Flex"] = 59] = "Flex"; /** * alias for angle token type */ - EnumToken[EnumToken["Angle"] = 24] = "Angle"; + EnumToken[EnumToken["Angle"] = 25] = "Angle"; /** * alias for color token type */ - EnumToken[EnumToken["Color"] = 50] = "Color"; + EnumToken[EnumToken["Color"] = 51] = "Color"; /** * alias for comma token type */ - EnumToken[EnumToken["Comma"] = 9] = "Comma"; + EnumToken[EnumToken["Comma"] = 10] = "Comma"; /** * alias for string token type */ - EnumToken[EnumToken["String"] = 20] = "String"; + EnumToken[EnumToken["String"] = 21] = "String"; /** * alias for length token type */ - EnumToken[EnumToken["Length"] = 23] = "Length"; + EnumToken[EnumToken["Length"] = 24] = "Length"; /** * alias for number token type */ - EnumToken[EnumToken["Number"] = 12] = "Number"; + EnumToken[EnumToken["Number"] = 13] = "Number"; /** * alias for percentage token type */ - EnumToken[EnumToken["Perc"] = 14] = "Perc"; + EnumToken[EnumToken["Perc"] = 15] = "Perc"; /** * alias for literal token type */ - EnumToken[EnumToken["Literal"] = 6] = "Literal"; + EnumToken[EnumToken["Literal"] = 7] = "Literal"; /** * alias for comment token type */ - EnumToken[EnumToken["Comment"] = 0] = "Comment"; + EnumToken[EnumToken["Comment"] = 1] = "Comment"; /** * alias for url function token type */ - EnumToken[EnumToken["UrlFunc"] = 18] = "UrlFunc"; + EnumToken[EnumToken["UrlFunc"] = 19] = "UrlFunc"; /** * alias for dimension token type */ - EnumToken[EnumToken["Dimension"] = 22] = "Dimension"; + EnumToken[EnumToken["Dimension"] = 23] = "Dimension"; /** * alias for frequency token type */ - EnumToken[EnumToken["Frequency"] = 26] = "Frequency"; + EnumToken[EnumToken["Frequency"] = 27] = "Frequency"; /** * alias for resolution token type */ - EnumToken[EnumToken["Resolution"] = 27] = "Resolution"; + EnumToken[EnumToken["Resolution"] = 28] = "Resolution"; /** * alias for whitespace token type */ - EnumToken[EnumToken["Whitespace"] = 36] = "Whitespace"; + EnumToken[EnumToken["Whitespace"] = 37] = "Whitespace"; /** * alias for identifier list token type */ - EnumToken[EnumToken["IdenList"] = 71] = "IdenList"; + EnumToken[EnumToken["IdenList"] = 72] = "IdenList"; /** * alias for dashed identifier token type */ - EnumToken[EnumToken["DashedIden"] = 8] = "DashedIden"; + EnumToken[EnumToken["DashedIden"] = 9] = "DashedIden"; /** * alias for grid template function token type */ - EnumToken[EnumToken["GridTemplateFunc"] = 72] = "GridTemplateFunc"; + EnumToken[EnumToken["GridTemplateFunc"] = 73] = "GridTemplateFunc"; /** * alias for image function token type */ - EnumToken[EnumToken["ImageFunc"] = 19] = "ImageFunc"; + EnumToken[EnumToken["ImageFunc"] = 20] = "ImageFunc"; /** * alias for comment node type */ - EnumToken[EnumToken["CommentNodeType"] = 0] = "CommentNodeType"; + EnumToken[EnumToken["CommentNodeType"] = 1] = "CommentNodeType"; /** * alias for cdata section node type */ - EnumToken[EnumToken["CDOCOMMNodeType"] = 1] = "CDOCOMMNodeType"; + EnumToken[EnumToken["CDOCOMMNodeType"] = 2] = "CDOCOMMNodeType"; /** * alias for timing function token type */ - EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction"; + EnumToken[EnumToken["TimingFunction"] = 18] = "TimingFunction"; /** * alias for timeline function token type */ - EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction"; + EnumToken[EnumToken["TimelineFunction"] = 17] = "TimelineFunction"; })(exports.EnumToken || (exports.EnumToken = {})); /** * Supported color types enum @@ -817,137 +782,141 @@ exports.ColorType = void 0; (function (ColorType) { /** - * deprecated system colors + * the color type is not known yet (the color function has not been parsed) */ - ColorType[ColorType["SYS"] = 0] = "SYS"; + ColorType[ColorType["NONE"] = 0] = "NONE"; + /** + * system colors + */ + ColorType[ColorType["SYS"] = 1] = "SYS"; /** * deprecated system colors */ - ColorType[ColorType["DPSYS"] = 1] = "DPSYS"; + ColorType[ColorType["DPSYS"] = 2] = "DPSYS"; /** * named colors */ - ColorType[ColorType["LIT"] = 2] = "LIT"; + ColorType[ColorType["LIT"] = 3] = "LIT"; /** * colors as hex values */ - ColorType[ColorType["HEX"] = 3] = "HEX"; + ColorType[ColorType["HEX"] = 4] = "HEX"; /** * colors as rgb values */ - ColorType[ColorType["RGBA"] = 4] = "RGBA"; + ColorType[ColorType["RGBA"] = 5] = "RGBA"; /** * colors using rgb */ - ColorType[ColorType["HSLA"] = 5] = "HSLA"; + ColorType[ColorType["HSLA"] = 6] = "HSLA"; /** * colors using hwb */ - ColorType[ColorType["HWB"] = 6] = "HWB"; + ColorType[ColorType["HWB"] = 7] = "HWB"; /** * colors using cmyk */ - ColorType[ColorType["CMYK"] = 7] = "CMYK"; + ColorType[ColorType["CMYK"] = 8] = "CMYK"; /** * colors using oklab * */ - ColorType[ColorType["OKLAB"] = 8] = "OKLAB"; + ColorType[ColorType["OKLAB"] = 9] = "OKLAB"; /** * colors using oklch * */ - ColorType[ColorType["OKLCH"] = 9] = "OKLCH"; + ColorType[ColorType["OKLCH"] = 10] = "OKLCH"; /** * colors using lab */ - ColorType[ColorType["LAB"] = 10] = "LAB"; + ColorType[ColorType["LAB"] = 11] = "LAB"; /** * colors using lch */ - ColorType[ColorType["LCH"] = 11] = "LCH"; + ColorType[ColorType["LCH"] = 12] = "LCH"; /** * colors using color() function */ - ColorType[ColorType["COLOR"] = 12] = "COLOR"; + ColorType[ColorType["COLOR"] = 13] = "COLOR"; /** * color using srgb */ - ColorType[ColorType["SRGB"] = 13] = "SRGB"; + ColorType[ColorType["SRGB"] = 14] = "SRGB"; /** * color using prophoto-rgb */ - ColorType[ColorType["PROPHOTO_RGB"] = 14] = "PROPHOTO_RGB"; + ColorType[ColorType["PROPHOTO_RGB"] = 15] = "PROPHOTO_RGB"; /** * color using a98-rgb */ - ColorType[ColorType["A98_RGB"] = 15] = "A98_RGB"; + ColorType[ColorType["A98_RGB"] = 16] = "A98_RGB"; /** * color using rec2020 */ - ColorType[ColorType["REC2020"] = 16] = "REC2020"; + ColorType[ColorType["REC2020"] = 17] = "REC2020"; /** * color using display-p3 */ - ColorType[ColorType["DISPLAY_P3"] = 17] = "DISPLAY_P3"; + ColorType[ColorType["DISPLAY_P3"] = 18] = "DISPLAY_P3"; /** * color using srgb-linear */ - ColorType[ColorType["SRGB_LINEAR"] = 18] = "SRGB_LINEAR"; + ColorType[ColorType["SRGB_LINEAR"] = 19] = "SRGB_LINEAR"; /** * color using xyz-d50 */ - ColorType[ColorType["XYZ_D50"] = 19] = "XYZ_D50"; + ColorType[ColorType["XYZ_D50"] = 20] = "XYZ_D50"; /** * color using xyz-d65 */ - ColorType[ColorType["XYZ_D65"] = 20] = "XYZ_D65"; + ColorType[ColorType["XYZ_D65"] = 21] = "XYZ_D65"; /** * light-dark() color function */ - ColorType[ColorType["LIGHT_DARK"] = 21] = "LIGHT_DARK"; + ColorType[ColorType["LIGHT_DARK"] = 22] = "LIGHT_DARK"; /** * color-mix() color function */ - ColorType[ColorType["COLOR_MIX"] = 22] = "COLOR_MIX"; + ColorType[ColorType["COLOR_MIX"] = 23] = "COLOR_MIX"; /** * non-standard color */ - ColorType[ColorType["NON_STD"] = 23] = "NON_STD"; + ColorType[ColorType["NON_STD"] = 24] = "NON_STD"; /** * custom color */ - ColorType[ColorType["CUSTOM_COLOR"] = 24] = "CUSTOM_COLOR"; + ColorType[ColorType["CUSTOM_COLOR"] = 25] = "CUSTOM_COLOR"; /** * alpha() color function */ - ColorType[ColorType["ALPHA"] = 25] = "ALPHA"; + ColorType[ColorType["ALPHA"] = 26] = "ALPHA"; /** * color using display-p3-linear */ - ColorType[ColorType["DISPLAY_P3_LINEAR"] = 26] = "DISPLAY_P3_LINEAR"; + ColorType[ColorType["DISPLAY_P3_LINEAR"] = 27] = "DISPLAY_P3_LINEAR"; /** * Contrast color */ - ColorType[ColorType["CONTRAST_COLOR"] = 27] = "CONTRAST_COLOR"; + ColorType[ColorType["CONTRAST_COLOR"] = 28] = "CONTRAST_COLOR"; /** * color layers */ - ColorType[ColorType["COLOR_LAYERS"] = 28] = "COLOR_LAYERS"; + ColorType[ColorType["COLOR_LAYERS"] = 29] = "COLOR_LAYERS"; /** * alias for rgba */ - ColorType[ColorType["RGB"] = 4] = "RGB"; + ColorType[ColorType["RGB"] = 5] = "RGB"; /** * alias for hsl */ - ColorType[ColorType["HSL"] = 5] = "HSL"; + ColorType[ColorType["HSL"] = 6] = "HSL"; /** * alias for xyz-d65 */ - ColorType[ColorType["XYZ"] = 20] = "XYZ"; + ColorType[ColorType["XYZ"] = 21] = "XYZ"; /** * alias for cmyk */ - ColorType[ColorType["DEVICE_CMYK"] = 7] = "DEVICE_CMYK"; + ColorType[ColorType["DEVICE_CMYK"] = 8] = "DEVICE_CMYK"; })(exports.ColorType || (exports.ColorType = {})); /** * Supported module case transform @@ -1017,16240 +986,17769 @@ */ ModuleScopeEnumOptions[ModuleScopeEnumOptions["Shortest"] = 512] = "Shortest"; })(exports.ModuleScopeEnumOptions || (exports.ModuleScopeEnumOptions = {})); + /** + * Options returned by the filters of {@link AstArena.walk} and {@link AstArena.walkValues} + */ + exports.WalkerOptionEnum = void 0; + (function (WalkerOptionEnum) { + /** + * ignore the current node and its children + */ + WalkerOptionEnum[WalkerOptionEnum["Ignore"] = 1] = "Ignore"; + /** + * stop walking the tree + */ + WalkerOptionEnum[WalkerOptionEnum["Stop"] = 2] = "Stop"; + /** + * ignore the current node and process its children + */ + WalkerOptionEnum[WalkerOptionEnum["Children"] = 4] = "Children"; + /** + * ignore the current node children + */ + WalkerOptionEnum[WalkerOptionEnum["IgnoreChildren"] = 8] = "IgnoreChildren"; + })(exports.WalkerOptionEnum || (exports.WalkerOptionEnum = {})); + /** + * Event types of the {@link AstArena.walkValues} filter + */ + exports.WalkerEvent = void 0; + (function (WalkerEvent) { + /** + * enter node + */ + WalkerEvent[WalkerEvent["Enter"] = 1] = "Enter"; + /** + * leave node + */ + WalkerEvent[WalkerEvent["Leave"] = 2] = "Leave"; + })(exports.WalkerEvent || (exports.WalkerEvent = {})); - var declarations = { - "-ms-accelerator": { - syntax: "false | true" - }, - "-ms-block-progression": { - syntax: "tb | rl | bt | lr" - }, - "-ms-content-zoom-chaining": { - syntax: "none | chained" - }, - "-ms-content-zoom-limit": { - syntax: "<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>" - }, - "-ms-content-zoom-limit-max": { - syntax: "" - }, - "-ms-content-zoom-limit-min": { - syntax: "" - }, - "-ms-content-zoom-snap": { - syntax: "<'-ms-content-zoom-snap-type'> || <'-ms-content-zoom-snap-points'>" - }, - "-ms-content-zoom-snap-points": { - syntax: "snapInterval( , ) | snapList( # )" - }, - "-ms-content-zoom-snap-type": { - syntax: "none | proximity | mandatory" - }, - "-ms-content-zooming": { - syntax: "none | zoom" - }, - "-ms-filter": { - syntax: "" - }, - "-ms-flow-from": { - syntax: "[ none | ]#" - }, - "-ms-flow-into": { - syntax: "[ none | ]#" - }, - "-ms-grid-columns": { - syntax: "none | | " - }, - "-ms-grid-rows": { - syntax: "none | | " - }, - "-ms-high-contrast-adjust": { - syntax: "auto | none" - }, - "-ms-hyphenate-limit-chars": { - syntax: "auto | {1,3}" - }, - "-ms-hyphenate-limit-lines": { - syntax: "no-limit | " - }, - "-ms-hyphenate-limit-zone": { - syntax: " | " - }, - "-ms-ime-align": { - syntax: "auto | after" - }, - "-ms-overflow-style": { - syntax: " auto | none | scrollbar | -ms-autohiding-scrollbar" - }, - "-ms-scroll-chaining": { - syntax: "chained | none" - }, - "-ms-scroll-limit": { - syntax: "<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>" - }, - "-ms-scroll-limit-x-max": { - syntax: "auto | " - }, - "-ms-scroll-limit-x-min": { - syntax: "" - }, - "-ms-scroll-limit-y-max": { - syntax: "auto | " - }, - "-ms-scroll-limit-y-min": { - syntax: "" - }, - "-ms-scroll-rails": { - syntax: "none | railed" - }, - "-ms-scroll-snap-points-x": { - syntax: "snapInterval( , ) | snapList( # )" - }, - "-ms-scroll-snap-points-y": { - syntax: "snapInterval( , ) | snapList( # )" - }, - "-ms-scroll-snap-type": { - syntax: "none | proximity | mandatory" - }, - "-ms-scroll-snap-x": { - syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>" - }, - "-ms-scroll-snap-y": { - syntax: "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>" - }, - "-ms-scroll-translation": { - syntax: "none | vertical-to-horizontal" - }, - "-ms-scrollbar-3dlight-color": { - syntax: "" - }, - "-ms-scrollbar-arrow-color": { - syntax: "" - }, - "-ms-scrollbar-base-color": { - syntax: "" - }, - "-ms-scrollbar-darkshadow-color": { - syntax: "" - }, - "-ms-scrollbar-face-color": { - syntax: "" - }, - "-ms-scrollbar-highlight-color": { - syntax: "" - }, - "-ms-scrollbar-shadow-color": { - syntax: "" - }, - "-ms-scrollbar-track-color": { - syntax: "" - }, - "-ms-text-autospace": { - syntax: "none | ideograph-alpha | ideograph-numeric | ideograph-parenthesis | ideograph-space" - }, - "-ms-touch-select": { - syntax: "grippers | none" - }, - "-ms-user-select": { - syntax: "none | element | text" - }, - "-ms-wrap-flow": { - syntax: "auto | both | start | end | maximum | clear" - }, - "-ms-wrap-margin": { - syntax: "" - }, - "-ms-wrap-through": { - syntax: "wrap | none" - }, - "-moz-appearance": { - syntax: "none | button | button-arrow-down | button-arrow-next | button-arrow-previous | button-arrow-up | button-bevel | button-focus | caret | checkbox | checkbox-container | checkbox-label | checkmenuitem | dualbutton | groupbox | listbox | listitem | menuarrow | menubar | menucheckbox | menuimage | menuitem | menuitemtext | menulist | menulist-button | menulist-text | menulist-textfield | menupopup | menuradio | menuseparator | meterbar | meterchunk | progressbar | progressbar-vertical | progresschunk | progresschunk-vertical | radio | radio-container | radio-label | radiomenuitem | range | range-thumb | resizer | resizerpanel | scale-horizontal | scalethumbend | scalethumb-horizontal | scalethumbstart | scalethumbtick | scalethumb-vertical | scale-vertical | scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical | searchfield | separator | sheet | spinner | spinner-downbutton | spinner-textfield | spinner-upbutton | splitter | statusbar | statusbarpanel | tab | tabpanel | tabpanels | tab-scroll-arrow-back | tab-scroll-arrow-forward | textfield | textfield-multiline | toolbar | toolbarbutton | toolbarbutton-dropdown | toolbargripper | toolbox | tooltip | treeheader | treeheadercell | treeheadersortarrow | treeitem | treeline | treetwisty | treetwistyopen | treeview | -moz-mac-unified-toolbar | -moz-win-borderless-glass | -moz-win-browsertabbar-toolbox | -moz-win-communicationstext | -moz-win-communications-toolbox | -moz-win-exclude-glass | -moz-win-glass | -moz-win-mediatext | -moz-win-media-toolbox | -moz-window-button-box | -moz-window-button-box-maximized | -moz-window-button-close | -moz-window-button-maximize | -moz-window-button-minimize | -moz-window-button-restore | -moz-window-frame-bottom | -moz-window-frame-left | -moz-window-frame-right | -moz-window-titlebar | -moz-window-titlebar-maximized" - }, - "-moz-binding": { - syntax: " | none" - }, - "-moz-border-bottom-colors": { - syntax: "+ | none" - }, - "-moz-border-left-colors": { - syntax: "+ | none" - }, - "-moz-border-right-colors": { - syntax: "+ | none" - }, - "-moz-border-top-colors": { - syntax: "+ | none" - }, - "-moz-context-properties": { - syntax: "none | [ fill | fill-opacity | stroke | stroke-opacity ]#" - }, - "-moz-float-edge": { - syntax: "border-box | content-box | margin-box | padding-box" - }, - "-moz-force-broken-image-icon": { - syntax: "0 | 1" - }, - "-moz-orient": { - syntax: "inline | block | horizontal | vertical" - }, - "-moz-outline-radius": { - syntax: "{1,4} [ / {1,4} ]?" - }, - "-moz-outline-radius-bottomleft": { - syntax: "" - }, - "-moz-outline-radius-bottomright": { - syntax: "" - }, - "-moz-outline-radius-topleft": { - syntax: "" - }, - "-moz-outline-radius-topright": { - syntax: "" - }, - "-moz-stack-sizing": { - syntax: "ignore | stretch-to-fit" - }, - "-moz-text-blink": { - syntax: "none | blink" - }, - "-moz-user-focus": { - syntax: "ignore | normal | select-after | select-before | select-menu | select-same | select-all | none" - }, - "-moz-user-input": { - syntax: "auto | none | enabled | disabled" - }, - "-moz-user-modify": { - syntax: "read-only | read-write | write-only" - }, - "-moz-window-dragging": { - syntax: "drag | no-drag" - }, - "-moz-window-shadow": { - syntax: "default | menu | tooltip | sheet | none" - }, - "-webkit-appearance": { - syntax: " none | button | button-bevel | caps-lock-indicator | caret | checkbox | default-button | inner-spin-button | listbox | listitem | media-controls-background | media-controls-fullscreen-background | media-current-time-display | media-enter-fullscreen-button | media-exit-fullscreen-button | media-fullscreen-button | media-mute-button | media-overlay-play-button | media-play-button | media-seek-back-button | media-seek-forward-button | media-slider | media-sliderthumb | media-time-remaining-display | media-toggle-closed-captions-button | media-volume-slider | media-volume-slider-container | media-volume-sliderthumb | menulist | menulist-button | menulist-text | menulist-textfield | meter | progress-bar | progress-bar-value | push-button | radio | scrollbarbutton-down | scrollbarbutton-left | scrollbarbutton-right | scrollbarbutton-up | scrollbargripper-horizontal | scrollbargripper-vertical | scrollbarthumb-horizontal | scrollbarthumb-vertical | scrollbartrack-horizontal | scrollbartrack-vertical | searchfield | searchfield-cancel-button | searchfield-decoration | searchfield-results-button | searchfield-results-decoration | slider-horizontal | slider-vertical | sliderthumb-horizontal | sliderthumb-vertical | square-button | textarea | textfield | -apple-pay-button" - }, - "-webkit-border-after": { - syntax: "<'border-top'>" - }, - "-webkit-border-after-color": { - syntax: "<'border-top-color'>" - }, - "-webkit-border-after-style": { - syntax: "<'border-top-style'>" - }, - "-webkit-border-after-width": { - syntax: "<'border-top-width'>" - }, - "-webkit-border-before": { - syntax: "<'border-top'>" - }, - "-webkit-border-before-color": { - syntax: "<'border-top-color'>" - }, - "-webkit-border-before-style": { - syntax: "<'border-top-style'>" - }, - "-webkit-border-before-width": { - syntax: "<'border-top-width'>" - }, - "-webkit-border-end": { - syntax: "<'border-top'>" - }, - "-webkit-border-end-color": { - syntax: "<'border-top-color'>" - }, - "-webkit-border-end-style": { - syntax: "<'border-top-style'>" - }, - "-webkit-border-end-width": { - syntax: "<'border-top-width'>" - }, - "-webkit-border-start": { - syntax: "<'border-top'>" - }, - "-webkit-border-start-color": { - syntax: "<'border-top-color'>" - }, - "-webkit-border-start-style": { - syntax: "<'border-top-style'>" - }, - "-webkit-border-start-width": { - syntax: "<'border-top-width'>" - }, - "-webkit-box-reflect": { - syntax: "[ above | below | right | left ]? ? ?" - }, - "-webkit-line-clamp": { - syntax: "none | " - }, - "-webkit-mask": { - syntax: "[ || [ / ]? || || [ | border | padding | content | text ] || [ | border | padding | content ] ]#" - }, - "-webkit-mask-attachment": { - syntax: "#" - }, - "-webkit-mask-clip": { - syntax: "[ | no-clip | border | padding | content | text ]#" - }, - "-webkit-mask-composite": { - syntax: "#" - }, - "-webkit-mask-image": { - syntax: "#" - }, - "-webkit-mask-origin": { - syntax: "[ | border | padding | content ]#" - }, - "-webkit-mask-position": { - syntax: "#" - }, - "-webkit-mask-position-x": { - syntax: "[ | left | center | right ]#" - }, - "-webkit-mask-position-y": { - syntax: "[ | top | center | bottom ]#" - }, - "-webkit-mask-repeat": { - syntax: "#" - }, - "-webkit-mask-repeat-x": { - syntax: "repeat | no-repeat | space | round" - }, - "-webkit-mask-repeat-y": { - syntax: "repeat | no-repeat | space | round" - }, - "-webkit-mask-size": { - syntax: "#" - }, - "-webkit-overflow-scrolling": { - syntax: "auto | touch" - }, - "-webkit-tap-highlight-color": { - syntax: "" - }, - "-webkit-text-fill-color": { - syntax: "" - }, - "-webkit-text-stroke": { - syntax: " || " - }, - "-webkit-text-stroke-color": { - syntax: "" - }, - "-webkit-text-stroke-width": { - syntax: "" - }, - "-webkit-touch-callout": { - syntax: "default | none" - }, - "-webkit-user-modify": { - syntax: "read-only | read-write | read-write-plaintext-only" - }, - "-webkit-user-select": { - syntax: " auto | none | text | all" - }, - "accent-color": { - syntax: "auto | " - }, - "align-content": { - syntax: "normal | | | ? " - }, - "align-items": { - syntax: "normal | stretch | | [ ? ] | anchor-center" - }, - "align-self": { - syntax: "auto | normal | stretch | | ? | anchor-center" - }, - "align-tracks": { - syntax: "[ normal | | | ? ]#" - }, - "alignment-baseline": { - syntax: " auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical" - }, - all: { - syntax: "initial | inherit | unset | revert | revert-layer" - }, - "anchor-name": { - syntax: "none | #" - }, - "anchor-scope": { - syntax: "none | all | #" - }, - animation: { - syntax: "#" - }, - "animation-composition": { - syntax: "#" - }, - "animation-delay": { - syntax: "