Add packages to optimize svgs dynamically
These packages will be used to dynamically optimize SVG images
during the build.
R=jacktfranklin@chromium.org
Bug: 1216402
Change-Id: I04e95aa7d79c9d67beaf8a7861182c52b16b7d0f
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2939992
Reviewed-by: Jack Franklin <jacktfranklin@chromium.org>
Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org>
diff --git a/node_modules/css-tree/CHANGELOG.md b/node_modules/css-tree/CHANGELOG.md
new file mode 100644
index 0000000..31051c5
--- /dev/null
+++ b/node_modules/css-tree/CHANGELOG.md
@@ -0,0 +1,590 @@
+## 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()` and `:nth-last-of-type()` pseudos
+- Changed the way to store locations
+ - Renamed `info` node property to `loc`
+ - Changed format of `loc` to store `start` and `end` positions
+
+## 1.0.0-alpha10 (January 11, 2017)
+
+- Reworked `Scanner` to be a single point to its functionality
+- Exposed `Scanner` class to be useful for external projects
+- Changed `walk()` function behaviour to traverse AST nodes in natural order
+- Implemented `walkUp()` function to traverse AST nodes from deepest to parent (behaves as `walk()` before)
+
+## 1.0.0-alpha9 (December 21, 2016)
+
+- Fixed `<angle>` generic according to specs that allow a `<number>` equals to zero to be used as valid value (#30)
+
+## 1.0.0-alpha8 (November 11, 2016)
+
+- Fixed `Scanner#skip()` issue method when cursor is moving to the end of source
+- Simplified `Progid` node
+- Changed behaviour for bad selector processing, now parsing fails instead of selector ignoring
+- Fixed `<id-selector>` generic syntax
+- Added `q` unit for `<length>` generic syntax
+- Refactored syntax parser (performance)
+- Reduced startup time by implementing lazy syntax parsing (default syntax doesn't parse on module load)
+- Updated syntax dictionaries and used [`mdn/data`](https://github.com/mdn/data) instead of `Template:CSSData`
+- Renamed `syntax.stringify()` method to `syntax.translate()`
+- Simplified generic syntax functions, those functions receive a single AST node for checking and should return `true` or `false`
+- Added exception for values that contains `var()`, those values are always valid for now
+- Added more tests and increase code coverage to `98.5%`
+
+## 1.0.0-alpha7 (October 7, 2016)
+
+- Added support for explicit descendant combinator (`>>`)
+- Implemented `Type` and `Universal` type nodes
+- Improved `Number` parsing by including sign and exponent (#26)
+- Parse `before`, `after`, `first-letter` and `first-line` pseudos with single colon as `PseudoElement`
+- Changed `FunctionalPseudo` node type to `PseudoClass`
+- Fixed attribute selector name parsing (namespace edge cases)
+- Fixed location calculation for specified offset when `eof` is reached
+- Added more non-standard colors (#25)
+- Removed obsolete `Syntax#getAll()` method
+- Fixed various edge cases, code clean up and performance improvements
+
+## 1.0.0-alpha6 (September 23, 2016)
+
+- More accurate positions for syntax mismatch errors
+- Added [`apple`](https://webkit.org/blog/3709/using-the-system-font-in-web-content/) specific font keywords (#20)
+- Changed `Property` node stucture from object to string
+- Renamed `Ruleset` node type to `Rule`
+- Removed `Argument` node type
+- Fixed `Dimension` and `Percentage` position computation
+- Fixed bad selector parsing (temporary solution)
+- Fixed location computation for CSS with very long lines that may lead to really long parsing with `positions:true` (even freeze)
+- Fixed `line` and `column` computation for `SyntaxMatch` error
+- Improved performance of parsing and translation. Now CSSTree is under 10ms in [PostCSS benchmark](https://github.com/postcss/benchmark).
diff --git a/node_modules/css-tree/LICENSE b/node_modules/css-tree/LICENSE
new file mode 100644
index 0000000..bf9d7ce
--- /dev/null
+++ b/node_modules/css-tree/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2016-2019 by Roman Dvornov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/css-tree/README.md b/node_modules/css-tree/README.md
new file mode 100644
index 0000000..f69d14a
--- /dev/null
+++ b/node_modules/css-tree/README.md
@@ -0,0 +1,130 @@
+<img align="right" width="111" height="111"
+ alt="CSSTree logo"
+ src="https://cloud.githubusercontent.com/assets/270491/19243723/6f9136c6-8f21-11e6-82ac-eeeee4c6c452.png"/>
+
+# CSSTree
+
+[](https://www.npmjs.com/package/css-tree)
+[](https://travis-ci.org/csstree/csstree)
+[](https://coveralls.io/github/csstree/csstree?branch=master)
+[](https://www.npmjs.com/package/css-tree)
+[](https://twitter.com/csstree)
+
+CSSTree is a tool set for CSS: [fast](https://github.com/postcss/benchmark) detailed parser (CSS → AST), walker (AST traversal), generator (AST → CSS) and lexer (validation and matching) based on specs and browser implementations. The main goal is to be efficient and W3C specs compliant, with focus on CSS analyzing and source-to-source transforming tasks.
+
+> NOTE: The library isn't in final shape and needs further improvements (e.g. AST format and API are subjects to change in next major versions). However it's stable enough and used by projects like [CSSO](https://github.com/css/csso) (CSS minifier) and [SVGO](https://github.com/svg/svgo) (SVG optimizer) in production.
+
+## Features
+
+- **Detailed parsing with an adjustable level of detail**
+
+ By default CSSTree parses CSS as detailed as possible, i.e. each single logical part is representing with its own AST node (see [AST format](docs/ast.md) for all possible node types). The parsing detail level can be changed through [parser options](docs/parsing.md#parsesource-options), for example, you can disable parsing of selectors or declaration values for component parts.
+
+- **Tolerant to errors by design**
+
+ Parser behaves as [spec says](https://www.w3.org/TR/css-syntax-3/#error-handling): "When errors occur in CSS, the parser attempts to recover gracefully, throwing away only the minimum amount of content before returning to parsing as normal". The only thing the parser departs from the specification is that it doesn't throw away bad content, but wraps it in a special node type (`Raw`) that allows processing it later.
+
+- **Fast and efficient**
+
+ CSSTree is created with focus on performance and effective memory consumption. Therefore it's [one of the fastest CSS parsers](https://github.com/postcss/benchmark) at the moment.
+
+- **Syntax validation**
+
+ The build-in lexer can test CSS against syntaxes defined by W3C. CSSTree uses [mdn/data](https://github.com/mdn/data/) as a basis for lexer's dictionaries and extends it with vendor specific and legacy syntaxes. Lexer can only check the declaration values currently, but this feature will be extended to other parts of the CSS in the future.
+
+## Documentation
+
+- [AST format](docs/ast.md)
+- [Parsing CSS → AST](docs/parsing.md)
+ - [parse(source[, options])](docs/parsing.md#parsesource-options)
+- [Serialization AST → CSS](docs/generate.md)
+ - [generate(ast[, options])](docs/generate.md#generateast-options)
+- [AST traversal](docs/traversal.md)
+ - [walk(ast, options)](docs/traversal.md#walkast-options)
+ - [find(ast, fn)](docs/traversal.md#findast-fn)
+ - [findLast(ast, fn)](docs/traversal.md#findlastast-fn)
+ - [findAll(ast, fn)](docs/traversal.md#findallast-fn)
+- [Utils for AST](docs/utils.md)
+ - [property(name)](docs/utils.md#propertyname)
+ - [keyword(name)](docs/utils.md#keywordname)
+ - [clone(ast)](docs/utils.md#cloneast)
+ - [fromPlainObject(object)](docs/utils.md#fromplainobjectobject)
+ - [toPlainObject(ast)](docs/utils.md#toplainobjectast)
+- [Value Definition Syntax](docs/definition-syntax.md)
+ - [parse(source)](docs/definition-syntax.md#parsesource)
+ - [walk(node, options, context)](docs/definition-syntax.md#walknode-options-context)
+ - [generate(node, options)](docs/definition-syntax.md#generatenode-options)
+ - [AST format](docs/definition-syntax.md#ast-format)
+
+## Tools
+
+* [AST Explorer](https://astexplorer.net/#/gist/244e2fb4da940df52bf0f4b94277db44/e79aff44611020b22cfd9708f3a99ce09b7d67a8) – explore CSSTree AST format with zero setup
+* [CSS syntax reference](https://csstree.github.io/docs/syntax.html)
+* [CSS syntax validator](https://csstree.github.io/docs/validator.html)
+
+## Related projects
+
+* [csstree-validator](https://github.com/csstree/validator) – NPM package to validate CSS
+* [stylelint-csstree-validator](https://github.com/csstree/stylelint-validator) – plugin for stylelint to validate CSS
+* [Grunt plugin](https://github.com/sergejmueller/grunt-csstree-validator)
+* [Gulp plugin](https://github.com/csstree/gulp-csstree)
+* [Sublime plugin](https://github.com/csstree/SublimeLinter-contrib-csstree)
+* [VS Code plugin](https://github.com/csstree/vscode-plugin)
+* [Atom plugin](https://github.com/csstree/atom-plugin)
+
+## Usage
+
+Install with npm:
+
+```
+> npm install css-tree
+```
+
+Basic usage:
+
+```js
+var csstree = require('css-tree');
+
+// parse CSS to AST
+var ast = csstree.parse('.example { world: "!" }');
+
+// traverse AST and modify it
+csstree.walk(ast, function(node) {
+ if (node.type === 'ClassSelector' && node.name === 'example') {
+ node.name = 'hello';
+ }
+});
+
+// generate CSS from AST
+console.log(csstree.generate(ast));
+// .hello{world:"!"}
+```
+
+Syntax matching:
+
+```js
+// parse CSS to AST as a declaration value
+var ast = csstree.parse('red 1px solid', { context: 'value' });
+
+// match to syntax of `border` property
+var matchResult = csstree.lexer.matchProperty('border', ast);
+
+// check first value node is a <color>
+console.log(matchResult.isType(ast.children.first(), 'color'));
+// true
+
+// get a type list matched to a node
+console.log(matchResult.getTrace(ast.children.first()));
+// [ { type: 'Property', name: 'border' },
+// { type: 'Type', name: 'color' },
+// { type: 'Type', name: 'named-color' },
+// { type: 'Keyword', name: 'red' } ]
+```
+
+## Top level API
+
+
+
+## License
+
+MIT
diff --git a/node_modules/css-tree/data/index.js b/node_modules/css-tree/data/index.js
new file mode 100755
index 0000000..ff56c24
--- /dev/null
+++ b/node_modules/css-tree/data/index.js
@@ -0,0 +1,103 @@
+const mdnAtrules = require('mdn-data/css/at-rules.json');
+const mdnProperties = require('mdn-data/css/properties.json');
+const mdnSyntaxes = require('mdn-data/css/syntaxes.json');
+const patch = require('./patch.json');
+const extendSyntax = /^\s*\|\s*/;
+
+function preprocessAtrules(dict) {
+ const result = Object.create(null);
+
+ for (const atruleName in dict) {
+ const atrule = dict[atruleName];
+ let descriptors = null;
+
+ if (atrule.descriptors) {
+ descriptors = Object.create(null);
+
+ for (const descriptor in atrule.descriptors) {
+ descriptors[descriptor] = atrule.descriptors[descriptor].syntax;
+ }
+ }
+
+ result[atruleName.substr(1)] = {
+ prelude: atrule.syntax.trim().match(/^@\S+\s+([^;\{]*)/)[1].trim() || null,
+ descriptors
+ };
+ }
+
+ return result;
+}
+
+function patchDictionary(dict, patchDict) {
+ const result = {};
+
+ // copy all syntaxes for an original dict
+ for (const key in dict) {
+ result[key] = dict[key].syntax || dict[key];
+ }
+
+ // apply a patch
+ for (const key in patchDict) {
+ if (key in dict) {
+ if (patchDict[key].syntax) {
+ result[key] = extendSyntax.test(patchDict[key].syntax)
+ ? result[key] + ' ' + patchDict[key].syntax.trim()
+ : patchDict[key].syntax;
+ } else {
+ delete result[key];
+ }
+ } else {
+ if (patchDict[key].syntax) {
+ result[key] = patchDict[key].syntax.replace(extendSyntax, '');
+ }
+ }
+ }
+
+ return result;
+}
+
+function unpackSyntaxes(dict) {
+ const result = {};
+
+ for (const key in dict) {
+ result[key] = dict[key].syntax;
+ }
+
+ return result;
+}
+
+function patchAtrules(dict, patchDict) {
+ const result = {};
+
+ // copy all syntaxes for an original dict
+ for (const key in dict) {
+ const patchDescriptors = (patchDict[key] && patchDict[key].descriptors) || null;
+
+ result[key] = {
+ prelude: key in patchDict && 'prelude' in patchDict[key]
+ ? patchDict[key].prelude
+ : dict[key].prelude || null,
+ descriptors: dict[key].descriptors
+ ? patchDictionary(dict[key].descriptors, patchDescriptors || {})
+ : patchDescriptors && unpackSyntaxes(patchDescriptors)
+ };
+ }
+
+ // apply a patch
+ for (const key in patchDict) {
+ if (!hasOwnProperty.call(dict, key)) {
+ result[key] = {
+ prelude: patchDict[key].prelude || null,
+ descriptors: patchDict[key].descriptors && unpackSyntaxes(patchDict[key].descriptors)
+ };
+ }
+ }
+
+ return result;
+}
+
+module.exports = {
+ types: patchDictionary(mdnSyntaxes, patch.syntaxes),
+ atrules: patchAtrules(preprocessAtrules(mdnAtrules), patch.atrules),
+ properties: patchDictionary(mdnProperties, patch.properties)
+};
diff --git a/node_modules/css-tree/data/patch.json b/node_modules/css-tree/data/patch.json
new file mode 100644
index 0000000..6b91136
--- /dev/null
+++ b/node_modules/css-tree/data/patch.json
@@ -0,0 +1,721 @@
+{
+ "atrules": {
+ "charset": {
+ "prelude": "<string>"
+ },
+ "font-face": {
+ "descriptors": {
+ "unicode-range": {
+ "comment": "replaces <unicode-range>, an old production name",
+ "syntax": "<urange>#"
+ }
+ }
+ }
+ },
+ "properties": {
+ "-moz-background-clip": {
+ "comment": "deprecated syntax in old Firefox, https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
+ "syntax": "padding | border"
+ },
+ "-moz-border-radius-bottomleft": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-left-radius",
+ "syntax": "<'border-bottom-left-radius'>"
+ },
+ "-moz-border-radius-bottomright": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
+ "syntax": "<'border-bottom-right-radius'>"
+ },
+ "-moz-border-radius-topleft": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-left-radius",
+ "syntax": "<'border-top-left-radius'>"
+ },
+ "-moz-border-radius-topright": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius",
+ "syntax": "<'border-bottom-right-radius'>"
+ },
+ "-moz-control-character-visibility": {
+ "comment": "firefox specific keywords, https://bugzilla.mozilla.org/show_bug.cgi?id=947588",
+ "syntax": "visible | hidden"
+ },
+ "-moz-osx-font-smoothing": {
+ "comment": "misssed old syntax https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
+ "syntax": "auto | grayscale"
+ },
+ "-moz-user-select": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
+ "syntax": "none | text | all | -moz-none"
+ },
+ "-ms-flex-align": {
+ "comment": "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
+ "syntax": "start | end | center | baseline | stretch"
+ },
+ "-ms-flex-item-align": {
+ "comment": "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align",
+ "syntax": "auto | start | end | center | baseline | stretch"
+ },
+ "-ms-flex-line-pack": {
+ "comment": "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack",
+ "syntax": "start | end | center | justify | distribute | stretch"
+ },
+ "-ms-flex-negative": {
+ "comment": "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+ "syntax": "<'flex-shrink'>"
+ },
+ "-ms-flex-pack": {
+ "comment": "misssed old syntax implemented in IE, https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack",
+ "syntax": "start | end | center | justify | distribute"
+ },
+ "-ms-flex-order": {
+ "comment": "misssed old syntax implemented in IE; https://msdn.microsoft.com/en-us/library/jj127303(v=vs.85).aspx",
+ "syntax": "<integer>"
+ },
+ "-ms-flex-positive": {
+ "comment": "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+ "syntax": "<'flex-grow'>"
+ },
+ "-ms-flex-preferred-size": {
+ "comment": "misssed old syntax implemented in IE; TODO: find references for comfirmation",
+ "syntax": "<'flex-basis'>"
+ },
+ "-ms-interpolation-mode": {
+ "comment": "https://msdn.microsoft.com/en-us/library/ff521095(v=vs.85).aspx",
+ "syntax": "nearest-neighbor | bicubic"
+ },
+ "-ms-grid-column-align": {
+ "comment": "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466338.aspx",
+ "syntax": "start | end | center | stretch"
+ },
+ "-ms-grid-row-align": {
+ "comment": "add this property first since it uses as fallback for flexbox, https://msdn.microsoft.com/en-us/library/windows/apps/hh466348.aspx",
+ "syntax": "start | end | center | stretch"
+ },
+ "-ms-hyphenate-limit-last": {
+ "comment": "misssed old syntax implemented in IE; https://www.w3.org/TR/css-text-4/#hyphenate-line-limits",
+ "syntax": "none | always | column | page | spread"
+ },
+ "-webkit-appearance": {
+ "comment": "webkit specific keywords",
+ "references": [
+ "http://css-infos.net/property/-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-background-clip": {
+ "comment": "https://developer.mozilla.org/en/docs/Web/CSS/background-clip",
+ "syntax": "[ <box> | border | padding | content | text ]#"
+ },
+ "-webkit-column-break-after": {
+ "comment": "added, http://help.dottoro.com/lcrthhhv.php",
+ "syntax": "always | auto | avoid"
+ },
+ "-webkit-column-break-before": {
+ "comment": "added, http://help.dottoro.com/lcxquvkf.php",
+ "syntax": "always | auto | avoid"
+ },
+ "-webkit-column-break-inside": {
+ "comment": "added, http://help.dottoro.com/lclhnthl.php",
+ "syntax": "always | auto | avoid"
+ },
+ "-webkit-font-smoothing": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth",
+ "syntax": "auto | none | antialiased | subpixel-antialiased"
+ },
+ "-webkit-mask-box-image": {
+ "comment": "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
+ "syntax": "[ <url> | <gradient> | none ] [ <length-percentage>{4} <-webkit-mask-box-repeat>{2} ]?"
+ },
+ "-webkit-print-color-adjust": {
+ "comment": "missed",
+ "references": [
+ "https://developer.mozilla.org/en/docs/Web/CSS/-webkit-print-color-adjust"
+ ],
+ "syntax": "economy | exact"
+ },
+ "-webkit-text-security": {
+ "comment": "missed; http://help.dottoro.com/lcbkewgt.php",
+ "syntax": "none | circle | disc | square"
+ },
+ "-webkit-user-drag": {
+ "comment": "missed; http://help.dottoro.com/lcbixvwm.php",
+ "syntax": "none | element | auto"
+ },
+ "-webkit-user-select": {
+ "comment": "auto is supported by old webkit, https://developer.mozilla.org/en-US/docs/Web/CSS/user-select",
+ "syntax": "auto | none | text | all"
+ },
+ "alignment-baseline": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#AlignmentBaselineProperty"
+ ],
+ "syntax": "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical"
+ },
+ "baseline-shift": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#BaselineShiftProperty"
+ ],
+ "syntax": "baseline | sub | super | <svg-length>"
+ },
+ "behavior": {
+ "comment": "added old IE property https://msdn.microsoft.com/en-us/library/ms530723(v=vs.85).aspx",
+ "syntax": "<url>+"
+ },
+ "clip-rule": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/masking.html#ClipRuleProperty"
+ ],
+ "syntax": "nonzero | evenodd"
+ },
+ "cue": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<'cue-before'> <'cue-after'>?"
+ },
+ "cue-after": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<url> <decibel>? | none"
+ },
+ "cue-before": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<url> <decibel>? | none"
+ },
+ "cursor": {
+ "comment": "added legacy keywords: hand, -webkit-grab. -webkit-grabbing, -webkit-zoom-in, -webkit-zoom-out, -moz-grab, -moz-grabbing, -moz-zoom-in, -moz-zoom-out",
+ "references": [
+ "https://www.sitepoint.com/css3-cursor-styles/"
+ ],
+ "syntax": "[ [ <url> [ <x> <y> ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing | hand | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out | -moz-grab | -moz-grabbing | -moz-zoom-in | -moz-zoom-out ] ]"
+ },
+ "display": {
+ "comment": "extended with -ms-flexbox",
+ "syntax": "| <-non-standard-display>"
+ },
+ "position": {
+ "comment": "extended with -webkit-sticky",
+ "syntax": "| -webkit-sticky"
+ },
+ "dominant-baseline": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#DominantBaselineProperty"
+ ],
+ "syntax": "auto | use-script | no-change | reset-size | ideographic | alphabetic | hanging | mathematical | central | middle | text-after-edge | text-before-edge"
+ },
+ "image-rendering": {
+ "comment": "extended with <-non-standard-image-rendering>, added SVG keywords optimizeSpeed and optimizeQuality",
+ "references": [
+ "https://developer.mozilla.org/en/docs/Web/CSS/image-rendering",
+ "https://www.w3.org/TR/SVG/painting.html#ImageRenderingProperty"
+ ],
+ "syntax": "| optimizeSpeed | optimizeQuality | <-non-standard-image-rendering>"
+ },
+ "fill": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#FillProperty"
+ ],
+ "syntax": "<paint>"
+ },
+ "fill-opacity": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#FillProperty"
+ ],
+ "syntax": "<number-zero-one>"
+ },
+ "fill-rule": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#FillProperty"
+ ],
+ "syntax": "nonzero | evenodd"
+ },
+ "filter": {
+ "comment": "extend with IE legacy syntaxes",
+ "syntax": "| <-ms-filter-function-list>"
+ },
+ "glyph-orientation-horizontal": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#GlyphOrientationHorizontalProperty"
+ ],
+ "syntax": "<angle>"
+ },
+ "glyph-orientation-vertical": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#GlyphOrientationVerticalProperty"
+ ],
+ "syntax": "<angle>"
+ },
+ "kerning": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#KerningProperty"
+ ],
+ "syntax": "auto | <svg-length>"
+ },
+ "letter-spacing": {
+ "comment": "fix syntax <length> -> <length-percentage>",
+ "references": [
+ "https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/letter-spacing"
+ ],
+ "syntax": "normal | <length-percentage>"
+ },
+ "marker": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+ ],
+ "syntax": "none | <url>"
+ },
+ "marker-end": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+ ],
+ "syntax": "none | <url>"
+ },
+ "marker-mid": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+ ],
+ "syntax": "none | <url>"
+ },
+ "marker-start": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#MarkerProperties"
+ ],
+ "syntax": "none | <url>"
+ },
+ "max-width": {
+ "comment": "fix auto -> none (https://github.com/mdn/data/pull/431); extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/max-width",
+ "syntax": "none | <length-percentage> | min-content | max-content | fit-content(<length-percentage>) | <-non-standard-width>"
+ },
+ "width": {
+ "comment": "per spec fit-content should be a function, however browsers are supporting it as a keyword (https://github.com/csstree/stylelint-validator/issues/29)",
+ "syntax": "| fit-content | -moz-fit-content | -webkit-fit-content"
+ },
+ "min-width": {
+ "comment": "extend by non-standard width keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
+ "syntax": "auto | <length-percentage> | min-content | max-content | fit-content(<length-percentage>) | <-non-standard-width>"
+ },
+ "overflow": {
+ "comment": "extend by vendor keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
+ "syntax": "| <-non-standard-overflow>"
+ },
+ "pause": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<'pause-before'> <'pause-after'>?"
+ },
+ "pause-after": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<time> | none | x-weak | weak | medium | strong | x-strong"
+ },
+ "pause-before": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<time> | none | x-weak | weak | medium | strong | x-strong"
+ },
+ "rest": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<'rest-before'> <'rest-after'>?"
+ },
+ "rest-after": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<time> | none | x-weak | weak | medium | strong | x-strong"
+ },
+ "rest-before": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<time> | none | x-weak | weak | medium | strong | x-strong"
+ },
+ "shape-rendering": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#ShapeRenderingPropert"
+ ],
+ "syntax": "auto | optimizeSpeed | crispEdges | geometricPrecision"
+ },
+ "src": {
+ "comment": "added @font-face's src property https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src",
+ "syntax": "[ <url> [ format( <string># ) ]? | local( <family-name> ) ]#"
+ },
+ "speak": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "auto | none | normal"
+ },
+ "speak-as": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "normal | spell-out || digits || [ literal-punctuation | no-punctuation ]"
+ },
+ "stroke": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "<paint>"
+ },
+ "stroke-dasharray": {
+ "comment": "added SVG property; a list of comma and/or white space separated <length>s and <percentage>s",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "none | [ <svg-length>+ ]#"
+ },
+ "stroke-dashoffset": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "<svg-length>"
+ },
+ "stroke-linecap": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "butt | round | square"
+ },
+ "stroke-linejoin": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "miter | round | bevel"
+ },
+ "stroke-miterlimit": {
+ "comment": "added SVG property (<miterlimit> = <number-one-or-greater>) ",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "<number-one-or-greater>"
+ },
+ "stroke-opacity": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "<number-zero-one>"
+ },
+ "stroke-width": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/painting.html#StrokeProperties"
+ ],
+ "syntax": "<svg-length>"
+ },
+ "text-anchor": {
+ "comment": "added SVG property",
+ "references": [
+ "https://www.w3.org/TR/SVG/text.html#TextAlignmentProperties"
+ ],
+ "syntax": "start | middle | end"
+ },
+ "unicode-bidi": {
+ "comment": "added prefixed keywords https://developer.mozilla.org/en-US/docs/Web/CSS/unicode-bidi",
+ "syntax": "| -moz-isolate | -moz-isolate-override | -moz-plaintext | -webkit-isolate | -webkit-isolate-override | -webkit-plaintext"
+ },
+ "unicode-range": {
+ "comment": "added missed property https://developer.mozilla.org/en-US/docs/Web/CSS/%40font-face/unicode-range",
+ "syntax": "<urange>#"
+ },
+ "voice-balance": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<number> | left | center | right | leftwards | rightwards"
+ },
+ "voice-duration": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "auto | <time>"
+ },
+ "voice-family": {
+ "comment": "<name> -> <family-name>, https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "[ [ <family-name> | <generic-voice> ] , ]* [ <family-name> | <generic-voice> ] | preserve"
+ },
+ "voice-pitch": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
+ },
+ "voice-range": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "<frequency> && absolute | [ [ x-low | low | medium | high | x-high ] || [ <frequency> | <semitones> | <percentage> ] ]"
+ },
+ "voice-rate": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "[ normal | x-slow | slow | medium | fast | x-fast ] || <percentage>"
+ },
+ "voice-stress": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "normal | strong | moderate | none | reduced"
+ },
+ "voice-volume": {
+ "comment": "https://www.w3.org/TR/css3-speech/#property-index",
+ "syntax": "silent | [ [ x-soft | soft | medium | loud | x-loud ] || <decibel> ]"
+ },
+ "writing-mode": {
+ "comment": "extend with SVG keywords",
+ "syntax": "| <svg-writing-mode>"
+ }
+ },
+ "syntaxes": {
+ "-legacy-gradient": {
+ "comment": "added collection of legacy gradient syntaxes",
+ "syntax": "<-webkit-gradient()> | <-legacy-linear-gradient> | <-legacy-repeating-linear-gradient> | <-legacy-radial-gradient> | <-legacy-repeating-radial-gradient>"
+ },
+ "-legacy-linear-gradient": {
+ "comment": "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+ "syntax": "-moz-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-linear-gradient( <-legacy-linear-gradient-arguments> )"
+ },
+ "-legacy-repeating-linear-gradient": {
+ "comment": "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+ "syntax": "-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> ) | -o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )"
+ },
+ "-legacy-linear-gradient-arguments": {
+ "comment": "like standard syntax but w/o `to` keyword https://developer.mozilla.org/en-US/docs/Web/CSS/linear-gradient",
+ "syntax": "[ <angle> | <side-or-corner> ]? , <color-stop-list>"
+ },
+ "-legacy-radial-gradient": {
+ "comment": "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+ "syntax": "-moz-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-radial-gradient( <-legacy-radial-gradient-arguments> )"
+ },
+ "-legacy-repeating-radial-gradient": {
+ "comment": "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+ "syntax": "-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> ) | -o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )"
+ },
+ "-legacy-radial-gradient-arguments": {
+ "comment": "deprecated syntax that implemented by some browsers https://www.w3.org/TR/2011/WD-css3-images-20110908/#radial-gradients",
+ "syntax": "[ <position> , ]? [ [ [ <-legacy-radial-gradient-shape> || <-legacy-radial-gradient-size> ] | [ <length> | <percentage> ]{2} ] , ]? <color-stop-list>"
+ },
+ "-legacy-radial-gradient-size": {
+ "comment": "before a standard it contains 2 extra keywords (`contain` and `cover`) https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltsize",
+ "syntax": "closest-side | closest-corner | farthest-side | farthest-corner | contain | cover"
+ },
+ "-legacy-radial-gradient-shape": {
+ "comment": "define to double sure it doesn't extends in future https://www.w3.org/TR/2011/WD-css3-images-20110908/#ltshape",
+ "syntax": "circle | ellipse"
+ },
+ "-non-standard-font": {
+ "comment": "non standard fonts",
+ "references": [
+ "https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
+ ],
+ "syntax": "-apple-system-body | -apple-system-headline | -apple-system-subheadline | -apple-system-caption1 | -apple-system-caption2 | -apple-system-footnote | -apple-system-short-body | -apple-system-short-headline | -apple-system-short-subheadline | -apple-system-short-caption1 | -apple-system-short-footnote | -apple-system-tall-body"
+ },
+ "-non-standard-color": {
+ "comment": "non standard colors",
+ "references": [
+ "http://cssdot.ru/%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA_CSS/color-i305.html",
+ "https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#Mozilla_Color_Preference_Extensions"
+ ],
+ "syntax": "-moz-ButtonDefault | -moz-ButtonHoverFace | -moz-ButtonHoverText | -moz-CellHighlight | -moz-CellHighlightText | -moz-Combobox | -moz-ComboboxText | -moz-Dialog | -moz-DialogText | -moz-dragtargetzone | -moz-EvenTreeRow | -moz-Field | -moz-FieldText | -moz-html-CellHighlight | -moz-html-CellHighlightText | -moz-mac-accentdarkestshadow | -moz-mac-accentdarkshadow | -moz-mac-accentface | -moz-mac-accentlightesthighlight | -moz-mac-accentlightshadow | -moz-mac-accentregularhighlight | -moz-mac-accentregularshadow | -moz-mac-chrome-active | -moz-mac-chrome-inactive | -moz-mac-focusring | -moz-mac-menuselect | -moz-mac-menushadow | -moz-mac-menutextselect | -moz-MenuHover | -moz-MenuHoverText | -moz-MenuBarText | -moz-MenuBarHoverText | -moz-nativehyperlinktext | -moz-OddTreeRow | -moz-win-communicationstext | -moz-win-mediatext | -moz-activehyperlinktext | -moz-default-background-color | -moz-default-color | -moz-hyperlinktext | -moz-visitedhyperlinktext | -webkit-activelink | -webkit-focus-ring-color | -webkit-link | -webkit-text"
+ },
+ "-non-standard-image-rendering": {
+ "comment": "non-standard keywords http://phrogz.net/tmp/canvas_image_zoom.html",
+ "syntax": "optimize-contrast | -moz-crisp-edges | -o-crisp-edges | -webkit-optimize-contrast"
+ },
+ "-non-standard-overflow": {
+ "comment": "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/overflow",
+ "syntax": "-moz-scrollbars-none | -moz-scrollbars-horizontal | -moz-scrollbars-vertical | -moz-hidden-unscrollable"
+ },
+ "-non-standard-width": {
+ "comment": "non-standard keywords https://developer.mozilla.org/en-US/docs/Web/CSS/width",
+ "syntax": "fill-available | min-intrinsic | intrinsic | -moz-available | -moz-fit-content | -moz-min-content | -moz-max-content | -webkit-min-content | -webkit-max-content"
+ },
+ "-webkit-gradient()": {
+ "comment": "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/ - TODO: simplify when after match algorithm improvement ( [, point, radius | , point] -> [, radius]? , point )",
+ "syntax": "-webkit-gradient( <-webkit-gradient-type>, <-webkit-gradient-point> [, <-webkit-gradient-point> | , <-webkit-gradient-radius>, <-webkit-gradient-point> ] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )"
+ },
+ "-webkit-gradient-color-stop": {
+ "comment": "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+ "syntax": "from( <color> ) | color-stop( [ <number-zero-one> | <percentage> ] , <color> ) | to( <color> )"
+ },
+ "-webkit-gradient-point": {
+ "comment": "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+ "syntax": "[ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]"
+ },
+ "-webkit-gradient-radius": {
+ "comment": "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+ "syntax": "<length> | <percentage>"
+ },
+ "-webkit-gradient-type": {
+ "comment": "first Apple proposal gradient syntax https://webkit.org/blog/175/introducing-css-gradients/",
+ "syntax": "linear | radial"
+ },
+ "-webkit-mask-box-repeat": {
+ "comment": "missed; https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-box-image",
+ "syntax": "repeat | stretch | round"
+ },
+ "-webkit-mask-clip-style": {
+ "comment": "missed; there is no enough information about `-webkit-mask-clip` property, but looks like all those keywords are working",
+ "syntax": "border | border-box | padding | padding-box | content | content-box | text"
+ },
+ "-ms-filter-function-list": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
+ "syntax": "<-ms-filter-function>+"
+ },
+ "-ms-filter-function": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
+ "syntax": "<-ms-filter-function-progid> | <-ms-filter-function-legacy>"
+ },
+ "-ms-filter-function-progid": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
+ "syntax": "'progid:' [ <ident-token> '.' ]* [ <ident-token> | <function-token> <any-value>? ) ]"
+ },
+ "-ms-filter-function-legacy": {
+ "comment": "https://developer.mozilla.org/en-US/docs/Web/CSS/-ms-filter",
+ "syntax": "<ident-token> | <function-token> <any-value>? )"
+ },
+ "-ms-filter": {
+ "syntax": "<string>"
+ },
+ "age": {
+ "comment": "https://www.w3.org/TR/css3-speech/#voice-family",
+ "syntax": "child | young | old"
+ },
+ "attr-name": {
+ "syntax": "<wq-name>"
+ },
+ "attr-fallback": {
+ "syntax": "<any-value>"
+ },
+ "border-radius": {
+ "comment": "missed, https://drafts.csswg.org/css-backgrounds-3/#the-border-radius",
+ "syntax": "<length-percentage>{1,2}"
+ },
+ "bottom": {
+ "comment": "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+ "syntax": "<length> | auto"
+ },
+ "content-list": {
+ "comment": "missed -> https://drafts.csswg.org/css-content/#typedef-content-list (document-url, <target> and leader() is omitted util stabilization)",
+ "syntax": "[ <string> | contents | <image> | <quote> | <target> | <leader()> | <attr()> | counter( <ident>, <'list-style-type'>? ) ]+"
+ },
+ "element()": {
+ "comment": "https://drafts.csswg.org/css-gcpm/#element-syntax & https://drafts.csswg.org/css-images-4/#element-notation",
+ "syntax": "element( <custom-ident> , [ first | start | last | first-except ]? ) | element( <id-selector> )"
+ },
+ "generic-voice": {
+ "comment": "https://www.w3.org/TR/css3-speech/#voice-family",
+ "syntax": "[ <age>? <gender> <integer>? ]"
+ },
+ "gender": {
+ "comment": "https://www.w3.org/TR/css3-speech/#voice-family",
+ "syntax": "male | female | neutral"
+ },
+ "generic-family": {
+ "comment": "added -apple-system",
+ "references": [
+ "https://webkit.org/blog/3709/using-the-system-font-in-web-content/"
+ ],
+ "syntax": "| -apple-system"
+ },
+ "gradient": {
+ "comment": "added legacy syntaxes support",
+ "syntax": "| <-legacy-gradient>"
+ },
+ "left": {
+ "comment": "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+ "syntax": "<length> | auto"
+ },
+ "mask-image": {
+ "comment": "missed; https://drafts.fxtf.org/css-masking-1/#the-mask-image",
+ "syntax": "<mask-reference>#"
+ },
+ "name-repeat": {
+ "comment": "missed, and looks like obsolete, keep it as is since other property syntaxes should be changed too; https://www.w3.org/TR/2015/WD-css-grid-1-20150917/#typedef-name-repeat",
+ "syntax": "repeat( [ <positive-integer> | auto-fill ], <line-names>+)"
+ },
+ "named-color": {
+ "comment": "added non standard color names",
+ "syntax": "| <-non-standard-color>"
+ },
+ "paint": {
+ "comment": "used by SVG https://www.w3.org/TR/SVG/painting.html#SpecifyingPaint",
+ "syntax": "none | <color> | <url> [ none | <color> ]? | context-fill | context-stroke"
+ },
+ "page-size": {
+ "comment": "https://www.w3.org/TR/css-page-3/#typedef-page-size-page-size",
+ "syntax": "A5 | A4 | A3 | B5 | B4 | JIS-B5 | JIS-B4 | letter | legal | ledger"
+ },
+ "ratio": {
+ "comment": "missed, https://drafts.csswg.org/mediaqueries-4/#typedef-ratio",
+ "syntax": "<integer> / <integer>"
+ },
+ "right": {
+ "comment": "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+ "syntax": "<length> | auto"
+ },
+ "shape": {
+ "comment": "missed spaces in function body and add backwards compatible syntax",
+ "syntax": "rect( <top>, <right>, <bottom>, <left> ) | rect( <top> <right> <bottom> <left> )"
+ },
+ "svg-length": {
+ "comment": "All coordinates and lengths in SVG can be specified with or without a unit identifier",
+ "references": [
+ "https://www.w3.org/TR/SVG11/coords.html#Units"
+ ],
+ "syntax": "<percentage> | <length> | <number>"
+ },
+ "svg-writing-mode": {
+ "comment": "SVG specific keywords (deprecated for CSS)",
+ "references": [
+ "https://developer.mozilla.org/en/docs/Web/CSS/writing-mode",
+ "https://www.w3.org/TR/SVG/text.html#WritingModeProperty"
+ ],
+ "syntax": "lr-tb | rl-tb | tb-rl | lr | rl | tb"
+ },
+ "top": {
+ "comment": "missed; not sure we should add it, but no others except `shape` is using it so it's ok for now; https://drafts.fxtf.org/css-masking-1/#funcdef-clip-rect",
+ "syntax": "<length> | auto"
+ },
+ "track-group": {
+ "comment": "used by old grid-columns and grid-rows syntax v0",
+ "syntax": "'(' [ <string>* <track-minmax> <string>* ]+ ')' [ '[' <positive-integer> ']' ]? | <track-minmax>"
+ },
+ "track-list-v0": {
+ "comment": "used by old grid-columns and grid-rows syntax v0",
+ "syntax": "[ <string>* <track-group> <string>* ]+ | none"
+ },
+ "track-minmax": {
+ "comment": "used by old grid-columns and grid-rows syntax v0",
+ "syntax": "minmax( <track-breadth> , <track-breadth> ) | auto | <track-breadth> | fit-content"
+ },
+ "x": {
+ "comment": "missed; not sure we should add it, but no others except `cursor` is using it so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
+ "syntax": "<number>"
+ },
+ "y": {
+ "comment": "missed; not sure we should add it, but no others except `cursor` is using so it's ok for now; https://drafts.csswg.org/css-ui-3/#cursor",
+ "syntax": "<number>"
+ },
+ "declaration": {
+ "comment": "missed, restored by https://drafts.csswg.org/css-syntax",
+ "syntax": "<ident-token> : <declaration-value>? [ '!' important ]?"
+ },
+ "declaration-list": {
+ "comment": "missed, restored by https://drafts.csswg.org/css-syntax",
+ "syntax": "[ <declaration>? ';' ]* <declaration>?"
+ },
+ "url": {
+ "comment": "https://drafts.csswg.org/css-values-4/#urls",
+ "syntax": "url( <string> <url-modifier>* ) | <url-token>"
+ },
+ "url-modifier": {
+ "comment": "https://drafts.csswg.org/css-values-4/#typedef-url-modifier",
+ "syntax": "<ident> | <function-token> <any-value> )"
+ },
+ "number-zero-one": {
+ "syntax": "<number [0,1]>"
+ },
+ "number-one-or-greater": {
+ "syntax": "<number [1,∞]>"
+ },
+ "positive-integer": {
+ "syntax": "<integer [0,∞]>"
+ },
+ "-non-standard-display": {
+ "syntax": "-ms-inline-flexbox | -ms-grid | -ms-inline-grid | -webkit-flex | -webkit-inline-flex | -webkit-box | -webkit-inline-box | -moz-inline-stack | -moz-box | -moz-inline-box"
+ }
+ }
+}
diff --git a/node_modules/css-tree/dist/csstree.js b/node_modules/css-tree/dist/csstree.js
new file mode 100644
index 0000000..9333729
--- /dev/null
+++ b/node_modules/css-tree/dist/csstree.js
@@ -0,0 +1,12606 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global = global || self, global.csstree = factory());
+}(this, (function () { 'use strict';
+
+ //
+ // list
+ // ┌──────┐
+ // ┌──────────────┼─head │
+ // │ │ tail─┼──────────────┐
+ // │ └──────┘ │
+ // ▼ ▼
+ // item item item item
+ // ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
+ // null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │
+ // │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null
+ // ├──────┤ ├──────┤ ├──────┤ ├──────┤
+ // │ data │ │ data │ │ data │ │ data │
+ // └──────┘ └──────┘ └──────┘ └──────┘
+ //
+
+ function createItem(data) {
+ return {
+ prev: null,
+ next: null,
+ data: data
+ };
+ }
+
+ function allocateCursor(node, prev, next) {
+ var cursor;
+
+ if (cursors !== null) {
+ cursor = cursors;
+ cursors = cursors.cursor;
+ cursor.prev = prev;
+ cursor.next = next;
+ cursor.cursor = node.cursor;
+ } else {
+ cursor = {
+ prev: prev,
+ next: next,
+ cursor: node.cursor
+ };
+ }
+
+ node.cursor = cursor;
+
+ return cursor;
+ }
+
+ function releaseCursor(node) {
+ var cursor = node.cursor;
+
+ node.cursor = cursor.cursor;
+ cursor.prev = null;
+ cursor.next = null;
+ cursor.cursor = cursors;
+ cursors = cursor;
+ }
+
+ var cursors = null;
+ var List = function() {
+ this.cursor = null;
+ this.head = null;
+ this.tail = null;
+ };
+
+ List.createItem = createItem;
+ List.prototype.createItem = createItem;
+
+ List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
+ var cursor = this.cursor;
+
+ while (cursor !== null) {
+ if (cursor.prev === prevOld) {
+ cursor.prev = prevNew;
+ }
+
+ if (cursor.next === nextOld) {
+ cursor.next = nextNew;
+ }
+
+ cursor = cursor.cursor;
+ }
+ };
+
+ List.prototype.getSize = function() {
+ var size = 0;
+ var cursor = this.head;
+
+ while (cursor) {
+ size++;
+ cursor = cursor.next;
+ }
+
+ return size;
+ };
+
+ List.prototype.fromArray = function(array) {
+ var cursor = null;
+
+ this.head = null;
+
+ for (var i = 0; i < array.length; i++) {
+ var item = createItem(array[i]);
+
+ if (cursor !== null) {
+ cursor.next = item;
+ } else {
+ this.head = item;
+ }
+
+ item.prev = cursor;
+ cursor = item;
+ }
+
+ this.tail = cursor;
+
+ return this;
+ };
+
+ List.prototype.toArray = function() {
+ var cursor = this.head;
+ var result = [];
+
+ while (cursor) {
+ result.push(cursor.data);
+ cursor = cursor.next;
+ }
+
+ return result;
+ };
+
+ List.prototype.toJSON = List.prototype.toArray;
+
+ List.prototype.isEmpty = function() {
+ return this.head === null;
+ };
+
+ List.prototype.first = function() {
+ return this.head && this.head.data;
+ };
+
+ List.prototype.last = function() {
+ return this.tail && this.tail.data;
+ };
+
+ List.prototype.each = function(fn, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, this.head);
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ fn.call(context, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+ };
+
+ List.prototype.forEach = List.prototype.each;
+
+ List.prototype.eachRight = function(fn, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, this.tail, null);
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ fn.call(context, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+ };
+
+ List.prototype.forEachRight = List.prototype.eachRight;
+
+ List.prototype.reduce = function(fn, initialValue, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, this.head);
+ var acc = initialValue;
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ acc = fn.call(context, acc, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+
+ return acc;
+ };
+
+ List.prototype.reduceRight = function(fn, initialValue, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, this.tail, null);
+ var acc = initialValue;
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ acc = fn.call(context, acc, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+
+ return acc;
+ };
+
+ List.prototype.nextUntil = function(start, fn, context) {
+ if (start === null) {
+ return;
+ }
+
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, start);
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ if (fn.call(context, item.data, item, this)) {
+ break;
+ }
+ }
+
+ // pop cursor
+ releaseCursor(this);
+ };
+
+ List.prototype.prevUntil = function(start, fn, context) {
+ if (start === null) {
+ return;
+ }
+
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, start, null);
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ if (fn.call(context, item.data, item, this)) {
+ break;
+ }
+ }
+
+ // pop cursor
+ releaseCursor(this);
+ };
+
+ List.prototype.some = function(fn, context) {
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ if (fn.call(context, cursor.data, cursor, this)) {
+ return true;
+ }
+
+ cursor = cursor.next;
+ }
+
+ return false;
+ };
+
+ List.prototype.map = function(fn, context) {
+ var result = new List();
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ result.appendData(fn.call(context, cursor.data, cursor, this));
+ cursor = cursor.next;
+ }
+
+ return result;
+ };
+
+ List.prototype.filter = function(fn, context) {
+ var result = new List();
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ if (fn.call(context, cursor.data, cursor, this)) {
+ result.appendData(cursor.data);
+ }
+ cursor = cursor.next;
+ }
+
+ return result;
+ };
+
+ List.prototype.clear = function() {
+ this.head = null;
+ this.tail = null;
+ };
+
+ List.prototype.copy = function() {
+ var result = new List();
+ var cursor = this.head;
+
+ while (cursor !== null) {
+ result.insert(createItem(cursor.data));
+ cursor = cursor.next;
+ }
+
+ return result;
+ };
+
+ List.prototype.prepend = function(item) {
+ // head
+ // ^
+ // item
+ this.updateCursors(null, item, this.head, item);
+
+ // insert to the beginning of the list
+ if (this.head !== null) {
+ // new item <- first item
+ this.head.prev = item;
+
+ // new item -> first item
+ item.next = this.head;
+ } else {
+ // if list has no head, then it also has no tail
+ // in this case tail points to the new item
+ this.tail = item;
+ }
+
+ // head always points to new item
+ this.head = item;
+
+ return this;
+ };
+
+ List.prototype.prependData = function(data) {
+ return this.prepend(createItem(data));
+ };
+
+ List.prototype.append = function(item) {
+ return this.insert(item);
+ };
+
+ List.prototype.appendData = function(data) {
+ return this.insert(createItem(data));
+ };
+
+ List.prototype.insert = function(item, before) {
+ if (before !== undefined && before !== null) {
+ // prev before
+ // ^
+ // item
+ this.updateCursors(before.prev, item, before, item);
+
+ if (before.prev === null) {
+ // insert to the beginning of list
+ if (this.head !== before) {
+ throw new Error('before doesn\'t belong to list');
+ }
+
+ // since head points to before therefore list doesn't empty
+ // no need to check tail
+ this.head = item;
+ before.prev = item;
+ item.next = before;
+
+ this.updateCursors(null, item);
+ } else {
+
+ // insert between two items
+ before.prev.next = item;
+ item.prev = before.prev;
+
+ before.prev = item;
+ item.next = before;
+ }
+ } else {
+ // tail
+ // ^
+ // item
+ this.updateCursors(this.tail, item, null, item);
+
+ // insert to the ending of the list
+ if (this.tail !== null) {
+ // last item -> new item
+ this.tail.next = item;
+
+ // last item <- new item
+ item.prev = this.tail;
+ } else {
+ // if list has no tail, then it also has no head
+ // in this case head points to new item
+ this.head = item;
+ }
+
+ // tail always points to new item
+ this.tail = item;
+ }
+
+ return this;
+ };
+
+ List.prototype.insertData = function(data, before) {
+ return this.insert(createItem(data), before);
+ };
+
+ List.prototype.remove = function(item) {
+ // item
+ // ^
+ // prev next
+ this.updateCursors(item, item.prev, item, item.next);
+
+ if (item.prev !== null) {
+ item.prev.next = item.next;
+ } else {
+ if (this.head !== item) {
+ throw new Error('item doesn\'t belong to list');
+ }
+
+ this.head = item.next;
+ }
+
+ if (item.next !== null) {
+ item.next.prev = item.prev;
+ } else {
+ if (this.tail !== item) {
+ throw new Error('item doesn\'t belong to list');
+ }
+
+ this.tail = item.prev;
+ }
+
+ item.prev = null;
+ item.next = null;
+
+ return item;
+ };
+
+ List.prototype.push = function(data) {
+ this.insert(createItem(data));
+ };
+
+ List.prototype.pop = function() {
+ if (this.tail !== null) {
+ return this.remove(this.tail);
+ }
+ };
+
+ List.prototype.unshift = function(data) {
+ this.prepend(createItem(data));
+ };
+
+ List.prototype.shift = function() {
+ if (this.head !== null) {
+ return this.remove(this.head);
+ }
+ };
+
+ List.prototype.prependList = function(list) {
+ return this.insertList(list, this.head);
+ };
+
+ List.prototype.appendList = function(list) {
+ return this.insertList(list);
+ };
+
+ List.prototype.insertList = function(list, before) {
+ // ignore empty lists
+ if (list.head === null) {
+ return this;
+ }
+
+ if (before !== undefined && before !== null) {
+ this.updateCursors(before.prev, list.tail, before, list.head);
+
+ // insert in the middle of dist list
+ if (before.prev !== null) {
+ // before.prev <-> list.head
+ before.prev.next = list.head;
+ list.head.prev = before.prev;
+ } else {
+ this.head = list.head;
+ }
+
+ before.prev = list.tail;
+ list.tail.next = before;
+ } else {
+ this.updateCursors(this.tail, list.tail, null, list.head);
+
+ // insert to end of the list
+ if (this.tail !== null) {
+ // if destination list has a tail, then it also has a head,
+ // but head doesn't change
+
+ // dest tail -> source head
+ this.tail.next = list.head;
+
+ // dest tail <- source head
+ list.head.prev = this.tail;
+ } else {
+ // if list has no a tail, then it also has no a head
+ // in this case points head to new item
+ this.head = list.head;
+ }
+
+ // tail always start point to new item
+ this.tail = list.tail;
+ }
+
+ list.head = null;
+ list.tail = null;
+
+ return this;
+ };
+
+ List.prototype.replace = function(oldItem, newItemOrList) {
+ if ('head' in newItemOrList) {
+ this.insertList(newItemOrList, oldItem);
+ } else {
+ this.insert(newItemOrList, oldItem);
+ }
+
+ this.remove(oldItem);
+ };
+
+ var List_1 = List;
+
+ var createCustomError = function createCustomError(name, message) {
+ // use Object.create(), because some VMs prevent setting line/column otherwise
+ // (iOS Safari 10 even throws an exception)
+ var error = Object.create(SyntaxError.prototype);
+ var errorStack = new Error();
+
+ error.name = name;
+ error.message = message;
+
+ Object.defineProperty(error, 'stack', {
+ get: function() {
+ return (errorStack.stack || '').replace(/^(.+\n){1,3}/, name + ': ' + message + '\n');
+ }
+ });
+
+ return error;
+ };
+
+ var MAX_LINE_LENGTH = 100;
+ var OFFSET_CORRECTION = 60;
+ var TAB_REPLACEMENT = ' ';
+
+ function sourceFragment(error, extraLines) {
+ function processLines(start, end) {
+ return lines.slice(start, end).map(function(line, idx) {
+ var num = String(start + idx + 1);
+
+ while (num.length < maxNumLength) {
+ num = ' ' + num;
+ }
+
+ return num + ' |' + line;
+ }).join('\n');
+ }
+
+ var lines = error.source.split(/\r\n?|\n|\f/);
+ var line = error.line;
+ var column = error.column;
+ var startLine = Math.max(1, line - extraLines) - 1;
+ var endLine = Math.min(line + extraLines, lines.length + 1);
+ var maxNumLength = Math.max(4, String(endLine).length) + 1;
+ var cutLeft = 0;
+
+ // column correction according to replaced tab before column
+ column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
+
+ if (column > MAX_LINE_LENGTH) {
+ cutLeft = column - OFFSET_CORRECTION + 3;
+ column = OFFSET_CORRECTION - 2;
+ }
+
+ for (var i = startLine; i <= endLine; i++) {
+ if (i >= 0 && i < lines.length) {
+ lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
+ lines[i] =
+ (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
+ lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
+ (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
+ }
+ }
+
+ return [
+ processLines(startLine, line),
+ new Array(column + maxNumLength + 2).join('-') + '^',
+ processLines(line, endLine)
+ ].filter(Boolean).join('\n');
+ }
+
+ var SyntaxError$1 = function(message, source, offset, line, column) {
+ var error = createCustomError('SyntaxError', message);
+
+ error.source = source;
+ error.offset = offset;
+ error.line = line;
+ error.column = column;
+
+ error.sourceFragment = function(extraLines) {
+ return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
+ };
+ Object.defineProperty(error, 'formattedMessage', {
+ get: function() {
+ return (
+ 'Parse error: ' + error.message + '\n' +
+ sourceFragment(error, 2)
+ );
+ }
+ });
+
+ // for backward capability
+ error.parseError = {
+ offset: offset,
+ line: line,
+ column: column
+ };
+
+ return error;
+ };
+
+ var _SyntaxError = SyntaxError$1;
+
+ // CSS Syntax Module Level 3
+ // https://www.w3.org/TR/css-syntax-3/
+ var TYPE = {
+ EOF: 0, // <EOF-token>
+ Ident: 1, // <ident-token>
+ Function: 2, // <function-token>
+ AtKeyword: 3, // <at-keyword-token>
+ Hash: 4, // <hash-token>
+ String: 5, // <string-token>
+ BadString: 6, // <bad-string-token>
+ Url: 7, // <url-token>
+ BadUrl: 8, // <bad-url-token>
+ Delim: 9, // <delim-token>
+ Number: 10, // <number-token>
+ Percentage: 11, // <percentage-token>
+ Dimension: 12, // <dimension-token>
+ WhiteSpace: 13, // <whitespace-token>
+ CDO: 14, // <CDO-token>
+ CDC: 15, // <CDC-token>
+ Colon: 16, // <colon-token> :
+ Semicolon: 17, // <semicolon-token> ;
+ Comma: 18, // <comma-token> ,
+ LeftSquareBracket: 19, // <[-token>
+ RightSquareBracket: 20, // <]-token>
+ LeftParenthesis: 21, // <(-token>
+ RightParenthesis: 22, // <)-token>
+ LeftCurlyBracket: 23, // <{-token>
+ RightCurlyBracket: 24, // <}-token>
+ Comment: 25
+ };
+
+ var NAME = Object.keys(TYPE).reduce(function(result, key) {
+ result[TYPE[key]] = key;
+ return result;
+ }, {});
+
+ var _const = {
+ TYPE: TYPE,
+ NAME: NAME
+ };
+
+ var EOF = 0;
+
+ // https://drafts.csswg.org/css-syntax-3/
+ // § 4.2. Definitions
+
+ // digit
+ // A code point between U+0030 DIGIT ZERO (0) and U+0039 DIGIT NINE (9).
+ function isDigit(code) {
+ return code >= 0x0030 && code <= 0x0039;
+ }
+
+ // hex digit
+ // A digit, or a code point between U+0041 LATIN CAPITAL LETTER A (A) and U+0046 LATIN CAPITAL LETTER F (F),
+ // or a code point between U+0061 LATIN SMALL LETTER A (a) and U+0066 LATIN SMALL LETTER F (f).
+ function isHexDigit(code) {
+ return (
+ isDigit(code) || // 0 .. 9
+ (code >= 0x0041 && code <= 0x0046) || // A .. F
+ (code >= 0x0061 && code <= 0x0066) // a .. f
+ );
+ }
+
+ // uppercase letter
+ // A code point between U+0041 LATIN CAPITAL LETTER A (A) and U+005A LATIN CAPITAL LETTER Z (Z).
+ function isUppercaseLetter(code) {
+ return code >= 0x0041 && code <= 0x005A;
+ }
+
+ // lowercase letter
+ // A code point between U+0061 LATIN SMALL LETTER A (a) and U+007A LATIN SMALL LETTER Z (z).
+ function isLowercaseLetter(code) {
+ return code >= 0x0061 && code <= 0x007A;
+ }
+
+ // letter
+ // An uppercase letter or a lowercase letter.
+ function isLetter(code) {
+ return isUppercaseLetter(code) || isLowercaseLetter(code);
+ }
+
+ // non-ASCII code point
+ // A code point with a value equal to or greater than U+0080 <control>.
+ function isNonAscii(code) {
+ return code >= 0x0080;
+ }
+
+ // name-start code point
+ // A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+ function isNameStart(code) {
+ return isLetter(code) || isNonAscii(code) || code === 0x005F;
+ }
+
+ // name code point
+ // A name-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+ function isName(code) {
+ return isNameStart(code) || isDigit(code) || code === 0x002D;
+ }
+
+ // non-printable code point
+ // A code point between U+0000 NULL and U+0008 BACKSPACE, or U+000B LINE TABULATION,
+ // or a code point between U+000E SHIFT OUT and U+001F INFORMATION SEPARATOR ONE, or U+007F DELETE.
+ function isNonPrintable(code) {
+ return (
+ (code >= 0x0000 && code <= 0x0008) ||
+ (code === 0x000B) ||
+ (code >= 0x000E && code <= 0x001F) ||
+ (code === 0x007F)
+ );
+ }
+
+ // newline
+ // U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,
+ // as they are converted to U+000A LINE FEED during preprocessing.
+ // TODO: we doesn't do a preprocessing, so check a code point for U+000D CARRIAGE RETURN and U+000C FORM FEED
+ function isNewline(code) {
+ return code === 0x000A || code === 0x000D || code === 0x000C;
+ }
+
+ // whitespace
+ // A newline, U+0009 CHARACTER TABULATION, or U+0020 SPACE.
+ function isWhiteSpace(code) {
+ return isNewline(code) || code === 0x0020 || code === 0x0009;
+ }
+
+ // § 4.3.8. Check if two code points are a valid escape
+ function isValidEscape(first, second) {
+ // If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
+ if (first !== 0x005C) {
+ return false;
+ }
+
+ // Otherwise, if the second code point is a newline or EOF, return false.
+ if (isNewline(second) || second === EOF) {
+ return false;
+ }
+
+ // Otherwise, return true.
+ return true;
+ }
+
+ // § 4.3.9. Check if three code points would start an identifier
+ function isIdentifierStart(first, second, third) {
+ // Look at the first code point:
+
+ // U+002D HYPHEN-MINUS
+ if (first === 0x002D) {
+ // If the second code point is a name-start code point or a U+002D HYPHEN-MINUS,
+ // or the second and third code points are a valid escape, return true. Otherwise, return false.
+ return (
+ isNameStart(second) ||
+ second === 0x002D ||
+ isValidEscape(second, third)
+ );
+ }
+
+ // name-start code point
+ if (isNameStart(first)) {
+ // Return true.
+ return true;
+ }
+
+ // U+005C REVERSE SOLIDUS (\)
+ if (first === 0x005C) {
+ // If the first and second code points are a valid escape, return true. Otherwise, return false.
+ return isValidEscape(first, second);
+ }
+
+ // anything else
+ // Return false.
+ return false;
+ }
+
+ // § 4.3.10. Check if three code points would start a number
+ function isNumberStart(first, second, third) {
+ // Look at the first code point:
+
+ // U+002B PLUS SIGN (+)
+ // U+002D HYPHEN-MINUS (-)
+ if (first === 0x002B || first === 0x002D) {
+ // If the second code point is a digit, return true.
+ if (isDigit(second)) {
+ return 2;
+ }
+
+ // Otherwise, if the second code point is a U+002E FULL STOP (.)
+ // and the third code point is a digit, return true.
+ // Otherwise, return false.
+ return second === 0x002E && isDigit(third) ? 3 : 0;
+ }
+
+ // U+002E FULL STOP (.)
+ if (first === 0x002E) {
+ // If the second code point is a digit, return true. Otherwise, return false.
+ return isDigit(second) ? 2 : 0;
+ }
+
+ // digit
+ if (isDigit(first)) {
+ // Return true.
+ return 1;
+ }
+
+ // anything else
+ // Return false.
+ return 0;
+ }
+
+ //
+ // Misc
+ //
+
+ // detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)
+ function isBOM(code) {
+ // UTF-16BE
+ if (code === 0xFEFF) {
+ return 1;
+ }
+
+ // UTF-16LE
+ if (code === 0xFFFE) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+ // Fast code category
+ //
+ // https://drafts.csswg.org/css-syntax/#tokenizer-definitions
+ // > non-ASCII code point
+ // > A code point with a value equal to or greater than U+0080 <control>
+ // > name-start code point
+ // > A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+ // > name code point
+ // > A name-start code point, a digit, or U+002D HYPHEN-MINUS (-)
+ // That means only ASCII code points has a special meaning and we define a maps for 0..127 codes only
+ var CATEGORY = new Array(0x80);
+ charCodeCategory.Eof = 0x80;
+ charCodeCategory.WhiteSpace = 0x82;
+ charCodeCategory.Digit = 0x83;
+ charCodeCategory.NameStart = 0x84;
+ charCodeCategory.NonPrintable = 0x85;
+
+ for (var i = 0; i < CATEGORY.length; i++) {
+ switch (true) {
+ case isWhiteSpace(i):
+ CATEGORY[i] = charCodeCategory.WhiteSpace;
+ break;
+
+ case isDigit(i):
+ CATEGORY[i] = charCodeCategory.Digit;
+ break;
+
+ case isNameStart(i):
+ CATEGORY[i] = charCodeCategory.NameStart;
+ break;
+
+ case isNonPrintable(i):
+ CATEGORY[i] = charCodeCategory.NonPrintable;
+ break;
+
+ default:
+ CATEGORY[i] = i || charCodeCategory.Eof;
+ }
+ }
+
+ function charCodeCategory(code) {
+ return code < 0x80 ? CATEGORY[code] : charCodeCategory.NameStart;
+ }
+ var charCodeDefinitions = {
+ isDigit: isDigit,
+ isHexDigit: isHexDigit,
+ isUppercaseLetter: isUppercaseLetter,
+ isLowercaseLetter: isLowercaseLetter,
+ isLetter: isLetter,
+ isNonAscii: isNonAscii,
+ isNameStart: isNameStart,
+ isName: isName,
+ isNonPrintable: isNonPrintable,
+ isNewline: isNewline,
+ isWhiteSpace: isWhiteSpace,
+ isValidEscape: isValidEscape,
+ isIdentifierStart: isIdentifierStart,
+ isNumberStart: isNumberStart,
+
+ isBOM: isBOM,
+ charCodeCategory: charCodeCategory
+ };
+
+ var isDigit$1 = charCodeDefinitions.isDigit;
+ var isHexDigit$1 = charCodeDefinitions.isHexDigit;
+ var isUppercaseLetter$1 = charCodeDefinitions.isUppercaseLetter;
+ var isName$1 = charCodeDefinitions.isName;
+ var isWhiteSpace$1 = charCodeDefinitions.isWhiteSpace;
+ var isValidEscape$1 = charCodeDefinitions.isValidEscape;
+
+ function getCharCode(source, offset) {
+ return offset < source.length ? source.charCodeAt(offset) : 0;
+ }
+
+ function getNewlineLength(source, offset, code) {
+ if (code === 13 /* \r */ && getCharCode(source, offset + 1) === 10 /* \n */) {
+ return 2;
+ }
+
+ return 1;
+ }
+
+ function cmpChar(testStr, offset, referenceCode) {
+ var code = testStr.charCodeAt(offset);
+
+ // code.toLowerCase() for A..Z
+ if (isUppercaseLetter$1(code)) {
+ code = code | 32;
+ }
+
+ return code === referenceCode;
+ }
+
+ function cmpStr(testStr, start, end, referenceStr) {
+ if (end - start !== referenceStr.length) {
+ return false;
+ }
+
+ if (start < 0 || end > testStr.length) {
+ return false;
+ }
+
+ for (var i = start; i < end; i++) {
+ var testCode = testStr.charCodeAt(i);
+ var referenceCode = referenceStr.charCodeAt(i - start);
+
+ // testCode.toLowerCase() for A..Z
+ if (isUppercaseLetter$1(testCode)) {
+ testCode = testCode | 32;
+ }
+
+ if (testCode !== referenceCode) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function findWhiteSpaceStart(source, offset) {
+ for (; offset >= 0; offset--) {
+ if (!isWhiteSpace$1(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset + 1;
+ }
+
+ function findWhiteSpaceEnd(source, offset) {
+ for (; offset < source.length; offset++) {
+ if (!isWhiteSpace$1(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset;
+ }
+
+ function findDecimalNumberEnd(source, offset) {
+ for (; offset < source.length; offset++) {
+ if (!isDigit$1(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset;
+ }
+
+ // § 4.3.7. Consume an escaped code point
+ function consumeEscaped(source, offset) {
+ // It assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed and
+ // that the next input code point has already been verified to be part of a valid escape.
+ offset += 2;
+
+ // hex digit
+ if (isHexDigit$1(getCharCode(source, offset - 1))) {
+ // Consume as many hex digits as possible, but no more than 5.
+ // Note that this means 1-6 hex digits have been consumed in total.
+ for (var maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) {
+ if (!isHexDigit$1(getCharCode(source, offset))) {
+ break;
+ }
+ }
+
+ // If the next input code point is whitespace, consume it as well.
+ var code = getCharCode(source, offset);
+ if (isWhiteSpace$1(code)) {
+ offset += getNewlineLength(source, offset, code);
+ }
+ }
+
+ return offset;
+ }
+
+ // §4.3.11. Consume a name
+ // Note: This algorithm does not do the verification of the first few code points that are necessary
+ // to ensure the returned code points would constitute an <ident-token>. If that is the intended use,
+ // ensure that the stream starts with an identifier before calling this algorithm.
+ function consumeName(source, offset) {
+ // Let result initially be an empty string.
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ // name code point
+ if (isName$1(code)) {
+ // Append the code point to result.
+ continue;
+ }
+
+ // the stream starts with a valid escape
+ if (isValidEscape$1(code, getCharCode(source, offset + 1))) {
+ // Consume an escaped code point. Append the returned code point to result.
+ offset = consumeEscaped(source, offset) - 1;
+ continue;
+ }
+
+ // anything else
+ // Reconsume the current input code point. Return result.
+ break;
+ }
+
+ return offset;
+ }
+
+ // §4.3.12. Consume a number
+ function consumeNumber(source, offset) {
+ var code = source.charCodeAt(offset);
+
+ // 2. If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-),
+ // consume it and append it to repr.
+ if (code === 0x002B || code === 0x002D) {
+ code = source.charCodeAt(offset += 1);
+ }
+
+ // 3. While the next input code point is a digit, consume it and append it to repr.
+ if (isDigit$1(code)) {
+ offset = findDecimalNumberEnd(source, offset + 1);
+ code = source.charCodeAt(offset);
+ }
+
+ // 4. If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then:
+ if (code === 0x002E && isDigit$1(source.charCodeAt(offset + 1))) {
+ // 4.1 Consume them.
+ // 4.2 Append them to repr.
+ code = source.charCodeAt(offset += 2);
+
+ // 4.3 Set type to "number".
+ // TODO
+
+ // 4.4 While the next input code point is a digit, consume it and append it to repr.
+
+ offset = findDecimalNumberEnd(source, offset);
+ }
+
+ // 5. If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E)
+ // or U+0065 LATIN SMALL LETTER E (e), ... , followed by a digit, then:
+ if (cmpChar(source, offset, 101 /* e */)) {
+ var sign = 0;
+ code = source.charCodeAt(offset + 1);
+
+ // ... optionally followed by U+002D HYPHEN-MINUS (-) or U+002B PLUS SIGN (+) ...
+ if (code === 0x002D || code === 0x002B) {
+ sign = 1;
+ code = source.charCodeAt(offset + 2);
+ }
+
+ // ... followed by a digit
+ if (isDigit$1(code)) {
+ // 5.1 Consume them.
+ // 5.2 Append them to repr.
+
+ // 5.3 Set type to "number".
+ // TODO
+
+ // 5.4 While the next input code point is a digit, consume it and append it to repr.
+ offset = findDecimalNumberEnd(source, offset + 1 + sign + 1);
+ }
+ }
+
+ return offset;
+ }
+
+ // § 4.3.14. Consume the remnants of a bad url
+ // ... its sole use is to consume enough of the input stream to reach a recovery point
+ // where normal tokenizing can resume.
+ function consumeBadUrlRemnants(source, offset) {
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ // U+0029 RIGHT PARENTHESIS ())
+ // EOF
+ if (code === 0x0029) {
+ // Return.
+ offset++;
+ break;
+ }
+
+ if (isValidEscape$1(code, getCharCode(source, offset + 1))) {
+ // Consume an escaped code point.
+ // Note: This allows an escaped right parenthesis ("\)") to be encountered
+ // without ending the <bad-url-token>. This is otherwise identical to
+ // the "anything else" clause.
+ offset = consumeEscaped(source, offset);
+ }
+ }
+
+ return offset;
+ }
+
+ var utils = {
+ consumeEscaped: consumeEscaped,
+ consumeName: consumeName,
+ consumeNumber: consumeNumber,
+ consumeBadUrlRemnants: consumeBadUrlRemnants,
+
+ cmpChar: cmpChar,
+ cmpStr: cmpStr,
+
+ getNewlineLength: getNewlineLength,
+ findWhiteSpaceStart: findWhiteSpaceStart,
+ findWhiteSpaceEnd: findWhiteSpaceEnd
+ };
+
+ var TYPE$1 = _const.TYPE;
+ var NAME$1 = _const.NAME;
+
+
+ var cmpStr$1 = utils.cmpStr;
+
+ var EOF$1 = TYPE$1.EOF;
+ var WHITESPACE = TYPE$1.WhiteSpace;
+ var COMMENT = TYPE$1.Comment;
+
+ var OFFSET_MASK = 0x00FFFFFF;
+ var TYPE_SHIFT = 24;
+
+ var TokenStream = function() {
+ this.offsetAndType = null;
+ this.balance = null;
+
+ this.reset();
+ };
+
+ TokenStream.prototype = {
+ reset: function() {
+ this.eof = false;
+ this.tokenIndex = -1;
+ this.tokenType = 0;
+ this.tokenStart = this.firstCharOffset;
+ this.tokenEnd = this.firstCharOffset;
+ },
+
+ lookupType: function(offset) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return this.offsetAndType[offset] >> TYPE_SHIFT;
+ }
+
+ return EOF$1;
+ },
+ lookupOffset: function(offset) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return this.offsetAndType[offset - 1] & OFFSET_MASK;
+ }
+
+ return this.source.length;
+ },
+ lookupValue: function(offset, referenceStr) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return cmpStr$1(
+ this.source,
+ this.offsetAndType[offset - 1] & OFFSET_MASK,
+ this.offsetAndType[offset] & OFFSET_MASK,
+ referenceStr
+ );
+ }
+
+ return false;
+ },
+ getTokenStart: function(tokenIndex) {
+ if (tokenIndex === this.tokenIndex) {
+ return this.tokenStart;
+ }
+
+ if (tokenIndex > 0) {
+ return tokenIndex < this.tokenCount
+ ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK
+ : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
+ }
+
+ return this.firstCharOffset;
+ },
+
+ // TODO: -> skipUntilBalanced
+ getRawLength: function(startToken, mode) {
+ var cursor = startToken;
+ var balanceEnd;
+ var offset = this.offsetAndType[Math.max(cursor - 1, 0)] & OFFSET_MASK;
+ var type;
+
+ loop:
+ for (; cursor < this.tokenCount; cursor++) {
+ balanceEnd = this.balance[cursor];
+
+ // stop scanning on balance edge that points to offset before start token
+ if (balanceEnd < startToken) {
+ break loop;
+ }
+
+ type = this.offsetAndType[cursor] >> TYPE_SHIFT;
+
+ // check token is stop type
+ switch (mode(type, this.source, offset)) {
+ case 1:
+ break loop;
+
+ case 2:
+ cursor++;
+ break loop;
+
+ default:
+ // fast forward to the end of balanced block
+ if (this.balance[balanceEnd] === cursor) {
+ cursor = balanceEnd;
+ }
+
+ offset = this.offsetAndType[cursor] & OFFSET_MASK;
+ }
+ }
+
+ return cursor - this.tokenIndex;
+ },
+ isBalanceEdge: function(pos) {
+ return this.balance[this.tokenIndex] < pos;
+ },
+ isDelim: function(code, offset) {
+ if (offset) {
+ return (
+ this.lookupType(offset) === TYPE$1.Delim &&
+ this.source.charCodeAt(this.lookupOffset(offset)) === code
+ );
+ }
+
+ return (
+ this.tokenType === TYPE$1.Delim &&
+ this.source.charCodeAt(this.tokenStart) === code
+ );
+ },
+
+ getTokenValue: function() {
+ return this.source.substring(this.tokenStart, this.tokenEnd);
+ },
+ getTokenLength: function() {
+ return this.tokenEnd - this.tokenStart;
+ },
+ substrToCursor: function(start) {
+ return this.source.substring(start, this.tokenStart);
+ },
+
+ skipWS: function() {
+ for (var i = this.tokenIndex, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
+ if ((this.offsetAndType[i] >> TYPE_SHIFT) !== WHITESPACE) {
+ break;
+ }
+ }
+
+ if (skipTokenCount > 0) {
+ this.skip(skipTokenCount);
+ }
+ },
+ skipSC: function() {
+ while (this.tokenType === WHITESPACE || this.tokenType === COMMENT) {
+ this.next();
+ }
+ },
+ skip: function(tokenCount) {
+ var next = this.tokenIndex + tokenCount;
+
+ if (next < this.tokenCount) {
+ this.tokenIndex = next;
+ this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
+ next = this.offsetAndType[next];
+ this.tokenType = next >> TYPE_SHIFT;
+ this.tokenEnd = next & OFFSET_MASK;
+ } else {
+ this.tokenIndex = this.tokenCount;
+ this.next();
+ }
+ },
+ next: function() {
+ var next = this.tokenIndex + 1;
+
+ if (next < this.tokenCount) {
+ this.tokenIndex = next;
+ this.tokenStart = this.tokenEnd;
+ next = this.offsetAndType[next];
+ this.tokenType = next >> TYPE_SHIFT;
+ this.tokenEnd = next & OFFSET_MASK;
+ } else {
+ this.tokenIndex = this.tokenCount;
+ this.eof = true;
+ this.tokenType = EOF$1;
+ this.tokenStart = this.tokenEnd = this.source.length;
+ }
+ },
+
+ forEachToken(fn) {
+ for (var i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {
+ var start = offset;
+ var item = this.offsetAndType[i];
+ var end = item & OFFSET_MASK;
+ var type = item >> TYPE_SHIFT;
+
+ offset = end;
+
+ fn(type, start, end, i);
+ }
+ },
+
+ dump() {
+ var tokens = new Array(this.tokenCount);
+
+ this.forEachToken((type, start, end, index) => {
+ tokens[index] = {
+ idx: index,
+ type: NAME$1[type],
+ chunk: this.source.substring(start, end),
+ balance: this.balance[index]
+ };
+ });
+
+ return tokens;
+ }
+ };
+
+ var TokenStream_1 = TokenStream;
+
+ function noop(value) {
+ return value;
+ }
+
+ function generateMultiplier(multiplier) {
+ if (multiplier.min === 0 && multiplier.max === 0) {
+ return '*';
+ }
+
+ if (multiplier.min === 0 && multiplier.max === 1) {
+ return '?';
+ }
+
+ if (multiplier.min === 1 && multiplier.max === 0) {
+ return multiplier.comma ? '#' : '+';
+ }
+
+ if (multiplier.min === 1 && multiplier.max === 1) {
+ return '';
+ }
+
+ return (
+ (multiplier.comma ? '#' : '') +
+ (multiplier.min === multiplier.max
+ ? '{' + multiplier.min + '}'
+ : '{' + multiplier.min + ',' + (multiplier.max !== 0 ? multiplier.max : '') + '}'
+ )
+ );
+ }
+
+ function generateTypeOpts(node) {
+ switch (node.type) {
+ case 'Range':
+ return (
+ ' [' +
+ (node.min === null ? '-∞' : node.min) +
+ ',' +
+ (node.max === null ? '∞' : node.max) +
+ ']'
+ );
+
+ default:
+ throw new Error('Unknown node type `' + node.type + '`');
+ }
+ }
+
+ function generateSequence(node, decorate, forceBraces, compact) {
+ var combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';
+ var result = node.terms.map(function(term) {
+ return generate(term, decorate, forceBraces, compact);
+ }).join(combinator);
+
+ if (node.explicit || forceBraces) {
+ result = (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');
+ }
+
+ return result;
+ }
+
+ function generate(node, decorate, forceBraces, compact) {
+ var result;
+
+ switch (node.type) {
+ case 'Group':
+ result =
+ generateSequence(node, decorate, forceBraces, compact) +
+ (node.disallowEmpty ? '!' : '');
+ break;
+
+ case 'Multiplier':
+ // return since node is a composition
+ return (
+ generate(node.term, decorate, forceBraces, compact) +
+ decorate(generateMultiplier(node), node)
+ );
+
+ case 'Type':
+ result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';
+ break;
+
+ case 'Property':
+ result = '<\'' + node.name + '\'>';
+ break;
+
+ case 'Keyword':
+ result = node.name;
+ break;
+
+ case 'AtKeyword':
+ result = '@' + node.name;
+ break;
+
+ case 'Function':
+ result = node.name + '(';
+ break;
+
+ case 'String':
+ case 'Token':
+ result = node.value;
+ break;
+
+ case 'Comma':
+ result = ',';
+ break;
+
+ default:
+ throw new Error('Unknown node type `' + node.type + '`');
+ }
+
+ return decorate(result, node);
+ }
+
+ var generate_1 = function(node, options) {
+ var decorate = noop;
+ var forceBraces = false;
+ var compact = false;
+
+ if (typeof options === 'function') {
+ decorate = options;
+ } else if (options) {
+ forceBraces = Boolean(options.forceBraces);
+ compact = Boolean(options.compact);
+ if (typeof options.decorate === 'function') {
+ decorate = options.decorate;
+ }
+ }
+
+ return generate(node, decorate, forceBraces, compact);
+ };
+
+ const defaultLoc = { offset: 0, line: 1, column: 1 };
+
+ function locateMismatch(matchResult, node) {
+ const tokens = matchResult.tokens;
+ const longestMatch = matchResult.longestMatch;
+ const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null;
+ const badNode = mismatchNode !== node ? mismatchNode : null;
+ let mismatchOffset = 0;
+ let mismatchLength = 0;
+ let entries = 0;
+ let css = '';
+ let start;
+ let end;
+
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i].value;
+
+ if (i === longestMatch) {
+ mismatchLength = token.length;
+ mismatchOffset = css.length;
+ }
+
+ if (badNode !== null && tokens[i].node === badNode) {
+ if (i <= longestMatch) {
+ entries++;
+ } else {
+ entries = 0;
+ }
+ }
+
+ css += token;
+ }
+
+ if (longestMatch === tokens.length || entries > 1) { // last
+ start = fromLoc(badNode || node, 'end') || buildLoc(defaultLoc, css);
+ end = buildLoc(start);
+ } else {
+ start = fromLoc(badNode, 'start') ||
+ buildLoc(fromLoc(node, 'start') || defaultLoc, css.slice(0, mismatchOffset));
+ end = fromLoc(badNode, 'end') ||
+ buildLoc(start, css.substr(mismatchOffset, mismatchLength));
+ }
+
+ return {
+ css,
+ mismatchOffset,
+ mismatchLength,
+ start,
+ end
+ };
+ }
+
+ function fromLoc(node, point) {
+ const value = node && node.loc && node.loc[point];
+
+ if (value) {
+ return 'line' in value ? buildLoc(value) : value;
+ }
+
+ return null;
+ }
+
+ function buildLoc({ offset, line, column }, extra) {
+ const loc = {
+ offset,
+ line,
+ column
+ };
+
+ if (extra) {
+ const lines = extra.split(/\n|\r\n?|\f/);
+
+ loc.offset += extra.length;
+ loc.line += lines.length - 1;
+ loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1;
+ }
+
+ return loc;
+ }
+
+ const SyntaxReferenceError = function(type, referenceName) {
+ const error = createCustomError(
+ 'SyntaxReferenceError',
+ type + (referenceName ? ' `' + referenceName + '`' : '')
+ );
+
+ error.reference = referenceName;
+
+ return error;
+ };
+
+ const SyntaxMatchError = function(message, syntax, node, matchResult) {
+ const error = createCustomError('SyntaxMatchError', message);
+ const {
+ css,
+ mismatchOffset,
+ mismatchLength,
+ start,
+ end
+ } = locateMismatch(matchResult, node);
+
+ error.rawMessage = message;
+ error.syntax = syntax ? generate_1(syntax) : '<generic>';
+ error.css = css;
+ error.mismatchOffset = mismatchOffset;
+ error.mismatchLength = mismatchLength;
+ error.message = message + '\n' +
+ ' syntax: ' + error.syntax + '\n' +
+ ' value: ' + (css || '<empty string>') + '\n' +
+ ' --------' + new Array(error.mismatchOffset + 1).join('-') + '^';
+
+ Object.assign(error, start);
+ error.loc = {
+ source: (node && node.loc && node.loc.source) || '<unknown>',
+ start,
+ end
+ };
+
+ return error;
+ };
+
+ var error = {
+ SyntaxReferenceError,
+ SyntaxMatchError
+ };
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var keywords = Object.create(null);
+ var properties = Object.create(null);
+ var HYPHENMINUS = 45; // '-'.charCodeAt()
+
+ function isCustomProperty(str, offset) {
+ offset = offset || 0;
+
+ return str.length - offset >= 2 &&
+ str.charCodeAt(offset) === HYPHENMINUS &&
+ str.charCodeAt(offset + 1) === HYPHENMINUS;
+ }
+
+ function getVendorPrefix(str, offset) {
+ offset = offset || 0;
+
+ // verdor prefix should be at least 3 chars length
+ if (str.length - offset >= 3) {
+ // vendor prefix starts with hyper minus following non-hyper minus
+ if (str.charCodeAt(offset) === HYPHENMINUS &&
+ str.charCodeAt(offset + 1) !== HYPHENMINUS) {
+ // vendor prefix should contain a hyper minus at the ending
+ var secondDashIndex = str.indexOf('-', offset + 2);
+
+ if (secondDashIndex !== -1) {
+ return str.substring(offset, secondDashIndex + 1);
+ }
+ }
+ }
+
+ return '';
+ }
+
+ function getKeywordDescriptor(keyword) {
+ if (hasOwnProperty.call(keywords, keyword)) {
+ return keywords[keyword];
+ }
+
+ var name = keyword.toLowerCase();
+
+ if (hasOwnProperty.call(keywords, name)) {
+ return keywords[keyword] = keywords[name];
+ }
+
+ var custom = isCustomProperty(name, 0);
+ var vendor = !custom ? getVendorPrefix(name, 0) : '';
+
+ return keywords[keyword] = Object.freeze({
+ basename: name.substr(vendor.length),
+ name: name,
+ vendor: vendor,
+ prefix: vendor,
+ custom: custom
+ });
+ }
+
+ function getPropertyDescriptor(property) {
+ if (hasOwnProperty.call(properties, property)) {
+ return properties[property];
+ }
+
+ var name = property;
+ var hack = property[0];
+
+ if (hack === '/') {
+ hack = property[1] === '/' ? '//' : '/';
+ } else if (hack !== '_' &&
+ hack !== '*' &&
+ hack !== '$' &&
+ hack !== '#' &&
+ hack !== '+' &&
+ hack !== '&') {
+ hack = '';
+ }
+
+ var custom = isCustomProperty(name, hack.length);
+
+ // re-use result when possible (the same as for lower case)
+ if (!custom) {
+ name = name.toLowerCase();
+ if (hasOwnProperty.call(properties, name)) {
+ return properties[property] = properties[name];
+ }
+ }
+
+ var vendor = !custom ? getVendorPrefix(name, hack.length) : '';
+ var prefix = name.substr(0, hack.length + vendor.length);
+
+ return properties[property] = Object.freeze({
+ basename: name.substr(prefix.length),
+ name: name.substr(hack.length),
+ hack: hack,
+ vendor: vendor,
+ prefix: prefix,
+ custom: custom
+ });
+ }
+
+ var names = {
+ keyword: getKeywordDescriptor,
+ property: getPropertyDescriptor,
+ isCustomProperty: isCustomProperty,
+ vendorPrefix: getVendorPrefix
+ };
+
+ var MIN_SIZE = 16 * 1024;
+ var SafeUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
+
+ var adoptBuffer = function adoptBuffer(buffer, size) {
+ if (buffer === null || buffer.length < size) {
+ return new SafeUint32Array(Math.max(size + 1024, MIN_SIZE));
+ }
+
+ return buffer;
+ };
+
+ var TYPE$2 = _const.TYPE;
+
+
+ var isNewline$1 = charCodeDefinitions.isNewline;
+ var isName$2 = charCodeDefinitions.isName;
+ var isValidEscape$2 = charCodeDefinitions.isValidEscape;
+ var isNumberStart$1 = charCodeDefinitions.isNumberStart;
+ var isIdentifierStart$1 = charCodeDefinitions.isIdentifierStart;
+ var charCodeCategory$1 = charCodeDefinitions.charCodeCategory;
+ var isBOM$1 = charCodeDefinitions.isBOM;
+
+
+ var cmpStr$2 = utils.cmpStr;
+ var getNewlineLength$1 = utils.getNewlineLength;
+ var findWhiteSpaceEnd$1 = utils.findWhiteSpaceEnd;
+ var consumeEscaped$1 = utils.consumeEscaped;
+ var consumeName$1 = utils.consumeName;
+ var consumeNumber$1 = utils.consumeNumber;
+ var consumeBadUrlRemnants$1 = utils.consumeBadUrlRemnants;
+
+ var OFFSET_MASK$1 = 0x00FFFFFF;
+ var TYPE_SHIFT$1 = 24;
+
+ function tokenize(source, stream) {
+ function getCharCode(offset) {
+ return offset < sourceLength ? source.charCodeAt(offset) : 0;
+ }
+
+ // § 4.3.3. Consume a numeric token
+ function consumeNumericToken() {
+ // Consume a number and let number be the result.
+ offset = consumeNumber$1(source, offset);
+
+ // If the next 3 input code points would start an identifier, then:
+ if (isIdentifierStart$1(getCharCode(offset), getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // Create a <dimension-token> with the same value and type flag as number, and a unit set initially to the empty string.
+ // Consume a name. Set the <dimension-token>’s unit to the returned value.
+ // Return the <dimension-token>.
+ type = TYPE$2.Dimension;
+ offset = consumeName$1(source, offset);
+ return;
+ }
+
+ // Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.
+ if (getCharCode(offset) === 0x0025) {
+ // Create a <percentage-token> with the same value as number, and return it.
+ type = TYPE$2.Percentage;
+ offset++;
+ return;
+ }
+
+ // Otherwise, create a <number-token> with the same value and type flag as number, and return it.
+ type = TYPE$2.Number;
+ }
+
+ // § 4.3.4. Consume an ident-like token
+ function consumeIdentLikeToken() {
+ const nameStartOffset = offset;
+
+ // Consume a name, and let string be the result.
+ offset = consumeName$1(source, offset);
+
+ // If string’s value is an ASCII case-insensitive match for "url",
+ // and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
+ if (cmpStr$2(source, nameStartOffset, offset, 'url') && getCharCode(offset) === 0x0028) {
+ // While the next two input code points are whitespace, consume the next input code point.
+ offset = findWhiteSpaceEnd$1(source, offset + 1);
+
+ // If the next one or two input code points are U+0022 QUOTATION MARK ("), U+0027 APOSTROPHE ('),
+ // or whitespace followed by U+0022 QUOTATION MARK (") or U+0027 APOSTROPHE ('),
+ // then create a <function-token> with its value set to string and return it.
+ if (getCharCode(offset) === 0x0022 ||
+ getCharCode(offset) === 0x0027) {
+ type = TYPE$2.Function;
+ offset = nameStartOffset + 4;
+ return;
+ }
+
+ // Otherwise, consume a url token, and return it.
+ consumeUrlToken();
+ return;
+ }
+
+ // Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
+ // Create a <function-token> with its value set to string and return it.
+ if (getCharCode(offset) === 0x0028) {
+ type = TYPE$2.Function;
+ offset++;
+ return;
+ }
+
+ // Otherwise, create an <ident-token> with its value set to string and return it.
+ type = TYPE$2.Ident;
+ }
+
+ // § 4.3.5. Consume a string token
+ function consumeStringToken(endingCodePoint) {
+ // This algorithm may be called with an ending code point, which denotes the code point
+ // that ends the string. If an ending code point is not specified,
+ // the current input code point is used.
+ if (!endingCodePoint) {
+ endingCodePoint = getCharCode(offset++);
+ }
+
+ // Initially create a <string-token> with its value set to the empty string.
+ type = TYPE$2.String;
+
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ switch (charCodeCategory$1(code)) {
+ // ending code point
+ case endingCodePoint:
+ // Return the <string-token>.
+ offset++;
+ return;
+
+ // EOF
+ case charCodeCategory$1.Eof:
+ // This is a parse error. Return the <string-token>.
+ return;
+
+ // newline
+ case charCodeCategory$1.WhiteSpace:
+ if (isNewline$1(code)) {
+ // This is a parse error. Reconsume the current input code point,
+ // create a <bad-string-token>, and return it.
+ offset += getNewlineLength$1(source, offset, code);
+ type = TYPE$2.BadString;
+ return;
+ }
+ break;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the next input code point is EOF, do nothing.
+ if (offset === source.length - 1) {
+ break;
+ }
+
+ var nextCode = getCharCode(offset + 1);
+
+ // Otherwise, if the next input code point is a newline, consume it.
+ if (isNewline$1(nextCode)) {
+ offset += getNewlineLength$1(source, offset + 1, nextCode);
+ } else if (isValidEscape$2(code, nextCode)) {
+ // Otherwise, (the stream starts with a valid escape) consume
+ // an escaped code point and append the returned code point to
+ // the <string-token>’s value.
+ offset = consumeEscaped$1(source, offset) - 1;
+ }
+ break;
+
+ // anything else
+ // Append the current input code point to the <string-token>’s value.
+ }
+ }
+ }
+
+ // § 4.3.6. Consume a url token
+ // Note: This algorithm assumes that the initial "url(" has already been consumed.
+ // This algorithm also assumes that it’s being called to consume an "unquoted" value, like url(foo).
+ // A quoted value, like url("foo"), is parsed as a <function-token>. Consume an ident-like token
+ // automatically handles this distinction; this algorithm shouldn’t be called directly otherwise.
+ function consumeUrlToken() {
+ // Initially create a <url-token> with its value set to the empty string.
+ type = TYPE$2.Url;
+
+ // Consume as much whitespace as possible.
+ offset = findWhiteSpaceEnd$1(source, offset);
+
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ switch (charCodeCategory$1(code)) {
+ // U+0029 RIGHT PARENTHESIS ())
+ case 0x0029:
+ // Return the <url-token>.
+ offset++;
+ return;
+
+ // EOF
+ case charCodeCategory$1.Eof:
+ // This is a parse error. Return the <url-token>.
+ return;
+
+ // whitespace
+ case charCodeCategory$1.WhiteSpace:
+ // Consume as much whitespace as possible.
+ offset = findWhiteSpaceEnd$1(source, offset);
+
+ // If the next input code point is U+0029 RIGHT PARENTHESIS ()) or EOF,
+ // consume it and return the <url-token>
+ // (if EOF was encountered, this is a parse error);
+ if (getCharCode(offset) === 0x0029 || offset >= source.length) {
+ if (offset < source.length) {
+ offset++;
+ }
+ return;
+ }
+
+ // otherwise, consume the remnants of a bad url, create a <bad-url-token>,
+ // and return it.
+ offset = consumeBadUrlRemnants$1(source, offset);
+ type = TYPE$2.BadUrl;
+ return;
+
+ // U+0022 QUOTATION MARK (")
+ // U+0027 APOSTROPHE (')
+ // U+0028 LEFT PARENTHESIS (()
+ // non-printable code point
+ case 0x0022:
+ case 0x0027:
+ case 0x0028:
+ case charCodeCategory$1.NonPrintable:
+ // This is a parse error. Consume the remnants of a bad url,
+ // create a <bad-url-token>, and return it.
+ offset = consumeBadUrlRemnants$1(source, offset);
+ type = TYPE$2.BadUrl;
+ return;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the stream starts with a valid escape, consume an escaped code point and
+ // append the returned code point to the <url-token>’s value.
+ if (isValidEscape$2(code, getCharCode(offset + 1))) {
+ offset = consumeEscaped$1(source, offset) - 1;
+ break;
+ }
+
+ // Otherwise, this is a parse error. Consume the remnants of a bad url,
+ // create a <bad-url-token>, and return it.
+ offset = consumeBadUrlRemnants$1(source, offset);
+ type = TYPE$2.BadUrl;
+ return;
+
+ // anything else
+ // Append the current input code point to the <url-token>’s value.
+ }
+ }
+ }
+
+ if (!stream) {
+ stream = new TokenStream_1();
+ }
+
+ // ensure source is a string
+ source = String(source || '');
+
+ var sourceLength = source.length;
+ var offsetAndType = adoptBuffer(stream.offsetAndType, sourceLength + 1); // +1 because of eof-token
+ var balance = adoptBuffer(stream.balance, sourceLength + 1);
+ var tokenCount = 0;
+ var start = isBOM$1(getCharCode(0));
+ var offset = start;
+ var balanceCloseType = 0;
+ var balanceStart = 0;
+ var balancePrev = 0;
+
+ // https://drafts.csswg.org/css-syntax-3/#consume-token
+ // § 4.3.1. Consume a token
+ while (offset < sourceLength) {
+ var code = source.charCodeAt(offset);
+ var type = 0;
+
+ balance[tokenCount] = sourceLength;
+
+ switch (charCodeCategory$1(code)) {
+ // whitespace
+ case charCodeCategory$1.WhiteSpace:
+ // Consume as much whitespace as possible. Return a <whitespace-token>.
+ type = TYPE$2.WhiteSpace;
+ offset = findWhiteSpaceEnd$1(source, offset + 1);
+ break;
+
+ // U+0022 QUOTATION MARK (")
+ case 0x0022:
+ // Consume a string token and return it.
+ consumeStringToken();
+ break;
+
+ // U+0023 NUMBER SIGN (#)
+ case 0x0023:
+ // If the next input code point is a name code point or the next two input code points are a valid escape, then:
+ if (isName$2(getCharCode(offset + 1)) || isValidEscape$2(getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // Create a <hash-token>.
+ type = TYPE$2.Hash;
+
+ // If the next 3 input code points would start an identifier, set the <hash-token>’s type flag to "id".
+ // if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {
+ // // TODO: set id flag
+ // }
+
+ // Consume a name, and set the <hash-token>’s value to the returned string.
+ offset = consumeName$1(source, offset + 1);
+
+ // Return the <hash-token>.
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+0027 APOSTROPHE (')
+ case 0x0027:
+ // Consume a string token and return it.
+ consumeStringToken();
+ break;
+
+ // U+0028 LEFT PARENTHESIS (()
+ case 0x0028:
+ // Return a <(-token>.
+ type = TYPE$2.LeftParenthesis;
+ offset++;
+ break;
+
+ // U+0029 RIGHT PARENTHESIS ())
+ case 0x0029:
+ // Return a <)-token>.
+ type = TYPE$2.RightParenthesis;
+ offset++;
+ break;
+
+ // U+002B PLUS SIGN (+)
+ case 0x002B:
+ // If the input stream starts with a number, ...
+ if (isNumberStart$1(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+ break;
+
+ // U+002C COMMA (,)
+ case 0x002C:
+ // Return a <comma-token>.
+ type = TYPE$2.Comma;
+ offset++;
+ break;
+
+ // U+002D HYPHEN-MINUS (-)
+ case 0x002D:
+ // If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
+ if (isNumberStart$1(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ consumeNumericToken();
+ } else {
+ // Otherwise, if the next 2 input code points are U+002D HYPHEN-MINUS U+003E GREATER-THAN SIGN (->), consume them and return a <CDC-token>.
+ if (getCharCode(offset + 1) === 0x002D &&
+ getCharCode(offset + 2) === 0x003E) {
+ type = TYPE$2.CDC;
+ offset = offset + 3;
+ } else {
+ // Otherwise, if the input stream starts with an identifier, ...
+ if (isIdentifierStart$1(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+ }
+ }
+ break;
+
+ // U+002E FULL STOP (.)
+ case 0x002E:
+ // If the input stream starts with a number, ...
+ if (isNumberStart$1(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+002F SOLIDUS (/)
+ case 0x002F:
+ // If the next two input code point are U+002F SOLIDUS (/) followed by a U+002A ASTERISK (*),
+ if (getCharCode(offset + 1) === 0x002A) {
+ // ... consume them and all following code points up to and including the first U+002A ASTERISK (*)
+ // followed by a U+002F SOLIDUS (/), or up to an EOF code point.
+ type = TYPE$2.Comment;
+ offset = source.indexOf('*/', offset + 2) + 2;
+ if (offset === 1) {
+ offset = source.length;
+ }
+ } else {
+ type = TYPE$2.Delim;
+ offset++;
+ }
+ break;
+
+ // U+003A COLON (:)
+ case 0x003A:
+ // Return a <colon-token>.
+ type = TYPE$2.Colon;
+ offset++;
+ break;
+
+ // U+003B SEMICOLON (;)
+ case 0x003B:
+ // Return a <semicolon-token>.
+ type = TYPE$2.Semicolon;
+ offset++;
+ break;
+
+ // U+003C LESS-THAN SIGN (<)
+ case 0x003C:
+ // If the next 3 input code points are U+0021 EXCLAMATION MARK U+002D HYPHEN-MINUS U+002D HYPHEN-MINUS (!--), ...
+ if (getCharCode(offset + 1) === 0x0021 &&
+ getCharCode(offset + 2) === 0x002D &&
+ getCharCode(offset + 3) === 0x002D) {
+ // ... consume them and return a <CDO-token>.
+ type = TYPE$2.CDO;
+ offset = offset + 4;
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+0040 COMMERCIAL AT (@)
+ case 0x0040:
+ // If the next 3 input code points would start an identifier, ...
+ if (isIdentifierStart$1(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {
+ // ... consume a name, create an <at-keyword-token> with its value set to the returned value, and return it.
+ type = TYPE$2.AtKeyword;
+ offset = consumeName$1(source, offset + 1);
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+005B LEFT SQUARE BRACKET ([)
+ case 0x005B:
+ // Return a <[-token>.
+ type = TYPE$2.LeftSquareBracket;
+ offset++;
+ break;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the input stream starts with a valid escape, ...
+ if (isValidEscape$2(code, getCharCode(offset + 1))) {
+ // ... reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ } else {
+ // Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+ break;
+
+ // U+005D RIGHT SQUARE BRACKET (])
+ case 0x005D:
+ // Return a <]-token>.
+ type = TYPE$2.RightSquareBracket;
+ offset++;
+ break;
+
+ // U+007B LEFT CURLY BRACKET ({)
+ case 0x007B:
+ // Return a <{-token>.
+ type = TYPE$2.LeftCurlyBracket;
+ offset++;
+ break;
+
+ // U+007D RIGHT CURLY BRACKET (})
+ case 0x007D:
+ // Return a <}-token>.
+ type = TYPE$2.RightCurlyBracket;
+ offset++;
+ break;
+
+ // digit
+ case charCodeCategory$1.Digit:
+ // Reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ break;
+
+ // name-start code point
+ case charCodeCategory$1.NameStart:
+ // Reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ break;
+
+ // EOF
+ case charCodeCategory$1.Eof:
+ // Return an <EOF-token>.
+ break;
+
+ // anything else
+ default:
+ // Return a <delim-token> with its value set to the current input code point.
+ type = TYPE$2.Delim;
+ offset++;
+ }
+
+ switch (type) {
+ case balanceCloseType:
+ balancePrev = balanceStart & OFFSET_MASK$1;
+ balanceStart = balance[balancePrev];
+ balanceCloseType = balanceStart >> TYPE_SHIFT$1;
+ balance[tokenCount] = balancePrev;
+ balance[balancePrev++] = tokenCount;
+ for (; balancePrev < tokenCount; balancePrev++) {
+ if (balance[balancePrev] === sourceLength) {
+ balance[balancePrev] = tokenCount;
+ }
+ }
+ break;
+
+ case TYPE$2.LeftParenthesis:
+ case TYPE$2.Function:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE$2.RightParenthesis;
+ balanceStart = (balanceCloseType << TYPE_SHIFT$1) | tokenCount;
+ break;
+
+ case TYPE$2.LeftSquareBracket:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE$2.RightSquareBracket;
+ balanceStart = (balanceCloseType << TYPE_SHIFT$1) | tokenCount;
+ break;
+
+ case TYPE$2.LeftCurlyBracket:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE$2.RightCurlyBracket;
+ balanceStart = (balanceCloseType << TYPE_SHIFT$1) | tokenCount;
+ break;
+ }
+
+ offsetAndType[tokenCount++] = (type << TYPE_SHIFT$1) | offset;
+ }
+
+ // finalize buffers
+ offsetAndType[tokenCount] = (TYPE$2.EOF << TYPE_SHIFT$1) | offset; // <EOF-token>
+ balance[tokenCount] = sourceLength;
+ balance[sourceLength] = sourceLength; // prevents false positive balance match with any token
+ while (balanceStart !== 0) {
+ balancePrev = balanceStart & OFFSET_MASK$1;
+ balanceStart = balance[balancePrev];
+ balance[balancePrev] = sourceLength;
+ }
+
+ // update stream
+ stream.source = source;
+ stream.firstCharOffset = start;
+ stream.offsetAndType = offsetAndType;
+ stream.tokenCount = tokenCount;
+ stream.balance = balance;
+ stream.reset();
+ stream.next();
+
+ return stream;
+ }
+
+ // extend tokenizer with constants
+ Object.keys(_const).forEach(function(key) {
+ tokenize[key] = _const[key];
+ });
+
+ // extend tokenizer with static methods from utils
+ Object.keys(charCodeDefinitions).forEach(function(key) {
+ tokenize[key] = charCodeDefinitions[key];
+ });
+ Object.keys(utils).forEach(function(key) {
+ tokenize[key] = utils[key];
+ });
+
+ var tokenizer = tokenize;
+
+ var isDigit$2 = tokenizer.isDigit;
+ var cmpChar$1 = tokenizer.cmpChar;
+ var TYPE$3 = tokenizer.TYPE;
+
+ var DELIM = TYPE$3.Delim;
+ var WHITESPACE$1 = TYPE$3.WhiteSpace;
+ var COMMENT$1 = TYPE$3.Comment;
+ var IDENT = TYPE$3.Ident;
+ var NUMBER = TYPE$3.Number;
+ var DIMENSION = TYPE$3.Dimension;
+ var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+ var HYPHENMINUS$1 = 0x002D; // U+002D HYPHEN-MINUS (-)
+ var N = 0x006E; // U+006E LATIN SMALL LETTER N (n)
+ var DISALLOW_SIGN = true;
+ var ALLOW_SIGN = false;
+
+ function isDelim(token, code) {
+ return token !== null && token.type === DELIM && token.value.charCodeAt(0) === code;
+ }
+
+ function skipSC(token, offset, getNextToken) {
+ while (token !== null && (token.type === WHITESPACE$1 || token.type === COMMENT$1)) {
+ token = getNextToken(++offset);
+ }
+
+ return offset;
+ }
+
+ function checkInteger(token, valueOffset, disallowSign, offset) {
+ if (!token) {
+ return 0;
+ }
+
+ var code = token.value.charCodeAt(valueOffset);
+
+ if (code === PLUSSIGN || code === HYPHENMINUS$1) {
+ if (disallowSign) {
+ // Number sign is not allowed
+ return 0;
+ }
+ valueOffset++;
+ }
+
+ for (; valueOffset < token.value.length; valueOffset++) {
+ if (!isDigit$2(token.value.charCodeAt(valueOffset))) {
+ // Integer is expected
+ return 0;
+ }
+ }
+
+ return offset + 1;
+ }
+
+ // ... <signed-integer>
+ // ... ['+' | '-'] <signless-integer>
+ function consumeB(token, offset_, getNextToken) {
+ var sign = false;
+ var offset = skipSC(token, offset_, getNextToken);
+
+ token = getNextToken(offset);
+
+ if (token === null) {
+ return offset_;
+ }
+
+ if (token.type !== NUMBER) {
+ if (isDelim(token, PLUSSIGN) || isDelim(token, HYPHENMINUS$1)) {
+ sign = true;
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ if (token === null && token.type !== NUMBER) {
+ return 0;
+ }
+ } else {
+ return offset_;
+ }
+ }
+
+ if (!sign) {
+ var code = token.value.charCodeAt(0);
+ if (code !== PLUSSIGN && code !== HYPHENMINUS$1) {
+ // Number sign is expected
+ return 0;
+ }
+ }
+
+ return checkInteger(token, sign ? 0 : 1, sign, offset);
+ }
+
+ // An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+ var genericAnPlusB = function anPlusB(token, getNextToken) {
+ /* eslint-disable brace-style*/
+ var offset = 0;
+
+ if (!token) {
+ return 0;
+ }
+
+ // <integer>
+ if (token.type === NUMBER) {
+ return checkInteger(token, 0, ALLOW_SIGN, offset); // b
+ }
+
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ // -n- <signless-integer>
+ // <dashndashdigit-ident>
+ else if (token.type === IDENT && token.value.charCodeAt(0) === HYPHENMINUS$1) {
+ // expect 1st char is N
+ if (!cmpChar$1(token.value, 1, N)) {
+ return 0;
+ }
+
+ switch (token.value.length) {
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ case 2:
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+
+ // -n- <signless-integer>
+ case 3:
+ if (token.value.charCodeAt(2) !== HYPHENMINUS$1) {
+ return 0;
+ }
+
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+
+ // <dashndashdigit-ident>
+ default:
+ if (token.value.charCodeAt(2) !== HYPHENMINUS$1) {
+ return 0;
+ }
+
+ return checkInteger(token, 3, DISALLOW_SIGN, offset);
+ }
+ }
+
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ // '+'? n- <signless-integer>
+ // '+'? <ndashdigit-ident>
+ else if (token.type === IDENT || (isDelim(token, PLUSSIGN) && getNextToken(offset + 1).type === IDENT)) {
+ // just ignore a plus
+ if (token.type !== IDENT) {
+ token = getNextToken(++offset);
+ }
+
+ if (token === null || !cmpChar$1(token.value, 0, N)) {
+ return 0;
+ }
+
+ switch (token.value.length) {
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ case 1:
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+
+ // '+'? n- <signless-integer>
+ case 2:
+ if (token.value.charCodeAt(1) !== HYPHENMINUS$1) {
+ return 0;
+ }
+
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+
+ // '+'? <ndashdigit-ident>
+ default:
+ if (token.value.charCodeAt(1) !== HYPHENMINUS$1) {
+ return 0;
+ }
+
+ return checkInteger(token, 2, DISALLOW_SIGN, offset);
+ }
+ }
+
+ // <ndashdigit-dimension>
+ // <ndash-dimension> <signless-integer>
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ else if (token.type === DIMENSION) {
+ var code = token.value.charCodeAt(0);
+ var sign = code === PLUSSIGN || code === HYPHENMINUS$1 ? 1 : 0;
+
+ for (var i = sign; i < token.value.length; i++) {
+ if (!isDigit$2(token.value.charCodeAt(i))) {
+ break;
+ }
+ }
+
+ if (i === sign) {
+ // Integer is expected
+ return 0;
+ }
+
+ if (!cmpChar$1(token.value, i, N)) {
+ return 0;
+ }
+
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ if (i + 1 === token.value.length) {
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+ } else {
+ if (token.value.charCodeAt(i + 1) !== HYPHENMINUS$1) {
+ return 0;
+ }
+
+ // <ndash-dimension> <signless-integer>
+ if (i + 2 === token.value.length) {
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+ }
+ // <ndashdigit-dimension>
+ else {
+ return checkInteger(token, i + 2, DISALLOW_SIGN, offset);
+ }
+ }
+ }
+
+ return 0;
+ };
+
+ var isHexDigit$2 = tokenizer.isHexDigit;
+ var cmpChar$2 = tokenizer.cmpChar;
+ var TYPE$4 = tokenizer.TYPE;
+
+ var IDENT$1 = TYPE$4.Ident;
+ var DELIM$1 = TYPE$4.Delim;
+ var NUMBER$1 = TYPE$4.Number;
+ var DIMENSION$1 = TYPE$4.Dimension;
+ var PLUSSIGN$1 = 0x002B; // U+002B PLUS SIGN (+)
+ var HYPHENMINUS$2 = 0x002D; // U+002D HYPHEN-MINUS (-)
+ var QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)
+ var U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+ function isDelim$1(token, code) {
+ return token !== null && token.type === DELIM$1 && token.value.charCodeAt(0) === code;
+ }
+
+ function startsWith(token, code) {
+ return token.value.charCodeAt(0) === code;
+ }
+
+ function hexSequence(token, offset, allowDash) {
+ for (var pos = offset, hexlen = 0; pos < token.value.length; pos++) {
+ var code = token.value.charCodeAt(pos);
+
+ if (code === HYPHENMINUS$2 && allowDash && hexlen !== 0) {
+ if (hexSequence(token, offset + hexlen + 1, false) > 0) {
+ return 6; // dissallow following question marks
+ }
+
+ return 0; // dash at the ending of a hex sequence is not allowed
+ }
+
+ if (!isHexDigit$2(code)) {
+ return 0; // not a hex digit
+ }
+
+ if (++hexlen > 6) {
+ return 0; // too many hex digits
+ } }
+
+ return hexlen;
+ }
+
+ function withQuestionMarkSequence(consumed, length, getNextToken) {
+ if (!consumed) {
+ return 0; // nothing consumed
+ }
+
+ while (isDelim$1(getNextToken(length), QUESTIONMARK)) {
+ if (++consumed > 6) {
+ return 0; // too many question marks
+ }
+
+ length++;
+ }
+
+ return length;
+ }
+
+ // https://drafts.csswg.org/css-syntax/#urange
+ // Informally, the <urange> production has three forms:
+ // U+0001
+ // Defines a range consisting of a single code point, in this case the code point "1".
+ // U+0001-00ff
+ // Defines a range of codepoints between the first and the second value, in this case
+ // the range between "1" and "ff" (255 in decimal) inclusive.
+ // U+00??
+ // Defines a range of codepoints where the "?" characters range over all hex digits,
+ // in this case defining the same as the value U+0000-00ff.
+ // In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+ //
+ // <urange> =
+ // u '+' <ident-token> '?'* |
+ // u <dimension-token> '?'* |
+ // u <number-token> '?'* |
+ // u <number-token> <dimension-token> |
+ // u <number-token> <number-token> |
+ // u '+' '?'+
+ var genericUrange = function urange(token, getNextToken) {
+ var length = 0;
+
+ // should start with `u` or `U`
+ if (token === null || token.type !== IDENT$1 || !cmpChar$2(token.value, 0, U)) {
+ return 0;
+ }
+
+ token = getNextToken(++length);
+ if (token === null) {
+ return 0;
+ }
+
+ // u '+' <ident-token> '?'*
+ // u '+' '?'+
+ if (isDelim$1(token, PLUSSIGN$1)) {
+ token = getNextToken(++length);
+ if (token === null) {
+ return 0;
+ }
+
+ if (token.type === IDENT$1) {
+ // u '+' <ident-token> '?'*
+ return withQuestionMarkSequence(hexSequence(token, 0, true), ++length, getNextToken);
+ }
+
+ if (isDelim$1(token, QUESTIONMARK)) {
+ // u '+' '?'+
+ return withQuestionMarkSequence(1, ++length, getNextToken);
+ }
+
+ // Hex digit or question mark is expected
+ return 0;
+ }
+
+ // u <number-token> '?'*
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (token.type === NUMBER$1) {
+ if (!startsWith(token, PLUSSIGN$1)) {
+ return 0;
+ }
+
+ var consumedHexLength = hexSequence(token, 1, true);
+ if (consumedHexLength === 0) {
+ return 0;
+ }
+
+ token = getNextToken(++length);
+ if (token === null) {
+ // u <number-token> <eof>
+ return length;
+ }
+
+ if (token.type === DIMENSION$1 || token.type === NUMBER$1) {
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (!startsWith(token, HYPHENMINUS$2) || !hexSequence(token, 1, false)) {
+ return 0;
+ }
+
+ return length + 1;
+ }
+
+ // u <number-token> '?'*
+ return withQuestionMarkSequence(consumedHexLength, length, getNextToken);
+ }
+
+ // u <dimension-token> '?'*
+ if (token.type === DIMENSION$1) {
+ if (!startsWith(token, PLUSSIGN$1)) {
+ return 0;
+ }
+
+ return withQuestionMarkSequence(hexSequence(token, 1, true), ++length, getNextToken);
+ }
+
+ return 0;
+ };
+
+ var isIdentifierStart$2 = tokenizer.isIdentifierStart;
+ var isHexDigit$3 = tokenizer.isHexDigit;
+ var isDigit$3 = tokenizer.isDigit;
+ var cmpStr$3 = tokenizer.cmpStr;
+ var consumeNumber$2 = tokenizer.consumeNumber;
+ var TYPE$5 = tokenizer.TYPE;
+
+
+
+ var cssWideKeywords = ['unset', 'initial', 'inherit'];
+ var calcFunctionNames = ['calc(', '-moz-calc(', '-webkit-calc('];
+
+ // https://www.w3.org/TR/css-values-3/#lengths
+ var LENGTH = {
+ // absolute length units
+ 'px': true,
+ 'mm': true,
+ 'cm': true,
+ 'in': true,
+ 'pt': true,
+ 'pc': true,
+ 'q': true,
+
+ // relative length units
+ 'em': true,
+ 'ex': true,
+ 'ch': true,
+ 'rem': true,
+
+ // viewport-percentage lengths
+ 'vh': true,
+ 'vw': true,
+ 'vmin': true,
+ 'vmax': true,
+ 'vm': true
+ };
+
+ var ANGLE = {
+ 'deg': true,
+ 'grad': true,
+ 'rad': true,
+ 'turn': true
+ };
+
+ var TIME = {
+ 's': true,
+ 'ms': true
+ };
+
+ var FREQUENCY = {
+ 'hz': true,
+ 'khz': true
+ };
+
+ // https://www.w3.org/TR/css-values-3/#resolution (https://drafts.csswg.org/css-values/#resolution)
+ var RESOLUTION = {
+ 'dpi': true,
+ 'dpcm': true,
+ 'dppx': true,
+ 'x': true // https://github.com/w3c/csswg-drafts/issues/461
+ };
+
+ // https://drafts.csswg.org/css-grid/#fr-unit
+ var FLEX = {
+ 'fr': true
+ };
+
+ // https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume
+ var DECIBEL = {
+ 'db': true
+ };
+
+ // https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch
+ var SEMITONES = {
+ 'st': true
+ };
+
+ // safe char code getter
+ function charCode(str, index) {
+ return index < str.length ? str.charCodeAt(index) : 0;
+ }
+
+ function eqStr(actual, expected) {
+ return cmpStr$3(actual, 0, actual.length, expected);
+ }
+
+ function eqStrAny(actual, expected) {
+ for (var i = 0; i < expected.length; i++) {
+ if (eqStr(actual, expected[i])) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // IE postfix hack, i.e. 123\0 or 123px\9
+ function isPostfixIeHack(str, offset) {
+ if (offset !== str.length - 2) {
+ return false;
+ }
+
+ return (
+ str.charCodeAt(offset) === 0x005C && // U+005C REVERSE SOLIDUS (\)
+ isDigit$3(str.charCodeAt(offset + 1))
+ );
+ }
+
+ function outOfRange(opts, value, numEnd) {
+ if (opts && opts.type === 'Range') {
+ var num = Number(
+ numEnd !== undefined && numEnd !== value.length
+ ? value.substr(0, numEnd)
+ : value
+ );
+
+ if (isNaN(num)) {
+ return true;
+ }
+
+ if (opts.min !== null && num < opts.min) {
+ return true;
+ }
+
+ if (opts.max !== null && num > opts.max) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function consumeFunction(token, getNextToken) {
+ var startIdx = token.index;
+ var length = 0;
+
+ // balanced token consuming
+ do {
+ length++;
+
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+ }
+
+ // TODO: implement
+ // can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed
+ // https://drafts.csswg.org/css-values/#calc-notation
+ function calc(next) {
+ return function(token, getNextToken, opts) {
+ if (token === null) {
+ return 0;
+ }
+
+ if (token.type === TYPE$5.Function && eqStrAny(token.value, calcFunctionNames)) {
+ return consumeFunction(token, getNextToken);
+ }
+
+ return next(token, getNextToken, opts);
+ };
+ }
+
+ function tokenType(expectedTokenType) {
+ return function(token) {
+ if (token === null || token.type !== expectedTokenType) {
+ return 0;
+ }
+
+ return 1;
+ };
+ }
+
+ function func(name) {
+ name = name + '(';
+
+ return function(token, getNextToken) {
+ if (token !== null && eqStr(token.value, name)) {
+ return consumeFunction(token, getNextToken);
+ }
+
+ return 0;
+ };
+ }
+
+ // =========================
+ // Complex types
+ //
+
+ // https://drafts.csswg.org/css-values-4/#custom-idents
+ // 4.2. Author-defined Identifiers: the <custom-ident> type
+ // Some properties accept arbitrary author-defined identifiers as a component value.
+ // This generic data type is denoted by <custom-ident>, and represents any valid CSS identifier
+ // that would not be misinterpreted as a pre-defined keyword in that property’s value definition.
+ //
+ // See also: https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident
+ function customIdent(token) {
+ if (token === null || token.type !== TYPE$5.Ident) {
+ return 0;
+ }
+
+ var name = token.value.toLowerCase();
+
+ // The CSS-wide keywords are not valid <custom-ident>s
+ if (eqStrAny(name, cssWideKeywords)) {
+ return 0;
+ }
+
+ // The default keyword is reserved and is also not a valid <custom-ident>
+ if (eqStr(name, 'default')) {
+ return 0;
+ }
+
+ // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)
+ // Specifications using <custom-ident> must specify clearly what other keywords
+ // are excluded from <custom-ident>, if any—for example by saying that any pre-defined keywords
+ // in that property’s value definition are excluded. Excluded keywords are excluded
+ // in all ASCII case permutations.
+
+ return 1;
+ }
+
+ // https://drafts.csswg.org/css-variables/#typedef-custom-property-name
+ // A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo.
+ // The <custom-property-name> production corresponds to this: it’s defined as any valid identifier
+ // that starts with two dashes, except -- itself, which is reserved for future use by CSS.
+ // NOTE: Current implementation treat `--` as a valid name since most (all?) major browsers treat it as valid.
+ function customPropertyName(token) {
+ // ... defined as any valid identifier
+ if (token === null || token.type !== TYPE$5.Ident) {
+ return 0;
+ }
+
+ // ... that starts with two dashes (U+002D HYPHEN-MINUS)
+ if (charCode(token.value, 0) !== 0x002D || charCode(token.value, 1) !== 0x002D) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ // https://drafts.csswg.org/css-color-4/#hex-notation
+ // The syntax of a <hex-color> is a <hash-token> token whose value consists of 3, 4, 6, or 8 hexadecimal digits.
+ // In other words, a hex color is written as a hash character, "#", followed by some number of digits 0-9 or
+ // letters a-f (the case of the letters doesn’t matter - #00ff00 is identical to #00FF00).
+ function hexColor(token) {
+ if (token === null || token.type !== TYPE$5.Hash) {
+ return 0;
+ }
+
+ var length = token.value.length;
+
+ // valid values (length): #rgb (4), #rgba (5), #rrggbb (7), #rrggbbaa (9)
+ if (length !== 4 && length !== 5 && length !== 7 && length !== 9) {
+ return 0;
+ }
+
+ for (var i = 1; i < length; i++) {
+ if (!isHexDigit$3(token.value.charCodeAt(i))) {
+ return 0;
+ }
+ }
+
+ return 1;
+ }
+
+ function idSelector(token) {
+ if (token === null || token.type !== TYPE$5.Hash) {
+ return 0;
+ }
+
+ if (!isIdentifierStart$2(charCode(token.value, 1), charCode(token.value, 2), charCode(token.value, 3))) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ // https://drafts.csswg.org/css-syntax/#any-value
+ // It represents the entirety of what a valid declaration can have as its value.
+ function declarationValue(token, getNextToken) {
+ if (!token) {
+ return 0;
+ }
+
+ var length = 0;
+ var level = 0;
+ var startIdx = token.index;
+
+ // The <declaration-value> production matches any sequence of one or more tokens,
+ // so long as the sequence ...
+ scan:
+ do {
+ switch (token.type) {
+ // ... does not contain <bad-string-token>, <bad-url-token>,
+ case TYPE$5.BadString:
+ case TYPE$5.BadUrl:
+ break scan;
+
+ // ... unmatched <)-token>, <]-token>, or <}-token>,
+ case TYPE$5.RightCurlyBracket:
+ case TYPE$5.RightParenthesis:
+ case TYPE$5.RightSquareBracket:
+ if (token.balance > token.index || token.balance < startIdx) {
+ break scan;
+ }
+
+ level--;
+ break;
+
+ // ... or top-level <semicolon-token> tokens
+ case TYPE$5.Semicolon:
+ if (level === 0) {
+ break scan;
+ }
+
+ break;
+
+ // ... or <delim-token> tokens with a value of "!"
+ case TYPE$5.Delim:
+ if (token.value === '!' && level === 0) {
+ break scan;
+ }
+
+ break;
+
+ case TYPE$5.Function:
+ case TYPE$5.LeftParenthesis:
+ case TYPE$5.LeftSquareBracket:
+ case TYPE$5.LeftCurlyBracket:
+ level++;
+ break;
+ }
+
+ length++;
+
+ // until balance closing
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+ }
+
+ // https://drafts.csswg.org/css-syntax/#any-value
+ // The <any-value> production is identical to <declaration-value>, but also
+ // allows top-level <semicolon-token> tokens and <delim-token> tokens
+ // with a value of "!". It represents the entirety of what valid CSS can be in any context.
+ function anyValue(token, getNextToken) {
+ if (!token) {
+ return 0;
+ }
+
+ var startIdx = token.index;
+ var length = 0;
+
+ // The <any-value> production matches any sequence of one or more tokens,
+ // so long as the sequence ...
+ scan:
+ do {
+ switch (token.type) {
+ // ... does not contain <bad-string-token>, <bad-url-token>,
+ case TYPE$5.BadString:
+ case TYPE$5.BadUrl:
+ break scan;
+
+ // ... unmatched <)-token>, <]-token>, or <}-token>,
+ case TYPE$5.RightCurlyBracket:
+ case TYPE$5.RightParenthesis:
+ case TYPE$5.RightSquareBracket:
+ if (token.balance > token.index || token.balance < startIdx) {
+ break scan;
+ }
+
+ break;
+ }
+
+ length++;
+
+ // until balance closing
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+ }
+
+ // =========================
+ // Dimensions
+ //
+
+ function dimension(type) {
+ return function(token, getNextToken, opts) {
+ if (token === null || token.type !== TYPE$5.Dimension) {
+ return 0;
+ }
+
+ var numberEnd = consumeNumber$2(token.value, 0);
+
+ // check unit
+ if (type !== null) {
+ // check for IE postfix hack, i.e. 123px\0 or 123px\9
+ var reverseSolidusOffset = token.value.indexOf('\\', numberEnd);
+ var unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset)
+ ? token.value.substr(numberEnd)
+ : token.value.substring(numberEnd, reverseSolidusOffset);
+
+ if (type.hasOwnProperty(unit.toLowerCase()) === false) {
+ return 0;
+ }
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, numberEnd)) {
+ return 0;
+ }
+
+ return 1;
+ };
+ }
+
+ // =========================
+ // Percentage
+ //
+
+ // §5.5. Percentages: the <percentage> type
+ // https://drafts.csswg.org/css-values-4/#percentages
+ function percentage(token, getNextToken, opts) {
+ // ... corresponds to the <percentage-token> production
+ if (token === null || token.type !== TYPE$5.Percentage) {
+ return 0;
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, token.value.length - 1)) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ // =========================
+ // Numeric
+ //
+
+ // https://drafts.csswg.org/css-values-4/#numbers
+ // The value <zero> represents a literal number with the value 0. Expressions that merely
+ // evaluate to a <number> with the value 0 (for example, calc(0)) do not match <zero>;
+ // only literal <number-token>s do.
+ function zero(next) {
+ if (typeof next !== 'function') {
+ next = function() {
+ return 0;
+ };
+ }
+
+ return function(token, getNextToken, opts) {
+ if (token !== null && token.type === TYPE$5.Number) {
+ if (Number(token.value) === 0) {
+ return 1;
+ }
+ }
+
+ return next(token, getNextToken, opts);
+ };
+ }
+
+ // § 5.3. Real Numbers: the <number> type
+ // https://drafts.csswg.org/css-values-4/#numbers
+ // Number values are denoted by <number>, and represent real numbers, possibly with a fractional component.
+ // ... It corresponds to the <number-token> production
+ function number(token, getNextToken, opts) {
+ if (token === null) {
+ return 0;
+ }
+
+ var numberEnd = consumeNumber$2(token.value, 0);
+ var isNumber = numberEnd === token.value.length;
+ if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) {
+ return 0;
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, numberEnd)) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ // §5.2. Integers: the <integer> type
+ // https://drafts.csswg.org/css-values-4/#integers
+ function integer(token, getNextToken, opts) {
+ // ... corresponds to a subset of the <number-token> production
+ if (token === null || token.type !== TYPE$5.Number) {
+ return 0;
+ }
+
+ // The first digit of an integer may be immediately preceded by `-` or `+` to indicate the integer’s sign.
+ var i = token.value.charCodeAt(0) === 0x002B || // U+002B PLUS SIGN (+)
+ token.value.charCodeAt(0) === 0x002D ? 1 : 0; // U+002D HYPHEN-MINUS (-)
+
+ // When written literally, an integer is one or more decimal digits 0 through 9 ...
+ for (; i < token.value.length; i++) {
+ if (!isDigit$3(token.value.charCodeAt(i))) {
+ return 0;
+ }
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, i)) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ var generic = {
+ // token types
+ 'ident-token': tokenType(TYPE$5.Ident),
+ 'function-token': tokenType(TYPE$5.Function),
+ 'at-keyword-token': tokenType(TYPE$5.AtKeyword),
+ 'hash-token': tokenType(TYPE$5.Hash),
+ 'string-token': tokenType(TYPE$5.String),
+ 'bad-string-token': tokenType(TYPE$5.BadString),
+ 'url-token': tokenType(TYPE$5.Url),
+ 'bad-url-token': tokenType(TYPE$5.BadUrl),
+ 'delim-token': tokenType(TYPE$5.Delim),
+ 'number-token': tokenType(TYPE$5.Number),
+ 'percentage-token': tokenType(TYPE$5.Percentage),
+ 'dimension-token': tokenType(TYPE$5.Dimension),
+ 'whitespace-token': tokenType(TYPE$5.WhiteSpace),
+ 'CDO-token': tokenType(TYPE$5.CDO),
+ 'CDC-token': tokenType(TYPE$5.CDC),
+ 'colon-token': tokenType(TYPE$5.Colon),
+ 'semicolon-token': tokenType(TYPE$5.Semicolon),
+ 'comma-token': tokenType(TYPE$5.Comma),
+ '[-token': tokenType(TYPE$5.LeftSquareBracket),
+ ']-token': tokenType(TYPE$5.RightSquareBracket),
+ '(-token': tokenType(TYPE$5.LeftParenthesis),
+ ')-token': tokenType(TYPE$5.RightParenthesis),
+ '{-token': tokenType(TYPE$5.LeftCurlyBracket),
+ '}-token': tokenType(TYPE$5.RightCurlyBracket),
+
+ // token type aliases
+ 'string': tokenType(TYPE$5.String),
+ 'ident': tokenType(TYPE$5.Ident),
+
+ // complex types
+ 'custom-ident': customIdent,
+ 'custom-property-name': customPropertyName,
+ 'hex-color': hexColor,
+ 'id-selector': idSelector, // element( <id-selector> )
+ 'an-plus-b': genericAnPlusB,
+ 'urange': genericUrange,
+ 'declaration-value': declarationValue,
+ 'any-value': anyValue,
+
+ // dimensions
+ 'dimension': calc(dimension(null)),
+ 'angle': calc(dimension(ANGLE)),
+ 'decibel': calc(dimension(DECIBEL)),
+ 'frequency': calc(dimension(FREQUENCY)),
+ 'flex': calc(dimension(FLEX)),
+ 'length': calc(zero(dimension(LENGTH))),
+ 'resolution': calc(dimension(RESOLUTION)),
+ 'semitones': calc(dimension(SEMITONES)),
+ 'time': calc(dimension(TIME)),
+
+ // percentage
+ 'percentage': calc(percentage),
+
+ // numeric
+ 'zero': zero(),
+ 'number': calc(number),
+ 'integer': calc(integer),
+
+ // old IE stuff
+ '-ms-legacy-expression': func('expression')
+ };
+
+ var _SyntaxError$1 = function SyntaxError(message, input, offset) {
+ var error = createCustomError('SyntaxError', message);
+
+ error.input = input;
+ error.offset = offset;
+ error.rawMessage = message;
+ error.message = error.rawMessage + '\n' +
+ ' ' + error.input + '\n' +
+ '--' + new Array((error.offset || error.input.length) + 1).join('-') + '^';
+
+ return error;
+ };
+
+ var TAB = 9;
+ var N$1 = 10;
+ var F = 12;
+ var R = 13;
+ var SPACE = 32;
+
+ var Tokenizer = function(str) {
+ this.str = str;
+ this.pos = 0;
+ };
+
+ Tokenizer.prototype = {
+ charCodeAt: function(pos) {
+ return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
+ },
+ charCode: function() {
+ return this.charCodeAt(this.pos);
+ },
+ nextCharCode: function() {
+ return this.charCodeAt(this.pos + 1);
+ },
+ nextNonWsCode: function(pos) {
+ return this.charCodeAt(this.findWsEnd(pos));
+ },
+ findWsEnd: function(pos) {
+ for (; pos < this.str.length; pos++) {
+ var code = this.str.charCodeAt(pos);
+ if (code !== R && code !== N$1 && code !== F && code !== SPACE && code !== TAB) {
+ break;
+ }
+ }
+
+ return pos;
+ },
+ substringToPos: function(end) {
+ return this.str.substring(this.pos, this.pos = end);
+ },
+ eat: function(code) {
+ if (this.charCode() !== code) {
+ this.error('Expect `' + String.fromCharCode(code) + '`');
+ }
+
+ this.pos++;
+ },
+ peek: function() {
+ return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';
+ },
+ error: function(message) {
+ throw new _SyntaxError$1(message, this.str, this.pos);
+ }
+ };
+
+ var tokenizer$1 = Tokenizer;
+
+ var TAB$1 = 9;
+ var N$2 = 10;
+ var F$1 = 12;
+ var R$1 = 13;
+ var SPACE$1 = 32;
+ var EXCLAMATIONMARK = 33; // !
+ var NUMBERSIGN = 35; // #
+ var AMPERSAND = 38; // &
+ var APOSTROPHE = 39; // '
+ var LEFTPARENTHESIS = 40; // (
+ var RIGHTPARENTHESIS = 41; // )
+ var ASTERISK = 42; // *
+ var PLUSSIGN$2 = 43; // +
+ var COMMA = 44; // ,
+ var HYPERMINUS = 45; // -
+ var LESSTHANSIGN = 60; // <
+ var GREATERTHANSIGN = 62; // >
+ var QUESTIONMARK$1 = 63; // ?
+ var COMMERCIALAT = 64; // @
+ var LEFTSQUAREBRACKET = 91; // [
+ var RIGHTSQUAREBRACKET = 93; // ]
+ var LEFTCURLYBRACKET = 123; // {
+ var VERTICALLINE = 124; // |
+ var RIGHTCURLYBRACKET = 125; // }
+ var INFINITY = 8734; // ∞
+ var NAME_CHAR = createCharMap(function(ch) {
+ return /[a-zA-Z0-9\-]/.test(ch);
+ });
+ var COMBINATOR_PRECEDENCE = {
+ ' ': 1,
+ '&&': 2,
+ '||': 3,
+ '|': 4
+ };
+
+ function createCharMap(fn) {
+ var array = typeof Uint32Array === 'function' ? new Uint32Array(128) : new Array(128);
+ for (var i = 0; i < 128; i++) {
+ array[i] = fn(String.fromCharCode(i)) ? 1 : 0;
+ }
+ return array;
+ }
+
+ function scanSpaces(tokenizer) {
+ return tokenizer.substringToPos(
+ tokenizer.findWsEnd(tokenizer.pos)
+ );
+ }
+
+ function scanWord(tokenizer) {
+ var end = tokenizer.pos;
+
+ for (; end < tokenizer.str.length; end++) {
+ var code = tokenizer.str.charCodeAt(end);
+ if (code >= 128 || NAME_CHAR[code] === 0) {
+ break;
+ }
+ }
+
+ if (tokenizer.pos === end) {
+ tokenizer.error('Expect a keyword');
+ }
+
+ return tokenizer.substringToPos(end);
+ }
+
+ function scanNumber(tokenizer) {
+ var end = tokenizer.pos;
+
+ for (; end < tokenizer.str.length; end++) {
+ var code = tokenizer.str.charCodeAt(end);
+ if (code < 48 || code > 57) {
+ break;
+ }
+ }
+
+ if (tokenizer.pos === end) {
+ tokenizer.error('Expect a number');
+ }
+
+ return tokenizer.substringToPos(end);
+ }
+
+ function scanString(tokenizer) {
+ var end = tokenizer.str.indexOf('\'', tokenizer.pos + 1);
+
+ if (end === -1) {
+ tokenizer.pos = tokenizer.str.length;
+ tokenizer.error('Expect an apostrophe');
+ }
+
+ return tokenizer.substringToPos(end + 1);
+ }
+
+ function readMultiplierRange(tokenizer) {
+ var min = null;
+ var max = null;
+
+ tokenizer.eat(LEFTCURLYBRACKET);
+
+ min = scanNumber(tokenizer);
+
+ if (tokenizer.charCode() === COMMA) {
+ tokenizer.pos++;
+ if (tokenizer.charCode() !== RIGHTCURLYBRACKET) {
+ max = scanNumber(tokenizer);
+ }
+ } else {
+ max = min;
+ }
+
+ tokenizer.eat(RIGHTCURLYBRACKET);
+
+ return {
+ min: Number(min),
+ max: max ? Number(max) : 0
+ };
+ }
+
+ function readMultiplier(tokenizer) {
+ var range = null;
+ var comma = false;
+
+ switch (tokenizer.charCode()) {
+ case ASTERISK:
+ tokenizer.pos++;
+
+ range = {
+ min: 0,
+ max: 0
+ };
+
+ break;
+
+ case PLUSSIGN$2:
+ tokenizer.pos++;
+
+ range = {
+ min: 1,
+ max: 0
+ };
+
+ break;
+
+ case QUESTIONMARK$1:
+ tokenizer.pos++;
+
+ range = {
+ min: 0,
+ max: 1
+ };
+
+ break;
+
+ case NUMBERSIGN:
+ tokenizer.pos++;
+
+ comma = true;
+
+ if (tokenizer.charCode() === LEFTCURLYBRACKET) {
+ range = readMultiplierRange(tokenizer);
+ } else {
+ range = {
+ min: 1,
+ max: 0
+ };
+ }
+
+ break;
+
+ case LEFTCURLYBRACKET:
+ range = readMultiplierRange(tokenizer);
+ break;
+
+ default:
+ return null;
+ }
+
+ return {
+ type: 'Multiplier',
+ comma: comma,
+ min: range.min,
+ max: range.max,
+ term: null
+ };
+ }
+
+ function maybeMultiplied(tokenizer, node) {
+ var multiplier = readMultiplier(tokenizer);
+
+ if (multiplier !== null) {
+ multiplier.term = node;
+ return multiplier;
+ }
+
+ return node;
+ }
+
+ function maybeToken(tokenizer) {
+ var ch = tokenizer.peek();
+
+ if (ch === '') {
+ return null;
+ }
+
+ return {
+ type: 'Token',
+ value: ch
+ };
+ }
+
+ function readProperty(tokenizer) {
+ var name;
+
+ tokenizer.eat(LESSTHANSIGN);
+ tokenizer.eat(APOSTROPHE);
+
+ name = scanWord(tokenizer);
+
+ tokenizer.eat(APOSTROPHE);
+ tokenizer.eat(GREATERTHANSIGN);
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Property',
+ name: name
+ });
+ }
+
+ // https://drafts.csswg.org/css-values-3/#numeric-ranges
+ // 4.1. Range Restrictions and Range Definition Notation
+ //
+ // Range restrictions can be annotated in the numeric type notation using CSS bracketed
+ // range notation—[min,max]—within the angle brackets, after the identifying keyword,
+ // indicating a closed range between (and including) min and max.
+ // For example, <integer [0, 10]> indicates an integer between 0 and 10, inclusive.
+ function readTypeRange(tokenizer) {
+ // use null for Infinity to make AST format JSON serializable/deserializable
+ var min = null; // -Infinity
+ var max = null; // Infinity
+ var sign = 1;
+
+ tokenizer.eat(LEFTSQUAREBRACKET);
+
+ if (tokenizer.charCode() === HYPERMINUS) {
+ tokenizer.peek();
+ sign = -1;
+ }
+
+ if (sign == -1 && tokenizer.charCode() === INFINITY) {
+ tokenizer.peek();
+ } else {
+ min = sign * Number(scanNumber(tokenizer));
+ }
+
+ scanSpaces(tokenizer);
+ tokenizer.eat(COMMA);
+ scanSpaces(tokenizer);
+
+ if (tokenizer.charCode() === INFINITY) {
+ tokenizer.peek();
+ } else {
+ sign = 1;
+
+ if (tokenizer.charCode() === HYPERMINUS) {
+ tokenizer.peek();
+ sign = -1;
+ }
+
+ max = sign * Number(scanNumber(tokenizer));
+ }
+
+ tokenizer.eat(RIGHTSQUAREBRACKET);
+
+ // If no range is indicated, either by using the bracketed range notation
+ // or in the property description, then [−∞,∞] is assumed.
+ if (min === null && max === null) {
+ return null;
+ }
+
+ return {
+ type: 'Range',
+ min: min,
+ max: max
+ };
+ }
+
+ function readType(tokenizer) {
+ var name;
+ var opts = null;
+
+ tokenizer.eat(LESSTHANSIGN);
+ name = scanWord(tokenizer);
+
+ if (tokenizer.charCode() === LEFTPARENTHESIS &&
+ tokenizer.nextCharCode() === RIGHTPARENTHESIS) {
+ tokenizer.pos += 2;
+ name += '()';
+ }
+
+ if (tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos)) === LEFTSQUAREBRACKET) {
+ scanSpaces(tokenizer);
+ opts = readTypeRange(tokenizer);
+ }
+
+ tokenizer.eat(GREATERTHANSIGN);
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Type',
+ name: name,
+ opts: opts
+ });
+ }
+
+ function readKeywordOrFunction(tokenizer) {
+ var name;
+
+ name = scanWord(tokenizer);
+
+ if (tokenizer.charCode() === LEFTPARENTHESIS) {
+ tokenizer.pos++;
+
+ return {
+ type: 'Function',
+ name: name
+ };
+ }
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Keyword',
+ name: name
+ });
+ }
+
+ function regroupTerms(terms, combinators) {
+ function createGroup(terms, combinator) {
+ return {
+ type: 'Group',
+ terms: terms,
+ combinator: combinator,
+ disallowEmpty: false,
+ explicit: false
+ };
+ }
+
+ combinators = Object.keys(combinators).sort(function(a, b) {
+ return COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b];
+ });
+
+ while (combinators.length > 0) {
+ var combinator = combinators.shift();
+ for (var i = 0, subgroupStart = 0; i < terms.length; i++) {
+ var term = terms[i];
+ if (term.type === 'Combinator') {
+ if (term.value === combinator) {
+ if (subgroupStart === -1) {
+ subgroupStart = i - 1;
+ }
+ terms.splice(i, 1);
+ i--;
+ } else {
+ if (subgroupStart !== -1 && i - subgroupStart > 1) {
+ terms.splice(
+ subgroupStart,
+ i - subgroupStart,
+ createGroup(terms.slice(subgroupStart, i), combinator)
+ );
+ i = subgroupStart + 1;
+ }
+ subgroupStart = -1;
+ }
+ }
+ }
+
+ if (subgroupStart !== -1 && combinators.length) {
+ terms.splice(
+ subgroupStart,
+ i - subgroupStart,
+ createGroup(terms.slice(subgroupStart, i), combinator)
+ );
+ }
+ }
+
+ return combinator;
+ }
+
+ function readImplicitGroup(tokenizer) {
+ var terms = [];
+ var combinators = {};
+ var token;
+ var prevToken = null;
+ var prevTokenPos = tokenizer.pos;
+
+ while (token = peek(tokenizer)) {
+ if (token.type !== 'Spaces') {
+ if (token.type === 'Combinator') {
+ // check for combinator in group beginning and double combinator sequence
+ if (prevToken === null || prevToken.type === 'Combinator') {
+ tokenizer.pos = prevTokenPos;
+ tokenizer.error('Unexpected combinator');
+ }
+
+ combinators[token.value] = true;
+ } else if (prevToken !== null && prevToken.type !== 'Combinator') {
+ combinators[' '] = true; // a b
+ terms.push({
+ type: 'Combinator',
+ value: ' '
+ });
+ }
+
+ terms.push(token);
+ prevToken = token;
+ prevTokenPos = tokenizer.pos;
+ }
+ }
+
+ // check for combinator in group ending
+ if (prevToken !== null && prevToken.type === 'Combinator') {
+ tokenizer.pos -= prevTokenPos;
+ tokenizer.error('Unexpected combinator');
+ }
+
+ return {
+ type: 'Group',
+ terms: terms,
+ combinator: regroupTerms(terms, combinators) || ' ',
+ disallowEmpty: false,
+ explicit: false
+ };
+ }
+
+ function readGroup(tokenizer) {
+ var result;
+
+ tokenizer.eat(LEFTSQUAREBRACKET);
+ result = readImplicitGroup(tokenizer);
+ tokenizer.eat(RIGHTSQUAREBRACKET);
+
+ result.explicit = true;
+
+ if (tokenizer.charCode() === EXCLAMATIONMARK) {
+ tokenizer.pos++;
+ result.disallowEmpty = true;
+ }
+
+ return result;
+ }
+
+ function peek(tokenizer) {
+ var code = tokenizer.charCode();
+
+ if (code < 128 && NAME_CHAR[code] === 1) {
+ return readKeywordOrFunction(tokenizer);
+ }
+
+ switch (code) {
+ case RIGHTSQUAREBRACKET:
+ // don't eat, stop scan a group
+ break;
+
+ case LEFTSQUAREBRACKET:
+ return maybeMultiplied(tokenizer, readGroup(tokenizer));
+
+ case LESSTHANSIGN:
+ return tokenizer.nextCharCode() === APOSTROPHE
+ ? readProperty(tokenizer)
+ : readType(tokenizer);
+
+ case VERTICALLINE:
+ return {
+ type: 'Combinator',
+ value: tokenizer.substringToPos(
+ tokenizer.nextCharCode() === VERTICALLINE
+ ? tokenizer.pos + 2
+ : tokenizer.pos + 1
+ )
+ };
+
+ case AMPERSAND:
+ tokenizer.pos++;
+ tokenizer.eat(AMPERSAND);
+
+ return {
+ type: 'Combinator',
+ value: '&&'
+ };
+
+ case COMMA:
+ tokenizer.pos++;
+ return {
+ type: 'Comma'
+ };
+
+ case APOSTROPHE:
+ return maybeMultiplied(tokenizer, {
+ type: 'String',
+ value: scanString(tokenizer)
+ });
+
+ case SPACE$1:
+ case TAB$1:
+ case N$2:
+ case R$1:
+ case F$1:
+ return {
+ type: 'Spaces',
+ value: scanSpaces(tokenizer)
+ };
+
+ case COMMERCIALAT:
+ code = tokenizer.nextCharCode();
+
+ if (code < 128 && NAME_CHAR[code] === 1) {
+ tokenizer.pos++;
+ return {
+ type: 'AtKeyword',
+ name: scanWord(tokenizer)
+ };
+ }
+
+ return maybeToken(tokenizer);
+
+ case ASTERISK:
+ case PLUSSIGN$2:
+ case QUESTIONMARK$1:
+ case NUMBERSIGN:
+ case EXCLAMATIONMARK:
+ // prohibited tokens (used as a multiplier start)
+ break;
+
+ case LEFTCURLYBRACKET:
+ // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting
+ // check next char isn't a number, because it's likely a disjoined multiplier
+ code = tokenizer.nextCharCode();
+
+ if (code < 48 || code > 57) {
+ return maybeToken(tokenizer);
+ }
+
+ break;
+
+ default:
+ return maybeToken(tokenizer);
+ }
+ }
+
+ function parse(source) {
+ var tokenizer = new tokenizer$1(source);
+ var result = readImplicitGroup(tokenizer);
+
+ if (tokenizer.pos !== source.length) {
+ tokenizer.error('Unexpected input');
+ }
+
+ // reduce redundant groups with single group term
+ if (result.terms.length === 1 && result.terms[0].type === 'Group') {
+ result = result.terms[0];
+ }
+
+ return result;
+ }
+
+ // warm up parse to elimitate code branches that never execute
+ // fix soft deoptimizations (insufficient type feedback)
+ parse('[a&&<b>#|<\'c\'>*||e() f{2} /,(% g#{1,2} h{2,})]!');
+
+ var parse_1 = parse;
+
+ var noop$1 = function() {};
+
+ function ensureFunction(value) {
+ return typeof value === 'function' ? value : noop$1;
+ }
+
+ var walk = function(node, options, context) {
+ function walk(node) {
+ enter.call(context, node);
+
+ switch (node.type) {
+ case 'Group':
+ node.terms.forEach(walk);
+ break;
+
+ case 'Multiplier':
+ walk(node.term);
+ break;
+
+ case 'Type':
+ case 'Property':
+ case 'Keyword':
+ case 'AtKeyword':
+ case 'Function':
+ case 'String':
+ case 'Token':
+ case 'Comma':
+ break;
+
+ default:
+ throw new Error('Unknown type: ' + node.type);
+ }
+
+ leave.call(context, node);
+ }
+
+ var enter = noop$1;
+ var leave = noop$1;
+
+ if (typeof options === 'function') {
+ enter = options;
+ } else if (options) {
+ enter = ensureFunction(options.enter);
+ leave = ensureFunction(options.leave);
+ }
+
+ if (enter === noop$1 && leave === noop$1) {
+ throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+ }
+
+ walk(node);
+ };
+
+ var tokenStream = new TokenStream_1();
+ var astToTokens = {
+ decorator: function(handlers) {
+ var curNode = null;
+ var prev = { len: 0, node: null };
+ var nodes = [prev];
+ var buffer = '';
+
+ return {
+ children: handlers.children,
+ node: function(node) {
+ var tmp = curNode;
+ curNode = node;
+ handlers.node.call(this, node);
+ curNode = tmp;
+ },
+ chunk: function(chunk) {
+ buffer += chunk;
+ if (prev.node !== curNode) {
+ nodes.push({
+ len: chunk.length,
+ node: curNode
+ });
+ } else {
+ prev.len += chunk.length;
+ }
+ },
+ result: function() {
+ return prepareTokens(buffer, nodes);
+ }
+ };
+ }
+ };
+
+ function prepareTokens(str, nodes) {
+ var tokens = [];
+ var nodesOffset = 0;
+ var nodesIndex = 0;
+ var currentNode = nodes ? nodes[nodesIndex].node : null;
+
+ tokenizer(str, tokenStream);
+
+ while (!tokenStream.eof) {
+ if (nodes) {
+ while (nodesIndex < nodes.length && nodesOffset + nodes[nodesIndex].len <= tokenStream.tokenStart) {
+ nodesOffset += nodes[nodesIndex++].len;
+ currentNode = nodes[nodesIndex].node;
+ }
+ }
+
+ tokens.push({
+ type: tokenStream.tokenType,
+ value: tokenStream.getTokenValue(),
+ index: tokenStream.tokenIndex, // TODO: remove it, temporary solution
+ balance: tokenStream.balance[tokenStream.tokenIndex], // TODO: remove it, temporary solution
+ node: currentNode
+ });
+ tokenStream.next();
+ // console.log({ ...tokens[tokens.length - 1], node: undefined });
+ }
+
+ return tokens;
+ }
+
+ var prepareTokens_1 = function(value, syntax) {
+ if (typeof value === 'string') {
+ return prepareTokens(value, null);
+ }
+
+ return syntax.generate(value, astToTokens);
+ };
+
+ var MATCH = { type: 'Match' };
+ var MISMATCH = { type: 'Mismatch' };
+ var DISALLOW_EMPTY = { type: 'DisallowEmpty' };
+ var LEFTPARENTHESIS$1 = 40; // (
+ var RIGHTPARENTHESIS$1 = 41; // )
+
+ function createCondition(match, thenBranch, elseBranch) {
+ // reduce node count
+ if (thenBranch === MATCH && elseBranch === MISMATCH) {
+ return match;
+ }
+
+ if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {
+ return match;
+ }
+
+ if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {
+ thenBranch = match.then;
+ match = match.match;
+ }
+
+ return {
+ type: 'If',
+ match: match,
+ then: thenBranch,
+ else: elseBranch
+ };
+ }
+
+ function isFunctionType(name) {
+ return (
+ name.length > 2 &&
+ name.charCodeAt(name.length - 2) === LEFTPARENTHESIS$1 &&
+ name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS$1
+ );
+ }
+
+ function isEnumCapatible(term) {
+ return (
+ term.type === 'Keyword' ||
+ term.type === 'AtKeyword' ||
+ term.type === 'Function' ||
+ term.type === 'Type' && isFunctionType(term.name)
+ );
+ }
+
+ function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {
+ switch (combinator) {
+ case ' ':
+ // Juxtaposing components means that all of them must occur, in the given order.
+ //
+ // a b c
+ // =
+ // match a
+ // then match b
+ // then match c
+ // then MATCH
+ // else MISMATCH
+ // else MISMATCH
+ // else MISMATCH
+ var result = MATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+
+ result = createCondition(
+ term,
+ result,
+ MISMATCH
+ );
+ }
+ return result;
+
+ case '|':
+ // A bar (|) separates two or more alternatives: exactly one of them must occur.
+ //
+ // a | b | c
+ // =
+ // match a
+ // then MATCH
+ // else match b
+ // then MATCH
+ // else match c
+ // then MATCH
+ // else MISMATCH
+
+ var result = MISMATCH;
+ var map = null;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+
+ // reduce sequence of keywords into a Enum
+ if (isEnumCapatible(term)) {
+ if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {
+ map = Object.create(null);
+ result = createCondition(
+ {
+ type: 'Enum',
+ map: map
+ },
+ MATCH,
+ result
+ );
+ }
+
+ if (map !== null) {
+ var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();
+ if (key in map === false) {
+ map[key] = term;
+ continue;
+ }
+ }
+ }
+
+ map = null;
+
+ // create a new conditonal node
+ result = createCondition(
+ term,
+ MATCH,
+ result
+ );
+ }
+ return result;
+
+ case '&&':
+ // A double ampersand (&&) separates two or more components,
+ // all of which must occur, in any order.
+
+ // Use MatchOnce for groups with a large number of terms,
+ // since &&-groups produces at least N!-node trees
+ if (terms.length > 5) {
+ return {
+ type: 'MatchOnce',
+ terms: terms,
+ all: true
+ };
+ }
+
+ // Use a combination tree for groups with small number of terms
+ //
+ // a && b && c
+ // =
+ // match a
+ // then [b && c]
+ // else match b
+ // then [a && c]
+ // else match c
+ // then [a && b]
+ // else MISMATCH
+ //
+ // a && b
+ // =
+ // match a
+ // then match b
+ // then MATCH
+ // else MISMATCH
+ // else match b
+ // then match a
+ // then MATCH
+ // else MISMATCH
+ // else MISMATCH
+ var result = MISMATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+ var thenClause;
+
+ if (terms.length > 1) {
+ thenClause = buildGroupMatchGraph(
+ combinator,
+ terms.filter(function(newGroupTerm) {
+ return newGroupTerm !== term;
+ }),
+ false
+ );
+ } else {
+ thenClause = MATCH;
+ }
+
+ result = createCondition(
+ term,
+ thenClause,
+ result
+ );
+ }
+ return result;
+
+ case '||':
+ // A double bar (||) separates two or more options:
+ // one or more of them must occur, in any order.
+
+ // Use MatchOnce for groups with a large number of terms,
+ // since ||-groups produces at least N!-node trees
+ if (terms.length > 5) {
+ return {
+ type: 'MatchOnce',
+ terms: terms,
+ all: false
+ };
+ }
+
+ // Use a combination tree for groups with small number of terms
+ //
+ // a || b || c
+ // =
+ // match a
+ // then [b || c]
+ // else match b
+ // then [a || c]
+ // else match c
+ // then [a || b]
+ // else MISMATCH
+ //
+ // a || b
+ // =
+ // match a
+ // then match b
+ // then MATCH
+ // else MATCH
+ // else match b
+ // then match a
+ // then MATCH
+ // else MATCH
+ // else MISMATCH
+ var result = atLeastOneTermMatched ? MATCH : MISMATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+ var thenClause;
+
+ if (terms.length > 1) {
+ thenClause = buildGroupMatchGraph(
+ combinator,
+ terms.filter(function(newGroupTerm) {
+ return newGroupTerm !== term;
+ }),
+ true
+ );
+ } else {
+ thenClause = MATCH;
+ }
+
+ result = createCondition(
+ term,
+ thenClause,
+ result
+ );
+ }
+ return result;
+ }
+ }
+
+ function buildMultiplierMatchGraph(node) {
+ var result = MATCH;
+ var matchTerm = buildMatchGraph(node.term);
+
+ if (node.max === 0) {
+ // disable repeating of empty match to prevent infinite loop
+ matchTerm = createCondition(
+ matchTerm,
+ DISALLOW_EMPTY,
+ MISMATCH
+ );
+
+ // an occurrence count is not limited, make a cycle;
+ // to collect more terms on each following matching mismatch
+ result = createCondition(
+ matchTerm,
+ null, // will be a loop
+ MISMATCH
+ );
+
+ result.then = createCondition(
+ MATCH,
+ MATCH,
+ result // make a loop
+ );
+
+ if (node.comma) {
+ result.then.else = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+ } else {
+ // create a match node chain for [min .. max] interval with optional matches
+ for (var i = node.min || 1; i <= node.max; i++) {
+ if (node.comma && result !== MATCH) {
+ result = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+
+ result = createCondition(
+ matchTerm,
+ createCondition(
+ MATCH,
+ MATCH,
+ result
+ ),
+ MISMATCH
+ );
+ }
+ }
+
+ if (node.min === 0) {
+ // allow zero match
+ result = createCondition(
+ MATCH,
+ MATCH,
+ result
+ );
+ } else {
+ // create a match node chain to collect [0 ... min - 1] required matches
+ for (var i = 0; i < node.min - 1; i++) {
+ if (node.comma && result !== MATCH) {
+ result = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+
+ result = createCondition(
+ matchTerm,
+ result,
+ MISMATCH
+ );
+ }
+ }
+
+ return result;
+ }
+
+ function buildMatchGraph(node) {
+ if (typeof node === 'function') {
+ return {
+ type: 'Generic',
+ fn: node
+ };
+ }
+
+ switch (node.type) {
+ case 'Group':
+ var result = buildGroupMatchGraph(
+ node.combinator,
+ node.terms.map(buildMatchGraph),
+ false
+ );
+
+ if (node.disallowEmpty) {
+ result = createCondition(
+ result,
+ DISALLOW_EMPTY,
+ MISMATCH
+ );
+ }
+
+ return result;
+
+ case 'Multiplier':
+ return buildMultiplierMatchGraph(node);
+
+ case 'Type':
+ case 'Property':
+ return {
+ type: node.type,
+ name: node.name,
+ syntax: node
+ };
+
+ case 'Keyword':
+ return {
+ type: node.type,
+ name: node.name.toLowerCase(),
+ syntax: node
+ };
+
+ case 'AtKeyword':
+ return {
+ type: node.type,
+ name: '@' + node.name.toLowerCase(),
+ syntax: node
+ };
+
+ case 'Function':
+ return {
+ type: node.type,
+ name: node.name.toLowerCase() + '(',
+ syntax: node
+ };
+
+ case 'String':
+ // convert a one char length String to a Token
+ if (node.value.length === 3) {
+ return {
+ type: 'Token',
+ value: node.value.charAt(1),
+ syntax: node
+ };
+ }
+
+ // otherwise use it as is
+ return {
+ type: node.type,
+ value: node.value.substr(1, node.value.length - 2).replace(/\\'/g, '\''),
+ syntax: node
+ };
+
+ case 'Token':
+ return {
+ type: node.type,
+ value: node.value,
+ syntax: node
+ };
+
+ case 'Comma':
+ return {
+ type: node.type,
+ syntax: node
+ };
+
+ default:
+ throw new Error('Unknown node type:', node.type);
+ }
+ }
+
+ var matchGraph = {
+ MATCH: MATCH,
+ MISMATCH: MISMATCH,
+ DISALLOW_EMPTY: DISALLOW_EMPTY,
+ buildMatchGraph: function(syntaxTree, ref) {
+ if (typeof syntaxTree === 'string') {
+ syntaxTree = parse_1(syntaxTree);
+ }
+
+ return {
+ type: 'MatchGraph',
+ match: buildMatchGraph(syntaxTree),
+ syntax: ref || null,
+ source: syntaxTree
+ };
+ }
+ };
+
+ var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+ var MATCH$1 = matchGraph.MATCH;
+ var MISMATCH$1 = matchGraph.MISMATCH;
+ var DISALLOW_EMPTY$1 = matchGraph.DISALLOW_EMPTY;
+ var TYPE$6 = _const.TYPE;
+
+ var STUB = 0;
+ var TOKEN = 1;
+ var OPEN_SYNTAX = 2;
+ var CLOSE_SYNTAX = 3;
+
+ var EXIT_REASON_MATCH = 'Match';
+ var EXIT_REASON_MISMATCH = 'Mismatch';
+ var EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';
+
+ var ITERATION_LIMIT = 15000;
+ var totalIterationCount = 0;
+
+ function reverseList(list) {
+ var prev = null;
+ var next = null;
+ var item = list;
+
+ while (item !== null) {
+ next = item.prev;
+ item.prev = prev;
+ prev = item;
+ item = next;
+ }
+
+ return prev;
+ }
+
+ function areStringsEqualCaseInsensitive(testStr, referenceStr) {
+ if (testStr.length !== referenceStr.length) {
+ return false;
+ }
+
+ for (var i = 0; i < testStr.length; i++) {
+ var testCode = testStr.charCodeAt(i);
+ var referenceCode = referenceStr.charCodeAt(i);
+
+ // testCode.toLowerCase() for U+0041 LATIN CAPITAL LETTER A (A) .. U+005A LATIN CAPITAL LETTER Z (Z).
+ if (testCode >= 0x0041 && testCode <= 0x005A) {
+ testCode = testCode | 32;
+ }
+
+ if (testCode !== referenceCode) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function isContextEdgeDelim(token) {
+ if (token.type !== TYPE$6.Delim) {
+ return false;
+ }
+
+ // Fix matching for unicode-range: U+30??, U+FF00-FF9F
+ // Probably we need to check out previous match instead
+ return token.value !== '?';
+ }
+
+ function isCommaContextStart(token) {
+ if (token === null) {
+ return true;
+ }
+
+ return (
+ token.type === TYPE$6.Comma ||
+ token.type === TYPE$6.Function ||
+ token.type === TYPE$6.LeftParenthesis ||
+ token.type === TYPE$6.LeftSquareBracket ||
+ token.type === TYPE$6.LeftCurlyBracket ||
+ isContextEdgeDelim(token)
+ );
+ }
+
+ function isCommaContextEnd(token) {
+ if (token === null) {
+ return true;
+ }
+
+ return (
+ token.type === TYPE$6.RightParenthesis ||
+ token.type === TYPE$6.RightSquareBracket ||
+ token.type === TYPE$6.RightCurlyBracket ||
+ token.type === TYPE$6.Delim
+ );
+ }
+
+ function internalMatch(tokens, state, syntaxes) {
+ function moveToNextToken() {
+ do {
+ tokenIndex++;
+ token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
+ } while (token !== null && (token.type === TYPE$6.WhiteSpace || token.type === TYPE$6.Comment));
+ }
+
+ function getNextToken(offset) {
+ var nextIndex = tokenIndex + offset;
+
+ return nextIndex < tokens.length ? tokens[nextIndex] : null;
+ }
+
+ function stateSnapshotFromSyntax(nextState, prev) {
+ return {
+ nextState: nextState,
+ matchStack: matchStack,
+ syntaxStack: syntaxStack,
+ thenStack: thenStack,
+ tokenIndex: tokenIndex,
+ prev: prev
+ };
+ }
+
+ function pushThenStack(nextState) {
+ thenStack = {
+ nextState: nextState,
+ matchStack: matchStack,
+ syntaxStack: syntaxStack,
+ prev: thenStack
+ };
+ }
+
+ function pushElseStack(nextState) {
+ elseStack = stateSnapshotFromSyntax(nextState, elseStack);
+ }
+
+ function addTokenToMatch() {
+ matchStack = {
+ type: TOKEN,
+ syntax: state.syntax,
+ token: token,
+ prev: matchStack
+ };
+
+ moveToNextToken();
+ syntaxStash = null;
+
+ if (tokenIndex > longestMatch) {
+ longestMatch = tokenIndex;
+ }
+ }
+
+ function openSyntax() {
+ syntaxStack = {
+ syntax: state.syntax,
+ opts: state.syntax.opts || (syntaxStack !== null && syntaxStack.opts) || null,
+ prev: syntaxStack
+ };
+
+ matchStack = {
+ type: OPEN_SYNTAX,
+ syntax: state.syntax,
+ token: matchStack.token,
+ prev: matchStack
+ };
+ }
+
+ function closeSyntax() {
+ if (matchStack.type === OPEN_SYNTAX) {
+ matchStack = matchStack.prev;
+ } else {
+ matchStack = {
+ type: CLOSE_SYNTAX,
+ syntax: syntaxStack.syntax,
+ token: matchStack.token,
+ prev: matchStack
+ };
+ }
+
+ syntaxStack = syntaxStack.prev;
+ }
+
+ var syntaxStack = null;
+ var thenStack = null;
+ var elseStack = null;
+
+ // null – stashing allowed, nothing stashed
+ // false – stashing disabled, nothing stashed
+ // anithing else – fail stashable syntaxes, some syntax stashed
+ var syntaxStash = null;
+
+ var iterationCount = 0; // count iterations and prevent infinite loop
+ var exitReason = null;
+
+ var token = null;
+ var tokenIndex = -1;
+ var longestMatch = 0;
+ var matchStack = {
+ type: STUB,
+ syntax: null,
+ token: null,
+ prev: null
+ };
+
+ moveToNextToken();
+
+ while (exitReason === null && ++iterationCount < ITERATION_LIMIT) {
+ // function mapList(list, fn) {
+ // var result = [];
+ // while (list) {
+ // result.unshift(fn(list));
+ // list = list.prev;
+ // }
+ // return result;
+ // }
+ // console.log('--\n',
+ // '#' + iterationCount,
+ // require('util').inspect({
+ // match: mapList(matchStack, x => x.type === TOKEN ? x.token && x.token.value : x.syntax ? ({ [OPEN_SYNTAX]: '<', [CLOSE_SYNTAX]: '</' }[x.type] || x.type) + '!' + x.syntax.name : null),
+ // token: token && token.value,
+ // tokenIndex,
+ // syntax: syntax.type + (syntax.id ? ' #' + syntax.id : '')
+ // }, { depth: null })
+ // );
+ switch (state.type) {
+ case 'Match':
+ if (thenStack === null) {
+ // turn to MISMATCH when some tokens left unmatched
+ if (token !== null) {
+ // doesn't mismatch if just one token left and it's an IE hack
+ if (tokenIndex !== tokens.length - 1 || (token.value !== '\\0' && token.value !== '\\9')) {
+ state = MISMATCH$1;
+ break;
+ }
+ }
+
+ // break the main loop, return a result - MATCH
+ exitReason = EXIT_REASON_MATCH;
+ break;
+ }
+
+ // go to next syntax (`then` branch)
+ state = thenStack.nextState;
+
+ // check match is not empty
+ if (state === DISALLOW_EMPTY$1) {
+ if (thenStack.matchStack === matchStack) {
+ state = MISMATCH$1;
+ break;
+ } else {
+ state = MATCH$1;
+ }
+ }
+
+ // close syntax if needed
+ while (thenStack.syntaxStack !== syntaxStack) {
+ closeSyntax();
+ }
+
+ // pop stack
+ thenStack = thenStack.prev;
+ break;
+
+ case 'Mismatch':
+ // when some syntax is stashed
+ if (syntaxStash !== null && syntaxStash !== false) {
+ // there is no else branches or a branch reduce match stack
+ if (elseStack === null || tokenIndex > elseStack.tokenIndex) {
+ // restore state from the stash
+ elseStack = syntaxStash;
+ syntaxStash = false; // disable stashing
+ }
+ } else if (elseStack === null) {
+ // no else branches -> break the main loop
+ // return a result - MISMATCH
+ exitReason = EXIT_REASON_MISMATCH;
+ break;
+ }
+
+ // go to next syntax (`else` branch)
+ state = elseStack.nextState;
+
+ // restore all the rest stack states
+ thenStack = elseStack.thenStack;
+ syntaxStack = elseStack.syntaxStack;
+ matchStack = elseStack.matchStack;
+ tokenIndex = elseStack.tokenIndex;
+ token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
+
+ // pop stack
+ elseStack = elseStack.prev;
+ break;
+
+ case 'MatchGraph':
+ state = state.match;
+ break;
+
+ case 'If':
+ // IMPORTANT: else stack push must go first,
+ // since it stores the state of thenStack before changes
+ if (state.else !== MISMATCH$1) {
+ pushElseStack(state.else);
+ }
+
+ if (state.then !== MATCH$1) {
+ pushThenStack(state.then);
+ }
+
+ state = state.match;
+ break;
+
+ case 'MatchOnce':
+ state = {
+ type: 'MatchOnceBuffer',
+ syntax: state,
+ index: 0,
+ mask: 0
+ };
+ break;
+
+ case 'MatchOnceBuffer':
+ var terms = state.syntax.terms;
+
+ if (state.index === terms.length) {
+ // no matches at all or it's required all terms to be matched
+ if (state.mask === 0 || state.syntax.all) {
+ state = MISMATCH$1;
+ break;
+ }
+
+ // a partial match is ok
+ state = MATCH$1;
+ break;
+ }
+
+ // all terms are matched
+ if (state.mask === (1 << terms.length) - 1) {
+ state = MATCH$1;
+ break;
+ }
+
+ for (; state.index < terms.length; state.index++) {
+ var matchFlag = 1 << state.index;
+
+ if ((state.mask & matchFlag) === 0) {
+ // IMPORTANT: else stack push must go first,
+ // since it stores the state of thenStack before changes
+ pushElseStack(state);
+ pushThenStack({
+ type: 'AddMatchOnce',
+ syntax: state.syntax,
+ mask: state.mask | matchFlag
+ });
+
+ // match
+ state = terms[state.index++];
+ break;
+ }
+ }
+ break;
+
+ case 'AddMatchOnce':
+ state = {
+ type: 'MatchOnceBuffer',
+ syntax: state.syntax,
+ index: 0,
+ mask: state.mask
+ };
+ break;
+
+ case 'Enum':
+ if (token !== null) {
+ var name = token.value.toLowerCase();
+
+ // drop \0 and \9 hack from keyword name
+ if (name.indexOf('\\') !== -1) {
+ name = name.replace(/\\[09].*$/, '');
+ }
+
+ if (hasOwnProperty$1.call(state.map, name)) {
+ state = state.map[name];
+ break;
+ }
+ }
+
+ state = MISMATCH$1;
+ break;
+
+ case 'Generic':
+ var opts = syntaxStack !== null ? syntaxStack.opts : null;
+ var lastTokenIndex = tokenIndex + Math.floor(state.fn(token, getNextToken, opts));
+
+ if (!isNaN(lastTokenIndex) && lastTokenIndex > tokenIndex) {
+ while (tokenIndex < lastTokenIndex) {
+ addTokenToMatch();
+ }
+
+ state = MATCH$1;
+ } else {
+ state = MISMATCH$1;
+ }
+
+ break;
+
+ case 'Type':
+ case 'Property':
+ var syntaxDict = state.type === 'Type' ? 'types' : 'properties';
+ var dictSyntax = hasOwnProperty$1.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null;
+
+ if (!dictSyntax || !dictSyntax.match) {
+ throw new Error(
+ 'Bad syntax reference: ' +
+ (state.type === 'Type'
+ ? '<' + state.name + '>'
+ : '<\'' + state.name + '\'>')
+ );
+ }
+
+ // stash a syntax for types with low priority
+ if (syntaxStash !== false && token !== null && state.type === 'Type') {
+ var lowPriorityMatching =
+ // https://drafts.csswg.org/css-values-4/#custom-idents
+ // When parsing positionally-ambiguous keywords in a property value, a <custom-ident> production
+ // can only claim the keyword if no other unfulfilled production can claim it.
+ (state.name === 'custom-ident' && token.type === TYPE$6.Ident) ||
+
+ // https://drafts.csswg.org/css-values-4/#lengths
+ // ... if a `0` could be parsed as either a <number> or a <length> in a property (such as line-height),
+ // it must parse as a <number>
+ (state.name === 'length' && token.value === '0');
+
+ if (lowPriorityMatching) {
+ if (syntaxStash === null) {
+ syntaxStash = stateSnapshotFromSyntax(state, elseStack);
+ }
+
+ state = MISMATCH$1;
+ break;
+ }
+ }
+
+ openSyntax();
+ state = dictSyntax.match;
+ break;
+
+ case 'Keyword':
+ var name = state.name;
+
+ if (token !== null) {
+ var keywordName = token.value;
+
+ // drop \0 and \9 hack from keyword name
+ if (keywordName.indexOf('\\') !== -1) {
+ keywordName = keywordName.replace(/\\[09].*$/, '');
+ }
+
+ if (areStringsEqualCaseInsensitive(keywordName, name)) {
+ addTokenToMatch();
+ state = MATCH$1;
+ break;
+ }
+ }
+
+ state = MISMATCH$1;
+ break;
+
+ case 'AtKeyword':
+ case 'Function':
+ if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) {
+ addTokenToMatch();
+ state = MATCH$1;
+ break;
+ }
+
+ state = MISMATCH$1;
+ break;
+
+ case 'Token':
+ if (token !== null && token.value === state.value) {
+ addTokenToMatch();
+ state = MATCH$1;
+ break;
+ }
+
+ state = MISMATCH$1;
+ break;
+
+ case 'Comma':
+ if (token !== null && token.type === TYPE$6.Comma) {
+ if (isCommaContextStart(matchStack.token)) {
+ state = MISMATCH$1;
+ } else {
+ addTokenToMatch();
+ state = isCommaContextEnd(token) ? MISMATCH$1 : MATCH$1;
+ }
+ } else {
+ state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH$1 : MISMATCH$1;
+ }
+
+ break;
+
+ case 'String':
+ var string = '';
+
+ for (var lastTokenIndex = tokenIndex; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) {
+ string += tokens[lastTokenIndex].value;
+ }
+
+ if (areStringsEqualCaseInsensitive(string, state.value)) {
+ while (tokenIndex < lastTokenIndex) {
+ addTokenToMatch();
+ }
+
+ state = MATCH$1;
+ } else {
+ state = MISMATCH$1;
+ }
+
+ break;
+
+ default:
+ throw new Error('Unknown node type: ' + state.type);
+ }
+ }
+
+ totalIterationCount += iterationCount;
+
+ switch (exitReason) {
+ case null:
+ console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');
+ exitReason = EXIT_REASON_ITERATION_LIMIT;
+ matchStack = null;
+ break;
+
+ case EXIT_REASON_MATCH:
+ while (syntaxStack !== null) {
+ closeSyntax();
+ }
+ break;
+
+ default:
+ matchStack = null;
+ }
+
+ return {
+ tokens: tokens,
+ reason: exitReason,
+ iterations: iterationCount,
+ match: matchStack,
+ longestMatch: longestMatch
+ };
+ }
+
+ function matchAsList(tokens, matchGraph, syntaxes) {
+ var matchResult = internalMatch(tokens, matchGraph, syntaxes || {});
+
+ if (matchResult.match !== null) {
+ var item = reverseList(matchResult.match).prev;
+
+ matchResult.match = [];
+
+ while (item !== null) {
+ switch (item.type) {
+ case STUB:
+ break;
+
+ case OPEN_SYNTAX:
+ case CLOSE_SYNTAX:
+ matchResult.match.push({
+ type: item.type,
+ syntax: item.syntax
+ });
+ break;
+
+ default:
+ matchResult.match.push({
+ token: item.token.value,
+ node: item.token.node
+ });
+ break;
+ }
+
+ item = item.prev;
+ }
+ }
+
+ return matchResult;
+ }
+
+ function matchAsTree(tokens, matchGraph, syntaxes) {
+ var matchResult = internalMatch(tokens, matchGraph, syntaxes || {});
+
+ if (matchResult.match === null) {
+ return matchResult;
+ }
+
+ var item = matchResult.match;
+ var host = matchResult.match = {
+ syntax: matchGraph.syntax || null,
+ match: []
+ };
+ var hostStack = [host];
+
+ // revert a list and start with 2nd item since 1st is a stub item
+ item = reverseList(item).prev;
+
+ // build a tree
+ while (item !== null) {
+ switch (item.type) {
+ case OPEN_SYNTAX:
+ host.match.push(host = {
+ syntax: item.syntax,
+ match: []
+ });
+ hostStack.push(host);
+ break;
+
+ case CLOSE_SYNTAX:
+ hostStack.pop();
+ host = hostStack[hostStack.length - 1];
+ break;
+
+ default:
+ host.match.push({
+ syntax: item.syntax || null,
+ token: item.token.value,
+ node: item.token.node
+ });
+ }
+
+ item = item.prev;
+ }
+
+ return matchResult;
+ }
+
+ var match = {
+ matchAsList: matchAsList,
+ matchAsTree: matchAsTree,
+ getTotalIterationCount: function() {
+ return totalIterationCount;
+ }
+ };
+
+ function getTrace(node) {
+ function shouldPutToTrace(syntax) {
+ if (syntax === null) {
+ return false;
+ }
+
+ return (
+ syntax.type === 'Type' ||
+ syntax.type === 'Property' ||
+ syntax.type === 'Keyword'
+ );
+ }
+
+ function hasMatch(matchNode) {
+ if (Array.isArray(matchNode.match)) {
+ // use for-loop for better perfomance
+ for (var i = 0; i < matchNode.match.length; i++) {
+ if (hasMatch(matchNode.match[i])) {
+ if (shouldPutToTrace(matchNode.syntax)) {
+ result.unshift(matchNode.syntax);
+ }
+
+ return true;
+ }
+ }
+ } else if (matchNode.node === node) {
+ result = shouldPutToTrace(matchNode.syntax)
+ ? [matchNode.syntax]
+ : [];
+
+ return true;
+ }
+
+ return false;
+ }
+
+ var result = null;
+
+ if (this.matched !== null) {
+ hasMatch(this.matched);
+ }
+
+ return result;
+ }
+
+ function testNode(match, node, fn) {
+ var trace = getTrace.call(match, node);
+
+ if (trace === null) {
+ return false;
+ }
+
+ return trace.some(fn);
+ }
+
+ function isType(node, type) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Type' && matchNode.name === type;
+ });
+ }
+
+ function isProperty(node, property) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Property' && matchNode.name === property;
+ });
+ }
+
+ function isKeyword(node) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Keyword';
+ });
+ }
+
+ var trace = {
+ getTrace: getTrace,
+ isType: isType,
+ isProperty: isProperty,
+ isKeyword: isKeyword
+ };
+
+ function getFirstMatchNode(matchNode) {
+ if ('node' in matchNode) {
+ return matchNode.node;
+ }
+
+ return getFirstMatchNode(matchNode.match[0]);
+ }
+
+ function getLastMatchNode(matchNode) {
+ if ('node' in matchNode) {
+ return matchNode.node;
+ }
+
+ return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
+ }
+
+ function matchFragments(lexer, ast, match, type, name) {
+ function findFragments(matchNode) {
+ if (matchNode.syntax !== null &&
+ matchNode.syntax.type === type &&
+ matchNode.syntax.name === name) {
+ var start = getFirstMatchNode(matchNode);
+ var end = getLastMatchNode(matchNode);
+
+ lexer.syntax.walk(ast, function(node, item, list) {
+ if (node === start) {
+ var nodes = new List_1();
+
+ do {
+ nodes.appendData(item.data);
+
+ if (item.data === end) {
+ break;
+ }
+
+ item = item.next;
+ } while (item !== null);
+
+ fragments.push({
+ parent: list,
+ nodes: nodes
+ });
+ }
+ });
+ }
+
+ if (Array.isArray(matchNode.match)) {
+ matchNode.match.forEach(findFragments);
+ }
+ }
+
+ var fragments = [];
+
+ if (match.matched !== null) {
+ findFragments(match.matched);
+ }
+
+ return fragments;
+ }
+
+ var search = {
+ matchFragments: matchFragments
+ };
+
+ var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+
+ function isValidNumber(value) {
+ // Number.isInteger(value) && value >= 0
+ return (
+ typeof value === 'number' &&
+ isFinite(value) &&
+ Math.floor(value) === value &&
+ value >= 0
+ );
+ }
+
+ function isValidLocation(loc) {
+ return (
+ Boolean(loc) &&
+ isValidNumber(loc.offset) &&
+ isValidNumber(loc.line) &&
+ isValidNumber(loc.column)
+ );
+ }
+
+ function createNodeStructureChecker(type, fields) {
+ return function checkNode(node, warn) {
+ if (!node || node.constructor !== Object) {
+ return warn(node, 'Type of node should be an Object');
+ }
+
+ for (var key in node) {
+ var valid = true;
+
+ if (hasOwnProperty$2.call(node, key) === false) {
+ continue;
+ }
+
+ if (key === 'type') {
+ if (node.type !== type) {
+ warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
+ }
+ } else if (key === 'loc') {
+ if (node.loc === null) {
+ continue;
+ } else if (node.loc && node.loc.constructor === Object) {
+ if (typeof node.loc.source !== 'string') {
+ key += '.source';
+ } else if (!isValidLocation(node.loc.start)) {
+ key += '.start';
+ } else if (!isValidLocation(node.loc.end)) {
+ key += '.end';
+ } else {
+ continue;
+ }
+ }
+
+ valid = false;
+ } else if (fields.hasOwnProperty(key)) {
+ for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
+ var fieldType = fields[key][i];
+
+ switch (fieldType) {
+ case String:
+ valid = typeof node[key] === 'string';
+ break;
+
+ case Boolean:
+ valid = typeof node[key] === 'boolean';
+ break;
+
+ case null:
+ valid = node[key] === null;
+ break;
+
+ default:
+ if (typeof fieldType === 'string') {
+ valid = node[key] && node[key].type === fieldType;
+ } else if (Array.isArray(fieldType)) {
+ valid = node[key] instanceof List_1;
+ }
+ }
+ }
+ } else {
+ warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
+ }
+
+ if (!valid) {
+ warn(node, 'Bad value for `' + type + '.' + key + '`');
+ }
+ }
+
+ for (var key in fields) {
+ if (hasOwnProperty$2.call(fields, key) &&
+ hasOwnProperty$2.call(node, key) === false) {
+ warn(node, 'Field `' + type + '.' + key + '` is missed');
+ }
+ }
+ };
+ }
+
+ function processStructure(name, nodeType) {
+ var structure = nodeType.structure;
+ var fields = {
+ type: String,
+ loc: true
+ };
+ var docs = {
+ type: '"' + name + '"'
+ };
+
+ for (var key in structure) {
+ if (hasOwnProperty$2.call(structure, key) === false) {
+ continue;
+ }
+
+ var docsTypes = [];
+ var fieldTypes = fields[key] = Array.isArray(structure[key])
+ ? structure[key].slice()
+ : [structure[key]];
+
+ for (var i = 0; i < fieldTypes.length; i++) {
+ var fieldType = fieldTypes[i];
+ if (fieldType === String || fieldType === Boolean) {
+ docsTypes.push(fieldType.name);
+ } else if (fieldType === null) {
+ docsTypes.push('null');
+ } else if (typeof fieldType === 'string') {
+ docsTypes.push('<' + fieldType + '>');
+ } else if (Array.isArray(fieldType)) {
+ docsTypes.push('List'); // TODO: use type enum
+ } else {
+ throw new Error('Wrong value `' + fieldType + '` in `' + name + '.' + key + '` structure definition');
+ }
+ }
+
+ docs[key] = docsTypes.join(' | ');
+ }
+
+ return {
+ docs: docs,
+ check: createNodeStructureChecker(name, fields)
+ };
+ }
+
+ var structure = {
+ getStructureFromConfig: function(config) {
+ var structure = {};
+
+ if (config.node) {
+ for (var name in config.node) {
+ if (hasOwnProperty$2.call(config.node, name)) {
+ var nodeType = config.node[name];
+
+ if (nodeType.structure) {
+ structure[name] = processStructure(name, nodeType);
+ } else {
+ throw new Error('Missed `structure` field in `' + name + '` node type definition');
+ }
+ }
+ }
+ }
+
+ return structure;
+ }
+ };
+
+ var SyntaxReferenceError$1 = error.SyntaxReferenceError;
+ var SyntaxMatchError$1 = error.SyntaxMatchError;
+
+
+
+
+
+
+ var buildMatchGraph$1 = matchGraph.buildMatchGraph;
+ var matchAsTree$1 = match.matchAsTree;
+
+
+ var getStructureFromConfig = structure.getStructureFromConfig;
+ var cssWideKeywords$1 = buildMatchGraph$1('inherit | initial | unset');
+ var cssWideKeywordsWithExpression = buildMatchGraph$1('inherit | initial | unset | <-ms-legacy-expression>');
+
+ function dumpMapSyntax(map, compact, syntaxAsAst) {
+ var result = {};
+
+ for (var name in map) {
+ if (map[name].syntax) {
+ result[name] = syntaxAsAst
+ ? map[name].syntax
+ : generate_1(map[name].syntax, { compact: compact });
+ }
+ }
+
+ return result;
+ }
+
+ function dumpAtruleMapSyntax(map, compact, syntaxAsAst) {
+ const result = {};
+
+ for (const [name, atrule] of Object.entries(map)) {
+ result[name] = {
+ prelude: atrule.prelude && (
+ syntaxAsAst
+ ? atrule.prelude.syntax
+ : generate_1(atrule.prelude.syntax, { compact })
+ ),
+ descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)
+ };
+ }
+
+ return result;
+ }
+
+ function valueHasVar(tokens) {
+ for (var i = 0; i < tokens.length; i++) {
+ if (tokens[i].value.toLowerCase() === 'var(') {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function buildMatchResult(match, error, iterations) {
+ return {
+ matched: match,
+ iterations: iterations,
+ error: error,
+ getTrace: trace.getTrace,
+ isType: trace.isType,
+ isProperty: trace.isProperty,
+ isKeyword: trace.isKeyword
+ };
+ }
+
+ function matchSyntax(lexer, syntax, value, useCommon) {
+ var tokens = prepareTokens_1(value, lexer.syntax);
+ var result;
+
+ if (valueHasVar(tokens)) {
+ return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
+ }
+
+ if (useCommon) {
+ result = matchAsTree$1(tokens, lexer.valueCommonSyntax, lexer);
+ }
+
+ if (!useCommon || !result.match) {
+ result = matchAsTree$1(tokens, syntax.match, lexer);
+ if (!result.match) {
+ return buildMatchResult(
+ null,
+ new SyntaxMatchError$1(result.reason, syntax.syntax, value, result),
+ result.iterations
+ );
+ }
+ }
+
+ return buildMatchResult(result.match, null, result.iterations);
+ }
+
+ var Lexer = function(config, syntax, structure) {
+ this.valueCommonSyntax = cssWideKeywords$1;
+ this.syntax = syntax;
+ this.generic = false;
+ this.atrules = {};
+ this.properties = {};
+ this.types = {};
+ this.structure = structure || getStructureFromConfig(config);
+
+ if (config) {
+ if (config.types) {
+ for (var name in config.types) {
+ this.addType_(name, config.types[name]);
+ }
+ }
+
+ if (config.generic) {
+ this.generic = true;
+ for (var name in generic) {
+ this.addType_(name, generic[name]);
+ }
+ }
+
+ if (config.atrules) {
+ for (var name in config.atrules) {
+ this.addAtrule_(name, config.atrules[name]);
+ }
+ }
+
+ if (config.properties) {
+ for (var name in config.properties) {
+ this.addProperty_(name, config.properties[name]);
+ }
+ }
+ }
+ };
+
+ Lexer.prototype = {
+ structure: {},
+ checkStructure: function(ast) {
+ function collectWarning(node, message) {
+ warns.push({
+ node: node,
+ message: message
+ });
+ }
+
+ var structure = this.structure;
+ var warns = [];
+
+ this.syntax.walk(ast, function(node) {
+ if (structure.hasOwnProperty(node.type)) {
+ structure[node.type].check(node, collectWarning);
+ } else {
+ collectWarning(node, 'Unknown node type `' + node.type + '`');
+ }
+ });
+
+ return warns.length ? warns : false;
+ },
+
+ createDescriptor: function(syntax, type, name, parent = null) {
+ var ref = {
+ type: type,
+ name: name
+ };
+ var descriptor = {
+ type: type,
+ name: name,
+ parent: parent,
+ syntax: null,
+ match: null
+ };
+
+ if (typeof syntax === 'function') {
+ descriptor.match = buildMatchGraph$1(syntax, ref);
+ } else {
+ if (typeof syntax === 'string') {
+ // lazy parsing on first access
+ Object.defineProperty(descriptor, 'syntax', {
+ get: function() {
+ Object.defineProperty(descriptor, 'syntax', {
+ value: parse_1(syntax)
+ });
+
+ return descriptor.syntax;
+ }
+ });
+ } else {
+ descriptor.syntax = syntax;
+ }
+
+ // lazy graph build on first access
+ Object.defineProperty(descriptor, 'match', {
+ get: function() {
+ Object.defineProperty(descriptor, 'match', {
+ value: buildMatchGraph$1(descriptor.syntax, ref)
+ });
+
+ return descriptor.match;
+ }
+ });
+ }
+
+ return descriptor;
+ },
+ addAtrule_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.atrules[name] = {
+ type: 'Atrule',
+ name: name,
+ prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,
+ descriptors: syntax.descriptors
+ ? Object.keys(syntax.descriptors).reduce((res, descName) => {
+ res[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);
+ return res;
+ }, {})
+ : null
+ };
+ },
+ addProperty_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.properties[name] = this.createDescriptor(syntax, 'Property', name);
+ },
+ addType_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.types[name] = this.createDescriptor(syntax, 'Type', name);
+
+ if (syntax === generic['-ms-legacy-expression']) {
+ this.valueCommonSyntax = cssWideKeywordsWithExpression;
+ }
+ },
+
+ checkAtruleName: function(atruleName) {
+ if (!this.getAtrule(atruleName)) {
+ return new SyntaxReferenceError$1('Unknown at-rule', '@' + atruleName);
+ }
+ },
+ checkAtrulePrelude: function(atruleName, prelude) {
+ let error = this.checkAtruleName(atruleName);
+
+ if (error) {
+ return error;
+ }
+
+ var atrule = this.getAtrule(atruleName);
+
+ if (!atrule.prelude && prelude) {
+ return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');
+ }
+
+ if (atrule.prelude && !prelude) {
+ return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');
+ }
+ },
+ checkAtruleDescriptorName: function(atruleName, descriptorName) {
+ let error = this.checkAtruleName(atruleName);
+
+ if (error) {
+ return error;
+ }
+
+ var atrule = this.getAtrule(atruleName);
+ var descriptor = names.keyword(descriptorName);
+
+ if (!atrule.descriptors) {
+ return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');
+ }
+
+ if (!atrule.descriptors[descriptor.name] &&
+ !atrule.descriptors[descriptor.basename]) {
+ return new SyntaxReferenceError$1('Unknown at-rule descriptor', descriptorName);
+ }
+ },
+ checkPropertyName: function(propertyName) {
+ var property = names.property(propertyName);
+
+ // don't match syntax for a custom property
+ if (property.custom) {
+ return new Error('Lexer matching doesn\'t applicable for custom properties');
+ }
+
+ if (!this.getProperty(propertyName)) {
+ return new SyntaxReferenceError$1('Unknown property', propertyName);
+ }
+ },
+
+ matchAtrulePrelude: function(atruleName, prelude) {
+ var error = this.checkAtrulePrelude(atruleName, prelude);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ if (!prelude) {
+ return buildMatchResult(null, null);
+ }
+
+ return matchSyntax(this, this.getAtrule(atruleName).prelude, prelude, false);
+ },
+ matchAtruleDescriptor: function(atruleName, descriptorName, value) {
+ var error = this.checkAtruleDescriptorName(atruleName, descriptorName);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ var atrule = this.getAtrule(atruleName);
+ var descriptor = names.keyword(descriptorName);
+
+ return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);
+ },
+ matchDeclaration: function(node) {
+ if (node.type !== 'Declaration') {
+ return buildMatchResult(null, new Error('Not a Declaration node'));
+ }
+
+ return this.matchProperty(node.property, node.value);
+ },
+ matchProperty: function(propertyName, value) {
+ var error = this.checkPropertyName(propertyName);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ return matchSyntax(this, this.getProperty(propertyName), value, true);
+ },
+ matchType: function(typeName, value) {
+ var typeSyntax = this.getType(typeName);
+
+ if (!typeSyntax) {
+ return buildMatchResult(null, new SyntaxReferenceError$1('Unknown type', typeName));
+ }
+
+ return matchSyntax(this, typeSyntax, value, false);
+ },
+ match: function(syntax, value) {
+ if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {
+ return buildMatchResult(null, new SyntaxReferenceError$1('Bad syntax'));
+ }
+
+ if (typeof syntax === 'string' || !syntax.match) {
+ syntax = this.createDescriptor(syntax, 'Type', 'anonymous');
+ }
+
+ return matchSyntax(this, syntax, value, false);
+ },
+
+ findValueFragments: function(propertyName, value, type, name) {
+ return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
+ },
+ findDeclarationValueFragments: function(declaration, type, name) {
+ return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
+ },
+ findAllFragments: function(ast, type, name) {
+ var result = [];
+
+ this.syntax.walk(ast, {
+ visit: 'Declaration',
+ enter: function(declaration) {
+ result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
+ }.bind(this)
+ });
+
+ return result;
+ },
+
+ getAtrule: function(atruleName, fallbackBasename = true) {
+ var atrule = names.keyword(atruleName);
+ var atruleEntry = atrule.vendor && fallbackBasename
+ ? this.atrules[atrule.name] || this.atrules[atrule.basename]
+ : this.atrules[atrule.name];
+
+ return atruleEntry || null;
+ },
+ getAtrulePrelude: function(atruleName, fallbackBasename = true) {
+ const atrule = this.getAtrule(atruleName, fallbackBasename);
+
+ return atrule && atrule.prelude || null;
+ },
+ getAtruleDescriptor: function(atruleName, name) {
+ return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators
+ ? this.atrules[atruleName].declarators[name] || null
+ : null;
+ },
+ getProperty: function(propertyName, fallbackBasename = true) {
+ var property = names.property(propertyName);
+ var propertyEntry = property.vendor && fallbackBasename
+ ? this.properties[property.name] || this.properties[property.basename]
+ : this.properties[property.name];
+
+ return propertyEntry || null;
+ },
+ getType: function(name) {
+ return this.types.hasOwnProperty(name) ? this.types[name] : null;
+ },
+
+ validate: function() {
+ function validate(syntax, name, broken, descriptor) {
+ if (broken.hasOwnProperty(name)) {
+ return broken[name];
+ }
+
+ broken[name] = false;
+ if (descriptor.syntax !== null) {
+ walk(descriptor.syntax, function(node) {
+ if (node.type !== 'Type' && node.type !== 'Property') {
+ return;
+ }
+
+ var map = node.type === 'Type' ? syntax.types : syntax.properties;
+ var brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
+
+ if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
+ broken[name] = true;
+ }
+ }, this);
+ }
+ }
+
+ var brokenTypes = {};
+ var brokenProperties = {};
+
+ for (var key in this.types) {
+ validate(this, key, brokenTypes, this.types[key]);
+ }
+
+ for (var key in this.properties) {
+ validate(this, key, brokenProperties, this.properties[key]);
+ }
+
+ brokenTypes = Object.keys(brokenTypes).filter(function(name) {
+ return brokenTypes[name];
+ });
+ brokenProperties = Object.keys(brokenProperties).filter(function(name) {
+ return brokenProperties[name];
+ });
+
+ if (brokenTypes.length || brokenProperties.length) {
+ return {
+ types: brokenTypes,
+ properties: brokenProperties
+ };
+ }
+
+ return null;
+ },
+ dump: function(syntaxAsAst, pretty) {
+ return {
+ generic: this.generic,
+ types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),
+ properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),
+ atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)
+ };
+ },
+ toString: function() {
+ return JSON.stringify(this.dump());
+ }
+ };
+
+ var Lexer_1 = Lexer;
+
+ var definitionSyntax = {
+ SyntaxError: _SyntaxError$1,
+ parse: parse_1,
+ generate: generate_1,
+ walk: walk
+ };
+
+ var isBOM$2 = tokenizer.isBOM;
+
+ var N$3 = 10;
+ var F$2 = 12;
+ var R$2 = 13;
+
+ function computeLinesAndColumns(host, source) {
+ var sourceLength = source.length;
+ var lines = adoptBuffer(host.lines, sourceLength); // +1
+ var line = host.startLine;
+ var columns = adoptBuffer(host.columns, sourceLength);
+ var column = host.startColumn;
+ var startOffset = source.length > 0 ? isBOM$2(source.charCodeAt(0)) : 0;
+
+ for (var i = startOffset; i < sourceLength; i++) { // -1
+ var code = source.charCodeAt(i);
+
+ lines[i] = line;
+ columns[i] = column++;
+
+ if (code === N$3 || code === R$2 || code === F$2) {
+ if (code === R$2 && i + 1 < sourceLength && source.charCodeAt(i + 1) === N$3) {
+ i++;
+ lines[i] = line;
+ columns[i] = column;
+ }
+
+ line++;
+ column = 1;
+ }
+ }
+
+ lines[i] = line;
+ columns[i] = column;
+
+ host.lines = lines;
+ host.columns = columns;
+ }
+
+ var OffsetToLocation = function() {
+ this.lines = null;
+ this.columns = null;
+ this.linesAndColumnsComputed = false;
+ };
+
+ OffsetToLocation.prototype = {
+ setSource: function(source, startOffset, startLine, startColumn) {
+ this.source = source;
+ this.startOffset = typeof startOffset === 'undefined' ? 0 : startOffset;
+ this.startLine = typeof startLine === 'undefined' ? 1 : startLine;
+ this.startColumn = typeof startColumn === 'undefined' ? 1 : startColumn;
+ this.linesAndColumnsComputed = false;
+ },
+
+ ensureLinesAndColumnsComputed: function() {
+ if (!this.linesAndColumnsComputed) {
+ computeLinesAndColumns(this, this.source);
+ this.linesAndColumnsComputed = true;
+ }
+ },
+ getLocation: function(offset, filename) {
+ this.ensureLinesAndColumnsComputed();
+
+ return {
+ source: filename,
+ offset: this.startOffset + offset,
+ line: this.lines[offset],
+ column: this.columns[offset]
+ };
+ },
+ getLocationRange: function(start, end, filename) {
+ this.ensureLinesAndColumnsComputed();
+
+ return {
+ source: filename,
+ start: {
+ offset: this.startOffset + start,
+ line: this.lines[start],
+ column: this.columns[start]
+ },
+ end: {
+ offset: this.startOffset + end,
+ line: this.lines[end],
+ column: this.columns[end]
+ }
+ };
+ }
+ };
+
+ var OffsetToLocation_1 = OffsetToLocation;
+
+ var TYPE$7 = tokenizer.TYPE;
+ var WHITESPACE$2 = TYPE$7.WhiteSpace;
+ var COMMENT$2 = TYPE$7.Comment;
+
+ var sequence = function readSequence(recognizer) {
+ var children = this.createList();
+ var child = null;
+ var context = {
+ recognizer: recognizer,
+ space: null,
+ ignoreWS: false,
+ ignoreWSAfter: false
+ };
+
+ this.scanner.skipSC();
+
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case COMMENT$2:
+ this.scanner.next();
+ continue;
+
+ case WHITESPACE$2:
+ if (context.ignoreWS) {
+ this.scanner.next();
+ } else {
+ context.space = this.WhiteSpace();
+ }
+ continue;
+ }
+
+ child = recognizer.getNode.call(this, context);
+
+ if (child === undefined) {
+ break;
+ }
+
+ if (context.space !== null) {
+ children.push(context.space);
+ context.space = null;
+ }
+
+ children.push(child);
+
+ if (context.ignoreWSAfter) {
+ context.ignoreWSAfter = false;
+ context.ignoreWS = true;
+ } else {
+ context.ignoreWS = false;
+ }
+ }
+
+ return children;
+ };
+
+ var { findWhiteSpaceStart: findWhiteSpaceStart$1, cmpStr: cmpStr$4 } = utils;
+
+ var noop$2 = function() {};
+
+ var TYPE$8 = _const.TYPE;
+ var NAME$2 = _const.NAME;
+ var WHITESPACE$3 = TYPE$8.WhiteSpace;
+ var COMMENT$3 = TYPE$8.Comment;
+ var IDENT$2 = TYPE$8.Ident;
+ var FUNCTION = TYPE$8.Function;
+ var URL = TYPE$8.Url;
+ var HASH = TYPE$8.Hash;
+ var PERCENTAGE = TYPE$8.Percentage;
+ var NUMBER$2 = TYPE$8.Number;
+ var NUMBERSIGN$1 = 0x0023; // U+0023 NUMBER SIGN (#)
+ var NULL = 0;
+
+ function createParseContext(name) {
+ return function() {
+ return this[name]();
+ };
+ }
+
+ function processConfig(config) {
+ var parserConfig = {
+ context: {},
+ scope: {},
+ atrule: {},
+ pseudo: {}
+ };
+
+ if (config.parseContext) {
+ for (var name in config.parseContext) {
+ switch (typeof config.parseContext[name]) {
+ case 'function':
+ parserConfig.context[name] = config.parseContext[name];
+ break;
+
+ case 'string':
+ parserConfig.context[name] = createParseContext(config.parseContext[name]);
+ break;
+ }
+ }
+ }
+
+ if (config.scope) {
+ for (var name in config.scope) {
+ parserConfig.scope[name] = config.scope[name];
+ }
+ }
+
+ if (config.atrule) {
+ for (var name in config.atrule) {
+ var atrule = config.atrule[name];
+
+ if (atrule.parse) {
+ parserConfig.atrule[name] = atrule.parse;
+ }
+ }
+ }
+
+ if (config.pseudo) {
+ for (var name in config.pseudo) {
+ var pseudo = config.pseudo[name];
+
+ if (pseudo.parse) {
+ parserConfig.pseudo[name] = pseudo.parse;
+ }
+ }
+ }
+
+ if (config.node) {
+ for (var name in config.node) {
+ parserConfig[name] = config.node[name].parse;
+ }
+ }
+
+ return parserConfig;
+ }
+
+ var create = function createParser(config) {
+ var parser = {
+ scanner: new TokenStream_1(),
+ locationMap: new OffsetToLocation_1(),
+
+ filename: '<unknown>',
+ needPositions: false,
+ onParseError: noop$2,
+ onParseErrorThrow: false,
+ parseAtrulePrelude: true,
+ parseRulePrelude: true,
+ parseValue: true,
+ parseCustomProperty: false,
+
+ readSequence: sequence,
+
+ createList: function() {
+ return new List_1();
+ },
+ createSingleNodeList: function(node) {
+ return new List_1().appendData(node);
+ },
+ getFirstListNode: function(list) {
+ return list && list.first();
+ },
+ getLastListNode: function(list) {
+ return list.last();
+ },
+
+ parseWithFallback: function(consumer, fallback) {
+ var startToken = this.scanner.tokenIndex;
+
+ try {
+ return consumer.call(this);
+ } catch (e) {
+ if (this.onParseErrorThrow) {
+ throw e;
+ }
+
+ var fallbackNode = fallback.call(this, startToken);
+
+ this.onParseErrorThrow = true;
+ this.onParseError(e, fallbackNode);
+ this.onParseErrorThrow = false;
+
+ return fallbackNode;
+ }
+ },
+
+ lookupNonWSType: function(offset) {
+ do {
+ var type = this.scanner.lookupType(offset++);
+ if (type !== WHITESPACE$3) {
+ return type;
+ }
+ } while (type !== NULL);
+
+ return NULL;
+ },
+
+ eat: function(tokenType) {
+ if (this.scanner.tokenType !== tokenType) {
+ var offset = this.scanner.tokenStart;
+ var message = NAME$2[tokenType] + ' is expected';
+
+ // tweak message and offset
+ switch (tokenType) {
+ case IDENT$2:
+ // when identifier is expected but there is a function or url
+ if (this.scanner.tokenType === FUNCTION || this.scanner.tokenType === URL) {
+ offset = this.scanner.tokenEnd - 1;
+ message = 'Identifier is expected but function found';
+ } else {
+ message = 'Identifier is expected';
+ }
+ break;
+
+ case HASH:
+ if (this.scanner.isDelim(NUMBERSIGN$1)) {
+ this.scanner.next();
+ offset++;
+ message = 'Name is expected';
+ }
+ break;
+
+ case PERCENTAGE:
+ if (this.scanner.tokenType === NUMBER$2) {
+ offset = this.scanner.tokenEnd;
+ message = 'Percent sign is expected';
+ }
+ break;
+
+ default:
+ // when test type is part of another token show error for current position + 1
+ // e.g. eat(HYPHENMINUS) will fail on "-foo", but pointing on "-" is odd
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === tokenType) {
+ offset = offset + 1;
+ }
+ }
+
+ this.error(message, offset);
+ }
+
+ this.scanner.next();
+ },
+
+ consume: function(tokenType) {
+ var value = this.scanner.getTokenValue();
+
+ this.eat(tokenType);
+
+ return value;
+ },
+ consumeFunctionName: function() {
+ var name = this.scanner.source.substring(this.scanner.tokenStart, this.scanner.tokenEnd - 1);
+
+ this.eat(FUNCTION);
+
+ return name;
+ },
+
+ getLocation: function(start, end) {
+ if (this.needPositions) {
+ return this.locationMap.getLocationRange(
+ start,
+ end,
+ this.filename
+ );
+ }
+
+ return null;
+ },
+ getLocationFromList: function(list) {
+ if (this.needPositions) {
+ var head = this.getFirstListNode(list);
+ var tail = this.getLastListNode(list);
+ return this.locationMap.getLocationRange(
+ head !== null ? head.loc.start.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+ tail !== null ? tail.loc.end.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+ this.filename
+ );
+ }
+
+ return null;
+ },
+
+ error: function(message, offset) {
+ var location = typeof offset !== 'undefined' && offset < this.scanner.source.length
+ ? this.locationMap.getLocation(offset)
+ : this.scanner.eof
+ ? this.locationMap.getLocation(findWhiteSpaceStart$1(this.scanner.source, this.scanner.source.length - 1))
+ : this.locationMap.getLocation(this.scanner.tokenStart);
+
+ throw new _SyntaxError(
+ message || 'Unexpected input',
+ this.scanner.source,
+ location.offset,
+ location.line,
+ location.column
+ );
+ }
+ };
+
+ config = processConfig(config || {});
+ for (var key in config) {
+ parser[key] = config[key];
+ }
+
+ return function(source, options) {
+ options = options || {};
+
+ var context = options.context || 'default';
+ var onComment = options.onComment;
+ var ast;
+
+ tokenizer(source, parser.scanner);
+ parser.locationMap.setSource(
+ source,
+ options.offset,
+ options.line,
+ options.column
+ );
+
+ parser.filename = options.filename || '<unknown>';
+ parser.needPositions = Boolean(options.positions);
+ parser.onParseError = typeof options.onParseError === 'function' ? options.onParseError : noop$2;
+ parser.onParseErrorThrow = false;
+ parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;
+ parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;
+ parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
+ parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
+
+ if (!parser.context.hasOwnProperty(context)) {
+ throw new Error('Unknown context `' + context + '`');
+ }
+
+ if (typeof onComment === 'function') {
+ parser.scanner.forEachToken((type, start, end) => {
+ if (type === COMMENT$3) {
+ const loc = parser.getLocation(start, end);
+ const value = cmpStr$4(source, end - 2, end, '*/')
+ ? source.slice(start + 2, end - 2)
+ : source.slice(start + 2, end);
+
+ onComment(value, loc);
+ }
+ });
+ }
+
+ ast = parser.context[context].call(parser, options);
+
+ if (!parser.scanner.eof) {
+ parser.error();
+ }
+
+ return ast;
+ };
+ };
+
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+ var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+ /**
+ * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+ */
+ var encode = function (number) {
+ if (0 <= number && number < intToCharMap.length) {
+ return intToCharMap[number];
+ }
+ throw new TypeError("Must be between 0 and 63: " + number);
+ };
+
+ /**
+ * Decode a single base 64 character code digit to an integer. Returns -1 on
+ * failure.
+ */
+ var decode = function (charCode) {
+ var bigA = 65; // 'A'
+ var bigZ = 90; // 'Z'
+
+ var littleA = 97; // 'a'
+ var littleZ = 122; // 'z'
+
+ var zero = 48; // '0'
+ var nine = 57; // '9'
+
+ var plus = 43; // '+'
+ var slash = 47; // '/'
+
+ var littleOffset = 26;
+ var numberOffset = 52;
+
+ // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+ if (bigA <= charCode && charCode <= bigZ) {
+ return (charCode - bigA);
+ }
+
+ // 26 - 51: abcdefghijklmnopqrstuvwxyz
+ if (littleA <= charCode && charCode <= littleZ) {
+ return (charCode - littleA + littleOffset);
+ }
+
+ // 52 - 61: 0123456789
+ if (zero <= charCode && charCode <= nine) {
+ return (charCode - zero + numberOffset);
+ }
+
+ // 62: +
+ if (charCode == plus) {
+ return 62;
+ }
+
+ // 63: /
+ if (charCode == slash) {
+ return 63;
+ }
+
+ // Invalid base64 digit.
+ return -1;
+ };
+
+ var base64 = {
+ encode: encode,
+ decode: decode
+ };
+
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+ // A single base 64 digit can contain 6 bits of data. For the base 64 variable
+ // length quantities we use in the source map spec, the first bit is the sign,
+ // the next four bits are the actual value, and the 6th bit is the
+ // continuation bit. The continuation bit tells us whether there are more
+ // digits in this value following this digit.
+ //
+ // Continuation
+ // | Sign
+ // | |
+ // V V
+ // 101011
+
+ var VLQ_BASE_SHIFT = 5;
+
+ // binary: 100000
+ var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+ // binary: 011111
+ var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+ // binary: 100000
+ var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+ /**
+ * Converts from a two-complement value to a value where the sign bit is
+ * placed in the least significant bit. For example, as decimals:
+ * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+ * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+ */
+ function toVLQSigned(aValue) {
+ return aValue < 0
+ ? ((-aValue) << 1) + 1
+ : (aValue << 1) + 0;
+ }
+
+ /**
+ * Converts to a two-complement value from a value where the sign bit is
+ * placed in the least significant bit. For example, as decimals:
+ * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+ * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+ */
+ function fromVLQSigned(aValue) {
+ var isNegative = (aValue & 1) === 1;
+ var shifted = aValue >> 1;
+ return isNegative
+ ? -shifted
+ : shifted;
+ }
+
+ /**
+ * Returns the base 64 VLQ encoded value.
+ */
+ var encode$1 = function base64VLQ_encode(aValue) {
+ var encoded = "";
+ var digit;
+
+ var vlq = toVLQSigned(aValue);
+
+ do {
+ digit = vlq & VLQ_BASE_MASK;
+ vlq >>>= VLQ_BASE_SHIFT;
+ if (vlq > 0) {
+ // There are still more digits in this value, so we must make sure the
+ // continuation bit is marked.
+ digit |= VLQ_CONTINUATION_BIT;
+ }
+ encoded += base64.encode(digit);
+ } while (vlq > 0);
+
+ return encoded;
+ };
+
+ /**
+ * Decodes the next base 64 VLQ value from the given string and returns the
+ * value and the rest of the string via the out parameter.
+ */
+ var decode$1 = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+ var strLen = aStr.length;
+ var result = 0;
+ var shift = 0;
+ var continuation, digit;
+
+ do {
+ if (aIndex >= strLen) {
+ throw new Error("Expected more digits in base 64 VLQ value.");
+ }
+
+ digit = base64.decode(aStr.charCodeAt(aIndex++));
+ if (digit === -1) {
+ throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+ }
+
+ continuation = !!(digit & VLQ_CONTINUATION_BIT);
+ digit &= VLQ_BASE_MASK;
+ result = result + (digit << shift);
+ shift += VLQ_BASE_SHIFT;
+ } while (continuation);
+
+ aOutParam.value = fromVLQSigned(result);
+ aOutParam.rest = aIndex;
+ };
+
+ var base64Vlq = {
+ encode: encode$1,
+ decode: decode$1
+ };
+
+ function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+ }
+
+ function getCjsExportFromNamespace (n) {
+ return n && n['default'] || n;
+ }
+
+ var util = createCommonjsModule(function (module, exports) {
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+ /**
+ * This is a helper function for getting values from parameter/options
+ * objects.
+ *
+ * @param args The object we are extracting values from
+ * @param name The name of the property we are getting.
+ * @param defaultValue An optional value to return if the property is missing
+ * from the object. If this is not specified and the property is missing, an
+ * error will be thrown.
+ */
+ function getArg(aArgs, aName, aDefaultValue) {
+ if (aName in aArgs) {
+ return aArgs[aName];
+ } else if (arguments.length === 3) {
+ return aDefaultValue;
+ } else {
+ throw new Error('"' + aName + '" is a required argument.');
+ }
+ }
+ exports.getArg = getArg;
+
+ var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+ var dataUrlRegexp = /^data:.+\,.+$/;
+
+ function urlParse(aUrl) {
+ var match = aUrl.match(urlRegexp);
+ if (!match) {
+ return null;
+ }
+ return {
+ scheme: match[1],
+ auth: match[2],
+ host: match[3],
+ port: match[4],
+ path: match[5]
+ };
+ }
+ exports.urlParse = urlParse;
+
+ function urlGenerate(aParsedUrl) {
+ var url = '';
+ if (aParsedUrl.scheme) {
+ url += aParsedUrl.scheme + ':';
+ }
+ url += '//';
+ if (aParsedUrl.auth) {
+ url += aParsedUrl.auth + '@';
+ }
+ if (aParsedUrl.host) {
+ url += aParsedUrl.host;
+ }
+ if (aParsedUrl.port) {
+ url += ":" + aParsedUrl.port;
+ }
+ if (aParsedUrl.path) {
+ url += aParsedUrl.path;
+ }
+ return url;
+ }
+ exports.urlGenerate = urlGenerate;
+
+ /**
+ * Normalizes a path, or the path portion of a URL:
+ *
+ * - Replaces consecutive slashes with one slash.
+ * - Removes unnecessary '.' parts.
+ * - Removes unnecessary '<dir>/..' parts.
+ *
+ * Based on code in the Node.js 'path' core module.
+ *
+ * @param aPath The path or url to normalize.
+ */
+ function normalize(aPath) {
+ var path = aPath;
+ var url = urlParse(aPath);
+ if (url) {
+ if (!url.path) {
+ return aPath;
+ }
+ path = url.path;
+ }
+ var isAbsolute = exports.isAbsolute(path);
+
+ var parts = path.split(/\/+/);
+ for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+ part = parts[i];
+ if (part === '.') {
+ parts.splice(i, 1);
+ } else if (part === '..') {
+ up++;
+ } else if (up > 0) {
+ if (part === '') {
+ // The first part is blank if the path is absolute. Trying to go
+ // above the root is a no-op. Therefore we can remove all '..' parts
+ // directly after the root.
+ parts.splice(i + 1, up);
+ up = 0;
+ } else {
+ parts.splice(i, 2);
+ up--;
+ }
+ }
+ }
+ path = parts.join('/');
+
+ if (path === '') {
+ path = isAbsolute ? '/' : '.';
+ }
+
+ if (url) {
+ url.path = path;
+ return urlGenerate(url);
+ }
+ return path;
+ }
+ exports.normalize = normalize;
+
+ /**
+ * Joins two paths/URLs.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be joined with the root.
+ *
+ * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+ * scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+ * first.
+ * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+ * is updated with the result and aRoot is returned. Otherwise the result
+ * is returned.
+ * - If aPath is absolute, the result is aPath.
+ * - Otherwise the two paths are joined with a slash.
+ * - Joining for example 'http://' and 'www.example.com' is also supported.
+ */
+ function join(aRoot, aPath) {
+ if (aRoot === "") {
+ aRoot = ".";
+ }
+ if (aPath === "") {
+ aPath = ".";
+ }
+ var aPathUrl = urlParse(aPath);
+ var aRootUrl = urlParse(aRoot);
+ if (aRootUrl) {
+ aRoot = aRootUrl.path || '/';
+ }
+
+ // `join(foo, '//www.example.org')`
+ if (aPathUrl && !aPathUrl.scheme) {
+ if (aRootUrl) {
+ aPathUrl.scheme = aRootUrl.scheme;
+ }
+ return urlGenerate(aPathUrl);
+ }
+
+ if (aPathUrl || aPath.match(dataUrlRegexp)) {
+ return aPath;
+ }
+
+ // `join('http://', 'www.example.com')`
+ if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+ aRootUrl.host = aPath;
+ return urlGenerate(aRootUrl);
+ }
+
+ var joined = aPath.charAt(0) === '/'
+ ? aPath
+ : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+ if (aRootUrl) {
+ aRootUrl.path = joined;
+ return urlGenerate(aRootUrl);
+ }
+ return joined;
+ }
+ exports.join = join;
+
+ exports.isAbsolute = function (aPath) {
+ return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
+ };
+
+ /**
+ * Make a path relative to a URL or another path.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be made relative to aRoot.
+ */
+ function relative(aRoot, aPath) {
+ if (aRoot === "") {
+ aRoot = ".";
+ }
+
+ aRoot = aRoot.replace(/\/$/, '');
+
+ // It is possible for the path to be above the root. In this case, simply
+ // checking whether the root is a prefix of the path won't work. Instead, we
+ // need to remove components from the root one by one, until either we find
+ // a prefix that fits, or we run out of components to remove.
+ var level = 0;
+ while (aPath.indexOf(aRoot + '/') !== 0) {
+ var index = aRoot.lastIndexOf("/");
+ if (index < 0) {
+ return aPath;
+ }
+
+ // If the only part of the root that is left is the scheme (i.e. http://,
+ // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+ // have exhausted all components, so the path is not relative to the root.
+ aRoot = aRoot.slice(0, index);
+ if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+ return aPath;
+ }
+
+ ++level;
+ }
+
+ // Make sure we add a "../" for each component we removed from the root.
+ return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+ }
+ exports.relative = relative;
+
+ var supportsNullProto = (function () {
+ var obj = Object.create(null);
+ return !('__proto__' in obj);
+ }());
+
+ function identity (s) {
+ return s;
+ }
+
+ /**
+ * Because behavior goes wacky when you set `__proto__` on objects, we
+ * have to prefix all the strings in our set with an arbitrary character.
+ *
+ * See https://github.com/mozilla/source-map/pull/31 and
+ * https://github.com/mozilla/source-map/issues/30
+ *
+ * @param String aStr
+ */
+ function toSetString(aStr) {
+ if (isProtoString(aStr)) {
+ return '$' + aStr;
+ }
+
+ return aStr;
+ }
+ exports.toSetString = supportsNullProto ? identity : toSetString;
+
+ function fromSetString(aStr) {
+ if (isProtoString(aStr)) {
+ return aStr.slice(1);
+ }
+
+ return aStr;
+ }
+ exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+ function isProtoString(s) {
+ if (!s) {
+ return false;
+ }
+
+ var length = s.length;
+
+ if (length < 9 /* "__proto__".length */) {
+ return false;
+ }
+
+ if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 2) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+ s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+ s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+ s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+ s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+ s.charCodeAt(length - 8) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 9) !== 95 /* '_' */) {
+ return false;
+ }
+
+ for (var i = length - 10; i >= 0; i--) {
+ if (s.charCodeAt(i) !== 36 /* '$' */) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Comparator between two mappings where the original positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same original source/line/column, but different generated
+ * line and column the same. Useful when searching for a mapping with a
+ * stubbed out mapping.
+ */
+ function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+ var cmp = strcmp(mappingA.source, mappingB.source);
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
+ if (cmp !== 0 || onlyCompareOriginal) {
+ return cmp;
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.generatedLine - mappingB.generatedLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ return strcmp(mappingA.name, mappingB.name);
+ }
+ exports.compareByOriginalPositions = compareByOriginalPositions;
+
+ /**
+ * Comparator between two mappings with deflated source and name indices where
+ * the generated positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same generated line and column, but different
+ * source/name/original line and column the same. Useful when searching for a
+ * mapping with a stubbed out mapping.
+ */
+ function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+ var cmp = mappingA.generatedLine - mappingB.generatedLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+ if (cmp !== 0 || onlyCompareGenerated) {
+ return cmp;
+ }
+
+ cmp = strcmp(mappingA.source, mappingB.source);
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ return strcmp(mappingA.name, mappingB.name);
+ }
+ exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+
+ function strcmp(aStr1, aStr2) {
+ if (aStr1 === aStr2) {
+ return 0;
+ }
+
+ if (aStr1 === null) {
+ return 1; // aStr2 !== null
+ }
+
+ if (aStr2 === null) {
+ return -1; // aStr1 !== null
+ }
+
+ if (aStr1 > aStr2) {
+ return 1;
+ }
+
+ return -1;
+ }
+
+ /**
+ * Comparator between two mappings with inflated source and name strings where
+ * the generated positions are compared.
+ */
+ function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+ var cmp = mappingA.generatedLine - mappingB.generatedLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = strcmp(mappingA.source, mappingB.source);
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn;
+ if (cmp !== 0) {
+ return cmp;
+ }
+
+ return strcmp(mappingA.name, mappingB.name);
+ }
+ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+
+ /**
+ * Strip any JSON XSSI avoidance prefix from the string (as documented
+ * in the source maps specification), and then parse the string as
+ * JSON.
+ */
+ function parseSourceMapInput(str) {
+ return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
+ }
+ exports.parseSourceMapInput = parseSourceMapInput;
+
+ /**
+ * Compute the URL of a source given the the source root, the source's
+ * URL, and the source map's URL.
+ */
+ function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+ sourceURL = sourceURL || '';
+
+ if (sourceRoot) {
+ // This follows what Chrome does.
+ if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+ sourceRoot += '/';
+ }
+ // The spec says:
+ // Line 4: An optional source root, useful for relocating source
+ // files on a server or removing repeated values in the
+ // “sources” entry. This value is prepended to the individual
+ // entries in the “source” field.
+ sourceURL = sourceRoot + sourceURL;
+ }
+
+ // Historically, SourceMapConsumer did not take the sourceMapURL as
+ // a parameter. This mode is still somewhat supported, which is why
+ // this code block is conditional. However, it's preferable to pass
+ // the source map URL to SourceMapConsumer, so that this function
+ // can implement the source URL resolution algorithm as outlined in
+ // the spec. This block is basically the equivalent of:
+ // new URL(sourceURL, sourceMapURL).toString()
+ // ... except it avoids using URL, which wasn't available in the
+ // older releases of node still supported by this library.
+ //
+ // The spec says:
+ // If the sources are not absolute URLs after prepending of the
+ // “sourceRoot”, the sources are resolved relative to the
+ // SourceMap (like resolving script src in a html document).
+ if (sourceMapURL) {
+ var parsed = urlParse(sourceMapURL);
+ if (!parsed) {
+ throw new Error("sourceMapURL could not be parsed");
+ }
+ if (parsed.path) {
+ // Strip the last path component, but keep the "/".
+ var index = parsed.path.lastIndexOf('/');
+ if (index >= 0) {
+ parsed.path = parsed.path.substring(0, index + 1);
+ }
+ }
+ sourceURL = join(urlGenerate(parsed), sourceURL);
+ }
+
+ return normalize(sourceURL);
+ }
+ exports.computeSourceURL = computeSourceURL;
+ });
+ var util_1 = util.getArg;
+ var util_2 = util.urlParse;
+ var util_3 = util.urlGenerate;
+ var util_4 = util.normalize;
+ var util_5 = util.join;
+ var util_6 = util.isAbsolute;
+ var util_7 = util.relative;
+ var util_8 = util.toSetString;
+ var util_9 = util.fromSetString;
+ var util_10 = util.compareByOriginalPositions;
+ var util_11 = util.compareByGeneratedPositionsDeflated;
+ var util_12 = util.compareByGeneratedPositionsInflated;
+ var util_13 = util.parseSourceMapInput;
+ var util_14 = util.computeSourceURL;
+
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+
+ var has = Object.prototype.hasOwnProperty;
+ var hasNativeMap = typeof Map !== "undefined";
+
+ /**
+ * A data structure which is a combination of an array and a set. Adding a new
+ * member is O(1), testing for membership is O(1), and finding the index of an
+ * element is O(1). Removing elements from the set is not supported. Only
+ * strings are supported for membership.
+ */
+ function ArraySet() {
+ this._array = [];
+ this._set = hasNativeMap ? new Map() : Object.create(null);
+ }
+
+ /**
+ * Static method for creating ArraySet instances from an existing array.
+ */
+ ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+ var set = new ArraySet();
+ for (var i = 0, len = aArray.length; i < len; i++) {
+ set.add(aArray[i], aAllowDuplicates);
+ }
+ return set;
+ };
+
+ /**
+ * Return how many unique items are in this ArraySet. If duplicates have been
+ * added, than those do not count towards the size.
+ *
+ * @returns Number
+ */
+ ArraySet.prototype.size = function ArraySet_size() {
+ return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+ };
+
+ /**
+ * Add the given string to this set.
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+ var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+ var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+ var idx = this._array.length;
+ if (!isDuplicate || aAllowDuplicates) {
+ this._array.push(aStr);
+ }
+ if (!isDuplicate) {
+ if (hasNativeMap) {
+ this._set.set(aStr, idx);
+ } else {
+ this._set[sStr] = idx;
+ }
+ }
+ };
+
+ /**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.has = function ArraySet_has(aStr) {
+ if (hasNativeMap) {
+ return this._set.has(aStr);
+ } else {
+ var sStr = util.toSetString(aStr);
+ return has.call(this._set, sStr);
+ }
+ };
+
+ /**
+ * What is the index of the given string in the array?
+ *
+ * @param String aStr
+ */
+ ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+ if (hasNativeMap) {
+ var idx = this._set.get(aStr);
+ if (idx >= 0) {
+ return idx;
+ }
+ } else {
+ var sStr = util.toSetString(aStr);
+ if (has.call(this._set, sStr)) {
+ return this._set[sStr];
+ }
+ }
+
+ throw new Error('"' + aStr + '" is not in the set.');
+ };
+
+ /**
+ * What is the element at the given index?
+ *
+ * @param Number aIdx
+ */
+ ArraySet.prototype.at = function ArraySet_at(aIdx) {
+ if (aIdx >= 0 && aIdx < this._array.length) {
+ return this._array[aIdx];
+ }
+ throw new Error('No element indexed by ' + aIdx);
+ };
+
+ /**
+ * Returns the array representation of this set (which has the proper indices
+ * indicated by indexOf). Note that this is a copy of the internal array used
+ * for storing the members so that no one can mess with internal state.
+ */
+ ArraySet.prototype.toArray = function ArraySet_toArray() {
+ return this._array.slice();
+ };
+
+ var ArraySet_1 = ArraySet;
+
+ var arraySet = {
+ ArraySet: ArraySet_1
+ };
+
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2014 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+
+
+ /**
+ * Determine whether mappingB is after mappingA with respect to generated
+ * position.
+ */
+ function generatedPositionAfter(mappingA, mappingB) {
+ // Optimized for most common case
+ var lineA = mappingA.generatedLine;
+ var lineB = mappingB.generatedLine;
+ var columnA = mappingA.generatedColumn;
+ var columnB = mappingB.generatedColumn;
+ return lineB > lineA || lineB == lineA && columnB >= columnA ||
+ util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+ }
+
+ /**
+ * A data structure to provide a sorted view of accumulated mappings in a
+ * performance conscious manner. It trades a neglibable overhead in general
+ * case for a large speedup in case of mappings being added in order.
+ */
+ function MappingList() {
+ this._array = [];
+ this._sorted = true;
+ // Serves as infimum
+ this._last = {generatedLine: -1, generatedColumn: 0};
+ }
+
+ /**
+ * Iterate through internal items. This method takes the same arguments that
+ * `Array.prototype.forEach` takes.
+ *
+ * NOTE: The order of the mappings is NOT guaranteed.
+ */
+ MappingList.prototype.unsortedForEach =
+ function MappingList_forEach(aCallback, aThisArg) {
+ this._array.forEach(aCallback, aThisArg);
+ };
+
+ /**
+ * Add the given source mapping.
+ *
+ * @param Object aMapping
+ */
+ MappingList.prototype.add = function MappingList_add(aMapping) {
+ if (generatedPositionAfter(this._last, aMapping)) {
+ this._last = aMapping;
+ this._array.push(aMapping);
+ } else {
+ this._sorted = false;
+ this._array.push(aMapping);
+ }
+ };
+
+ /**
+ * Returns the flat, sorted array of mappings. The mappings are sorted by
+ * generated position.
+ *
+ * WARNING: This method returns internal data without copying, for
+ * performance. The return value must NOT be mutated, and should be treated as
+ * an immutable borrow. If you want to take ownership, you must make your own
+ * copy.
+ */
+ MappingList.prototype.toArray = function MappingList_toArray() {
+ if (!this._sorted) {
+ this._array.sort(util.compareByGeneratedPositionsInflated);
+ this._sorted = true;
+ }
+ return this._array;
+ };
+
+ var MappingList_1 = MappingList;
+
+ var mappingList = {
+ MappingList: MappingList_1
+ };
+
+ /* -*- Mode: js; js-indent-level: 2; -*- */
+ /*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+
+
+ var ArraySet$1 = arraySet.ArraySet;
+ var MappingList$1 = mappingList.MappingList;
+
+ /**
+ * An instance of the SourceMapGenerator represents a source map which is
+ * being built incrementally. You may pass an object with the following
+ * properties:
+ *
+ * - file: The filename of the generated source.
+ * - sourceRoot: A root for all relative URLs in this source map.
+ */
+ function SourceMapGenerator(aArgs) {
+ if (!aArgs) {
+ aArgs = {};
+ }
+ this._file = util.getArg(aArgs, 'file', null);
+ this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+ this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+ this._sources = new ArraySet$1();
+ this._names = new ArraySet$1();
+ this._mappings = new MappingList$1();
+ this._sourcesContents = null;
+ }
+
+ SourceMapGenerator.prototype._version = 3;
+
+ /**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param aSourceMapConsumer The SourceMap.
+ */
+ SourceMapGenerator.fromSourceMap =
+ function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
+ var sourceRoot = aSourceMapConsumer.sourceRoot;
+ var generator = new SourceMapGenerator({
+ file: aSourceMapConsumer.file,
+ sourceRoot: sourceRoot
+ });
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ var newMapping = {
+ generated: {
+ line: mapping.generatedLine,
+ column: mapping.generatedColumn
+ }
+ };
+
+ if (mapping.source != null) {
+ newMapping.source = mapping.source;
+ if (sourceRoot != null) {
+ newMapping.source = util.relative(sourceRoot, newMapping.source);
+ }
+
+ newMapping.original = {
+ line: mapping.originalLine,
+ column: mapping.originalColumn
+ };
+
+ if (mapping.name != null) {
+ newMapping.name = mapping.name;
+ }
+ }
+
+ generator.addMapping(newMapping);
+ });
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ var sourceRelative = sourceFile;
+ if (sourceRoot !== null) {
+ sourceRelative = util.relative(sourceRoot, sourceFile);
+ }
+
+ if (!generator._sources.has(sourceRelative)) {
+ generator._sources.add(sourceRelative);
+ }
+
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+ if (content != null) {
+ generator.setSourceContent(sourceFile, content);
+ }
+ });
+ return generator;
+ };
+
+ /**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ * - generated: An object with the generated line and column positions.
+ * - original: An object with the original line and column positions.
+ * - source: The original source file (relative to the sourceRoot).
+ * - name: An optional original token name for this mapping.
+ */
+ SourceMapGenerator.prototype.addMapping =
+ function SourceMapGenerator_addMapping(aArgs) {
+ var generated = util.getArg(aArgs, 'generated');
+ var original = util.getArg(aArgs, 'original', null);
+ var source = util.getArg(aArgs, 'source', null);
+ var name = util.getArg(aArgs, 'name', null);
+
+ if (!this._skipValidation) {
+ this._validateMapping(generated, original, source, name);
+ }
+
+ if (source != null) {
+ source = String(source);
+ if (!this._sources.has(source)) {
+ this._sources.add(source);
+ }
+ }
+
+ if (name != null) {
+ name = String(name);
+ if (!this._names.has(name)) {
+ this._names.add(name);
+ }
+ }
+
+ this._mappings.add({
+ generatedLine: generated.line,
+ generatedColumn: generated.column,
+ originalLine: original != null && original.line,
+ originalColumn: original != null && original.column,
+ source: source,
+ name: name
+ });
+ };
+
+ /**
+ * Set the source content for a source file.
+ */
+ SourceMapGenerator.prototype.setSourceContent =
+ function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+ var source = aSourceFile;
+ if (this._sourceRoot != null) {
+ source = util.relative(this._sourceRoot, source);
+ }
+
+ if (aSourceContent != null) {
+ // Add the source content to the _sourcesContents map.
+ // Create a new _sourcesContents map if the property is null.
+ if (!this._sourcesContents) {
+ this._sourcesContents = Object.create(null);
+ }
+ this._sourcesContents[util.toSetString(source)] = aSourceContent;
+ } else if (this._sourcesContents) {
+ // Remove the source file from the _sourcesContents map.
+ // If the _sourcesContents map is empty, set the property to null.
+ delete this._sourcesContents[util.toSetString(source)];
+ if (Object.keys(this._sourcesContents).length === 0) {
+ this._sourcesContents = null;
+ }
+ }
+ };
+
+ /**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param aSourceMapConsumer The source map to be applied.
+ * @param aSourceFile Optional. The filename of the source file.
+ * If omitted, SourceMapConsumer's file property will be used.
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
+ * to be applied. If relative, it is relative to the SourceMapConsumer.
+ * This parameter is needed when the two source maps aren't in the same
+ * directory, and the source map to be applied contains relative source
+ * paths. If so, those relative source paths need to be rewritten
+ * relative to the SourceMapGenerator.
+ */
+ SourceMapGenerator.prototype.applySourceMap =
+ function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+ var sourceFile = aSourceFile;
+ // If aSourceFile is omitted, we will use the file property of the SourceMap
+ if (aSourceFile == null) {
+ if (aSourceMapConsumer.file == null) {
+ throw new Error(
+ 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+ 'or the source map\'s "file" property. Both were omitted.'
+ );
+ }
+ sourceFile = aSourceMapConsumer.file;
+ }
+ var sourceRoot = this._sourceRoot;
+ // Make "sourceFile" relative if an absolute Url is passed.
+ if (sourceRoot != null) {
+ sourceFile = util.relative(sourceRoot, sourceFile);
+ }
+ // Applying the SourceMap can add and remove items from the sources and
+ // the names array.
+ var newSources = new ArraySet$1();
+ var newNames = new ArraySet$1();
+
+ // Find mappings for the "sourceFile"
+ this._mappings.unsortedForEach(function (mapping) {
+ if (mapping.source === sourceFile && mapping.originalLine != null) {
+ // Check if it can be mapped by the source map, then update the mapping.
+ var original = aSourceMapConsumer.originalPositionFor({
+ line: mapping.originalLine,
+ column: mapping.originalColumn
+ });
+ if (original.source != null) {
+ // Copy mapping
+ mapping.source = original.source;
+ if (aSourceMapPath != null) {
+ mapping.source = util.join(aSourceMapPath, mapping.source);
+ }
+ if (sourceRoot != null) {
+ mapping.source = util.relative(sourceRoot, mapping.source);
+ }
+ mapping.originalLine = original.line;
+ mapping.originalColumn = original.column;
+ if (original.name != null) {
+ mapping.name = original.name;
+ }
+ }
+ }
+
+ var source = mapping.source;
+ if (source != null && !newSources.has(source)) {
+ newSources.add(source);
+ }
+
+ var name = mapping.name;
+ if (name != null && !newNames.has(name)) {
+ newNames.add(name);
+ }
+
+ }, this);
+ this._sources = newSources;
+ this._names = newNames;
+
+ // Copy sourcesContents of applied map.
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+ if (content != null) {
+ if (aSourceMapPath != null) {
+ sourceFile = util.join(aSourceMapPath, sourceFile);
+ }
+ if (sourceRoot != null) {
+ sourceFile = util.relative(sourceRoot, sourceFile);
+ }
+ this.setSourceContent(sourceFile, content);
+ }
+ }, this);
+ };
+
+ /**
+ * A mapping can have one of the three levels of data:
+ *
+ * 1. Just the generated position.
+ * 2. The Generated position, original position, and original source.
+ * 3. Generated and original position, original source, as well as a name
+ * token.
+ *
+ * To maintain consistency, we validate that any new mapping being added falls
+ * in to one of these categories.
+ */
+ SourceMapGenerator.prototype._validateMapping =
+ function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+ aName) {
+ // When aOriginal is truthy but has empty values for .line and .column,
+ // it is most likely a programmer error. In this case we throw a very
+ // specific error message to try to guide them the right way.
+ // For example: https://github.com/Polymer/polymer-bundler/pull/519
+ if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+ throw new Error(
+ 'original.line and original.column are not numbers -- you probably meant to omit ' +
+ 'the original mapping entirely and only map the generated position. If so, pass ' +
+ 'null for the original mapping instead of an object with empty or null values.'
+ );
+ }
+
+ if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+ && aGenerated.line > 0 && aGenerated.column >= 0
+ && !aOriginal && !aSource && !aName) {
+ // Case 1.
+ return;
+ }
+ else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+ && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+ && aGenerated.line > 0 && aGenerated.column >= 0
+ && aOriginal.line > 0 && aOriginal.column >= 0
+ && aSource) {
+ // Cases 2 and 3.
+ return;
+ }
+ else {
+ throw new Error('Invalid mapping: ' + JSON.stringify({
+ generated: aGenerated,
+ source: aSource,
+ original: aOriginal,
+ name: aName
+ }));
+ }
+ };
+
+ /**
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
+ * specified by the source map format.
+ */
+ SourceMapGenerator.prototype._serializeMappings =
+ function SourceMapGenerator_serializeMappings() {
+ var previousGeneratedColumn = 0;
+ var previousGeneratedLine = 1;
+ var previousOriginalColumn = 0;
+ var previousOriginalLine = 0;
+ var previousName = 0;
+ var previousSource = 0;
+ var result = '';
+ var next;
+ var mapping;
+ var nameIdx;
+ var sourceIdx;
+
+ var mappings = this._mappings.toArray();
+ for (var i = 0, len = mappings.length; i < len; i++) {
+ mapping = mappings[i];
+ next = '';
+
+ if (mapping.generatedLine !== previousGeneratedLine) {
+ previousGeneratedColumn = 0;
+ while (mapping.generatedLine !== previousGeneratedLine) {
+ next += ';';
+ previousGeneratedLine++;
+ }
+ }
+ else {
+ if (i > 0) {
+ if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+ continue;
+ }
+ next += ',';
+ }
+ }
+
+ next += base64Vlq.encode(mapping.generatedColumn
+ - previousGeneratedColumn);
+ previousGeneratedColumn = mapping.generatedColumn;
+
+ if (mapping.source != null) {
+ sourceIdx = this._sources.indexOf(mapping.source);
+ next += base64Vlq.encode(sourceIdx - previousSource);
+ previousSource = sourceIdx;
+
+ // lines are stored 0-based in SourceMap spec version 3
+ next += base64Vlq.encode(mapping.originalLine - 1
+ - previousOriginalLine);
+ previousOriginalLine = mapping.originalLine - 1;
+
+ next += base64Vlq.encode(mapping.originalColumn
+ - previousOriginalColumn);
+ previousOriginalColumn = mapping.originalColumn;
+
+ if (mapping.name != null) {
+ nameIdx = this._names.indexOf(mapping.name);
+ next += base64Vlq.encode(nameIdx - previousName);
+ previousName = nameIdx;
+ }
+ }
+
+ result += next;
+ }
+
+ return result;
+ };
+
+ SourceMapGenerator.prototype._generateSourcesContent =
+ function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+ return aSources.map(function (source) {
+ if (!this._sourcesContents) {
+ return null;
+ }
+ if (aSourceRoot != null) {
+ source = util.relative(aSourceRoot, source);
+ }
+ var key = util.toSetString(source);
+ return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+ ? this._sourcesContents[key]
+ : null;
+ }, this);
+ };
+
+ /**
+ * Externalize the source map.
+ */
+ SourceMapGenerator.prototype.toJSON =
+ function SourceMapGenerator_toJSON() {
+ var map = {
+ version: this._version,
+ sources: this._sources.toArray(),
+ names: this._names.toArray(),
+ mappings: this._serializeMappings()
+ };
+ if (this._file != null) {
+ map.file = this._file;
+ }
+ if (this._sourceRoot != null) {
+ map.sourceRoot = this._sourceRoot;
+ }
+ if (this._sourcesContents) {
+ map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+ }
+
+ return map;
+ };
+
+ /**
+ * Render the source map being generated to a string.
+ */
+ SourceMapGenerator.prototype.toString =
+ function SourceMapGenerator_toString() {
+ return JSON.stringify(this.toJSON());
+ };
+
+ var SourceMapGenerator_1 = SourceMapGenerator;
+
+ var sourceMapGenerator = {
+ SourceMapGenerator: SourceMapGenerator_1
+ };
+
+ var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;
+ var trackNodes = {
+ Atrule: true,
+ Selector: true,
+ Declaration: true
+ };
+
+ var sourceMap = function generateSourceMap(handlers) {
+ var map = new SourceMapGenerator$1();
+ var line = 1;
+ var column = 0;
+ var generated = {
+ line: 1,
+ column: 0
+ };
+ var original = {
+ line: 0, // should be zero to add first mapping
+ column: 0
+ };
+ var sourceMappingActive = false;
+ var activatedGenerated = {
+ line: 1,
+ column: 0
+ };
+ var activatedMapping = {
+ generated: activatedGenerated
+ };
+
+ var handlersNode = handlers.node;
+ handlers.node = function(node) {
+ if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
+ var nodeLine = node.loc.start.line;
+ var nodeColumn = node.loc.start.column - 1;
+
+ if (original.line !== nodeLine ||
+ original.column !== nodeColumn) {
+ original.line = nodeLine;
+ original.column = nodeColumn;
+
+ generated.line = line;
+ generated.column = column;
+
+ if (sourceMappingActive) {
+ sourceMappingActive = false;
+ if (generated.line !== activatedGenerated.line ||
+ generated.column !== activatedGenerated.column) {
+ map.addMapping(activatedMapping);
+ }
+ }
+
+ sourceMappingActive = true;
+ map.addMapping({
+ source: node.loc.source,
+ original: original,
+ generated: generated
+ });
+ }
+ }
+
+ handlersNode.call(this, node);
+
+ if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
+ activatedGenerated.line = line;
+ activatedGenerated.column = column;
+ }
+ };
+
+ var handlersChunk = handlers.chunk;
+ handlers.chunk = function(chunk) {
+ for (var i = 0; i < chunk.length; i++) {
+ if (chunk.charCodeAt(i) === 10) { // \n
+ line++;
+ column = 0;
+ } else {
+ column++;
+ }
+ }
+
+ handlersChunk(chunk);
+ };
+
+ var handlersResult = handlers.result;
+ handlers.result = function() {
+ if (sourceMappingActive) {
+ map.addMapping(activatedMapping);
+ }
+
+ return {
+ css: handlersResult(),
+ map: map
+ };
+ };
+
+ return handlers;
+ };
+
+ var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+
+ function processChildren(node, delimeter) {
+ var list = node.children;
+ var prev = null;
+
+ if (typeof delimeter !== 'function') {
+ list.forEach(this.node, this);
+ } else {
+ list.forEach(function(node) {
+ if (prev !== null) {
+ delimeter.call(this, prev);
+ }
+
+ this.node(node);
+ prev = node;
+ }, this);
+ }
+ }
+
+ var create$1 = function createGenerator(config) {
+ function processNode(node) {
+ if (hasOwnProperty$3.call(types, node.type)) {
+ types[node.type].call(this, node);
+ } else {
+ throw new Error('Unknown node type: ' + node.type);
+ }
+ }
+
+ var types = {};
+
+ if (config.node) {
+ for (var name in config.node) {
+ types[name] = config.node[name].generate;
+ }
+ }
+
+ return function(node, options) {
+ var buffer = '';
+ var handlers = {
+ children: processChildren,
+ node: processNode,
+ chunk: function(chunk) {
+ buffer += chunk;
+ },
+ result: function() {
+ return buffer;
+ }
+ };
+
+ if (options) {
+ if (typeof options.decorator === 'function') {
+ handlers = options.decorator(handlers);
+ }
+
+ if (options.sourceMap) {
+ handlers = sourceMap(handlers);
+ }
+ }
+
+ handlers.node(node);
+
+ return handlers.result();
+ };
+ };
+
+ var create$2 = function createConvertors(walk) {
+ return {
+ fromPlainObject: function(ast) {
+ walk(ast, {
+ enter: function(node) {
+ if (node.children && node.children instanceof List_1 === false) {
+ node.children = new List_1().fromArray(node.children);
+ }
+ }
+ });
+
+ return ast;
+ },
+ toPlainObject: function(ast) {
+ walk(ast, {
+ leave: function(node) {
+ if (node.children && node.children instanceof List_1) {
+ node.children = node.children.toArray();
+ }
+ }
+ });
+
+ return ast;
+ }
+ };
+ };
+
+ var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+ var noop$3 = function() {};
+
+ function ensureFunction$1(value) {
+ return typeof value === 'function' ? value : noop$3;
+ }
+
+ function invokeForType(fn, type) {
+ return function(node, item, list) {
+ if (node.type === type) {
+ fn.call(this, node, item, list);
+ }
+ };
+ }
+
+ function getWalkersFromStructure(name, nodeType) {
+ var structure = nodeType.structure;
+ var walkers = [];
+
+ for (var key in structure) {
+ if (hasOwnProperty$4.call(structure, key) === false) {
+ continue;
+ }
+
+ var fieldTypes = structure[key];
+ var walker = {
+ name: key,
+ type: false,
+ nullable: false
+ };
+
+ if (!Array.isArray(structure[key])) {
+ fieldTypes = [structure[key]];
+ }
+
+ for (var i = 0; i < fieldTypes.length; i++) {
+ var fieldType = fieldTypes[i];
+ if (fieldType === null) {
+ walker.nullable = true;
+ } else if (typeof fieldType === 'string') {
+ walker.type = 'node';
+ } else if (Array.isArray(fieldType)) {
+ walker.type = 'list';
+ }
+ }
+
+ if (walker.type) {
+ walkers.push(walker);
+ }
+ }
+
+ if (walkers.length) {
+ return {
+ context: nodeType.walkContext,
+ fields: walkers
+ };
+ }
+
+ return null;
+ }
+
+ function getTypesFromConfig(config) {
+ var types = {};
+
+ for (var name in config.node) {
+ if (hasOwnProperty$4.call(config.node, name)) {
+ var nodeType = config.node[name];
+
+ if (!nodeType.structure) {
+ throw new Error('Missed `structure` field in `' + name + '` node type definition');
+ }
+
+ types[name] = getWalkersFromStructure(name, nodeType);
+ }
+ }
+
+ return types;
+ }
+
+ function createTypeIterator(config, reverse) {
+ var fields = config.fields.slice();
+ var contextName = config.context;
+ var useContext = typeof contextName === 'string';
+
+ if (reverse) {
+ fields.reverse();
+ }
+
+ return function(node, context, walk, walkReducer) {
+ var prevContextValue;
+
+ if (useContext) {
+ prevContextValue = context[contextName];
+ context[contextName] = node;
+ }
+
+ for (var i = 0; i < fields.length; i++) {
+ var field = fields[i];
+ var ref = node[field.name];
+
+ if (!field.nullable || ref) {
+ if (field.type === 'list') {
+ var breakWalk = reverse
+ ? ref.reduceRight(walkReducer, false)
+ : ref.reduce(walkReducer, false);
+
+ if (breakWalk) {
+ return true;
+ }
+ } else if (walk(ref)) {
+ return true;
+ }
+ }
+ }
+
+ if (useContext) {
+ context[contextName] = prevContextValue;
+ }
+ };
+ }
+
+ function createFastTraveralMap(iterators) {
+ return {
+ Atrule: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block
+ },
+ Rule: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block
+ },
+ Declaration: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block,
+ DeclarationList: iterators.DeclarationList
+ }
+ };
+ }
+
+ var create$3 = function createWalker(config) {
+ var types = getTypesFromConfig(config);
+ var iteratorsNatural = {};
+ var iteratorsReverse = {};
+ var breakWalk = Symbol('break-walk');
+ var skipNode = Symbol('skip-node');
+
+ for (var name in types) {
+ if (hasOwnProperty$4.call(types, name) && types[name] !== null) {
+ iteratorsNatural[name] = createTypeIterator(types[name], false);
+ iteratorsReverse[name] = createTypeIterator(types[name], true);
+ }
+ }
+
+ var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
+ var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
+
+ var walk = function(root, options) {
+ function walkNode(node, item, list) {
+ var enterRet = enter.call(context, node, item, list);
+
+ if (enterRet === breakWalk) {
+ debugger;
+ return true;
+ }
+
+ if (enterRet === skipNode) {
+ return false;
+ }
+
+ if (iterators.hasOwnProperty(node.type)) {
+ if (iterators[node.type](node, context, walkNode, walkReducer)) {
+ return true;
+ }
+ }
+
+ if (leave.call(context, node, item, list) === breakWalk) {
+ return true;
+ }
+
+ return false;
+ }
+
+ var walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);
+ var enter = noop$3;
+ var leave = noop$3;
+ var iterators = iteratorsNatural;
+ var context = {
+ break: breakWalk,
+ skip: skipNode,
+
+ root: root,
+ stylesheet: null,
+ atrule: null,
+ atrulePrelude: null,
+ rule: null,
+ selector: null,
+ block: null,
+ declaration: null,
+ function: null
+ };
+
+ if (typeof options === 'function') {
+ enter = options;
+ } else if (options) {
+ enter = ensureFunction$1(options.enter);
+ leave = ensureFunction$1(options.leave);
+
+ if (options.reverse) {
+ iterators = iteratorsReverse;
+ }
+
+ if (options.visit) {
+ if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
+ iterators = options.reverse
+ ? fastTraversalIteratorsReverse[options.visit]
+ : fastTraversalIteratorsNatural[options.visit];
+ } else if (!types.hasOwnProperty(options.visit)) {
+ throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).join(', ') + ')');
+ }
+
+ enter = invokeForType(enter, options.visit);
+ leave = invokeForType(leave, options.visit);
+ }
+ }
+
+ if (enter === noop$3 && leave === noop$3) {
+ throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+ }
+
+ walkNode(root);
+ };
+
+ walk.break = breakWalk;
+ walk.skip = skipNode;
+
+ walk.find = function(ast, fn) {
+ var found = null;
+
+ walk(ast, function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found = node;
+ return breakWalk;
+ }
+ });
+
+ return found;
+ };
+
+ walk.findLast = function(ast, fn) {
+ var found = null;
+
+ walk(ast, {
+ reverse: true,
+ enter: function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found = node;
+ return breakWalk;
+ }
+ }
+ });
+
+ return found;
+ };
+
+ walk.findAll = function(ast, fn) {
+ var found = [];
+
+ walk(ast, function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found.push(node);
+ }
+ });
+
+ return found;
+ };
+
+ return walk;
+ };
+
+ var clone = function clone(node) {
+ var result = {};
+
+ for (var key in node) {
+ var value = node[key];
+
+ if (value) {
+ if (Array.isArray(value) || value instanceof List_1) {
+ value = value.map(clone);
+ } else if (value.constructor === Object) {
+ value = clone(value);
+ }
+ }
+
+ result[key] = value;
+ }
+
+ return result;
+ };
+
+ const hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+ const shape = {
+ generic: true,
+ types: appendOrAssign,
+ atrules: {
+ prelude: appendOrAssignOrNull,
+ descriptors: appendOrAssignOrNull
+ },
+ properties: appendOrAssign,
+ parseContext: assign,
+ scope: deepAssign,
+ atrule: ['parse'],
+ pseudo: ['parse'],
+ node: ['name', 'structure', 'parse', 'generate', 'walkContext']
+ };
+
+ function isObject(value) {
+ return value && value.constructor === Object;
+ }
+
+ function copy(value) {
+ return isObject(value)
+ ? Object.assign({}, value)
+ : value;
+ }
+
+ function assign(dest, src) {
+ return Object.assign(dest, src);
+ }
+
+ function deepAssign(dest, src) {
+ for (const key in src) {
+ if (hasOwnProperty$5.call(src, key)) {
+ if (isObject(dest[key])) {
+ deepAssign(dest[key], copy(src[key]));
+ } else {
+ dest[key] = copy(src[key]);
+ }
+ }
+ }
+
+ return dest;
+ }
+
+ function append(a, b) {
+ if (typeof b === 'string' && /^\s*\|/.test(b)) {
+ return typeof a === 'string'
+ ? a + b
+ : b.replace(/^\s*\|\s*/, '');
+ }
+
+ return b || null;
+ }
+
+ function appendOrAssign(a, b) {
+ if (typeof b === 'string') {
+ return append(a, b);
+ }
+
+ const result = Object.assign({}, a);
+ for (let key in b) {
+ if (hasOwnProperty$5.call(b, key)) {
+ result[key] = append(hasOwnProperty$5.call(a, key) ? a[key] : undefined, b[key]);
+ }
+ }
+
+ return result;
+ }
+
+ function appendOrAssignOrNull(a, b) {
+ const result = appendOrAssign(a, b);
+
+ return !isObject(result) || Object.keys(result).length
+ ? result
+ : null;
+ }
+
+ function mix(dest, src, shape) {
+ for (const key in shape) {
+ if (hasOwnProperty$5.call(shape, key) === false) {
+ continue;
+ }
+
+ if (shape[key] === true) {
+ if (key in src) {
+ if (hasOwnProperty$5.call(src, key)) {
+ dest[key] = copy(src[key]);
+ }
+ }
+ } else if (shape[key]) {
+ if (typeof shape[key] === 'function') {
+ const fn = shape[key];
+ dest[key] = fn({}, dest[key]);
+ dest[key] = fn(dest[key] || {}, src[key]);
+ } else if (isObject(shape[key])) {
+ const result = {};
+
+ for (let name in dest[key]) {
+ result[name] = mix({}, dest[key][name], shape[key]);
+ }
+
+ for (let name in src[key]) {
+ result[name] = mix(result[name] || {}, src[key][name], shape[key]);
+ }
+
+ dest[key] = result;
+ } else if (Array.isArray(shape[key])) {
+ const res = {};
+ const innerShape = shape[key].reduce(function(s, k) {
+ s[k] = true;
+ return s;
+ }, {});
+
+ for (const [name, value] of Object.entries(dest[key] || {})) {
+ res[name] = {};
+ if (value) {
+ mix(res[name], value, innerShape);
+ }
+ }
+
+ for (const name in src[key]) {
+ if (hasOwnProperty$5.call(src[key], name)) {
+ if (!res[name]) {
+ res[name] = {};
+ }
+
+ if (src[key] && src[key][name]) {
+ mix(res[name], src[key][name], innerShape);
+ }
+ }
+ }
+
+ dest[key] = res;
+ }
+ }
+ }
+ return dest;
+ }
+
+ var mix_1 = (dest, src) => mix(dest, src, shape);
+
+ function createSyntax(config) {
+ var parse = create(config);
+ var walk = create$3(config);
+ var generate = create$1(config);
+ var convert = create$2(walk);
+
+ var syntax = {
+ List: List_1,
+ SyntaxError: _SyntaxError,
+ TokenStream: TokenStream_1,
+ Lexer: Lexer_1,
+
+ vendorPrefix: names.vendorPrefix,
+ keyword: names.keyword,
+ property: names.property,
+ isCustomProperty: names.isCustomProperty,
+
+ definitionSyntax: definitionSyntax,
+ lexer: null,
+ createLexer: function(config) {
+ return new Lexer_1(config, syntax, syntax.lexer.structure);
+ },
+
+ tokenize: tokenizer,
+ parse: parse,
+ walk: walk,
+ generate: generate,
+
+ find: walk.find,
+ findLast: walk.findLast,
+ findAll: walk.findAll,
+
+ clone: clone,
+ fromPlainObject: convert.fromPlainObject,
+ toPlainObject: convert.toPlainObject,
+
+ createSyntax: function(config) {
+ return createSyntax(mix_1({}, config));
+ },
+ fork: function(extension) {
+ var base = mix_1({}, config); // copy of config
+ return createSyntax(
+ typeof extension === 'function'
+ ? extension(base, Object.assign)
+ : mix_1(base, extension)
+ );
+ }
+ };
+
+ syntax.lexer = new Lexer_1({
+ generic: true,
+ types: config.types,
+ atrules: config.atrules,
+ properties: config.properties,
+ node: config.node
+ }, syntax);
+
+ return syntax;
+ }
+ var create_1 = function(config) {
+ return createSyntax(mix_1({}, config));
+ };
+
+ var create$4 = {
+ create: create_1
+ };
+
+ var data = {
+ "generic": true,
+ "types": {
+ "absolute-size": "xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large",
+ "alpha-value": "<number>|<percentage>",
+ "angle-percentage": "<angle>|<percentage>",
+ "angular-color-hint": "<angle-percentage>",
+ "angular-color-stop": "<color>&&<color-stop-angle>?",
+ "angular-color-stop-list": "[<angular-color-stop> [, <angular-color-hint>]?]# , <angular-color-stop>",
+ "animateable-feature": "scroll-position|contents|<custom-ident>",
+ "attachment": "scroll|fixed|local",
+ "attr()": "attr( <attr-name> <type-or-unit>? [, <attr-fallback>]? )",
+ "attr-matcher": "['~'|'|'|'^'|'$'|'*']? '='",
+ "attr-modifier": "i|s",
+ "attribute-selector": "'[' <wq-name> ']'|'[' <wq-name> <attr-matcher> [<string-token>|<ident-token>] <attr-modifier>? ']'",
+ "auto-repeat": "repeat( [auto-fill|auto-fit] , [<line-names>? <fixed-size>]+ <line-names>? )",
+ "auto-track-list": "[<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>? <auto-repeat> [<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>?",
+ "baseline-position": "[first|last]? baseline",
+ "basic-shape": "<inset()>|<circle()>|<ellipse()>|<polygon()>|<path()>",
+ "bg-image": "none|<image>",
+ "bg-layer": "<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>",
+ "bg-position": "[[left|center|right|top|bottom|<length-percentage>]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]|[center|[left|right] <length-percentage>?]&&[center|[top|bottom] <length-percentage>?]]",
+ "bg-size": "[<length-percentage>|auto]{1,2}|cover|contain",
+ "blur()": "blur( <length> )",
+ "blend-mode": "normal|multiply|screen|overlay|darken|lighten|color-dodge|color-burn|hard-light|soft-light|difference|exclusion|hue|saturation|color|luminosity",
+ "box": "border-box|padding-box|content-box",
+ "brightness()": "brightness( <number-percentage> )",
+ "calc()": "calc( <calc-sum> )",
+ "calc-sum": "<calc-product> [['+'|'-'] <calc-product>]*",
+ "calc-product": "<calc-value> ['*' <calc-value>|'/' <number>]*",
+ "calc-value": "<number>|<dimension>|<percentage>|( <calc-sum> )",
+ "cf-final-image": "<image>|<color>",
+ "cf-mixing-image": "<percentage>?&&<image>",
+ "circle()": "circle( [<shape-radius>]? [at <position>]? )",
+ "clamp()": "clamp( <calc-sum>#{3} )",
+ "class-selector": "'.' <ident-token>",
+ "clip-source": "<url>",
+ "color": "<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hex-color>|<named-color>|currentcolor|<deprecated-system-color>",
+ "color-stop": "<color-stop-length>|<color-stop-angle>",
+ "color-stop-angle": "<angle-percentage>{1,2}",
+ "color-stop-length": "<length-percentage>{1,2}",
+ "color-stop-list": "[<linear-color-stop> [, <linear-color-hint>]?]# , <linear-color-stop>",
+ "combinator": "'>'|'+'|'~'|['||']",
+ "common-lig-values": "[common-ligatures|no-common-ligatures]",
+ "compat-auto": "searchfield|textarea|push-button|slider-horizontal|checkbox|radio|square-button|menulist|listbox|meter|progress-bar|button",
+ "composite-style": "clear|copy|source-over|source-in|source-out|source-atop|destination-over|destination-in|destination-out|destination-atop|xor",
+ "compositing-operator": "add|subtract|intersect|exclude",
+ "compound-selector": "[<type-selector>? <subclass-selector>* [<pseudo-element-selector> <pseudo-class-selector>*]*]!",
+ "compound-selector-list": "<compound-selector>#",
+ "complex-selector": "<compound-selector> [<combinator>? <compound-selector>]*",
+ "complex-selector-list": "<complex-selector>#",
+ "conic-gradient()": "conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )",
+ "contextual-alt-values": "[contextual|no-contextual]",
+ "content-distribution": "space-between|space-around|space-evenly|stretch",
+ "content-list": "[<string>|contents|<image>|<quote>|<target>|<leader()>|<attr()>|counter( <ident> , <'list-style-type'>? )]+",
+ "content-position": "center|start|end|flex-start|flex-end",
+ "content-replacement": "<image>",
+ "contrast()": "contrast( [<number-percentage>] )",
+ "counter()": "counter( <custom-ident> , <counter-style>? )",
+ "counter-style": "<counter-style-name>|symbols( )",
+ "counter-style-name": "<custom-ident>",
+ "counters()": "counters( <custom-ident> , <string> , <counter-style>? )",
+ "cross-fade()": "cross-fade( <cf-mixing-image> , <cf-final-image>? )",
+ "cubic-bezier-timing-function": "ease|ease-in|ease-out|ease-in-out|cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )",
+ "deprecated-system-color": "ActiveBorder|ActiveCaption|AppWorkspace|Background|ButtonFace|ButtonHighlight|ButtonShadow|ButtonText|CaptionText|GrayText|Highlight|HighlightText|InactiveBorder|InactiveCaption|InactiveCaptionText|InfoBackground|InfoText|Menu|MenuText|Scrollbar|ThreeDDarkShadow|ThreeDFace|ThreeDHighlight|ThreeDLightShadow|ThreeDShadow|Window|WindowFrame|WindowText",
+ "discretionary-lig-values": "[discretionary-ligatures|no-discretionary-ligatures]",
+ "display-box": "contents|none",
+ "display-inside": "flow|flow-root|table|flex|grid|ruby",
+ "display-internal": "table-row-group|table-header-group|table-footer-group|table-row|table-cell|table-column-group|table-column|table-caption|ruby-base|ruby-text|ruby-base-container|ruby-text-container",
+ "display-legacy": "inline-block|inline-list-item|inline-table|inline-flex|inline-grid",
+ "display-listitem": "<display-outside>?&&[flow|flow-root]?&&list-item",
+ "display-outside": "block|inline|run-in",
+ "drop-shadow()": "drop-shadow( <length>{2,3} <color>? )",
+ "east-asian-variant-values": "[jis78|jis83|jis90|jis04|simplified|traditional]",
+ "east-asian-width-values": "[full-width|proportional-width]",
+ "element()": "element( <custom-ident> , [first|start|last|first-except]? )|element( <id-selector> )",
+ "ellipse()": "ellipse( [<shape-radius>{2}]? [at <position>]? )",
+ "ending-shape": "circle|ellipse",
+ "env()": "env( <custom-ident> , <declaration-value>? )",
+ "explicit-track-list": "[<line-names>? <track-size>]+ <line-names>?",
+ "family-name": "<string>|<custom-ident>+",
+ "feature-tag-value": "<string> [<integer>|on|off]?",
+ "feature-type": "@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation",
+ "feature-value-block": "<feature-type> '{' <feature-value-declaration-list> '}'",
+ "feature-value-block-list": "<feature-value-block>+",
+ "feature-value-declaration": "<custom-ident> : <integer>+ ;",
+ "feature-value-declaration-list": "<feature-value-declaration>",
+ "feature-value-name": "<custom-ident>",
+ "fill-rule": "nonzero|evenodd",
+ "filter-function": "<blur()>|<brightness()>|<contrast()>|<drop-shadow()>|<grayscale()>|<hue-rotate()>|<invert()>|<opacity()>|<saturate()>|<sepia()>",
+ "filter-function-list": "[<filter-function>|<url>]+",
+ "final-bg-layer": "<'background-color'>||<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>",
+ "fit-content()": "fit-content( [<length>|<percentage>] )",
+ "fixed-breadth": "<length-percentage>",
+ "fixed-repeat": "repeat( [<positive-integer>] , [<line-names>? <fixed-size>]+ <line-names>? )",
+ "fixed-size": "<fixed-breadth>|minmax( <fixed-breadth> , <track-breadth> )|minmax( <inflexible-breadth> , <fixed-breadth> )",
+ "font-stretch-absolute": "normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|<percentage>",
+ "font-variant-css21": "[normal|small-caps]",
+ "font-weight-absolute": "normal|bold|<number [1,1000]>",
+ "frequency-percentage": "<frequency>|<percentage>",
+ "general-enclosed": "[<function-token> <any-value> )]|( <ident> <any-value> )",
+ "generic-family": "serif|sans-serif|cursive|fantasy|monospace|-apple-system",
+ "generic-name": "serif|sans-serif|cursive|fantasy|monospace",
+ "geometry-box": "<shape-box>|fill-box|stroke-box|view-box",
+ "gradient": "<linear-gradient()>|<repeating-linear-gradient()>|<radial-gradient()>|<repeating-radial-gradient()>|<conic-gradient()>|<-legacy-gradient>",
+ "grayscale()": "grayscale( <number-percentage> )",
+ "grid-line": "auto|<custom-ident>|[<integer>&&<custom-ident>?]|[span&&[<integer>||<custom-ident>]]",
+ "historical-lig-values": "[historical-ligatures|no-historical-ligatures]",
+ "hsl()": "hsl( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsl( <hue> , <percentage> , <percentage> , <alpha-value>? )",
+ "hsla()": "hsla( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsla( <hue> , <percentage> , <percentage> , <alpha-value>? )",
+ "hue": "<number>|<angle>",
+ "hue-rotate()": "hue-rotate( <angle> )",
+ "image": "<url>|<image()>|<image-set()>|<element()>|<paint()>|<cross-fade()>|<gradient>",
+ "image()": "image( <image-tags>? [<image-src>? , <color>?]! )",
+ "image-set()": "image-set( <image-set-option># )",
+ "image-set-option": "[<image>|<string>] <resolution>",
+ "image-src": "<url>|<string>",
+ "image-tags": "ltr|rtl",
+ "inflexible-breadth": "<length>|<percentage>|min-content|max-content|auto",
+ "inset()": "inset( <length-percentage>{1,4} [round <'border-radius'>]? )",
+ "invert()": "invert( <number-percentage> )",
+ "keyframes-name": "<custom-ident>|<string>",
+ "keyframe-block": "<keyframe-selector># { <declaration-list> }",
+ "keyframe-block-list": "<keyframe-block>+",
+ "keyframe-selector": "from|to|<percentage>",
+ "leader()": "leader( <leader-type> )",
+ "leader-type": "dotted|solid|space|<string>",
+ "length-percentage": "<length>|<percentage>",
+ "line-names": "'[' <custom-ident>* ']'",
+ "line-name-list": "[<line-names>|<name-repeat>]+",
+ "line-style": "none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset",
+ "line-width": "<length>|thin|medium|thick",
+ "linear-color-hint": "<length-percentage>",
+ "linear-color-stop": "<color> <color-stop-length>?",
+ "linear-gradient()": "linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )",
+ "mask-layer": "<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||<geometry-box>||[<geometry-box>|no-clip]||<compositing-operator>||<masking-mode>",
+ "mask-position": "[<length-percentage>|left|center|right] [<length-percentage>|top|center|bottom]?",
+ "mask-reference": "none|<image>|<mask-source>",
+ "mask-source": "<url>",
+ "masking-mode": "alpha|luminance|match-source",
+ "matrix()": "matrix( <number>#{6} )",
+ "matrix3d()": "matrix3d( <number>#{16} )",
+ "max()": "max( <calc-sum># )",
+ "media-and": "<media-in-parens> [and <media-in-parens>]+",
+ "media-condition": "<media-not>|<media-and>|<media-or>|<media-in-parens>",
+ "media-condition-without-or": "<media-not>|<media-and>|<media-in-parens>",
+ "media-feature": "( [<mf-plain>|<mf-boolean>|<mf-range>] )",
+ "media-in-parens": "( <media-condition> )|<media-feature>|<general-enclosed>",
+ "media-not": "not <media-in-parens>",
+ "media-or": "<media-in-parens> [or <media-in-parens>]+",
+ "media-query": "<media-condition>|[not|only]? <media-type> [and <media-condition-without-or>]?",
+ "media-query-list": "<media-query>#",
+ "media-type": "<ident>",
+ "mf-boolean": "<mf-name>",
+ "mf-name": "<ident>",
+ "mf-plain": "<mf-name> : <mf-value>",
+ "mf-range": "<mf-name> ['<'|'>']? '='? <mf-value>|<mf-value> ['<'|'>']? '='? <mf-name>|<mf-value> '<' '='? <mf-name> '<' '='? <mf-value>|<mf-value> '>' '='? <mf-name> '>' '='? <mf-value>",
+ "mf-value": "<number>|<dimension>|<ident>|<ratio>",
+ "min()": "min( <calc-sum># )",
+ "minmax()": "minmax( [<length>|<percentage>|min-content|max-content|auto] , [<length>|<percentage>|<flex>|min-content|max-content|auto] )",
+ "named-color": "transparent|aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|<-non-standard-color>",
+ "namespace-prefix": "<ident>",
+ "ns-prefix": "[<ident-token>|'*']? '|'",
+ "number-percentage": "<number>|<percentage>",
+ "numeric-figure-values": "[lining-nums|oldstyle-nums]",
+ "numeric-fraction-values": "[diagonal-fractions|stacked-fractions]",
+ "numeric-spacing-values": "[proportional-nums|tabular-nums]",
+ "nth": "<an-plus-b>|even|odd",
+ "opacity()": "opacity( [<number-percentage>] )",
+ "overflow-position": "unsafe|safe",
+ "outline-radius": "<length>|<percentage>",
+ "page-body": "<declaration>? [; <page-body>]?|<page-margin-box> <page-body>",
+ "page-margin-box": "<page-margin-box-type> '{' <declaration-list> '}'",
+ "page-margin-box-type": "@top-left-corner|@top-left|@top-center|@top-right|@top-right-corner|@bottom-left-corner|@bottom-left|@bottom-center|@bottom-right|@bottom-right-corner|@left-top|@left-middle|@left-bottom|@right-top|@right-middle|@right-bottom",
+ "page-selector-list": "[<page-selector>#]?",
+ "page-selector": "<pseudo-page>+|<ident> <pseudo-page>*",
+ "path()": "path( [<fill-rule> ,]? <string> )",
+ "paint()": "paint( <ident> , <declaration-value>? )",
+ "perspective()": "perspective( <length> )",
+ "polygon()": "polygon( <fill-rule>? , [<length-percentage> <length-percentage>]# )",
+ "position": "[[left|center|right]||[top|center|bottom]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]?|[[left|right] <length-percentage>]&&[[top|bottom] <length-percentage>]]",
+ "pseudo-class-selector": "':' <ident-token>|':' <function-token> <any-value> ')'",
+ "pseudo-element-selector": "':' <pseudo-class-selector>",
+ "pseudo-page": ": [left|right|first|blank]",
+ "quote": "open-quote|close-quote|no-open-quote|no-close-quote",
+ "radial-gradient()": "radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )",
+ "relative-selector": "<combinator>? <complex-selector>",
+ "relative-selector-list": "<relative-selector>#",
+ "relative-size": "larger|smaller",
+ "repeat-style": "repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}",
+ "repeating-linear-gradient()": "repeating-linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )",
+ "repeating-radial-gradient()": "repeating-radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )",
+ "rgb()": "rgb( <percentage>{3} [/ <alpha-value>]? )|rgb( <number>{3} [/ <alpha-value>]? )|rgb( <percentage>#{3} , <alpha-value>? )|rgb( <number>#{3} , <alpha-value>? )",
+ "rgba()": "rgba( <percentage>{3} [/ <alpha-value>]? )|rgba( <number>{3} [/ <alpha-value>]? )|rgba( <percentage>#{3} , <alpha-value>? )|rgba( <number>#{3} , <alpha-value>? )",
+ "rotate()": "rotate( [<angle>|<zero>] )",
+ "rotate3d()": "rotate3d( <number> , <number> , <number> , [<angle>|<zero>] )",
+ "rotateX()": "rotateX( [<angle>|<zero>] )",
+ "rotateY()": "rotateY( [<angle>|<zero>] )",
+ "rotateZ()": "rotateZ( [<angle>|<zero>] )",
+ "saturate()": "saturate( <number-percentage> )",
+ "scale()": "scale( <number> , <number>? )",
+ "scale3d()": "scale3d( <number> , <number> , <number> )",
+ "scaleX()": "scaleX( <number> )",
+ "scaleY()": "scaleY( <number> )",
+ "scaleZ()": "scaleZ( <number> )",
+ "self-position": "center|start|end|self-start|self-end|flex-start|flex-end",
+ "shape-radius": "<length-percentage>|closest-side|farthest-side",
+ "skew()": "skew( [<angle>|<zero>] , [<angle>|<zero>]? )",
+ "skewX()": "skewX( [<angle>|<zero>] )",
+ "skewY()": "skewY( [<angle>|<zero>] )",
+ "sepia()": "sepia( <number-percentage> )",
+ "shadow": "inset?&&<length>{2,4}&&<color>?",
+ "shadow-t": "[<length>{2,3}&&<color>?]",
+ "shape": "rect( <top> , <right> , <bottom> , <left> )|rect( <top> <right> <bottom> <left> )",
+ "shape-box": "<box>|margin-box",
+ "side-or-corner": "[left|right]||[top|bottom]",
+ "single-animation": "<time>||<timing-function>||<time>||<single-animation-iteration-count>||<single-animation-direction>||<single-animation-fill-mode>||<single-animation-play-state>||[none|<keyframes-name>]",
+ "single-animation-direction": "normal|reverse|alternate|alternate-reverse",
+ "single-animation-fill-mode": "none|forwards|backwards|both",
+ "single-animation-iteration-count": "infinite|<number>",
+ "single-animation-play-state": "running|paused",
+ "single-transition": "[none|<single-transition-property>]||<time>||<timing-function>||<time>",
+ "single-transition-property": "all|<custom-ident>",
+ "size": "closest-side|farthest-side|closest-corner|farthest-corner|<length>|<length-percentage>{2}",
+ "step-position": "jump-start|jump-end|jump-none|jump-both|start|end",
+ "step-timing-function": "step-start|step-end|steps( <integer> [, <step-position>]? )",
+ "subclass-selector": "<id-selector>|<class-selector>|<attribute-selector>|<pseudo-class-selector>",
+ "supports-condition": "not <supports-in-parens>|<supports-in-parens> [and <supports-in-parens>]*|<supports-in-parens> [or <supports-in-parens>]*",
+ "supports-in-parens": "( <supports-condition> )|<supports-feature>|<general-enclosed>",
+ "supports-feature": "<supports-decl>|<supports-selector-fn>",
+ "supports-decl": "( <declaration> )",
+ "supports-selector-fn": "selector( <complex-selector> )",
+ "symbol": "<string>|<image>|<custom-ident>",
+ "target": "<target-counter()>|<target-counters()>|<target-text()>",
+ "target-counter()": "target-counter( [<string>|<url>] , <custom-ident> , <counter-style>? )",
+ "target-counters()": "target-counters( [<string>|<url>] , <custom-ident> , <string> , <counter-style>? )",
+ "target-text()": "target-text( [<string>|<url>] , [content|before|after|first-letter]? )",
+ "time-percentage": "<time>|<percentage>",
+ "timing-function": "linear|<cubic-bezier-timing-function>|<step-timing-function>",
+ "track-breadth": "<length-percentage>|<flex>|min-content|max-content|auto",
+ "track-list": "[<line-names>? [<track-size>|<track-repeat>]]+ <line-names>?",
+ "track-repeat": "repeat( [<positive-integer>] , [<line-names>? <track-size>]+ <line-names>? )",
+ "track-size": "<track-breadth>|minmax( <inflexible-breadth> , <track-breadth> )|fit-content( [<length>|<percentage>] )",
+ "transform-function": "<matrix()>|<translate()>|<translateX()>|<translateY()>|<scale()>|<scaleX()>|<scaleY()>|<rotate()>|<skew()>|<skewX()>|<skewY()>|<matrix3d()>|<translate3d()>|<translateZ()>|<scale3d()>|<scaleZ()>|<rotate3d()>|<rotateX()>|<rotateY()>|<rotateZ()>|<perspective()>",
+ "transform-list": "<transform-function>+",
+ "translate()": "translate( <length-percentage> , <length-percentage>? )",
+ "translate3d()": "translate3d( <length-percentage> , <length-percentage> , <length> )",
+ "translateX()": "translateX( <length-percentage> )",
+ "translateY()": "translateY( <length-percentage> )",
+ "translateZ()": "translateZ( <length> )",
+ "type-or-unit": "string|color|url|integer|number|length|angle|time|frequency|cap|ch|em|ex|ic|lh|rlh|rem|vb|vi|vw|vh|vmin|vmax|mm|Q|cm|in|pt|pc|px|deg|grad|rad|turn|ms|s|Hz|kHz|%",
+ "type-selector": "<wq-name>|<ns-prefix>? '*'",
+ "var()": "var( <custom-property-name> , <declaration-value>? )",
+ "viewport-length": "auto|<length-percentage>",
+ "wq-name": "<ns-prefix>? <ident-token>",
+ "-legacy-gradient": "<-webkit-gradient()>|<-legacy-linear-gradient>|<-legacy-repeating-linear-gradient>|<-legacy-radial-gradient>|<-legacy-repeating-radial-gradient>",
+ "-legacy-linear-gradient": "-moz-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-linear-gradient( <-legacy-linear-gradient-arguments> )",
+ "-legacy-repeating-linear-gradient": "-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )",
+ "-legacy-linear-gradient-arguments": "[<angle>|<side-or-corner>]? , <color-stop-list>",
+ "-legacy-radial-gradient": "-moz-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-radial-gradient( <-legacy-radial-gradient-arguments> )",
+ "-legacy-repeating-radial-gradient": "-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )",
+ "-legacy-radial-gradient-arguments": "[<position> ,]? [[[<-legacy-radial-gradient-shape>||<-legacy-radial-gradient-size>]|[<length>|<percentage>]{2}] ,]? <color-stop-list>",
+ "-legacy-radial-gradient-size": "closest-side|closest-corner|farthest-side|farthest-corner|contain|cover",
+ "-legacy-radial-gradient-shape": "circle|ellipse",
+ "-non-standard-font": "-apple-system-body|-apple-system-headline|-apple-system-subheadline|-apple-system-caption1|-apple-system-caption2|-apple-system-footnote|-apple-system-short-body|-apple-system-short-headline|-apple-system-short-subheadline|-apple-system-short-caption1|-apple-system-short-footnote|-apple-system-tall-body",
+ "-non-standard-color": "-moz-ButtonDefault|-moz-ButtonHoverFace|-moz-ButtonHoverText|-moz-CellHighlight|-moz-CellHighlightText|-moz-Combobox|-moz-ComboboxText|-moz-Dialog|-moz-DialogText|-moz-dragtargetzone|-moz-EvenTreeRow|-moz-Field|-moz-FieldText|-moz-html-CellHighlight|-moz-html-CellHighlightText|-moz-mac-accentdarkestshadow|-moz-mac-accentdarkshadow|-moz-mac-accentface|-moz-mac-accentlightesthighlight|-moz-mac-accentlightshadow|-moz-mac-accentregularhighlight|-moz-mac-accentregularshadow|-moz-mac-chrome-active|-moz-mac-chrome-inactive|-moz-mac-focusring|-moz-mac-menuselect|-moz-mac-menushadow|-moz-mac-menutextselect|-moz-MenuHover|-moz-MenuHoverText|-moz-MenuBarText|-moz-MenuBarHoverText|-moz-nativehyperlinktext|-moz-OddTreeRow|-moz-win-communicationstext|-moz-win-mediatext|-moz-activehyperlinktext|-moz-default-background-color|-moz-default-color|-moz-hyperlinktext|-moz-visitedhyperlinktext|-webkit-activelink|-webkit-focus-ring-color|-webkit-link|-webkit-text",
+ "-non-standard-image-rendering": "optimize-contrast|-moz-crisp-edges|-o-crisp-edges|-webkit-optimize-contrast",
+ "-non-standard-overflow": "-moz-scrollbars-none|-moz-scrollbars-horizontal|-moz-scrollbars-vertical|-moz-hidden-unscrollable",
+ "-non-standard-width": "fill-available|min-intrinsic|intrinsic|-moz-available|-moz-fit-content|-moz-min-content|-moz-max-content|-webkit-min-content|-webkit-max-content",
+ "-webkit-gradient()": "-webkit-gradient( <-webkit-gradient-type> , <-webkit-gradient-point> [, <-webkit-gradient-point>|, <-webkit-gradient-radius> , <-webkit-gradient-point>] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )",
+ "-webkit-gradient-color-stop": "from( <color> )|color-stop( [<number-zero-one>|<percentage>] , <color> )|to( <color> )",
+ "-webkit-gradient-point": "[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]",
+ "-webkit-gradient-radius": "<length>|<percentage>",
+ "-webkit-gradient-type": "linear|radial",
+ "-webkit-mask-box-repeat": "repeat|stretch|round",
+ "-webkit-mask-clip-style": "border|border-box|padding|padding-box|content|content-box|text",
+ "-ms-filter-function-list": "<-ms-filter-function>+",
+ "-ms-filter-function": "<-ms-filter-function-progid>|<-ms-filter-function-legacy>",
+ "-ms-filter-function-progid": "'progid:' [<ident-token> '.']* [<ident-token>|<function-token> <any-value>? )]",
+ "-ms-filter-function-legacy": "<ident-token>|<function-token> <any-value>? )",
+ "-ms-filter": "<string>",
+ "age": "child|young|old",
+ "attr-name": "<wq-name>",
+ "attr-fallback": "<any-value>",
+ "border-radius": "<length-percentage>{1,2}",
+ "bottom": "<length>|auto",
+ "generic-voice": "[<age>? <gender> <integer>?]",
+ "gender": "male|female|neutral",
+ "left": "<length>|auto",
+ "mask-image": "<mask-reference>#",
+ "name-repeat": "repeat( [<positive-integer>|auto-fill] , <line-names>+ )",
+ "paint": "none|<color>|<url> [none|<color>]?|context-fill|context-stroke",
+ "page-size": "A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger",
+ "ratio": "<integer> / <integer>",
+ "right": "<length>|auto",
+ "svg-length": "<percentage>|<length>|<number>",
+ "svg-writing-mode": "lr-tb|rl-tb|tb-rl|lr|rl|tb",
+ "top": "<length>|auto",
+ "track-group": "'(' [<string>* <track-minmax> <string>*]+ ')' ['[' <positive-integer> ']']?|<track-minmax>",
+ "track-list-v0": "[<string>* <track-group> <string>*]+|none",
+ "track-minmax": "minmax( <track-breadth> , <track-breadth> )|auto|<track-breadth>|fit-content",
+ "x": "<number>",
+ "y": "<number>",
+ "declaration": "<ident-token> : <declaration-value>? ['!' important]?",
+ "declaration-list": "[<declaration>? ';']* <declaration>?",
+ "url": "url( <string> <url-modifier>* )|<url-token>",
+ "url-modifier": "<ident>|<function-token> <any-value> )",
+ "number-zero-one": "<number [0,1]>",
+ "number-one-or-greater": "<number [1,∞]>",
+ "positive-integer": "<integer [0,∞]>",
+ "-non-standard-display": "-ms-inline-flexbox|-ms-grid|-ms-inline-grid|-webkit-flex|-webkit-inline-flex|-webkit-box|-webkit-inline-box|-moz-inline-stack|-moz-box|-moz-inline-box"
+ },
+ "properties": {
+ "--*": "<declaration-value>",
+ "-ms-accelerator": "false|true",
+ "-ms-block-progression": "tb|rl|bt|lr",
+ "-ms-content-zoom-chaining": "none|chained",
+ "-ms-content-zooming": "none|zoom",
+ "-ms-content-zoom-limit": "<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>",
+ "-ms-content-zoom-limit-max": "<percentage>",
+ "-ms-content-zoom-limit-min": "<percentage>",
+ "-ms-content-zoom-snap": "<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>",
+ "-ms-content-zoom-snap-points": "snapInterval( <percentage> , <percentage> )|snapList( <percentage># )",
+ "-ms-content-zoom-snap-type": "none|proximity|mandatory",
+ "-ms-filter": "<string>",
+ "-ms-flow-from": "[none|<custom-ident>]#",
+ "-ms-flow-into": "[none|<custom-ident>]#",
+ "-ms-grid-columns": "none|<track-list>|<auto-track-list>",
+ "-ms-grid-rows": "none|<track-list>|<auto-track-list>",
+ "-ms-high-contrast-adjust": "auto|none",
+ "-ms-hyphenate-limit-chars": "auto|<integer>{1,3}",
+ "-ms-hyphenate-limit-lines": "no-limit|<integer>",
+ "-ms-hyphenate-limit-zone": "<percentage>|<length>",
+ "-ms-ime-align": "auto|after",
+ "-ms-overflow-style": "auto|none|scrollbar|-ms-autohiding-scrollbar",
+ "-ms-scrollbar-3dlight-color": "<color>",
+ "-ms-scrollbar-arrow-color": "<color>",
+ "-ms-scrollbar-base-color": "<color>",
+ "-ms-scrollbar-darkshadow-color": "<color>",
+ "-ms-scrollbar-face-color": "<color>",
+ "-ms-scrollbar-highlight-color": "<color>",
+ "-ms-scrollbar-shadow-color": "<color>",
+ "-ms-scrollbar-track-color": "<color>",
+ "-ms-scroll-chaining": "chained|none",
+ "-ms-scroll-limit": "<'-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": "auto|<length>",
+ "-ms-scroll-limit-x-min": "<length>",
+ "-ms-scroll-limit-y-max": "auto|<length>",
+ "-ms-scroll-limit-y-min": "<length>",
+ "-ms-scroll-rails": "none|railed",
+ "-ms-scroll-snap-points-x": "snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )",
+ "-ms-scroll-snap-points-y": "snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )",
+ "-ms-scroll-snap-type": "none|proximity|mandatory",
+ "-ms-scroll-snap-x": "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>",
+ "-ms-scroll-snap-y": "<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>",
+ "-ms-scroll-translation": "none|vertical-to-horizontal",
+ "-ms-text-autospace": "none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space",
+ "-ms-touch-select": "grippers|none",
+ "-ms-user-select": "none|element|text",
+ "-ms-wrap-flow": "auto|both|start|end|maximum|clear",
+ "-ms-wrap-margin": "<length>",
+ "-ms-wrap-through": "wrap|none",
+ "-moz-appearance": "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": "<url>|none",
+ "-moz-border-bottom-colors": "<color>+|none",
+ "-moz-border-left-colors": "<color>+|none",
+ "-moz-border-right-colors": "<color>+|none",
+ "-moz-border-top-colors": "<color>+|none",
+ "-moz-context-properties": "none|[fill|fill-opacity|stroke|stroke-opacity]#",
+ "-moz-float-edge": "border-box|content-box|margin-box|padding-box",
+ "-moz-force-broken-image-icon": "<integer [0,1]>",
+ "-moz-image-region": "<shape>|auto",
+ "-moz-orient": "inline|block|horizontal|vertical",
+ "-moz-outline-radius": "<outline-radius>{1,4} [/ <outline-radius>{1,4}]?",
+ "-moz-outline-radius-bottomleft": "<outline-radius>",
+ "-moz-outline-radius-bottomright": "<outline-radius>",
+ "-moz-outline-radius-topleft": "<outline-radius>",
+ "-moz-outline-radius-topright": "<outline-radius>",
+ "-moz-stack-sizing": "ignore|stretch-to-fit",
+ "-moz-text-blink": "none|blink",
+ "-moz-user-focus": "ignore|normal|select-after|select-before|select-menu|select-same|select-all|none",
+ "-moz-user-input": "auto|none|enabled|disabled",
+ "-moz-user-modify": "read-only|read-write|write-only",
+ "-moz-window-dragging": "drag|no-drag",
+ "-moz-window-shadow": "default|menu|tooltip|sheet|none",
+ "-webkit-appearance": "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-before": "<'border-width'>||<'border-style'>||<'color'>",
+ "-webkit-border-before-color": "<'color'>",
+ "-webkit-border-before-style": "<'border-style'>",
+ "-webkit-border-before-width": "<'border-width'>",
+ "-webkit-box-reflect": "[above|below|right|left]? <length>? <image>?",
+ "-webkit-line-clamp": "none|<integer>",
+ "-webkit-mask": "[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<box>|border|padding|content|text]||[<box>|border|padding|content]]#",
+ "-webkit-mask-attachment": "<attachment>#",
+ "-webkit-mask-clip": "[<box>|border|padding|content|text]#",
+ "-webkit-mask-composite": "<composite-style>#",
+ "-webkit-mask-image": "<mask-reference>#",
+ "-webkit-mask-origin": "[<box>|border|padding|content]#",
+ "-webkit-mask-position": "<position>#",
+ "-webkit-mask-position-x": "[<length-percentage>|left|center|right]#",
+ "-webkit-mask-position-y": "[<length-percentage>|top|center|bottom]#",
+ "-webkit-mask-repeat": "<repeat-style>#",
+ "-webkit-mask-repeat-x": "repeat|no-repeat|space|round",
+ "-webkit-mask-repeat-y": "repeat|no-repeat|space|round",
+ "-webkit-mask-size": "<bg-size>#",
+ "-webkit-overflow-scrolling": "auto|touch",
+ "-webkit-tap-highlight-color": "<color>",
+ "-webkit-text-fill-color": "<color>",
+ "-webkit-text-stroke": "<length>||<color>",
+ "-webkit-text-stroke-color": "<color>",
+ "-webkit-text-stroke-width": "<length>",
+ "-webkit-touch-callout": "default|none",
+ "-webkit-user-modify": "read-only|read-write|read-write-plaintext-only",
+ "align-content": "normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>",
+ "align-items": "normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]",
+ "align-self": "auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>",
+ "align-tracks": "[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#",
+ "all": "initial|inherit|unset|revert",
+ "animation": "<single-animation>#",
+ "animation-delay": "<time>#",
+ "animation-direction": "<single-animation-direction>#",
+ "animation-duration": "<time>#",
+ "animation-fill-mode": "<single-animation-fill-mode>#",
+ "animation-iteration-count": "<single-animation-iteration-count>#",
+ "animation-name": "[none|<keyframes-name>]#",
+ "animation-play-state": "<single-animation-play-state>#",
+ "animation-timing-function": "<timing-function>#",
+ "appearance": "none|auto|textfield|menulist-button|<compat-auto>",
+ "aspect-ratio": "auto|<ratio>",
+ "azimuth": "<angle>|[[left-side|far-left|left|center-left|center|center-right|right|far-right|right-side]||behind]|leftwards|rightwards",
+ "backdrop-filter": "none|<filter-function-list>",
+ "backface-visibility": "visible|hidden",
+ "background": "[<bg-layer> ,]* <final-bg-layer>",
+ "background-attachment": "<attachment>#",
+ "background-blend-mode": "<blend-mode>#",
+ "background-clip": "<box>#",
+ "background-color": "<color>",
+ "background-image": "<bg-image>#",
+ "background-origin": "<box>#",
+ "background-position": "<bg-position>#",
+ "background-position-x": "[center|[[left|right|x-start|x-end]? <length-percentage>?]!]#",
+ "background-position-y": "[center|[[top|bottom|y-start|y-end]? <length-percentage>?]!]#",
+ "background-repeat": "<repeat-style>#",
+ "background-size": "<bg-size>#",
+ "block-overflow": "clip|ellipsis|<string>",
+ "block-size": "<'width'>",
+ "border": "<line-width>||<line-style>||<color>",
+ "border-block": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-block-color": "<'border-top-color'>{1,2}",
+ "border-block-style": "<'border-top-style'>",
+ "border-block-width": "<'border-top-width'>",
+ "border-block-end": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-block-end-color": "<'border-top-color'>",
+ "border-block-end-style": "<'border-top-style'>",
+ "border-block-end-width": "<'border-top-width'>",
+ "border-block-start": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-block-start-color": "<'border-top-color'>",
+ "border-block-start-style": "<'border-top-style'>",
+ "border-block-start-width": "<'border-top-width'>",
+ "border-bottom": "<line-width>||<line-style>||<color>",
+ "border-bottom-color": "<'border-top-color'>",
+ "border-bottom-left-radius": "<length-percentage>{1,2}",
+ "border-bottom-right-radius": "<length-percentage>{1,2}",
+ "border-bottom-style": "<line-style>",
+ "border-bottom-width": "<line-width>",
+ "border-collapse": "collapse|separate",
+ "border-color": "<color>{1,4}",
+ "border-end-end-radius": "<length-percentage>{1,2}",
+ "border-end-start-radius": "<length-percentage>{1,2}",
+ "border-image": "<'border-image-source'>||<'border-image-slice'> [/ <'border-image-width'>|/ <'border-image-width'>? / <'border-image-outset'>]?||<'border-image-repeat'>",
+ "border-image-outset": "[<length>|<number>]{1,4}",
+ "border-image-repeat": "[stretch|repeat|round|space]{1,2}",
+ "border-image-slice": "<number-percentage>{1,4}&&fill?",
+ "border-image-source": "none|<image>",
+ "border-image-width": "[<length-percentage>|<number>|auto]{1,4}",
+ "border-inline": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-inline-end": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-inline-color": "<'border-top-color'>{1,2}",
+ "border-inline-style": "<'border-top-style'>",
+ "border-inline-width": "<'border-top-width'>",
+ "border-inline-end-color": "<'border-top-color'>",
+ "border-inline-end-style": "<'border-top-style'>",
+ "border-inline-end-width": "<'border-top-width'>",
+ "border-inline-start": "<'border-top-width'>||<'border-top-style'>||<'color'>",
+ "border-inline-start-color": "<'border-top-color'>",
+ "border-inline-start-style": "<'border-top-style'>",
+ "border-inline-start-width": "<'border-top-width'>",
+ "border-left": "<line-width>||<line-style>||<color>",
+ "border-left-color": "<color>",
+ "border-left-style": "<line-style>",
+ "border-left-width": "<line-width>",
+ "border-radius": "<length-percentage>{1,4} [/ <length-percentage>{1,4}]?",
+ "border-right": "<line-width>||<line-style>||<color>",
+ "border-right-color": "<color>",
+ "border-right-style": "<line-style>",
+ "border-right-width": "<line-width>",
+ "border-spacing": "<length> <length>?",
+ "border-start-end-radius": "<length-percentage>{1,2}",
+ "border-start-start-radius": "<length-percentage>{1,2}",
+ "border-style": "<line-style>{1,4}",
+ "border-top": "<line-width>||<line-style>||<color>",
+ "border-top-color": "<color>",
+ "border-top-left-radius": "<length-percentage>{1,2}",
+ "border-top-right-radius": "<length-percentage>{1,2}",
+ "border-top-style": "<line-style>",
+ "border-top-width": "<line-width>",
+ "border-width": "<line-width>{1,4}",
+ "bottom": "<length>|<percentage>|auto",
+ "box-align": "start|center|end|baseline|stretch",
+ "box-decoration-break": "slice|clone",
+ "box-direction": "normal|reverse|inherit",
+ "box-flex": "<number>",
+ "box-flex-group": "<integer>",
+ "box-lines": "single|multiple",
+ "box-ordinal-group": "<integer>",
+ "box-orient": "horizontal|vertical|inline-axis|block-axis|inherit",
+ "box-pack": "start|center|end|justify",
+ "box-shadow": "none|<shadow>#",
+ "box-sizing": "content-box|border-box",
+ "break-after": "auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region",
+ "break-before": "auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region",
+ "break-inside": "auto|avoid|avoid-page|avoid-column|avoid-region",
+ "caption-side": "top|bottom|block-start|block-end|inline-start|inline-end",
+ "caret-color": "auto|<color>",
+ "clear": "none|left|right|both|inline-start|inline-end",
+ "clip": "<shape>|auto",
+ "clip-path": "<clip-source>|[<basic-shape>||<geometry-box>]|none",
+ "color": "<color>",
+ "color-adjust": "economy|exact",
+ "column-count": "<integer>|auto",
+ "column-fill": "auto|balance|balance-all",
+ "column-gap": "normal|<length-percentage>",
+ "column-rule": "<'column-rule-width'>||<'column-rule-style'>||<'column-rule-color'>",
+ "column-rule-color": "<color>",
+ "column-rule-style": "<'border-style'>",
+ "column-rule-width": "<'border-width'>",
+ "column-span": "none|all",
+ "column-width": "<length>|auto",
+ "columns": "<'column-width'>||<'column-count'>",
+ "contain": "none|strict|content|[size||layout||style||paint]",
+ "content": "normal|none|[<content-replacement>|<content-list>] [/ <string>]?",
+ "counter-increment": "[<custom-ident> <integer>?]+|none",
+ "counter-reset": "[<custom-ident> <integer>?]+|none",
+ "counter-set": "[<custom-ident> <integer>?]+|none",
+ "cursor": "[[<url> [<x> <y>]? ,]* [auto|default|none|context-menu|help|pointer|progress|wait|cell|crosshair|text|vertical-text|alias|copy|move|no-drop|not-allowed|e-resize|n-resize|ne-resize|nw-resize|s-resize|se-resize|sw-resize|w-resize|ew-resize|ns-resize|nesw-resize|nwse-resize|col-resize|row-resize|all-scroll|zoom-in|zoom-out|grab|grabbing|hand|-webkit-grab|-webkit-grabbing|-webkit-zoom-in|-webkit-zoom-out|-moz-grab|-moz-grabbing|-moz-zoom-in|-moz-zoom-out]]",
+ "direction": "ltr|rtl",
+ "display": "[<display-outside>||<display-inside>]|<display-listitem>|<display-internal>|<display-box>|<display-legacy>|<-non-standard-display>",
+ "empty-cells": "show|hide",
+ "filter": "none|<filter-function-list>|<-ms-filter-function-list>",
+ "flex": "none|[<'flex-grow'> <'flex-shrink'>?||<'flex-basis'>]",
+ "flex-basis": "content|<'width'>",
+ "flex-direction": "row|row-reverse|column|column-reverse",
+ "flex-flow": "<'flex-direction'>||<'flex-wrap'>",
+ "flex-grow": "<number>",
+ "flex-shrink": "<number>",
+ "flex-wrap": "nowrap|wrap|wrap-reverse",
+ "float": "left|right|none|inline-start|inline-end",
+ "font": "[[<'font-style'>||<font-variant-css21>||<'font-weight'>||<'font-stretch'>]? <'font-size'> [/ <'line-height'>]? <'font-family'>]|caption|icon|menu|message-box|small-caption|status-bar",
+ "font-family": "[<family-name>|<generic-family>]#",
+ "font-feature-settings": "normal|<feature-tag-value>#",
+ "font-kerning": "auto|normal|none",
+ "font-language-override": "normal|<string>",
+ "font-optical-sizing": "auto|none",
+ "font-variation-settings": "normal|[<string> <number>]#",
+ "font-size": "<absolute-size>|<relative-size>|<length-percentage>",
+ "font-size-adjust": "none|<number>",
+ "font-smooth": "auto|never|always|<absolute-size>|<length>",
+ "font-stretch": "<font-stretch-absolute>",
+ "font-style": "normal|italic|oblique <angle>?",
+ "font-synthesis": "none|[weight||style]",
+ "font-variant": "normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]",
+ "font-variant-alternates": "normal|[stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )]",
+ "font-variant-caps": "normal|small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps",
+ "font-variant-east-asian": "normal|[<east-asian-variant-values>||<east-asian-width-values>||ruby]",
+ "font-variant-ligatures": "normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>]",
+ "font-variant-numeric": "normal|[<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero]",
+ "font-variant-position": "normal|sub|super",
+ "font-weight": "<font-weight-absolute>|bolder|lighter",
+ "gap": "<'row-gap'> <'column-gap'>?",
+ "grid": "<'grid-template'>|<'grid-template-rows'> / [auto-flow&&dense?] <'grid-auto-columns'>?|[auto-flow&&dense?] <'grid-auto-rows'>? / <'grid-template-columns'>",
+ "grid-area": "<grid-line> [/ <grid-line>]{0,3}",
+ "grid-auto-columns": "<track-size>+",
+ "grid-auto-flow": "[row|column]||dense",
+ "grid-auto-rows": "<track-size>+",
+ "grid-column": "<grid-line> [/ <grid-line>]?",
+ "grid-column-end": "<grid-line>",
+ "grid-column-gap": "<length-percentage>",
+ "grid-column-start": "<grid-line>",
+ "grid-gap": "<'grid-row-gap'> <'grid-column-gap'>?",
+ "grid-row": "<grid-line> [/ <grid-line>]?",
+ "grid-row-end": "<grid-line>",
+ "grid-row-gap": "<length-percentage>",
+ "grid-row-start": "<grid-line>",
+ "grid-template": "none|[<'grid-template-rows'> / <'grid-template-columns'>]|[<line-names>? <string> <track-size>? <line-names>?]+ [/ <explicit-track-list>]?",
+ "grid-template-areas": "none|<string>+",
+ "grid-template-columns": "none|<track-list>|<auto-track-list>|subgrid <line-name-list>?",
+ "grid-template-rows": "none|<track-list>|<auto-track-list>|subgrid <line-name-list>?",
+ "hanging-punctuation": "none|[first||[force-end|allow-end]||last]",
+ "height": "auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )",
+ "hyphens": "none|manual|auto",
+ "image-orientation": "from-image|<angle>|[<angle>? flip]",
+ "image-rendering": "auto|crisp-edges|pixelated|optimizeSpeed|optimizeQuality|<-non-standard-image-rendering>",
+ "image-resolution": "[from-image||<resolution>]&&snap?",
+ "ime-mode": "auto|normal|active|inactive|disabled",
+ "initial-letter": "normal|[<number> <integer>?]",
+ "initial-letter-align": "[auto|alphabetic|hanging|ideographic]",
+ "inline-size": "<'width'>",
+ "inset": "<'top'>{1,4}",
+ "inset-block": "<'top'>{1,2}",
+ "inset-block-end": "<'top'>",
+ "inset-block-start": "<'top'>",
+ "inset-inline": "<'top'>{1,2}",
+ "inset-inline-end": "<'top'>",
+ "inset-inline-start": "<'top'>",
+ "isolation": "auto|isolate",
+ "justify-content": "normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]",
+ "justify-items": "normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|legacy|legacy&&[left|right|center]",
+ "justify-self": "auto|normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]",
+ "justify-tracks": "[normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]]#",
+ "left": "<length>|<percentage>|auto",
+ "letter-spacing": "normal|<length-percentage>",
+ "line-break": "auto|loose|normal|strict|anywhere",
+ "line-clamp": "none|<integer>",
+ "line-height": "normal|<number>|<length>|<percentage>",
+ "line-height-step": "<length>",
+ "list-style": "<'list-style-type'>||<'list-style-position'>||<'list-style-image'>",
+ "list-style-image": "<url>|none",
+ "list-style-position": "inside|outside",
+ "list-style-type": "<counter-style>|<string>|none",
+ "margin": "[<length>|<percentage>|auto]{1,4}",
+ "margin-block": "<'margin-left'>{1,2}",
+ "margin-block-end": "<'margin-left'>",
+ "margin-block-start": "<'margin-left'>",
+ "margin-bottom": "<length>|<percentage>|auto",
+ "margin-inline": "<'margin-left'>{1,2}",
+ "margin-inline-end": "<'margin-left'>",
+ "margin-inline-start": "<'margin-left'>",
+ "margin-left": "<length>|<percentage>|auto",
+ "margin-right": "<length>|<percentage>|auto",
+ "margin-top": "<length>|<percentage>|auto",
+ "margin-trim": "none|in-flow|all",
+ "mask": "<mask-layer>#",
+ "mask-border": "<'mask-border-source'>||<'mask-border-slice'> [/ <'mask-border-width'>? [/ <'mask-border-outset'>]?]?||<'mask-border-repeat'>||<'mask-border-mode'>",
+ "mask-border-mode": "luminance|alpha",
+ "mask-border-outset": "[<length>|<number>]{1,4}",
+ "mask-border-repeat": "[stretch|repeat|round|space]{1,2}",
+ "mask-border-slice": "<number-percentage>{1,4} fill?",
+ "mask-border-source": "none|<image>",
+ "mask-border-width": "[<length-percentage>|<number>|auto]{1,4}",
+ "mask-clip": "[<geometry-box>|no-clip]#",
+ "mask-composite": "<compositing-operator>#",
+ "mask-image": "<mask-reference>#",
+ "mask-mode": "<masking-mode>#",
+ "mask-origin": "<geometry-box>#",
+ "mask-position": "<position>#",
+ "mask-repeat": "<repeat-style>#",
+ "mask-size": "<bg-size>#",
+ "mask-type": "luminance|alpha",
+ "masonry-auto-flow": "[pack|next]||[definite-first|ordered]",
+ "math-style": "normal|compact",
+ "max-block-size": "<'max-width'>",
+ "max-height": "none|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )",
+ "max-inline-size": "<'max-width'>",
+ "max-lines": "none|<integer>",
+ "max-width": "none|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )|<-non-standard-width>",
+ "min-block-size": "<'min-width'>",
+ "min-height": "auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )",
+ "min-inline-size": "<'min-width'>",
+ "min-width": "auto|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )|<-non-standard-width>",
+ "mix-blend-mode": "<blend-mode>",
+ "object-fit": "fill|contain|cover|none|scale-down",
+ "object-position": "<position>",
+ "offset": "[<'offset-position'>? [<'offset-path'> [<'offset-distance'>||<'offset-rotate'>]?]?]! [/ <'offset-anchor'>]?",
+ "offset-anchor": "auto|<position>",
+ "offset-distance": "<length-percentage>",
+ "offset-path": "none|ray( [<angle>&&<size>&&contain?] )|<path()>|<url>|[<basic-shape>||<geometry-box>]",
+ "offset-position": "auto|<position>",
+ "offset-rotate": "[auto|reverse]||<angle>",
+ "opacity": "<alpha-value>",
+ "order": "<integer>",
+ "orphans": "<integer>",
+ "outline": "[<'outline-color'>||<'outline-style'>||<'outline-width'>]",
+ "outline-color": "<color>|invert",
+ "outline-offset": "<length>",
+ "outline-style": "auto|<'border-style'>",
+ "outline-width": "<line-width>",
+ "overflow": "[visible|hidden|clip|scroll|auto]{1,2}|<-non-standard-overflow>",
+ "overflow-anchor": "auto|none",
+ "overflow-block": "visible|hidden|clip|scroll|auto",
+ "overflow-clip-box": "padding-box|content-box",
+ "overflow-inline": "visible|hidden|clip|scroll|auto",
+ "overflow-wrap": "normal|break-word|anywhere",
+ "overflow-x": "visible|hidden|clip|scroll|auto",
+ "overflow-y": "visible|hidden|clip|scroll|auto",
+ "overscroll-behavior": "[contain|none|auto]{1,2}",
+ "overscroll-behavior-block": "contain|none|auto",
+ "overscroll-behavior-inline": "contain|none|auto",
+ "overscroll-behavior-x": "contain|none|auto",
+ "overscroll-behavior-y": "contain|none|auto",
+ "padding": "[<length>|<percentage>]{1,4}",
+ "padding-block": "<'padding-left'>{1,2}",
+ "padding-block-end": "<'padding-left'>",
+ "padding-block-start": "<'padding-left'>",
+ "padding-bottom": "<length>|<percentage>",
+ "padding-inline": "<'padding-left'>{1,2}",
+ "padding-inline-end": "<'padding-left'>",
+ "padding-inline-start": "<'padding-left'>",
+ "padding-left": "<length>|<percentage>",
+ "padding-right": "<length>|<percentage>",
+ "padding-top": "<length>|<percentage>",
+ "page-break-after": "auto|always|avoid|left|right|recto|verso",
+ "page-break-before": "auto|always|avoid|left|right|recto|verso",
+ "page-break-inside": "auto|avoid",
+ "paint-order": "normal|[fill||stroke||markers]",
+ "perspective": "none|<length>",
+ "perspective-origin": "<position>",
+ "place-content": "<'align-content'> <'justify-content'>?",
+ "place-items": "<'align-items'> <'justify-items'>?",
+ "place-self": "<'align-self'> <'justify-self'>?",
+ "pointer-events": "auto|none|visiblePainted|visibleFill|visibleStroke|visible|painted|fill|stroke|all|inherit",
+ "position": "static|relative|absolute|sticky|fixed|-webkit-sticky",
+ "quotes": "none|auto|[<string> <string>]+",
+ "resize": "none|both|horizontal|vertical|block|inline",
+ "right": "<length>|<percentage>|auto",
+ "rotate": "none|<angle>|[x|y|z|<number>{3}]&&<angle>",
+ "row-gap": "normal|<length-percentage>",
+ "ruby-align": "start|center|space-between|space-around",
+ "ruby-merge": "separate|collapse|auto",
+ "ruby-position": "over|under|inter-character",
+ "scale": "none|<number>{1,3}",
+ "scrollbar-color": "auto|dark|light|<color>{2}",
+ "scrollbar-gutter": "auto|[stable|always]&&both?&&force?",
+ "scrollbar-width": "auto|thin|none",
+ "scroll-behavior": "auto|smooth",
+ "scroll-margin": "<length>{1,4}",
+ "scroll-margin-block": "<length>{1,2}",
+ "scroll-margin-block-start": "<length>",
+ "scroll-margin-block-end": "<length>",
+ "scroll-margin-bottom": "<length>",
+ "scroll-margin-inline": "<length>{1,2}",
+ "scroll-margin-inline-start": "<length>",
+ "scroll-margin-inline-end": "<length>",
+ "scroll-margin-left": "<length>",
+ "scroll-margin-right": "<length>",
+ "scroll-margin-top": "<length>",
+ "scroll-padding": "[auto|<length-percentage>]{1,4}",
+ "scroll-padding-block": "[auto|<length-percentage>]{1,2}",
+ "scroll-padding-block-start": "auto|<length-percentage>",
+ "scroll-padding-block-end": "auto|<length-percentage>",
+ "scroll-padding-bottom": "auto|<length-percentage>",
+ "scroll-padding-inline": "[auto|<length-percentage>]{1,2}",
+ "scroll-padding-inline-start": "auto|<length-percentage>",
+ "scroll-padding-inline-end": "auto|<length-percentage>",
+ "scroll-padding-left": "auto|<length-percentage>",
+ "scroll-padding-right": "auto|<length-percentage>",
+ "scroll-padding-top": "auto|<length-percentage>",
+ "scroll-snap-align": "[none|start|end|center]{1,2}",
+ "scroll-snap-coordinate": "none|<position>#",
+ "scroll-snap-destination": "<position>",
+ "scroll-snap-points-x": "none|repeat( <length-percentage> )",
+ "scroll-snap-points-y": "none|repeat( <length-percentage> )",
+ "scroll-snap-stop": "normal|always",
+ "scroll-snap-type": "none|[x|y|block|inline|both] [mandatory|proximity]?",
+ "scroll-snap-type-x": "none|mandatory|proximity",
+ "scroll-snap-type-y": "none|mandatory|proximity",
+ "shape-image-threshold": "<alpha-value>",
+ "shape-margin": "<length-percentage>",
+ "shape-outside": "none|<shape-box>||<basic-shape>|<image>",
+ "tab-size": "<integer>|<length>",
+ "table-layout": "auto|fixed",
+ "text-align": "start|end|left|right|center|justify|match-parent",
+ "text-align-last": "auto|start|end|left|right|center|justify",
+ "text-combine-upright": "none|all|[digits <integer>?]",
+ "text-decoration": "<'text-decoration-line'>||<'text-decoration-style'>||<'text-decoration-color'>||<'text-decoration-thickness'>",
+ "text-decoration-color": "<color>",
+ "text-decoration-line": "none|[underline||overline||line-through||blink]|spelling-error|grammar-error",
+ "text-decoration-skip": "none|[objects||[spaces|[leading-spaces||trailing-spaces]]||edges||box-decoration]",
+ "text-decoration-skip-ink": "auto|all|none",
+ "text-decoration-style": "solid|double|dotted|dashed|wavy",
+ "text-decoration-thickness": "auto|from-font|<length>|<percentage>",
+ "text-emphasis": "<'text-emphasis-style'>||<'text-emphasis-color'>",
+ "text-emphasis-color": "<color>",
+ "text-emphasis-position": "[over|under]&&[right|left]",
+ "text-emphasis-style": "none|[[filled|open]||[dot|circle|double-circle|triangle|sesame]]|<string>",
+ "text-indent": "<length-percentage>&&hanging?&&each-line?",
+ "text-justify": "auto|inter-character|inter-word|none",
+ "text-orientation": "mixed|upright|sideways",
+ "text-overflow": "[clip|ellipsis|<string>]{1,2}",
+ "text-rendering": "auto|optimizeSpeed|optimizeLegibility|geometricPrecision",
+ "text-shadow": "none|<shadow-t>#",
+ "text-size-adjust": "none|auto|<percentage>",
+ "text-transform": "none|capitalize|uppercase|lowercase|full-width|full-size-kana",
+ "text-underline-offset": "auto|<length>|<percentage>",
+ "text-underline-position": "auto|from-font|[under||[left|right]]",
+ "top": "<length>|<percentage>|auto",
+ "touch-action": "auto|none|[[pan-x|pan-left|pan-right]||[pan-y|pan-up|pan-down]||pinch-zoom]|manipulation",
+ "transform": "none|<transform-list>",
+ "transform-box": "content-box|border-box|fill-box|stroke-box|view-box",
+ "transform-origin": "[<length-percentage>|left|center|right|top|bottom]|[[<length-percentage>|left|center|right]&&[<length-percentage>|top|center|bottom]] <length>?",
+ "transform-style": "flat|preserve-3d",
+ "transition": "<single-transition>#",
+ "transition-delay": "<time>#",
+ "transition-duration": "<time>#",
+ "transition-property": "none|<single-transition-property>#",
+ "transition-timing-function": "<timing-function>#",
+ "translate": "none|<length-percentage> [<length-percentage> <length>?]?",
+ "unicode-bidi": "normal|embed|isolate|bidi-override|isolate-override|plaintext|-moz-isolate|-moz-isolate-override|-moz-plaintext|-webkit-isolate|-webkit-isolate-override|-webkit-plaintext",
+ "user-select": "auto|text|none|contain|all",
+ "vertical-align": "baseline|sub|super|text-top|text-bottom|middle|top|bottom|<percentage>|<length>",
+ "visibility": "visible|hidden|collapse",
+ "white-space": "normal|pre|nowrap|pre-wrap|pre-line|break-spaces",
+ "widows": "<integer>",
+ "width": "auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )|fit-content|-moz-fit-content|-webkit-fit-content",
+ "will-change": "auto|<animateable-feature>#",
+ "word-break": "normal|break-all|keep-all|break-word",
+ "word-spacing": "normal|<length-percentage>",
+ "word-wrap": "normal|break-word",
+ "writing-mode": "horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr|<svg-writing-mode>",
+ "z-index": "auto|<integer>",
+ "zoom": "normal|reset|<number>|<percentage>",
+ "-moz-background-clip": "padding|border",
+ "-moz-border-radius-bottomleft": "<'border-bottom-left-radius'>",
+ "-moz-border-radius-bottomright": "<'border-bottom-right-radius'>",
+ "-moz-border-radius-topleft": "<'border-top-left-radius'>",
+ "-moz-border-radius-topright": "<'border-bottom-right-radius'>",
+ "-moz-control-character-visibility": "visible|hidden",
+ "-moz-osx-font-smoothing": "auto|grayscale",
+ "-moz-user-select": "none|text|all|-moz-none",
+ "-ms-flex-align": "start|end|center|baseline|stretch",
+ "-ms-flex-item-align": "auto|start|end|center|baseline|stretch",
+ "-ms-flex-line-pack": "start|end|center|justify|distribute|stretch",
+ "-ms-flex-negative": "<'flex-shrink'>",
+ "-ms-flex-pack": "start|end|center|justify|distribute",
+ "-ms-flex-order": "<integer>",
+ "-ms-flex-positive": "<'flex-grow'>",
+ "-ms-flex-preferred-size": "<'flex-basis'>",
+ "-ms-interpolation-mode": "nearest-neighbor|bicubic",
+ "-ms-grid-column-align": "start|end|center|stretch",
+ "-ms-grid-row-align": "start|end|center|stretch",
+ "-ms-hyphenate-limit-last": "none|always|column|page|spread",
+ "-webkit-background-clip": "[<box>|border|padding|content|text]#",
+ "-webkit-column-break-after": "always|auto|avoid",
+ "-webkit-column-break-before": "always|auto|avoid",
+ "-webkit-column-break-inside": "always|auto|avoid",
+ "-webkit-font-smoothing": "auto|none|antialiased|subpixel-antialiased",
+ "-webkit-mask-box-image": "[<url>|<gradient>|none] [<length-percentage>{4} <-webkit-mask-box-repeat>{2}]?",
+ "-webkit-print-color-adjust": "economy|exact",
+ "-webkit-text-security": "none|circle|disc|square",
+ "-webkit-user-drag": "none|element|auto",
+ "-webkit-user-select": "auto|none|text|all",
+ "alignment-baseline": "auto|baseline|before-edge|text-before-edge|middle|central|after-edge|text-after-edge|ideographic|alphabetic|hanging|mathematical",
+ "baseline-shift": "baseline|sub|super|<svg-length>",
+ "behavior": "<url>+",
+ "clip-rule": "nonzero|evenodd",
+ "cue": "<'cue-before'> <'cue-after'>?",
+ "cue-after": "<url> <decibel>?|none",
+ "cue-before": "<url> <decibel>?|none",
+ "dominant-baseline": "auto|use-script|no-change|reset-size|ideographic|alphabetic|hanging|mathematical|central|middle|text-after-edge|text-before-edge",
+ "fill": "<paint>",
+ "fill-opacity": "<number-zero-one>",
+ "fill-rule": "nonzero|evenodd",
+ "glyph-orientation-horizontal": "<angle>",
+ "glyph-orientation-vertical": "<angle>",
+ "kerning": "auto|<svg-length>",
+ "marker": "none|<url>",
+ "marker-end": "none|<url>",
+ "marker-mid": "none|<url>",
+ "marker-start": "none|<url>",
+ "pause": "<'pause-before'> <'pause-after'>?",
+ "pause-after": "<time>|none|x-weak|weak|medium|strong|x-strong",
+ "pause-before": "<time>|none|x-weak|weak|medium|strong|x-strong",
+ "rest": "<'rest-before'> <'rest-after'>?",
+ "rest-after": "<time>|none|x-weak|weak|medium|strong|x-strong",
+ "rest-before": "<time>|none|x-weak|weak|medium|strong|x-strong",
+ "shape-rendering": "auto|optimizeSpeed|crispEdges|geometricPrecision",
+ "src": "[<url> [format( <string># )]?|local( <family-name> )]#",
+ "speak": "auto|none|normal",
+ "speak-as": "normal|spell-out||digits||[literal-punctuation|no-punctuation]",
+ "stroke": "<paint>",
+ "stroke-dasharray": "none|[<svg-length>+]#",
+ "stroke-dashoffset": "<svg-length>",
+ "stroke-linecap": "butt|round|square",
+ "stroke-linejoin": "miter|round|bevel",
+ "stroke-miterlimit": "<number-one-or-greater>",
+ "stroke-opacity": "<number-zero-one>",
+ "stroke-width": "<svg-length>",
+ "text-anchor": "start|middle|end",
+ "unicode-range": "<urange>#",
+ "voice-balance": "<number>|left|center|right|leftwards|rightwards",
+ "voice-duration": "auto|<time>",
+ "voice-family": "[[<family-name>|<generic-voice>] ,]* [<family-name>|<generic-voice>]|preserve",
+ "voice-pitch": "<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]",
+ "voice-range": "<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]",
+ "voice-rate": "[normal|x-slow|slow|medium|fast|x-fast]||<percentage>",
+ "voice-stress": "normal|strong|moderate|none|reduced",
+ "voice-volume": "silent|[[x-soft|soft|medium|loud|x-loud]||<decibel>]"
+ },
+ "atrules": {
+ "charset": {
+ "prelude": "<string>",
+ "descriptors": null
+ },
+ "counter-style": {
+ "prelude": "<counter-style-name>",
+ "descriptors": {
+ "additive-symbols": "[<integer>&&<symbol>]#",
+ "fallback": "<counter-style-name>",
+ "negative": "<symbol> <symbol>?",
+ "pad": "<integer>&&<symbol>",
+ "prefix": "<symbol>",
+ "range": "[[<integer>|infinite]{2}]#|auto",
+ "speak-as": "auto|bullets|numbers|words|spell-out|<counter-style-name>",
+ "suffix": "<symbol>",
+ "symbols": "<symbol>+",
+ "system": "cyclic|numeric|alphabetic|symbolic|additive|[fixed <integer>?]|[extends <counter-style-name>]"
+ }
+ },
+ "document": {
+ "prelude": "[<url>|url-prefix( <string> )|domain( <string> )|media-document( <string> )|regexp( <string> )]#",
+ "descriptors": null
+ },
+ "font-face": {
+ "prelude": null,
+ "descriptors": {
+ "font-display": "[auto|block|swap|fallback|optional]",
+ "font-family": "<family-name>",
+ "font-feature-settings": "normal|<feature-tag-value>#",
+ "font-variation-settings": "normal|[<string> <number>]#",
+ "font-stretch": "<font-stretch-absolute>{1,2}",
+ "font-style": "normal|italic|oblique <angle>{0,2}",
+ "font-weight": "<font-weight-absolute>{1,2}",
+ "font-variant": "normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]",
+ "src": "[<url> [format( <string># )]?|local( <family-name> )]#",
+ "unicode-range": "<urange>#"
+ }
+ },
+ "font-feature-values": {
+ "prelude": "<family-name>#",
+ "descriptors": null
+ },
+ "import": {
+ "prelude": "[<string>|<url>] [<media-query-list>]?",
+ "descriptors": null
+ },
+ "keyframes": {
+ "prelude": "<keyframes-name>",
+ "descriptors": null
+ },
+ "media": {
+ "prelude": "<media-query-list>",
+ "descriptors": null
+ },
+ "namespace": {
+ "prelude": "<namespace-prefix>? [<string>|<url>]",
+ "descriptors": null
+ },
+ "page": {
+ "prelude": "<page-selector-list>",
+ "descriptors": {
+ "bleed": "auto|<length>",
+ "marks": "none|[crop||cross]",
+ "size": "<length>{1,2}|auto|[<page-size>||[portrait|landscape]]"
+ }
+ },
+ "property": {
+ "prelude": "<custom-property-name>",
+ "descriptors": {
+ "syntax": "<string>",
+ "inherits": "true|false",
+ "initial-value": "<string>"
+ }
+ },
+ "supports": {
+ "prelude": "<supports-condition>",
+ "descriptors": null
+ },
+ "viewport": {
+ "prelude": null,
+ "descriptors": {
+ "height": "<viewport-length>{1,2}",
+ "max-height": "<viewport-length>",
+ "max-width": "<viewport-length>",
+ "max-zoom": "auto|<number>|<percentage>",
+ "min-height": "<viewport-length>",
+ "min-width": "<viewport-length>",
+ "min-zoom": "auto|<number>|<percentage>",
+ "orientation": "auto|portrait|landscape",
+ "user-zoom": "zoom|fixed",
+ "viewport-fit": "auto|contain|cover",
+ "width": "<viewport-length>{1,2}",
+ "zoom": "auto|<number>|<percentage>"
+ }
+ }
+ }
+ };
+
+ var cmpChar$3 = tokenizer.cmpChar;
+ var isDigit$4 = tokenizer.isDigit;
+ var TYPE$9 = tokenizer.TYPE;
+
+ var WHITESPACE$4 = TYPE$9.WhiteSpace;
+ var COMMENT$4 = TYPE$9.Comment;
+ var IDENT$3 = TYPE$9.Ident;
+ var NUMBER$3 = TYPE$9.Number;
+ var DIMENSION$2 = TYPE$9.Dimension;
+ var PLUSSIGN$3 = 0x002B; // U+002B PLUS SIGN (+)
+ var HYPHENMINUS$3 = 0x002D; // U+002D HYPHEN-MINUS (-)
+ var N$4 = 0x006E; // U+006E LATIN SMALL LETTER N (n)
+ var DISALLOW_SIGN$1 = true;
+ var ALLOW_SIGN$1 = false;
+
+ function checkInteger$1(offset, disallowSign) {
+ var pos = this.scanner.tokenStart + offset;
+ var code = this.scanner.source.charCodeAt(pos);
+
+ if (code === PLUSSIGN$3 || code === HYPHENMINUS$3) {
+ if (disallowSign) {
+ this.error('Number sign is not allowed');
+ }
+ pos++;
+ }
+
+ for (; pos < this.scanner.tokenEnd; pos++) {
+ if (!isDigit$4(this.scanner.source.charCodeAt(pos))) {
+ this.error('Integer is expected', pos);
+ }
+ }
+ }
+
+ function checkTokenIsInteger(disallowSign) {
+ return checkInteger$1.call(this, 0, disallowSign);
+ }
+
+ function expectCharCode(offset, code) {
+ if (!cmpChar$3(this.scanner.source, this.scanner.tokenStart + offset, code)) {
+ var msg = '';
+
+ switch (code) {
+ case N$4:
+ msg = 'N is expected';
+ break;
+ case HYPHENMINUS$3:
+ msg = 'HyphenMinus is expected';
+ break;
+ }
+
+ this.error(msg, this.scanner.tokenStart + offset);
+ }
+ }
+
+ // ... <signed-integer>
+ // ... ['+' | '-'] <signless-integer>
+ function consumeB$1() {
+ var offset = 0;
+ var sign = 0;
+ var type = this.scanner.tokenType;
+
+ while (type === WHITESPACE$4 || type === COMMENT$4) {
+ type = this.scanner.lookupType(++offset);
+ }
+
+ if (type !== NUMBER$3) {
+ if (this.scanner.isDelim(PLUSSIGN$3, offset) ||
+ this.scanner.isDelim(HYPHENMINUS$3, offset)) {
+ sign = this.scanner.isDelim(PLUSSIGN$3, offset) ? PLUSSIGN$3 : HYPHENMINUS$3;
+
+ do {
+ type = this.scanner.lookupType(++offset);
+ } while (type === WHITESPACE$4 || type === COMMENT$4);
+
+ if (type !== NUMBER$3) {
+ this.scanner.skip(offset);
+ checkTokenIsInteger.call(this, DISALLOW_SIGN$1);
+ }
+ } else {
+ return null;
+ }
+ }
+
+ if (offset > 0) {
+ this.scanner.skip(offset);
+ }
+
+ if (sign === 0) {
+ type = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+ if (type !== PLUSSIGN$3 && type !== HYPHENMINUS$3) {
+ this.error('Number sign is expected');
+ }
+ }
+
+ checkTokenIsInteger.call(this, sign !== 0);
+ return sign === HYPHENMINUS$3 ? '-' + this.consume(NUMBER$3) : this.consume(NUMBER$3);
+ }
+
+ // An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+ var AnPlusB = {
+ name: 'AnPlusB',
+ structure: {
+ a: [String, null],
+ b: [String, null]
+ },
+ parse: function() {
+ /* eslint-disable brace-style*/
+ var start = this.scanner.tokenStart;
+ var a = null;
+ var b = null;
+
+ // <integer>
+ if (this.scanner.tokenType === NUMBER$3) {
+ checkTokenIsInteger.call(this, ALLOW_SIGN$1);
+ b = this.consume(NUMBER$3);
+ }
+
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ // -n- <signless-integer>
+ // <dashndashdigit-ident>
+ else if (this.scanner.tokenType === IDENT$3 && cmpChar$3(this.scanner.source, this.scanner.tokenStart, HYPHENMINUS$3)) {
+ a = '-1';
+
+ expectCharCode.call(this, 1, N$4);
+
+ switch (this.scanner.getTokenLength()) {
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ case 2:
+ this.scanner.next();
+ b = consumeB$1.call(this);
+ break;
+
+ // -n- <signless-integer>
+ case 3:
+ expectCharCode.call(this, 2, HYPHENMINUS$3);
+
+ this.scanner.next();
+ this.scanner.skipSC();
+
+ checkTokenIsInteger.call(this, DISALLOW_SIGN$1);
+
+ b = '-' + this.consume(NUMBER$3);
+ break;
+
+ // <dashndashdigit-ident>
+ default:
+ expectCharCode.call(this, 2, HYPHENMINUS$3);
+ checkInteger$1.call(this, 3, DISALLOW_SIGN$1);
+ this.scanner.next();
+
+ b = this.scanner.substrToCursor(start + 2);
+ }
+ }
+
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ // '+'? n- <signless-integer>
+ // '+'? <ndashdigit-ident>
+ else if (this.scanner.tokenType === IDENT$3 || (this.scanner.isDelim(PLUSSIGN$3) && this.scanner.lookupType(1) === IDENT$3)) {
+ var sign = 0;
+ a = '1';
+
+ // just ignore a plus
+ if (this.scanner.isDelim(PLUSSIGN$3)) {
+ sign = 1;
+ this.scanner.next();
+ }
+
+ expectCharCode.call(this, 0, N$4);
+
+ switch (this.scanner.getTokenLength()) {
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ case 1:
+ this.scanner.next();
+ b = consumeB$1.call(this);
+ break;
+
+ // '+'? n- <signless-integer>
+ case 2:
+ expectCharCode.call(this, 1, HYPHENMINUS$3);
+
+ this.scanner.next();
+ this.scanner.skipSC();
+
+ checkTokenIsInteger.call(this, DISALLOW_SIGN$1);
+
+ b = '-' + this.consume(NUMBER$3);
+ break;
+
+ // '+'? <ndashdigit-ident>
+ default:
+ expectCharCode.call(this, 1, HYPHENMINUS$3);
+ checkInteger$1.call(this, 2, DISALLOW_SIGN$1);
+ this.scanner.next();
+
+ b = this.scanner.substrToCursor(start + sign + 1);
+ }
+ }
+
+ // <ndashdigit-dimension>
+ // <ndash-dimension> <signless-integer>
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ else if (this.scanner.tokenType === DIMENSION$2) {
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+ var sign = code === PLUSSIGN$3 || code === HYPHENMINUS$3;
+
+ for (var i = this.scanner.tokenStart + sign; i < this.scanner.tokenEnd; i++) {
+ if (!isDigit$4(this.scanner.source.charCodeAt(i))) {
+ break;
+ }
+ }
+
+ if (i === this.scanner.tokenStart + sign) {
+ this.error('Integer is expected', this.scanner.tokenStart + sign);
+ }
+
+ expectCharCode.call(this, i - this.scanner.tokenStart, N$4);
+ a = this.scanner.source.substring(start, i);
+
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ if (i + 1 === this.scanner.tokenEnd) {
+ this.scanner.next();
+ b = consumeB$1.call(this);
+ } else {
+ expectCharCode.call(this, i - this.scanner.tokenStart + 1, HYPHENMINUS$3);
+
+ // <ndash-dimension> <signless-integer>
+ if (i + 2 === this.scanner.tokenEnd) {
+ this.scanner.next();
+ this.scanner.skipSC();
+ checkTokenIsInteger.call(this, DISALLOW_SIGN$1);
+ b = '-' + this.consume(NUMBER$3);
+ }
+ // <ndashdigit-dimension>
+ else {
+ checkInteger$1.call(this, i - this.scanner.tokenStart + 2, DISALLOW_SIGN$1);
+ this.scanner.next();
+ b = this.scanner.substrToCursor(i + 1);
+ }
+ }
+ } else {
+ this.error();
+ }
+
+ if (a !== null && a.charCodeAt(0) === PLUSSIGN$3) {
+ a = a.substr(1);
+ }
+
+ if (b !== null && b.charCodeAt(0) === PLUSSIGN$3) {
+ b = b.substr(1);
+ }
+
+ return {
+ type: 'AnPlusB',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ a: a,
+ b: b
+ };
+ },
+ generate: function(node) {
+ var a = node.a !== null && node.a !== undefined;
+ var b = node.b !== null && node.b !== undefined;
+
+ if (a) {
+ this.chunk(
+ node.a === '+1' ? '+n' : // eslint-disable-line operator-linebreak, indent
+ node.a === '1' ? 'n' : // eslint-disable-line operator-linebreak, indent
+ node.a === '-1' ? '-n' : // eslint-disable-line operator-linebreak, indent
+ node.a + 'n' // eslint-disable-line operator-linebreak, indent
+ );
+
+ if (b) {
+ b = String(node.b);
+ if (b.charAt(0) === '-' || b.charAt(0) === '+') {
+ this.chunk(b.charAt(0));
+ this.chunk(b.substr(1));
+ } else {
+ this.chunk('+');
+ this.chunk(b);
+ }
+ }
+ } else {
+ this.chunk(String(node.b));
+ }
+ }
+ };
+
+ var TYPE$a = tokenizer.TYPE;
+
+ var WhiteSpace = TYPE$a.WhiteSpace;
+ var Semicolon = TYPE$a.Semicolon;
+ var LeftCurlyBracket = TYPE$a.LeftCurlyBracket;
+ var Delim = TYPE$a.Delim;
+ var EXCLAMATIONMARK$1 = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+ function getOffsetExcludeWS() {
+ if (this.scanner.tokenIndex > 0) {
+ if (this.scanner.lookupType(-1) === WhiteSpace) {
+ return this.scanner.tokenIndex > 1
+ ? this.scanner.getTokenStart(this.scanner.tokenIndex - 1)
+ : this.scanner.firstCharOffset;
+ }
+ }
+
+ return this.scanner.tokenStart;
+ }
+
+ // 0, 0, false
+ function balanceEnd() {
+ return 0;
+ }
+
+ // LEFTCURLYBRACKET, 0, false
+ function leftCurlyBracket(tokenType) {
+ return tokenType === LeftCurlyBracket ? 1 : 0;
+ }
+
+ // LEFTCURLYBRACKET, SEMICOLON, false
+ function leftCurlyBracketOrSemicolon(tokenType) {
+ return tokenType === LeftCurlyBracket || tokenType === Semicolon ? 1 : 0;
+ }
+
+ // EXCLAMATIONMARK, SEMICOLON, false
+ function exclamationMarkOrSemicolon(tokenType, source, offset) {
+ if (tokenType === Delim && source.charCodeAt(offset) === EXCLAMATIONMARK$1) {
+ return 1;
+ }
+
+ return tokenType === Semicolon ? 1 : 0;
+ }
+
+ // 0, SEMICOLON, true
+ function semicolonIncluded(tokenType) {
+ return tokenType === Semicolon ? 2 : 0;
+ }
+
+ var Raw = {
+ name: 'Raw',
+ structure: {
+ value: String
+ },
+ parse: function(startToken, mode, excludeWhiteSpace) {
+ var startOffset = this.scanner.getTokenStart(startToken);
+ var endOffset;
+
+ this.scanner.skip(
+ this.scanner.getRawLength(startToken, mode || balanceEnd)
+ );
+
+ if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
+ endOffset = getOffsetExcludeWS.call(this);
+ } else {
+ endOffset = this.scanner.tokenStart;
+ }
+
+ return {
+ type: 'Raw',
+ loc: this.getLocation(startOffset, endOffset),
+ value: this.scanner.source.substring(startOffset, endOffset)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ },
+
+ mode: {
+ default: balanceEnd,
+ leftCurlyBracket: leftCurlyBracket,
+ leftCurlyBracketOrSemicolon: leftCurlyBracketOrSemicolon,
+ exclamationMarkOrSemicolon: exclamationMarkOrSemicolon,
+ semicolonIncluded: semicolonIncluded
+ }
+ };
+
+ var TYPE$b = tokenizer.TYPE;
+ var rawMode = Raw.mode;
+
+ var ATKEYWORD = TYPE$b.AtKeyword;
+ var SEMICOLON = TYPE$b.Semicolon;
+ var LEFTCURLYBRACKET$1 = TYPE$b.LeftCurlyBracket;
+ var RIGHTCURLYBRACKET$1 = TYPE$b.RightCurlyBracket;
+
+ function consumeRaw(startToken) {
+ return this.Raw(startToken, rawMode.leftCurlyBracketOrSemicolon, true);
+ }
+
+ function isDeclarationBlockAtrule() {
+ for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
+ if (type === RIGHTCURLYBRACKET$1) {
+ return true;
+ }
+
+ if (type === LEFTCURLYBRACKET$1 ||
+ type === ATKEYWORD) {
+ return false;
+ }
+ }
+
+ return false;
+ }
+
+ var Atrule = {
+ name: 'Atrule',
+ structure: {
+ name: String,
+ prelude: ['AtrulePrelude', 'Raw', null],
+ block: ['Block', null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var nameLowerCase;
+ var prelude = null;
+ var block = null;
+
+ this.eat(ATKEYWORD);
+
+ name = this.scanner.substrToCursor(start + 1);
+ nameLowerCase = name.toLowerCase();
+ this.scanner.skipSC();
+
+ // parse prelude
+ if (this.scanner.eof === false &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET$1 &&
+ this.scanner.tokenType !== SEMICOLON) {
+ if (this.parseAtrulePrelude) {
+ prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
+
+ // turn empty AtrulePrelude into null
+ if (prelude.type === 'AtrulePrelude' && prelude.children.head === null) {
+ prelude = null;
+ }
+ } else {
+ prelude = consumeRaw.call(this, this.scanner.tokenIndex);
+ }
+
+ this.scanner.skipSC();
+ }
+
+ switch (this.scanner.tokenType) {
+ case SEMICOLON:
+ this.scanner.next();
+ break;
+
+ case LEFTCURLYBRACKET$1:
+ if (this.atrule.hasOwnProperty(nameLowerCase) &&
+ typeof this.atrule[nameLowerCase].block === 'function') {
+ block = this.atrule[nameLowerCase].block.call(this);
+ } else {
+ // TODO: should consume block content as Raw?
+ block = this.Block(isDeclarationBlockAtrule.call(this));
+ }
+
+ break;
+ }
+
+ return {
+ type: 'Atrule',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ prelude: prelude,
+ block: block
+ };
+ },
+ generate: function(node) {
+ this.chunk('@');
+ this.chunk(node.name);
+
+ if (node.prelude !== null) {
+ this.chunk(' ');
+ this.node(node.prelude);
+ }
+
+ if (node.block) {
+ this.node(node.block);
+ } else {
+ this.chunk(';');
+ }
+ },
+ walkContext: 'atrule'
+ };
+
+ var TYPE$c = tokenizer.TYPE;
+
+ var SEMICOLON$1 = TYPE$c.Semicolon;
+ var LEFTCURLYBRACKET$2 = TYPE$c.LeftCurlyBracket;
+
+ var AtrulePrelude = {
+ name: 'AtrulePrelude',
+ structure: {
+ children: [[]]
+ },
+ parse: function(name) {
+ var children = null;
+
+ if (name !== null) {
+ name = name.toLowerCase();
+ }
+
+ this.scanner.skipSC();
+
+ if (this.atrule.hasOwnProperty(name) &&
+ typeof this.atrule[name].prelude === 'function') {
+ // custom consumer
+ children = this.atrule[name].prelude.call(this);
+ } else {
+ // default consumer
+ children = this.readSequence(this.scope.AtrulePrelude);
+ }
+
+ this.scanner.skipSC();
+
+ if (this.scanner.eof !== true &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET$2 &&
+ this.scanner.tokenType !== SEMICOLON$1) {
+ this.error('Semicolon or block is expected');
+ }
+
+ if (children === null) {
+ children = this.createList();
+ }
+
+ return {
+ type: 'AtrulePrelude',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ },
+ walkContext: 'atrulePrelude'
+ };
+
+ var TYPE$d = tokenizer.TYPE;
+
+ var IDENT$4 = TYPE$d.Ident;
+ var STRING = TYPE$d.String;
+ var COLON = TYPE$d.Colon;
+ var LEFTSQUAREBRACKET$1 = TYPE$d.LeftSquareBracket;
+ var RIGHTSQUAREBRACKET$1 = TYPE$d.RightSquareBracket;
+ var DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)
+ var ASTERISK$1 = 0x002A; // U+002A ASTERISK (*)
+ var EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)
+ var CIRCUMFLEXACCENT = 0x005E; // U+005E (^)
+ var VERTICALLINE$1 = 0x007C; // U+007C VERTICAL LINE (|)
+ var TILDE = 0x007E; // U+007E TILDE (~)
+
+ function getAttributeName() {
+ if (this.scanner.eof) {
+ this.error('Unexpected end of input');
+ }
+
+ var start = this.scanner.tokenStart;
+ var expectIdent = false;
+ var checkColon = true;
+
+ if (this.scanner.isDelim(ASTERISK$1)) {
+ expectIdent = true;
+ checkColon = false;
+ this.scanner.next();
+ } else if (!this.scanner.isDelim(VERTICALLINE$1)) {
+ this.eat(IDENT$4);
+ }
+
+ if (this.scanner.isDelim(VERTICALLINE$1)) {
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 1) !== EQUALSSIGN) {
+ this.scanner.next();
+ this.eat(IDENT$4);
+ } else if (expectIdent) {
+ this.error('Identifier is expected', this.scanner.tokenEnd);
+ }
+ } else if (expectIdent) {
+ this.error('Vertical line is expected');
+ }
+
+ if (checkColon && this.scanner.tokenType === COLON) {
+ this.scanner.next();
+ this.eat(IDENT$4);
+ }
+
+ return {
+ type: 'Identifier',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+ }
+
+ function getOperator() {
+ var start = this.scanner.tokenStart;
+ var code = this.scanner.source.charCodeAt(start);
+
+ if (code !== EQUALSSIGN && // =
+ code !== TILDE && // ~=
+ code !== CIRCUMFLEXACCENT && // ^=
+ code !== DOLLARSIGN && // $=
+ code !== ASTERISK$1 && // *=
+ code !== VERTICALLINE$1 // |=
+ ) {
+ this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
+ }
+
+ this.scanner.next();
+
+ if (code !== EQUALSSIGN) {
+ if (!this.scanner.isDelim(EQUALSSIGN)) {
+ this.error('Equal sign is expected');
+ }
+
+ this.scanner.next();
+ }
+
+ return this.scanner.substrToCursor(start);
+ }
+
+ // '[' <wq-name> ']'
+ // '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
+ var AttributeSelector = {
+ name: 'AttributeSelector',
+ structure: {
+ name: 'Identifier',
+ matcher: [String, null],
+ value: ['String', 'Identifier', null],
+ flags: [String, null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var matcher = null;
+ var value = null;
+ var flags = null;
+
+ this.eat(LEFTSQUAREBRACKET$1);
+ this.scanner.skipSC();
+
+ name = getAttributeName.call(this);
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType !== RIGHTSQUAREBRACKET$1) {
+ // avoid case `[name i]`
+ if (this.scanner.tokenType !== IDENT$4) {
+ matcher = getOperator.call(this);
+
+ this.scanner.skipSC();
+
+ value = this.scanner.tokenType === STRING
+ ? this.String()
+ : this.Identifier();
+
+ this.scanner.skipSC();
+ }
+
+ // attribute flags
+ if (this.scanner.tokenType === IDENT$4) {
+ flags = this.scanner.getTokenValue();
+ this.scanner.next();
+
+ this.scanner.skipSC();
+ }
+ }
+
+ this.eat(RIGHTSQUAREBRACKET$1);
+
+ return {
+ type: 'AttributeSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ matcher: matcher,
+ value: value,
+ flags: flags
+ };
+ },
+ generate: function(node) {
+ var flagsPrefix = ' ';
+
+ this.chunk('[');
+ this.node(node.name);
+
+ if (node.matcher !== null) {
+ this.chunk(node.matcher);
+
+ if (node.value !== null) {
+ this.node(node.value);
+
+ // space between string and flags is not required
+ if (node.value.type === 'String') {
+ flagsPrefix = '';
+ }
+ }
+ }
+
+ if (node.flags !== null) {
+ this.chunk(flagsPrefix);
+ this.chunk(node.flags);
+ }
+
+ this.chunk(']');
+ }
+ };
+
+ var TYPE$e = tokenizer.TYPE;
+ var rawMode$1 = Raw.mode;
+
+ var WHITESPACE$5 = TYPE$e.WhiteSpace;
+ var COMMENT$5 = TYPE$e.Comment;
+ var SEMICOLON$2 = TYPE$e.Semicolon;
+ var ATKEYWORD$1 = TYPE$e.AtKeyword;
+ var LEFTCURLYBRACKET$3 = TYPE$e.LeftCurlyBracket;
+ var RIGHTCURLYBRACKET$2 = TYPE$e.RightCurlyBracket;
+
+ function consumeRaw$1(startToken) {
+ return this.Raw(startToken, null, true);
+ }
+ function consumeRule() {
+ return this.parseWithFallback(this.Rule, consumeRaw$1);
+ }
+ function consumeRawDeclaration(startToken) {
+ return this.Raw(startToken, rawMode$1.semicolonIncluded, true);
+ }
+ function consumeDeclaration() {
+ if (this.scanner.tokenType === SEMICOLON$2) {
+ return consumeRawDeclaration.call(this, this.scanner.tokenIndex);
+ }
+
+ var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
+
+ if (this.scanner.tokenType === SEMICOLON$2) {
+ this.scanner.next();
+ }
+
+ return node;
+ }
+
+ var Block = {
+ name: 'Block',
+ structure: {
+ children: [[
+ 'Atrule',
+ 'Rule',
+ 'Declaration'
+ ]]
+ },
+ parse: function(isDeclaration) {
+ var consumer = isDeclaration ? consumeDeclaration : consumeRule;
+
+ var start = this.scanner.tokenStart;
+ var children = this.createList();
+
+ this.eat(LEFTCURLYBRACKET$3);
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case RIGHTCURLYBRACKET$2:
+ break scan;
+
+ case WHITESPACE$5:
+ case COMMENT$5:
+ this.scanner.next();
+ break;
+
+ case ATKEYWORD$1:
+ children.push(this.parseWithFallback(this.Atrule, consumeRaw$1));
+ break;
+
+ default:
+ children.push(consumer.call(this));
+ }
+ }
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTCURLYBRACKET$2);
+ }
+
+ return {
+ type: 'Block',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('{');
+ this.children(node, function(prev) {
+ if (prev.type === 'Declaration') {
+ this.chunk(';');
+ }
+ });
+ this.chunk('}');
+ },
+ walkContext: 'block'
+ };
+
+ var TYPE$f = tokenizer.TYPE;
+
+ var LEFTSQUAREBRACKET$2 = TYPE$f.LeftSquareBracket;
+ var RIGHTSQUAREBRACKET$2 = TYPE$f.RightSquareBracket;
+
+ var Brackets = {
+ name: 'Brackets',
+ structure: {
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var children = null;
+
+ this.eat(LEFTSQUAREBRACKET$2);
+
+ children = readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTSQUAREBRACKET$2);
+ }
+
+ return {
+ type: 'Brackets',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('[');
+ this.children(node);
+ this.chunk(']');
+ }
+ };
+
+ var CDC = tokenizer.TYPE.CDC;
+
+ var CDC_1 = {
+ name: 'CDC',
+ structure: [],
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(CDC); // -->
+
+ return {
+ type: 'CDC',
+ loc: this.getLocation(start, this.scanner.tokenStart)
+ };
+ },
+ generate: function() {
+ this.chunk('-->');
+ }
+ };
+
+ var CDO = tokenizer.TYPE.CDO;
+
+ var CDO_1 = {
+ name: 'CDO',
+ structure: [],
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(CDO); // <!--
+
+ return {
+ type: 'CDO',
+ loc: this.getLocation(start, this.scanner.tokenStart)
+ };
+ },
+ generate: function() {
+ this.chunk('<!--');
+ }
+ };
+
+ var TYPE$g = tokenizer.TYPE;
+
+ var IDENT$5 = TYPE$g.Ident;
+ var FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+
+ // '.' ident
+ var ClassSelector = {
+ name: 'ClassSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ if (!this.scanner.isDelim(FULLSTOP)) {
+ this.error('Full stop is expected');
+ }
+
+ this.scanner.next();
+
+ return {
+ type: 'ClassSelector',
+ loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
+ name: this.consume(IDENT$5)
+ };
+ },
+ generate: function(node) {
+ this.chunk('.');
+ this.chunk(node.name);
+ }
+ };
+
+ var TYPE$h = tokenizer.TYPE;
+
+ var IDENT$6 = TYPE$h.Ident;
+ var PLUSSIGN$4 = 0x002B; // U+002B PLUS SIGN (+)
+ var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+ var GREATERTHANSIGN$1 = 0x003E; // U+003E GREATER-THAN SIGN (>)
+ var TILDE$1 = 0x007E; // U+007E TILDE (~)
+
+ // + | > | ~ | /deep/
+ var Combinator = {
+ name: 'Combinator',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ switch (code) {
+ case GREATERTHANSIGN$1:
+ case PLUSSIGN$4:
+ case TILDE$1:
+ this.scanner.next();
+ break;
+
+ case SOLIDUS:
+ this.scanner.next();
+
+ if (this.scanner.tokenType !== IDENT$6 || this.scanner.lookupValue(0, 'deep') === false) {
+ this.error('Identifier `deep` is expected');
+ }
+
+ this.scanner.next();
+
+ if (!this.scanner.isDelim(SOLIDUS)) {
+ this.error('Solidus is expected');
+ }
+
+ this.scanner.next();
+ break;
+
+ default:
+ this.error('Combinator is expected');
+ }
+
+ return {
+ type: 'Combinator',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+ };
+
+ var TYPE$i = tokenizer.TYPE;
+
+ var COMMENT$6 = TYPE$i.Comment;
+ var ASTERISK$2 = 0x002A; // U+002A ASTERISK (*)
+ var SOLIDUS$1 = 0x002F; // U+002F SOLIDUS (/)
+
+ // '/*' .* '*/'
+ var Comment = {
+ name: 'Comment',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var end = this.scanner.tokenEnd;
+
+ this.eat(COMMENT$6);
+
+ if ((end - start + 2) >= 2 &&
+ this.scanner.source.charCodeAt(end - 2) === ASTERISK$2 &&
+ this.scanner.source.charCodeAt(end - 1) === SOLIDUS$1) {
+ end -= 2;
+ }
+
+ return {
+ type: 'Comment',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start + 2, end)
+ };
+ },
+ generate: function(node) {
+ this.chunk('/*');
+ this.chunk(node.value);
+ this.chunk('*/');
+ }
+ };
+
+ var isCustomProperty$1 = names.isCustomProperty;
+ var TYPE$j = tokenizer.TYPE;
+ var rawMode$2 = Raw.mode;
+
+ var IDENT$7 = TYPE$j.Ident;
+ var HASH$1 = TYPE$j.Hash;
+ var COLON$1 = TYPE$j.Colon;
+ var SEMICOLON$3 = TYPE$j.Semicolon;
+ var DELIM$2 = TYPE$j.Delim;
+ var WHITESPACE$6 = TYPE$j.WhiteSpace;
+ var EXCLAMATIONMARK$2 = 0x0021; // U+0021 EXCLAMATION MARK (!)
+ var NUMBERSIGN$2 = 0x0023; // U+0023 NUMBER SIGN (#)
+ var DOLLARSIGN$1 = 0x0024; // U+0024 DOLLAR SIGN ($)
+ var AMPERSAND$1 = 0x0026; // U+0026 ANPERSAND (&)
+ var ASTERISK$3 = 0x002A; // U+002A ASTERISK (*)
+ var PLUSSIGN$5 = 0x002B; // U+002B PLUS SIGN (+)
+ var SOLIDUS$2 = 0x002F; // U+002F SOLIDUS (/)
+
+ function consumeValueRaw(startToken) {
+ return this.Raw(startToken, rawMode$2.exclamationMarkOrSemicolon, true);
+ }
+
+ function consumeCustomPropertyRaw(startToken) {
+ return this.Raw(startToken, rawMode$2.exclamationMarkOrSemicolon, false);
+ }
+
+ function consumeValue() {
+ var startValueToken = this.scanner.tokenIndex;
+ var value = this.Value();
+
+ if (value.type !== 'Raw' &&
+ this.scanner.eof === false &&
+ this.scanner.tokenType !== SEMICOLON$3 &&
+ this.scanner.isDelim(EXCLAMATIONMARK$2) === false &&
+ this.scanner.isBalanceEdge(startValueToken) === false) {
+ this.error();
+ }
+
+ return value;
+ }
+
+ var Declaration = {
+ name: 'Declaration',
+ structure: {
+ important: [Boolean, String],
+ property: String,
+ value: ['Value', 'Raw']
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var startToken = this.scanner.tokenIndex;
+ var property = readProperty$1.call(this);
+ var customProperty = isCustomProperty$1(property);
+ var parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
+ var consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
+ var important = false;
+ var value;
+
+ this.scanner.skipSC();
+ this.eat(COLON$1);
+
+ const valueStart = this.scanner.tokenIndex;
+
+ if (!customProperty) {
+ this.scanner.skipSC();
+ }
+
+ if (parseValue) {
+ value = this.parseWithFallback(consumeValue, consumeRaw);
+ } else {
+ value = consumeRaw.call(this, this.scanner.tokenIndex);
+ }
+
+ if (customProperty && value.type === 'Value' && value.children.isEmpty()) {
+ for (let offset = valueStart - this.scanner.tokenIndex; offset <= 0; offset++) {
+ if (this.scanner.lookupType(offset) === WHITESPACE$6) {
+ value.children.appendData({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+ });
+ break;
+ }
+ }
+ }
+
+ if (this.scanner.isDelim(EXCLAMATIONMARK$2)) {
+ important = getImportant.call(this);
+ this.scanner.skipSC();
+ }
+
+ // Do not include semicolon to range per spec
+ // https://drafts.csswg.org/css-syntax/#declaration-diagram
+
+ if (this.scanner.eof === false &&
+ this.scanner.tokenType !== SEMICOLON$3 &&
+ this.scanner.isBalanceEdge(startToken) === false) {
+ this.error();
+ }
+
+ return {
+ type: 'Declaration',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ important: important,
+ property: property,
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.property);
+ this.chunk(':');
+ this.node(node.value);
+
+ if (node.important) {
+ this.chunk(node.important === true ? '!important' : '!' + node.important);
+ }
+ },
+ walkContext: 'declaration'
+ };
+
+ function readProperty$1() {
+ var start = this.scanner.tokenStart;
+
+ // hacks
+ if (this.scanner.tokenType === DELIM$2) {
+ switch (this.scanner.source.charCodeAt(this.scanner.tokenStart)) {
+ case ASTERISK$3:
+ case DOLLARSIGN$1:
+ case PLUSSIGN$5:
+ case NUMBERSIGN$2:
+ case AMPERSAND$1:
+ this.scanner.next();
+ break;
+
+ // TODO: not sure we should support this hack
+ case SOLIDUS$2:
+ this.scanner.next();
+ if (this.scanner.isDelim(SOLIDUS$2)) {
+ this.scanner.next();
+ }
+ break;
+ }
+ }
+
+ if (this.scanner.tokenType === HASH$1) {
+ this.eat(HASH$1);
+ } else {
+ this.eat(IDENT$7);
+ }
+
+ return this.scanner.substrToCursor(start);
+ }
+
+ // ! ws* important
+ function getImportant() {
+ this.eat(DELIM$2);
+ this.scanner.skipSC();
+
+ var important = this.consume(IDENT$7);
+
+ // store original value in case it differ from `important`
+ // for better original source restoring and hacks like `!ie` support
+ return important === 'important' ? true : important;
+ }
+
+ var TYPE$k = tokenizer.TYPE;
+ var rawMode$3 = Raw.mode;
+
+ var WHITESPACE$7 = TYPE$k.WhiteSpace;
+ var COMMENT$7 = TYPE$k.Comment;
+ var SEMICOLON$4 = TYPE$k.Semicolon;
+
+ function consumeRaw$2(startToken) {
+ return this.Raw(startToken, rawMode$3.semicolonIncluded, true);
+ }
+
+ var DeclarationList = {
+ name: 'DeclarationList',
+ structure: {
+ children: [[
+ 'Declaration'
+ ]]
+ },
+ parse: function() {
+ var children = this.createList();
+
+
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE$7:
+ case COMMENT$7:
+ case SEMICOLON$4:
+ this.scanner.next();
+ break;
+
+ default:
+ children.push(this.parseWithFallback(this.Declaration, consumeRaw$2));
+ }
+ }
+
+ return {
+ type: 'DeclarationList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function(prev) {
+ if (prev.type === 'Declaration') {
+ this.chunk(';');
+ }
+ });
+ }
+ };
+
+ var consumeNumber$3 = utils.consumeNumber;
+ var TYPE$l = tokenizer.TYPE;
+
+ var DIMENSION$3 = TYPE$l.Dimension;
+
+ var Dimension = {
+ name: 'Dimension',
+ structure: {
+ value: String,
+ unit: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var numberEnd = consumeNumber$3(this.scanner.source, start);
+
+ this.eat(DIMENSION$3);
+
+ return {
+ type: 'Dimension',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start, numberEnd),
+ unit: this.scanner.source.substring(numberEnd, this.scanner.tokenStart)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ this.chunk(node.unit);
+ }
+ };
+
+ var TYPE$m = tokenizer.TYPE;
+
+ var RIGHTPARENTHESIS$2 = TYPE$m.RightParenthesis;
+
+ // <function-token> <sequence> )
+ var _Function = {
+ name: 'Function',
+ structure: {
+ name: String,
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var name = this.consumeFunctionName();
+ var nameLowerCase = name.toLowerCase();
+ var children;
+
+ children = recognizer.hasOwnProperty(nameLowerCase)
+ ? recognizer[nameLowerCase].call(this, recognizer)
+ : readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTPARENTHESIS$2);
+ }
+
+ return {
+ type: 'Function',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ },
+ walkContext: 'function'
+ };
+
+ var TYPE$n = tokenizer.TYPE;
+
+ var HASH$2 = TYPE$n.Hash;
+
+ // '#' ident
+ var Hash = {
+ name: 'Hash',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(HASH$2);
+
+ return {
+ type: 'Hash',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start + 1)
+ };
+ },
+ generate: function(node) {
+ this.chunk('#');
+ this.chunk(node.value);
+ }
+ };
+
+ var TYPE$o = tokenizer.TYPE;
+
+ var IDENT$8 = TYPE$o.Ident;
+
+ var Identifier = {
+ name: 'Identifier',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ return {
+ type: 'Identifier',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ name: this.consume(IDENT$8)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+ };
+
+ var TYPE$p = tokenizer.TYPE;
+
+ var HASH$3 = TYPE$p.Hash;
+
+ // <hash-token>
+ var IdSelector = {
+ name: 'IdSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ // TODO: check value is an ident
+ this.eat(HASH$3);
+
+ return {
+ type: 'IdSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start + 1)
+ };
+ },
+ generate: function(node) {
+ this.chunk('#');
+ this.chunk(node.name);
+ }
+ };
+
+ var TYPE$q = tokenizer.TYPE;
+
+ var IDENT$9 = TYPE$q.Ident;
+ var NUMBER$4 = TYPE$q.Number;
+ var DIMENSION$4 = TYPE$q.Dimension;
+ var LEFTPARENTHESIS$2 = TYPE$q.LeftParenthesis;
+ var RIGHTPARENTHESIS$3 = TYPE$q.RightParenthesis;
+ var COLON$2 = TYPE$q.Colon;
+ var DELIM$3 = TYPE$q.Delim;
+
+ var MediaFeature = {
+ name: 'MediaFeature',
+ structure: {
+ name: String,
+ value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var value = null;
+
+ this.eat(LEFTPARENTHESIS$2);
+ this.scanner.skipSC();
+
+ name = this.consume(IDENT$9);
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType !== RIGHTPARENTHESIS$3) {
+ this.eat(COLON$2);
+ this.scanner.skipSC();
+
+ switch (this.scanner.tokenType) {
+ case NUMBER$4:
+ if (this.lookupNonWSType(1) === DELIM$3) {
+ value = this.Ratio();
+ } else {
+ value = this.Number();
+ }
+
+ break;
+
+ case DIMENSION$4:
+ value = this.Dimension();
+ break;
+
+ case IDENT$9:
+ value = this.Identifier();
+
+ break;
+
+ default:
+ this.error('Number, dimension, ratio or identifier is expected');
+ }
+
+ this.scanner.skipSC();
+ }
+
+ this.eat(RIGHTPARENTHESIS$3);
+
+ return {
+ type: 'MediaFeature',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk('(');
+ this.chunk(node.name);
+ if (node.value !== null) {
+ this.chunk(':');
+ this.node(node.value);
+ }
+ this.chunk(')');
+ }
+ };
+
+ var TYPE$r = tokenizer.TYPE;
+
+ var WHITESPACE$8 = TYPE$r.WhiteSpace;
+ var COMMENT$8 = TYPE$r.Comment;
+ var IDENT$a = TYPE$r.Ident;
+ var LEFTPARENTHESIS$3 = TYPE$r.LeftParenthesis;
+
+ var MediaQuery = {
+ name: 'MediaQuery',
+ structure: {
+ children: [[
+ 'Identifier',
+ 'MediaFeature',
+ 'WhiteSpace'
+ ]]
+ },
+ parse: function() {
+ this.scanner.skipSC();
+
+ var children = this.createList();
+ var child = null;
+ var space = null;
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case COMMENT$8:
+ this.scanner.next();
+ continue;
+
+ case WHITESPACE$8:
+ space = this.WhiteSpace();
+ continue;
+
+ case IDENT$a:
+ child = this.Identifier();
+ break;
+
+ case LEFTPARENTHESIS$3:
+ child = this.MediaFeature();
+ break;
+
+ default:
+ break scan;
+ }
+
+ if (space !== null) {
+ children.push(space);
+ space = null;
+ }
+
+ children.push(child);
+ }
+
+ if (child === null) {
+ this.error('Identifier or parenthesis is expected');
+ }
+
+ return {
+ type: 'MediaQuery',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+ };
+
+ var COMMA$1 = tokenizer.TYPE.Comma;
+
+ var MediaQueryList = {
+ name: 'MediaQueryList',
+ structure: {
+ children: [[
+ 'MediaQuery'
+ ]]
+ },
+ parse: function(relative) {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ while (!this.scanner.eof) {
+ children.push(this.MediaQuery(relative));
+
+ if (this.scanner.tokenType !== COMMA$1) {
+ break;
+ }
+
+ this.scanner.next();
+ }
+
+ return {
+ type: 'MediaQueryList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function() {
+ this.chunk(',');
+ });
+ }
+ };
+
+ var Nth = {
+ name: 'Nth',
+ structure: {
+ nth: ['AnPlusB', 'Identifier'],
+ selector: ['SelectorList', null]
+ },
+ parse: function(allowOfClause) {
+ this.scanner.skipSC();
+
+ var start = this.scanner.tokenStart;
+ var end = start;
+ var selector = null;
+ var query;
+
+ if (this.scanner.lookupValue(0, 'odd') || this.scanner.lookupValue(0, 'even')) {
+ query = this.Identifier();
+ } else {
+ query = this.AnPlusB();
+ }
+
+ this.scanner.skipSC();
+
+ if (allowOfClause && this.scanner.lookupValue(0, 'of')) {
+ this.scanner.next();
+
+ selector = this.SelectorList();
+
+ if (this.needPositions) {
+ end = this.getLastListNode(selector.children).loc.end.offset;
+ }
+ } else {
+ if (this.needPositions) {
+ end = query.loc.end.offset;
+ }
+ }
+
+ return {
+ type: 'Nth',
+ loc: this.getLocation(start, end),
+ nth: query,
+ selector: selector
+ };
+ },
+ generate: function(node) {
+ this.node(node.nth);
+ if (node.selector !== null) {
+ this.chunk(' of ');
+ this.node(node.selector);
+ }
+ }
+ };
+
+ var NUMBER$5 = tokenizer.TYPE.Number;
+
+ var _Number = {
+ name: 'Number',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ return {
+ type: 'Number',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ value: this.consume(NUMBER$5)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+ };
+
+ // '/' | '*' | ',' | ':' | '+' | '-'
+ var Operator = {
+ name: 'Operator',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.scanner.next();
+
+ return {
+ type: 'Operator',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+ };
+
+ var TYPE$s = tokenizer.TYPE;
+
+ var LEFTPARENTHESIS$4 = TYPE$s.LeftParenthesis;
+ var RIGHTPARENTHESIS$4 = TYPE$s.RightParenthesis;
+
+ var Parentheses = {
+ name: 'Parentheses',
+ structure: {
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var children = null;
+
+ this.eat(LEFTPARENTHESIS$4);
+
+ children = readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTPARENTHESIS$4);
+ }
+
+ return {
+ type: 'Parentheses',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+ };
+
+ var consumeNumber$4 = utils.consumeNumber;
+ var TYPE$t = tokenizer.TYPE;
+
+ var PERCENTAGE$1 = TYPE$t.Percentage;
+
+ var Percentage = {
+ name: 'Percentage',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var numberEnd = consumeNumber$4(this.scanner.source, start);
+
+ this.eat(PERCENTAGE$1);
+
+ return {
+ type: 'Percentage',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start, numberEnd)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ this.chunk('%');
+ }
+ };
+
+ var TYPE$u = tokenizer.TYPE;
+
+ var IDENT$b = TYPE$u.Ident;
+ var FUNCTION$1 = TYPE$u.Function;
+ var COLON$3 = TYPE$u.Colon;
+ var RIGHTPARENTHESIS$5 = TYPE$u.RightParenthesis;
+
+ // : [ <ident> | <function-token> <any-value>? ) ]
+ var PseudoClassSelector = {
+ name: 'PseudoClassSelector',
+ structure: {
+ name: String,
+ children: [['Raw'], null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = null;
+ var name;
+ var nameLowerCase;
+
+ this.eat(COLON$3);
+
+ if (this.scanner.tokenType === FUNCTION$1) {
+ name = this.consumeFunctionName();
+ nameLowerCase = name.toLowerCase();
+
+ if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+ this.scanner.skipSC();
+ children = this.pseudo[nameLowerCase].call(this);
+ this.scanner.skipSC();
+ } else {
+ children = this.createList();
+ children.push(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ }
+
+ this.eat(RIGHTPARENTHESIS$5);
+ } else {
+ name = this.consume(IDENT$b);
+ }
+
+ return {
+ type: 'PseudoClassSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk(':');
+ this.chunk(node.name);
+
+ if (node.children !== null) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+ },
+ walkContext: 'function'
+ };
+
+ var TYPE$v = tokenizer.TYPE;
+
+ var IDENT$c = TYPE$v.Ident;
+ var FUNCTION$2 = TYPE$v.Function;
+ var COLON$4 = TYPE$v.Colon;
+ var RIGHTPARENTHESIS$6 = TYPE$v.RightParenthesis;
+
+ // :: [ <ident> | <function-token> <any-value>? ) ]
+ var PseudoElementSelector = {
+ name: 'PseudoElementSelector',
+ structure: {
+ name: String,
+ children: [['Raw'], null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = null;
+ var name;
+ var nameLowerCase;
+
+ this.eat(COLON$4);
+ this.eat(COLON$4);
+
+ if (this.scanner.tokenType === FUNCTION$2) {
+ name = this.consumeFunctionName();
+ nameLowerCase = name.toLowerCase();
+
+ if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+ this.scanner.skipSC();
+ children = this.pseudo[nameLowerCase].call(this);
+ this.scanner.skipSC();
+ } else {
+ children = this.createList();
+ children.push(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ }
+
+ this.eat(RIGHTPARENTHESIS$6);
+ } else {
+ name = this.consume(IDENT$c);
+ }
+
+ return {
+ type: 'PseudoElementSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('::');
+ this.chunk(node.name);
+
+ if (node.children !== null) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+ },
+ walkContext: 'function'
+ };
+
+ var isDigit$5 = tokenizer.isDigit;
+ var TYPE$w = tokenizer.TYPE;
+
+ var NUMBER$6 = TYPE$w.Number;
+ var DELIM$4 = TYPE$w.Delim;
+ var SOLIDUS$3 = 0x002F; // U+002F SOLIDUS (/)
+ var FULLSTOP$1 = 0x002E; // U+002E FULL STOP (.)
+
+ // Terms of <ratio> should be a positive numbers (not zero or negative)
+ // (see https://drafts.csswg.org/mediaqueries-3/#values)
+ // However, -o-min-device-pixel-ratio takes fractional values as a ratio's term
+ // and this is using by various sites. Therefore we relax checking on parse
+ // to test a term is unsigned number without an exponent part.
+ // Additional checking may be applied on lexer validation.
+ function consumeNumber$5() {
+ this.scanner.skipWS();
+
+ var value = this.consume(NUMBER$6);
+
+ for (var i = 0; i < value.length; i++) {
+ var code = value.charCodeAt(i);
+ if (!isDigit$5(code) && code !== FULLSTOP$1) {
+ this.error('Unsigned number is expected', this.scanner.tokenStart - value.length + i);
+ }
+ }
+
+ if (Number(value) === 0) {
+ this.error('Zero number is not allowed', this.scanner.tokenStart - value.length);
+ }
+
+ return value;
+ }
+
+ // <positive-integer> S* '/' S* <positive-integer>
+ var Ratio = {
+ name: 'Ratio',
+ structure: {
+ left: String,
+ right: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var left = consumeNumber$5.call(this);
+ var right;
+
+ this.scanner.skipWS();
+
+ if (!this.scanner.isDelim(SOLIDUS$3)) {
+ this.error('Solidus is expected');
+ }
+ this.eat(DELIM$4);
+ right = consumeNumber$5.call(this);
+
+ return {
+ type: 'Ratio',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ left: left,
+ right: right
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.left);
+ this.chunk('/');
+ this.chunk(node.right);
+ }
+ };
+
+ var TYPE$x = tokenizer.TYPE;
+ var rawMode$4 = Raw.mode;
+
+ var LEFTCURLYBRACKET$4 = TYPE$x.LeftCurlyBracket;
+
+ function consumeRaw$3(startToken) {
+ return this.Raw(startToken, rawMode$4.leftCurlyBracket, true);
+ }
+
+ function consumePrelude() {
+ var prelude = this.SelectorList();
+
+ if (prelude.type !== 'Raw' &&
+ this.scanner.eof === false &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET$4) {
+ this.error();
+ }
+
+ return prelude;
+ }
+
+ var Rule = {
+ name: 'Rule',
+ structure: {
+ prelude: ['SelectorList', 'Raw'],
+ block: ['Block']
+ },
+ parse: function() {
+ var startToken = this.scanner.tokenIndex;
+ var startOffset = this.scanner.tokenStart;
+ var prelude;
+ var block;
+
+ if (this.parseRulePrelude) {
+ prelude = this.parseWithFallback(consumePrelude, consumeRaw$3);
+ } else {
+ prelude = consumeRaw$3.call(this, startToken);
+ }
+
+ block = this.Block(true);
+
+ return {
+ type: 'Rule',
+ loc: this.getLocation(startOffset, this.scanner.tokenStart),
+ prelude: prelude,
+ block: block
+ };
+ },
+ generate: function(node) {
+ this.node(node.prelude);
+ this.node(node.block);
+ },
+ walkContext: 'rule'
+ };
+
+ var Selector = {
+ name: 'Selector',
+ structure: {
+ children: [[
+ 'TypeSelector',
+ 'IdSelector',
+ 'ClassSelector',
+ 'AttributeSelector',
+ 'PseudoClassSelector',
+ 'PseudoElementSelector',
+ 'Combinator',
+ 'WhiteSpace'
+ ]]
+ },
+ parse: function() {
+ var children = this.readSequence(this.scope.Selector);
+
+ // nothing were consumed
+ if (this.getFirstListNode(children) === null) {
+ this.error('Selector is expected');
+ }
+
+ return {
+ type: 'Selector',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+ };
+
+ var TYPE$y = tokenizer.TYPE;
+
+ var COMMA$2 = TYPE$y.Comma;
+
+ var SelectorList = {
+ name: 'SelectorList',
+ structure: {
+ children: [[
+ 'Selector',
+ 'Raw'
+ ]]
+ },
+ parse: function() {
+ var children = this.createList();
+
+ while (!this.scanner.eof) {
+ children.push(this.Selector());
+
+ if (this.scanner.tokenType === COMMA$2) {
+ this.scanner.next();
+ continue;
+ }
+
+ break;
+ }
+
+ return {
+ type: 'SelectorList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function() {
+ this.chunk(',');
+ });
+ },
+ walkContext: 'selector'
+ };
+
+ var STRING$1 = tokenizer.TYPE.String;
+
+ var _String = {
+ name: 'String',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ return {
+ type: 'String',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ value: this.consume(STRING$1)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+ };
+
+ var TYPE$z = tokenizer.TYPE;
+
+ var WHITESPACE$9 = TYPE$z.WhiteSpace;
+ var COMMENT$9 = TYPE$z.Comment;
+ var ATKEYWORD$2 = TYPE$z.AtKeyword;
+ var CDO$1 = TYPE$z.CDO;
+ var CDC$1 = TYPE$z.CDC;
+ var EXCLAMATIONMARK$3 = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+ function consumeRaw$4(startToken) {
+ return this.Raw(startToken, null, false);
+ }
+
+ var StyleSheet = {
+ name: 'StyleSheet',
+ structure: {
+ children: [[
+ 'Comment',
+ 'CDO',
+ 'CDC',
+ 'Atrule',
+ 'Rule',
+ 'Raw'
+ ]]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = this.createList();
+ var child;
+
+
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE$9:
+ this.scanner.next();
+ continue;
+
+ case COMMENT$9:
+ // ignore comments except exclamation comments (i.e. /*! .. */) on top level
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK$3) {
+ this.scanner.next();
+ continue;
+ }
+
+ child = this.Comment();
+ break;
+
+ case CDO$1: // <!--
+ child = this.CDO();
+ break;
+
+ case CDC$1: // -->
+ child = this.CDC();
+ break;
+
+ // CSS Syntax Module Level 3
+ // §2.2 Error handling
+ // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
+ case ATKEYWORD$2:
+ child = this.parseWithFallback(this.Atrule, consumeRaw$4);
+ break;
+
+ // Anything else starts a qualified rule ...
+ default:
+ child = this.parseWithFallback(this.Rule, consumeRaw$4);
+ }
+
+ children.push(child);
+ }
+
+ return {
+ type: 'StyleSheet',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ },
+ walkContext: 'stylesheet'
+ };
+
+ var TYPE$A = tokenizer.TYPE;
+
+ var IDENT$d = TYPE$A.Ident;
+ var ASTERISK$4 = 0x002A; // U+002A ASTERISK (*)
+ var VERTICALLINE$2 = 0x007C; // U+007C VERTICAL LINE (|)
+
+ function eatIdentifierOrAsterisk() {
+ if (this.scanner.tokenType !== IDENT$d &&
+ this.scanner.isDelim(ASTERISK$4) === false) {
+ this.error('Identifier or asterisk is expected');
+ }
+
+ this.scanner.next();
+ }
+
+ // ident
+ // ident|ident
+ // ident|*
+ // *
+ // *|ident
+ // *|*
+ // |ident
+ // |*
+ var TypeSelector = {
+ name: 'TypeSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ if (this.scanner.isDelim(VERTICALLINE$2)) {
+ this.scanner.next();
+ eatIdentifierOrAsterisk.call(this);
+ } else {
+ eatIdentifierOrAsterisk.call(this);
+
+ if (this.scanner.isDelim(VERTICALLINE$2)) {
+ this.scanner.next();
+ eatIdentifierOrAsterisk.call(this);
+ }
+ }
+
+ return {
+ type: 'TypeSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+ };
+
+ var isHexDigit$4 = tokenizer.isHexDigit;
+ var cmpChar$4 = tokenizer.cmpChar;
+ var TYPE$B = tokenizer.TYPE;
+ var NAME$3 = tokenizer.NAME;
+
+ var IDENT$e = TYPE$B.Ident;
+ var NUMBER$7 = TYPE$B.Number;
+ var DIMENSION$5 = TYPE$B.Dimension;
+ var PLUSSIGN$6 = 0x002B; // U+002B PLUS SIGN (+)
+ var HYPHENMINUS$4 = 0x002D; // U+002D HYPHEN-MINUS (-)
+ var QUESTIONMARK$2 = 0x003F; // U+003F QUESTION MARK (?)
+ var U$1 = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+ function eatHexSequence(offset, allowDash) {
+ for (var pos = this.scanner.tokenStart + offset, len = 0; pos < this.scanner.tokenEnd; pos++) {
+ var code = this.scanner.source.charCodeAt(pos);
+
+ if (code === HYPHENMINUS$4 && allowDash && len !== 0) {
+ if (eatHexSequence.call(this, offset + len + 1, false) === 0) {
+ this.error();
+ }
+
+ return -1;
+ }
+
+ if (!isHexDigit$4(code)) {
+ this.error(
+ allowDash && len !== 0
+ ? 'HyphenMinus' + (len < 6 ? ' or hex digit' : '') + ' is expected'
+ : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),
+ pos
+ );
+ }
+
+ if (++len > 6) {
+ this.error('Too many hex digits', pos);
+ } }
+
+ this.scanner.next();
+ return len;
+ }
+
+ function eatQuestionMarkSequence(max) {
+ var count = 0;
+
+ while (this.scanner.isDelim(QUESTIONMARK$2)) {
+ if (++count > max) {
+ this.error('Too many question marks');
+ }
+
+ this.scanner.next();
+ }
+ }
+
+ function startsWith$1(code) {
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== code) {
+ this.error(NAME$3[code] + ' is expected');
+ }
+ }
+
+ // https://drafts.csswg.org/css-syntax/#urange
+ // Informally, the <urange> production has three forms:
+ // U+0001
+ // Defines a range consisting of a single code point, in this case the code point "1".
+ // U+0001-00ff
+ // Defines a range of codepoints between the first and the second value, in this case
+ // the range between "1" and "ff" (255 in decimal) inclusive.
+ // U+00??
+ // Defines a range of codepoints where the "?" characters range over all hex digits,
+ // in this case defining the same as the value U+0000-00ff.
+ // In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+ //
+ // <urange> =
+ // u '+' <ident-token> '?'* |
+ // u <dimension-token> '?'* |
+ // u <number-token> '?'* |
+ // u <number-token> <dimension-token> |
+ // u <number-token> <number-token> |
+ // u '+' '?'+
+ function scanUnicodeRange() {
+ var hexLength = 0;
+
+ // u '+' <ident-token> '?'*
+ // u '+' '?'+
+ if (this.scanner.isDelim(PLUSSIGN$6)) {
+ this.scanner.next();
+
+ if (this.scanner.tokenType === IDENT$e) {
+ hexLength = eatHexSequence.call(this, 0, true);
+ if (hexLength > 0) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ }
+ return;
+ }
+
+ if (this.scanner.isDelim(QUESTIONMARK$2)) {
+ this.scanner.next();
+ eatQuestionMarkSequence.call(this, 5);
+ return;
+ }
+
+ this.error('Hex digit or question mark is expected');
+ return;
+ }
+
+ // u <number-token> '?'*
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (this.scanner.tokenType === NUMBER$7) {
+ startsWith$1.call(this, PLUSSIGN$6);
+ hexLength = eatHexSequence.call(this, 1, true);
+
+ if (this.scanner.isDelim(QUESTIONMARK$2)) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ return;
+ }
+
+ if (this.scanner.tokenType === DIMENSION$5 ||
+ this.scanner.tokenType === NUMBER$7) {
+ startsWith$1.call(this, HYPHENMINUS$4);
+ eatHexSequence.call(this, 1, false);
+ return;
+ }
+
+ return;
+ }
+
+ // u <dimension-token> '?'*
+ if (this.scanner.tokenType === DIMENSION$5) {
+ startsWith$1.call(this, PLUSSIGN$6);
+ hexLength = eatHexSequence.call(this, 1, true);
+
+ if (hexLength > 0) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ }
+
+ return;
+ }
+
+ this.error();
+ }
+
+ var UnicodeRange = {
+ name: 'UnicodeRange',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ // U or u
+ if (!cmpChar$4(this.scanner.source, start, U$1)) {
+ this.error('U is expected');
+ }
+
+ if (!cmpChar$4(this.scanner.source, start + 1, PLUSSIGN$6)) {
+ this.error('Plus sign is expected');
+ }
+
+ this.scanner.next();
+ scanUnicodeRange.call(this);
+
+ return {
+ type: 'UnicodeRange',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+ };
+
+ var isWhiteSpace$2 = tokenizer.isWhiteSpace;
+ var cmpStr$5 = tokenizer.cmpStr;
+ var TYPE$C = tokenizer.TYPE;
+
+ var FUNCTION$3 = TYPE$C.Function;
+ var URL$1 = TYPE$C.Url;
+ var RIGHTPARENTHESIS$7 = TYPE$C.RightParenthesis;
+
+ // <url-token> | <function-token> <string> )
+ var Url = {
+ name: 'Url',
+ structure: {
+ value: ['String', 'Raw']
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var value;
+
+ switch (this.scanner.tokenType) {
+ case URL$1:
+ var rawStart = start + 4;
+ var rawEnd = this.scanner.tokenEnd - 1;
+
+ while (rawStart < rawEnd && isWhiteSpace$2(this.scanner.source.charCodeAt(rawStart))) {
+ rawStart++;
+ }
+
+ while (rawStart < rawEnd && isWhiteSpace$2(this.scanner.source.charCodeAt(rawEnd - 1))) {
+ rawEnd--;
+ }
+
+ value = {
+ type: 'Raw',
+ loc: this.getLocation(rawStart, rawEnd),
+ value: this.scanner.source.substring(rawStart, rawEnd)
+ };
+
+ this.eat(URL$1);
+ break;
+
+ case FUNCTION$3:
+ if (!cmpStr$5(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')) {
+ this.error('Function name must be `url`');
+ }
+
+ this.eat(FUNCTION$3);
+ this.scanner.skipSC();
+ value = this.String();
+ this.scanner.skipSC();
+ this.eat(RIGHTPARENTHESIS$7);
+ break;
+
+ default:
+ this.error('Url or Function is expected');
+ }
+
+ return {
+ type: 'Url',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk('url');
+ this.chunk('(');
+ this.node(node.value);
+ this.chunk(')');
+ }
+ };
+
+ var Value = {
+ name: 'Value',
+ structure: {
+ children: [[]]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = this.readSequence(this.scope.Value);
+
+ return {
+ type: 'Value',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+ };
+
+ var WHITESPACE$a = tokenizer.TYPE.WhiteSpace;
+ var SPACE$2 = Object.freeze({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+ });
+
+ var WhiteSpace$1 = {
+ name: 'WhiteSpace',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ this.eat(WHITESPACE$a);
+ return SPACE$2;
+
+ // return {
+ // type: 'WhiteSpace',
+ // loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ // value: this.consume(WHITESPACE)
+ // };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+ };
+
+ var node = {
+ AnPlusB: AnPlusB,
+ Atrule: Atrule,
+ AtrulePrelude: AtrulePrelude,
+ AttributeSelector: AttributeSelector,
+ Block: Block,
+ Brackets: Brackets,
+ CDC: CDC_1,
+ CDO: CDO_1,
+ ClassSelector: ClassSelector,
+ Combinator: Combinator,
+ Comment: Comment,
+ Declaration: Declaration,
+ DeclarationList: DeclarationList,
+ Dimension: Dimension,
+ Function: _Function,
+ Hash: Hash,
+ Identifier: Identifier,
+ IdSelector: IdSelector,
+ MediaFeature: MediaFeature,
+ MediaQuery: MediaQuery,
+ MediaQueryList: MediaQueryList,
+ Nth: Nth,
+ Number: _Number,
+ Operator: Operator,
+ Parentheses: Parentheses,
+ Percentage: Percentage,
+ PseudoClassSelector: PseudoClassSelector,
+ PseudoElementSelector: PseudoElementSelector,
+ Ratio: Ratio,
+ Raw: Raw,
+ Rule: Rule,
+ Selector: Selector,
+ SelectorList: SelectorList,
+ String: _String,
+ StyleSheet: StyleSheet,
+ TypeSelector: TypeSelector,
+ UnicodeRange: UnicodeRange,
+ Url: Url,
+ Value: Value,
+ WhiteSpace: WhiteSpace$1
+ };
+
+ var lexer = {
+ generic: true,
+ types: data.types,
+ atrules: data.atrules,
+ properties: data.properties,
+ node: node
+ };
+
+ var cmpChar$5 = tokenizer.cmpChar;
+ var cmpStr$6 = tokenizer.cmpStr;
+ var TYPE$D = tokenizer.TYPE;
+
+ var IDENT$f = TYPE$D.Ident;
+ var STRING$2 = TYPE$D.String;
+ var NUMBER$8 = TYPE$D.Number;
+ var FUNCTION$4 = TYPE$D.Function;
+ var URL$2 = TYPE$D.Url;
+ var HASH$4 = TYPE$D.Hash;
+ var DIMENSION$6 = TYPE$D.Dimension;
+ var PERCENTAGE$2 = TYPE$D.Percentage;
+ var LEFTPARENTHESIS$5 = TYPE$D.LeftParenthesis;
+ var LEFTSQUAREBRACKET$3 = TYPE$D.LeftSquareBracket;
+ var COMMA$3 = TYPE$D.Comma;
+ var DELIM$5 = TYPE$D.Delim;
+ var NUMBERSIGN$3 = 0x0023; // U+0023 NUMBER SIGN (#)
+ var ASTERISK$5 = 0x002A; // U+002A ASTERISK (*)
+ var PLUSSIGN$7 = 0x002B; // U+002B PLUS SIGN (+)
+ var HYPHENMINUS$5 = 0x002D; // U+002D HYPHEN-MINUS (-)
+ var SOLIDUS$4 = 0x002F; // U+002F SOLIDUS (/)
+ var U$2 = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+ var _default = function defaultRecognizer(context) {
+ switch (this.scanner.tokenType) {
+ case HASH$4:
+ return this.Hash();
+
+ case COMMA$3:
+ context.space = null;
+ context.ignoreWSAfter = true;
+ return this.Operator();
+
+ case LEFTPARENTHESIS$5:
+ return this.Parentheses(this.readSequence, context.recognizer);
+
+ case LEFTSQUAREBRACKET$3:
+ return this.Brackets(this.readSequence, context.recognizer);
+
+ case STRING$2:
+ return this.String();
+
+ case DIMENSION$6:
+ return this.Dimension();
+
+ case PERCENTAGE$2:
+ return this.Percentage();
+
+ case NUMBER$8:
+ return this.Number();
+
+ case FUNCTION$4:
+ return cmpStr$6(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')
+ ? this.Url()
+ : this.Function(this.readSequence, context.recognizer);
+
+ case URL$2:
+ return this.Url();
+
+ case IDENT$f:
+ // check for unicode range, it should start with u+ or U+
+ if (cmpChar$5(this.scanner.source, this.scanner.tokenStart, U$2) &&
+ cmpChar$5(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN$7)) {
+ return this.UnicodeRange();
+ } else {
+ return this.Identifier();
+ }
+
+ case DELIM$5:
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ if (code === SOLIDUS$4 ||
+ code === ASTERISK$5 ||
+ code === PLUSSIGN$7 ||
+ code === HYPHENMINUS$5) {
+ return this.Operator(); // TODO: replace with Delim
+ }
+
+ // TODO: produce a node with Delim node type
+
+ if (code === NUMBERSIGN$3) {
+ this.error('Hex or identifier is expected', this.scanner.tokenStart + 1);
+ }
+
+ break;
+ }
+ };
+
+ var atrulePrelude = {
+ getNode: _default
+ };
+
+ var TYPE$E = tokenizer.TYPE;
+
+ var DELIM$6 = TYPE$E.Delim;
+ var IDENT$g = TYPE$E.Ident;
+ var DIMENSION$7 = TYPE$E.Dimension;
+ var PERCENTAGE$3 = TYPE$E.Percentage;
+ var NUMBER$9 = TYPE$E.Number;
+ var HASH$5 = TYPE$E.Hash;
+ var COLON$5 = TYPE$E.Colon;
+ var LEFTSQUAREBRACKET$4 = TYPE$E.LeftSquareBracket;
+ var NUMBERSIGN$4 = 0x0023; // U+0023 NUMBER SIGN (#)
+ var ASTERISK$6 = 0x002A; // U+002A ASTERISK (*)
+ var PLUSSIGN$8 = 0x002B; // U+002B PLUS SIGN (+)
+ var SOLIDUS$5 = 0x002F; // U+002F SOLIDUS (/)
+ var FULLSTOP$2 = 0x002E; // U+002E FULL STOP (.)
+ var GREATERTHANSIGN$2 = 0x003E; // U+003E GREATER-THAN SIGN (>)
+ var VERTICALLINE$3 = 0x007C; // U+007C VERTICAL LINE (|)
+ var TILDE$2 = 0x007E; // U+007E TILDE (~)
+
+ function getNode(context) {
+ switch (this.scanner.tokenType) {
+ case LEFTSQUAREBRACKET$4:
+ return this.AttributeSelector();
+
+ case HASH$5:
+ return this.IdSelector();
+
+ case COLON$5:
+ if (this.scanner.lookupType(1) === COLON$5) {
+ return this.PseudoElementSelector();
+ } else {
+ return this.PseudoClassSelector();
+ }
+
+ case IDENT$g:
+ return this.TypeSelector();
+
+ case NUMBER$9:
+ case PERCENTAGE$3:
+ return this.Percentage();
+
+ case DIMENSION$7:
+ // throws when .123ident
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === FULLSTOP$2) {
+ this.error('Identifier is expected', this.scanner.tokenStart + 1);
+ }
+ break;
+
+ case DELIM$6:
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ switch (code) {
+ case PLUSSIGN$8:
+ case GREATERTHANSIGN$2:
+ case TILDE$2:
+ context.space = null;
+ context.ignoreWSAfter = true;
+ return this.Combinator();
+
+ case SOLIDUS$5: // /deep/
+ return this.Combinator();
+
+ case FULLSTOP$2:
+ return this.ClassSelector();
+
+ case ASTERISK$6:
+ case VERTICALLINE$3:
+ return this.TypeSelector();
+
+ case NUMBERSIGN$4:
+ return this.IdSelector();
+ }
+
+ break;
+ }
+ }
+ var selector = {
+ getNode: getNode
+ };
+
+ // legacy IE function
+ // expression( <any-value> )
+ var expression = function() {
+ return this.createSingleNodeList(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ };
+
+ var TYPE$F = tokenizer.TYPE;
+ var rawMode$5 = Raw.mode;
+
+ var COMMA$4 = TYPE$F.Comma;
+ var WHITESPACE$b = TYPE$F.WhiteSpace;
+
+ // var( <ident> , <value>? )
+ var _var = function() {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ // NOTE: Don't check more than a first argument is an ident, rest checks are for lexer
+ children.push(this.Identifier());
+
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType === COMMA$4) {
+ children.push(this.Operator());
+
+ const startIndex = this.scanner.tokenIndex;
+ const value = this.parseCustomProperty
+ ? this.Value(null)
+ : this.Raw(this.scanner.tokenIndex, rawMode$5.exclamationMarkOrSemicolon, false);
+
+ if (value.type === 'Value' && value.children.isEmpty()) {
+ for (let offset = startIndex - this.scanner.tokenIndex; offset <= 0; offset++) {
+ if (this.scanner.lookupType(offset) === WHITESPACE$b) {
+ value.children.appendData({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+ });
+ break;
+ }
+ }
+ }
+
+ children.push(value);
+ }
+
+ return children;
+ };
+
+ var value = {
+ getNode: _default,
+ 'expression': expression,
+ 'var': _var
+ };
+
+ var scope = {
+ AtrulePrelude: atrulePrelude,
+ Selector: selector,
+ Value: value
+ };
+
+ var fontFace = {
+ parse: {
+ prelude: null,
+ block: function() {
+ return this.Block(true);
+ }
+ }
+ };
+
+ var TYPE$G = tokenizer.TYPE;
+
+ var STRING$3 = TYPE$G.String;
+ var IDENT$h = TYPE$G.Ident;
+ var URL$3 = TYPE$G.Url;
+ var FUNCTION$5 = TYPE$G.Function;
+ var LEFTPARENTHESIS$6 = TYPE$G.LeftParenthesis;
+
+ var _import = {
+ parse: {
+ prelude: function() {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ switch (this.scanner.tokenType) {
+ case STRING$3:
+ children.push(this.String());
+ break;
+
+ case URL$3:
+ case FUNCTION$5:
+ children.push(this.Url());
+ break;
+
+ default:
+ this.error('String or url() is expected');
+ }
+
+ if (this.lookupNonWSType(0) === IDENT$h ||
+ this.lookupNonWSType(0) === LEFTPARENTHESIS$6) {
+ children.push(this.WhiteSpace());
+ children.push(this.MediaQueryList());
+ }
+
+ return children;
+ },
+ block: null
+ }
+ };
+
+ var media = {
+ parse: {
+ prelude: function() {
+ return this.createSingleNodeList(
+ this.MediaQueryList()
+ );
+ },
+ block: function() {
+ return this.Block(false);
+ }
+ }
+ };
+
+ var page = {
+ parse: {
+ prelude: function() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ },
+ block: function() {
+ return this.Block(true);
+ }
+ }
+ };
+
+ var TYPE$H = tokenizer.TYPE;
+
+ var WHITESPACE$c = TYPE$H.WhiteSpace;
+ var COMMENT$a = TYPE$H.Comment;
+ var IDENT$i = TYPE$H.Ident;
+ var FUNCTION$6 = TYPE$H.Function;
+ var COLON$6 = TYPE$H.Colon;
+ var LEFTPARENTHESIS$7 = TYPE$H.LeftParenthesis;
+
+ function consumeRaw$5() {
+ return this.createSingleNodeList(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ }
+
+ function parentheses() {
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType === IDENT$i &&
+ this.lookupNonWSType(1) === COLON$6) {
+ return this.createSingleNodeList(
+ this.Declaration()
+ );
+ }
+
+ return readSequence.call(this);
+ }
+
+ function readSequence() {
+ var children = this.createList();
+ var space = null;
+ var child;
+
+ this.scanner.skipSC();
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE$c:
+ space = this.WhiteSpace();
+ continue;
+
+ case COMMENT$a:
+ this.scanner.next();
+ continue;
+
+ case FUNCTION$6:
+ child = this.Function(consumeRaw$5, this.scope.AtrulePrelude);
+ break;
+
+ case IDENT$i:
+ child = this.Identifier();
+ break;
+
+ case LEFTPARENTHESIS$7:
+ child = this.Parentheses(parentheses, this.scope.AtrulePrelude);
+ break;
+
+ default:
+ break scan;
+ }
+
+ if (space !== null) {
+ children.push(space);
+ space = null;
+ }
+
+ children.push(child);
+ }
+
+ return children;
+ }
+
+ var supports = {
+ parse: {
+ prelude: function() {
+ var children = readSequence.call(this);
+
+ if (this.getFirstListNode(children) === null) {
+ this.error('Condition is expected');
+ }
+
+ return children;
+ },
+ block: function() {
+ return this.Block(false);
+ }
+ }
+ };
+
+ var atrule = {
+ 'font-face': fontFace,
+ 'import': _import,
+ 'media': media,
+ 'page': page,
+ 'supports': supports
+ };
+
+ var dir = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.Identifier()
+ );
+ }
+ };
+
+ var has$1 = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ }
+ };
+
+ var lang = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.Identifier()
+ );
+ }
+ };
+
+ var selectorList = {
+ parse: function selectorList() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ }
+ };
+
+ var matches = selectorList;
+
+ var not = selectorList;
+
+ var ALLOW_OF_CLAUSE = true;
+
+ var nthWithOfClause = {
+ parse: function nthWithOfClause() {
+ return this.createSingleNodeList(
+ this.Nth(ALLOW_OF_CLAUSE)
+ );
+ }
+ };
+
+ var nthChild = nthWithOfClause;
+
+ var nthLastChild = nthWithOfClause;
+
+ var DISALLOW_OF_CLAUSE = false;
+
+ var nth = {
+ parse: function nth() {
+ return this.createSingleNodeList(
+ this.Nth(DISALLOW_OF_CLAUSE)
+ );
+ }
+ };
+
+ var nthLastOfType = nth;
+
+ var nthOfType = nth;
+
+ var slotted = {
+ parse: function compoundSelector() {
+ return this.createSingleNodeList(
+ this.Selector()
+ );
+ }
+ };
+
+ var pseudo = {
+ 'dir': dir,
+ 'has': has$1,
+ 'lang': lang,
+ 'matches': matches,
+ 'not': not,
+ 'nth-child': nthChild,
+ 'nth-last-child': nthLastChild,
+ 'nth-last-of-type': nthLastOfType,
+ 'nth-of-type': nthOfType,
+ 'slotted': slotted
+ };
+
+ var parser = {
+ parseContext: {
+ default: 'StyleSheet',
+ stylesheet: 'StyleSheet',
+ atrule: 'Atrule',
+ atrulePrelude: function(options) {
+ return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);
+ },
+ mediaQueryList: 'MediaQueryList',
+ mediaQuery: 'MediaQuery',
+ rule: 'Rule',
+ selectorList: 'SelectorList',
+ selector: 'Selector',
+ block: function() {
+ return this.Block(true);
+ },
+ declarationList: 'DeclarationList',
+ declaration: 'Declaration',
+ value: 'Value'
+ },
+ scope: scope,
+ atrule: atrule,
+ pseudo: pseudo,
+ node: node
+ };
+
+ var walker = {
+ node: node
+ };
+
+ var version = "1.1.3";
+ var _package = {
+ version: version
+ };
+
+ var _package$1 = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ version: version,
+ 'default': _package
+ });
+
+ var require$$4 = getCjsExportFromNamespace(_package$1);
+
+ function merge() {
+ var dest = {};
+
+ for (var i = 0; i < arguments.length; i++) {
+ var src = arguments[i];
+ for (var key in src) {
+ dest[key] = src[key];
+ }
+ }
+
+ return dest;
+ }
+
+ var syntax = create$4.create(
+ merge(
+ lexer,
+ parser,
+ walker
+ )
+ );
+ var version$1 = require$$4.version;
+ syntax.version = version$1;
+
+ var lib = syntax;
+
+ return lib;
+
+})));
diff --git a/node_modules/css-tree/dist/csstree.min.js b/node_modules/css-tree/dist/csstree.min.js
new file mode 100644
index 0000000..774475e
--- /dev/null
+++ b/node_modules/css-tree/dist/csstree.min.js
@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e=e||self).csstree=t()}(this,(function(){"use strict";function e(e){return{prev:null,next:null,data:e}}function t(e,t,n){var i;return null!==r?(i=r,r=r.cursor,i.prev=t,i.next=n,i.cursor=e.cursor):i={prev:t,next:n,cursor:e.cursor},e.cursor=i,i}function n(e){var t=e.cursor;e.cursor=t.cursor,t.prev=null,t.next=null,t.cursor=r,r=t}var r=null,i=function(){this.cursor=null,this.head=null,this.tail=null};i.createItem=e,i.prototype.createItem=e,i.prototype.updateCursors=function(e,t,n,r){for(var i=this.cursor;null!==i;)i.prev===e&&(i.prev=t),i.next===n&&(i.next=r),i=i.cursor},i.prototype.getSize=function(){for(var e=0,t=this.head;t;)e++,t=t.next;return e},i.prototype.fromArray=function(t){var n=null;this.head=null;for(var r=0;r<t.length;r++){var i=e(t[r]);null!==n?n.next=i:this.head=i,i.prev=n,n=i}return this.tail=n,this},i.prototype.toArray=function(){for(var e=this.head,t=[];e;)t.push(e.data),e=e.next;return t},i.prototype.toJSON=i.prototype.toArray,i.prototype.isEmpty=function(){return null===this.head},i.prototype.first=function(){return this.head&&this.head.data},i.prototype.last=function(){return this.tail&&this.tail.data},i.prototype.each=function(e,r){var i;void 0===r&&(r=this);for(var a=t(this,null,this.head);null!==a.next;)i=a.next,a.next=i.next,e.call(r,i.data,i,this);n(this)},i.prototype.forEach=i.prototype.each,i.prototype.eachRight=function(e,r){var i;void 0===r&&(r=this);for(var a=t(this,this.tail,null);null!==a.prev;)i=a.prev,a.prev=i.prev,e.call(r,i.data,i,this);n(this)},i.prototype.forEachRight=i.prototype.eachRight,i.prototype.reduce=function(e,r,i){var a;void 0===i&&(i=this);for(var o=t(this,null,this.head),s=r;null!==o.next;)a=o.next,o.next=a.next,s=e.call(i,s,a.data,a,this);return n(this),s},i.prototype.reduceRight=function(e,r,i){var a;void 0===i&&(i=this);for(var o=t(this,this.tail,null),s=r;null!==o.prev;)a=o.prev,o.prev=a.prev,s=e.call(i,s,a.data,a,this);return n(this),s},i.prototype.nextUntil=function(e,r,i){if(null!==e){var a;void 0===i&&(i=this);for(var o=t(this,null,e);null!==o.next&&(a=o.next,o.next=a.next,!r.call(i,a.data,a,this)););n(this)}},i.prototype.prevUntil=function(e,r,i){if(null!==e){var a;void 0===i&&(i=this);for(var o=t(this,e,null);null!==o.prev&&(a=o.prev,o.prev=a.prev,!r.call(i,a.data,a,this)););n(this)}},i.prototype.some=function(e,t){var n=this.head;for(void 0===t&&(t=this);null!==n;){if(e.call(t,n.data,n,this))return!0;n=n.next}return!1},i.prototype.map=function(e,t){var n=new i,r=this.head;for(void 0===t&&(t=this);null!==r;)n.appendData(e.call(t,r.data,r,this)),r=r.next;return n},i.prototype.filter=function(e,t){var n=new i,r=this.head;for(void 0===t&&(t=this);null!==r;)e.call(t,r.data,r,this)&&n.appendData(r.data),r=r.next;return n},i.prototype.clear=function(){this.head=null,this.tail=null},i.prototype.copy=function(){for(var t=new i,n=this.head;null!==n;)t.insert(e(n.data)),n=n.next;return t},i.prototype.prepend=function(e){return this.updateCursors(null,e,this.head,e),null!==this.head?(this.head.prev=e,e.next=this.head):this.tail=e,this.head=e,this},i.prototype.prependData=function(t){return this.prepend(e(t))},i.prototype.append=function(e){return this.insert(e)},i.prototype.appendData=function(t){return this.insert(e(t))},i.prototype.insert=function(e,t){if(null!=t)if(this.updateCursors(t.prev,e,t,e),null===t.prev){if(this.head!==t)throw new Error("before doesn't belong to list");this.head=e,t.prev=e,e.next=t,this.updateCursors(null,e)}else t.prev.next=e,e.prev=t.prev,t.prev=e,e.next=t;else this.updateCursors(this.tail,e,null,e),null!==this.tail?(this.tail.next=e,e.prev=this.tail):this.head=e,this.tail=e;return this},i.prototype.insertData=function(t,n){return this.insert(e(t),n)},i.prototype.remove=function(e){if(this.updateCursors(e,e.prev,e,e.next),null!==e.prev)e.prev.next=e.next;else{if(this.head!==e)throw new Error("item doesn't belong to list");this.head=e.next}if(null!==e.next)e.next.prev=e.prev;else{if(this.tail!==e)throw new Error("item doesn't belong to list");this.tail=e.prev}return e.prev=null,e.next=null,e},i.prototype.push=function(t){this.insert(e(t))},i.prototype.pop=function(){if(null!==this.tail)return this.remove(this.tail)},i.prototype.unshift=function(t){this.prepend(e(t))},i.prototype.shift=function(){if(null!==this.head)return this.remove(this.head)},i.prototype.prependList=function(e){return this.insertList(e,this.head)},i.prototype.appendList=function(e){return this.insertList(e)},i.prototype.insertList=function(e,t){return null===e.head||(null!=t?(this.updateCursors(t.prev,e.tail,t,e.head),null!==t.prev?(t.prev.next=e.head,e.head.prev=t.prev):this.head=e.head,t.prev=e.tail,e.tail.next=t):(this.updateCursors(this.tail,e.tail,null,e.head),null!==this.tail?(this.tail.next=e.head,e.head.prev=this.tail):this.head=e.head,this.tail=e.tail),e.head=null,e.tail=null),this},i.prototype.replace=function(e,t){"head"in t?this.insertList(t,e):this.insert(t,e),this.remove(e)};var a=i,o=function(e,t){var n=Object.create(SyntaxError.prototype),r=new Error;return n.name=e,n.message=t,Object.defineProperty(n,"stack",{get:function(){return(r.stack||"").replace(/^(.+\n){1,3}/,e+": "+t+"\n")}}),n};function s(e,t){function n(e,t){return r.slice(e,t).map((function(t,n){for(var r=String(e+n+1);r.length<l;)r=" "+r;return r+" |"+t})).join("\n")}var r=e.source.split(/\r\n?|\n|\f/),i=e.line,a=e.column,o=Math.max(1,i-t)-1,s=Math.min(i+t,r.length+1),l=Math.max(4,String(s).length)+1,c=0;(a+=(" ".length-1)*(r[i-1].substr(0,a-1).match(/\t/g)||[]).length)>100&&(c=a-60+3,a=58);for(var u=o;u<=s;u++)u>=0&&u<r.length&&(r[u]=r[u].replace(/\t/g," "),r[u]=(c>0&&r[u].length>c?"…":"")+r[u].substr(c,98)+(r[u].length>c+100-1?"…":""));return[n(o,i),new Array(a+l+2).join("-")+"^",n(i,s)].filter(Boolean).join("\n")}var l=function(e,t,n,r,i){var a=o("SyntaxError",e);return a.source=t,a.offset=n,a.line=r,a.column=i,a.sourceFragment=function(e){return s(a,isNaN(e)?0:e)},Object.defineProperty(a,"formattedMessage",{get:function(){return"Parse error: "+a.message+"\n"+s(a,2)}}),a.parseError={offset:n,line:r,column:i},a},c={EOF:0,Ident:1,Function:2,AtKeyword:3,Hash:4,String:5,BadString:6,Url:7,BadUrl:8,Delim:9,Number:10,Percentage:11,Dimension:12,WhiteSpace:13,CDO:14,CDC:15,Colon:16,Semicolon:17,Comma:18,LeftSquareBracket:19,RightSquareBracket:20,LeftParenthesis:21,RightParenthesis:22,LeftCurlyBracket:23,RightCurlyBracket:24,Comment:25},u=Object.keys(c).reduce((function(e,t){return e[c[t]]=t,e}),{}),h={TYPE:c,NAME:u};function p(e){return e>=48&&e<=57}function d(e){return e>=65&&e<=90}function m(e){return e>=97&&e<=122}function g(e){return d(e)||m(e)}function f(e){return e>=128}function b(e){return g(e)||f(e)||95===e}function y(e){return e>=0&&e<=8||11===e||e>=14&&e<=31||127===e}function k(e){return 10===e||13===e||12===e}function v(e){return k(e)||32===e||9===e}function x(e,t){return 92===e&&(!k(t)&&0!==t)}var w=new Array(128);C.Eof=128,C.WhiteSpace=130,C.Digit=131,C.NameStart=132,C.NonPrintable=133;for(var S=0;S<w.length;S++)switch(!0){case v(S):w[S]=C.WhiteSpace;break;case p(S):w[S]=C.Digit;break;case b(S):w[S]=C.NameStart;break;case y(S):w[S]=C.NonPrintable;break;default:w[S]=S||C.Eof}function C(e){return e<128?w[e]:C.NameStart}var z={isDigit:p,isHexDigit:function(e){return p(e)||e>=65&&e<=70||e>=97&&e<=102},isUppercaseLetter:d,isLowercaseLetter:m,isLetter:g,isNonAscii:f,isNameStart:b,isName:function(e){return b(e)||p(e)||45===e},isNonPrintable:y,isNewline:k,isWhiteSpace:v,isValidEscape:x,isIdentifierStart:function(e,t,n){return 45===e?b(t)||45===t||x(t,n):!!b(e)||92===e&&x(e,t)},isNumberStart:function(e,t,n){return 43===e||45===e?p(t)?2:46===t&&p(n)?3:0:46===e?p(t)?2:0:p(e)?1:0},isBOM:function(e){return 65279===e||65534===e?1:0},charCodeCategory:C},A=z.isDigit,P=z.isHexDigit,T=z.isUppercaseLetter,L=z.isName,E=z.isWhiteSpace,D=z.isValidEscape;function O(e,t){return t<e.length?e.charCodeAt(t):0}function B(e,t,n){return 13===n&&10===O(e,t+1)?2:1}function I(e,t,n){var r=e.charCodeAt(t);return T(r)&&(r|=32),r===n}function N(e,t){for(;t<e.length&&A(e.charCodeAt(t));t++);return t}function R(e,t){if(P(O(e,(t+=2)-1))){for(var n=Math.min(e.length,t+5);t<n&&P(O(e,t));t++);var r=O(e,t);E(r)&&(t+=B(e,t,r))}return t}var M={consumeEscaped:R,consumeName:function(e,t){for(;t<e.length;t++){var n=e.charCodeAt(t);if(!L(n)){if(!D(n,O(e,t+1)))break;t=R(e,t)-1}}return t},consumeNumber:function(e,t){var n=e.charCodeAt(t);if(43!==n&&45!==n||(n=e.charCodeAt(t+=1)),A(n)&&(t=N(e,t+1),n=e.charCodeAt(t)),46===n&&A(e.charCodeAt(t+1))&&(n=e.charCodeAt(t+=2),t=N(e,t)),I(e,t,101)){var r=0;45!==(n=e.charCodeAt(t+1))&&43!==n||(r=1,n=e.charCodeAt(t+2)),A(n)&&(t=N(e,t+1+r+1))}return t},consumeBadUrlRemnants:function(e,t){for(;t<e.length;t++){var n=e.charCodeAt(t);if(41===n){t++;break}D(n,O(e,t+1))&&(t=R(e,t))}return t},cmpChar:I,cmpStr:function(e,t,n,r){if(n-t!==r.length)return!1;if(t<0||n>e.length)return!1;for(var i=t;i<n;i++){var a=e.charCodeAt(i),o=r.charCodeAt(i-t);if(T(a)&&(a|=32),a!==o)return!1}return!0},getNewlineLength:B,findWhiteSpaceStart:function(e,t){for(;t>=0&&E(e.charCodeAt(t));t--);return t+1},findWhiteSpaceEnd:function(e,t){for(;t<e.length&&E(e.charCodeAt(t));t++);return t}},j=h.TYPE,_=h.NAME,F=M.cmpStr,W=j.EOF,q=j.WhiteSpace,Y=j.Comment,U=function(){this.offsetAndType=null,this.balance=null,this.reset()};U.prototype={reset:function(){this.eof=!1,this.tokenIndex=-1,this.tokenType=0,this.tokenStart=this.firstCharOffset,this.tokenEnd=this.firstCharOffset},lookupType:function(e){return(e+=this.tokenIndex)<this.tokenCount?this.offsetAndType[e]>>24:W},lookupOffset:function(e){return(e+=this.tokenIndex)<this.tokenCount?16777215&this.offsetAndType[e-1]:this.source.length},lookupValue:function(e,t){return(e+=this.tokenIndex)<this.tokenCount&&F(this.source,16777215&this.offsetAndType[e-1],16777215&this.offsetAndType[e],t)},getTokenStart:function(e){return e===this.tokenIndex?this.tokenStart:e>0?e<this.tokenCount?16777215&this.offsetAndType[e-1]:16777215&this.offsetAndType[this.tokenCount]:this.firstCharOffset},getRawLength:function(e,t){var n,r=e,i=16777215&this.offsetAndType[Math.max(r-1,0)];e:for(;r<this.tokenCount&&!((n=this.balance[r])<e);r++)switch(t(this.offsetAndType[r]>>24,this.source,i)){case 1:break e;case 2:r++;break e;default:this.balance[n]===r&&(r=n),i=16777215&this.offsetAndType[r]}return r-this.tokenIndex},isBalanceEdge:function(e){return this.balance[this.tokenIndex]<e},isDelim:function(e,t){return t?this.lookupType(t)===j.Delim&&this.source.charCodeAt(this.lookupOffset(t))===e:this.tokenType===j.Delim&&this.source.charCodeAt(this.tokenStart)===e},getTokenValue:function(){return this.source.substring(this.tokenStart,this.tokenEnd)},getTokenLength:function(){return this.tokenEnd-this.tokenStart},substrToCursor:function(e){return this.source.substring(e,this.tokenStart)},skipWS:function(){for(var e=this.tokenIndex,t=0;e<this.tokenCount&&this.offsetAndType[e]>>24===q;e++,t++);t>0&&this.skip(t)},skipSC:function(){for(;this.tokenType===q||this.tokenType===Y;)this.next()},skip:function(e){var t=this.tokenIndex+e;t<this.tokenCount?(this.tokenIndex=t,this.tokenStart=16777215&this.offsetAndType[t-1],t=this.offsetAndType[t],this.tokenType=t>>24,this.tokenEnd=16777215&t):(this.tokenIndex=this.tokenCount,this.next())},next:function(){var e=this.tokenIndex+1;e<this.tokenCount?(this.tokenIndex=e,this.tokenStart=this.tokenEnd,e=this.offsetAndType[e],this.tokenType=e>>24,this.tokenEnd=16777215&e):(this.tokenIndex=this.tokenCount,this.eof=!0,this.tokenType=W,this.tokenStart=this.tokenEnd=this.source.length)},forEachToken(e){for(var t=0,n=this.firstCharOffset;t<this.tokenCount;t++){var r=n,i=this.offsetAndType[t],a=16777215&i;n=a,e(i>>24,r,a,t)}},dump(){var e=new Array(this.tokenCount);return this.forEachToken((t,n,r,i)=>{e[i]={idx:i,type:_[t],chunk:this.source.substring(n,r),balance:this.balance[i]}}),e}};var H=U;function V(e){return e}function K(e,t,n,r){var i,a;switch(e.type){case"Group":i=function(e,t,n,r){var i=" "===e.combinator||r?e.combinator:" "+e.combinator+" ",a=e.terms.map((function(e){return K(e,t,n,r)})).join(i);return(e.explicit||n)&&(a=(r||","===a[0]?"[":"[ ")+a+(r?"]":" ]")),a}(e,t,n,r)+(e.disallowEmpty?"!":"");break;case"Multiplier":return K(e.term,t,n,r)+t(0===(a=e).min&&0===a.max?"*":0===a.min&&1===a.max?"?":1===a.min&&0===a.max?a.comma?"#":"+":1===a.min&&1===a.max?"":(a.comma?"#":"")+(a.min===a.max?"{"+a.min+"}":"{"+a.min+","+(0!==a.max?a.max:"")+"}"),e);case"Type":i="<"+e.name+(e.opts?t(function(e){switch(e.type){case"Range":return" ["+(null===e.min?"-∞":e.min)+","+(null===e.max?"∞":e.max)+"]";default:throw new Error("Unknown node type `"+e.type+"`")}}(e.opts),e.opts):"")+">";break;case"Property":i="<'"+e.name+"'>";break;case"Keyword":i=e.name;break;case"AtKeyword":i="@"+e.name;break;case"Function":i=e.name+"(";break;case"String":case"Token":i=e.value;break;case"Comma":i=",";break;default:throw new Error("Unknown node type `"+e.type+"`")}return t(i,e)}var G=function(e,t){var n=V,r=!1,i=!1;return"function"==typeof t?n=t:t&&(r=Boolean(t.forceBraces),i=Boolean(t.compact),"function"==typeof t.decorate&&(n=t.decorate)),K(e,n,r,i)};const Q={offset:0,line:1,column:1};function X(e,t){const n=e&&e.loc&&e.loc[t];return n?"line"in n?Z(n):n:null}function Z({offset:e,line:t,column:n},r){const i={offset:e,line:t,column:n};if(r){const e=r.split(/\n|\r\n?|\f/);i.offset+=r.length,i.line+=e.length-1,i.column=1===e.length?i.column+r.length:e.pop().length+1}return i}var $=function(e,t){const n=o("SyntaxReferenceError",e+(t?" `"+t+"`":""));return n.reference=t,n},J=function(e,t,n,r){const i=o("SyntaxMatchError",e),{css:a,mismatchOffset:s,mismatchLength:l,start:c,end:u}=function(e,t){const n=e.tokens,r=e.longestMatch,i=r<n.length&&n[r].node||null,a=i!==t?i:null;let o,s,l=0,c=0,u=0,h="";for(let e=0;e<n.length;e++){const t=n[e].value;e===r&&(c=t.length,l=h.length),null!==a&&n[e].node===a&&(e<=r?u++:u=0),h+=t}return r===n.length||u>1?(o=X(a||t,"end")||Z(Q,h),s=Z(o)):(o=X(a,"start")||Z(X(t,"start")||Q,h.slice(0,l)),s=X(a,"end")||Z(o,h.substr(l,c))),{css:h,mismatchOffset:l,mismatchLength:c,start:o,end:s}}(r,n);return i.rawMessage=e,i.syntax=t?G(t):"<generic>",i.css=a,i.mismatchOffset=s,i.mismatchLength=l,i.message=e+"\n syntax: "+i.syntax+"\n value: "+(a||"<empty string>")+"\n --------"+new Array(i.mismatchOffset+1).join("-")+"^",Object.assign(i,c),i.loc={source:n&&n.loc&&n.loc.source||"<unknown>",start:c,end:u},i},ee=Object.prototype.hasOwnProperty,te=Object.create(null),ne=Object.create(null);function re(e,t){return t=t||0,e.length-t>=2&&45===e.charCodeAt(t)&&45===e.charCodeAt(t+1)}function ie(e,t){if(t=t||0,e.length-t>=3&&45===e.charCodeAt(t)&&45!==e.charCodeAt(t+1)){var n=e.indexOf("-",t+2);if(-1!==n)return e.substring(t,n+1)}return""}var ae={keyword:function(e){if(ee.call(te,e))return te[e];var t=e.toLowerCase();if(ee.call(te,t))return te[e]=te[t];var n=re(t,0),r=n?"":ie(t,0);return te[e]=Object.freeze({basename:t.substr(r.length),name:t,vendor:r,prefix:r,custom:n})},property:function(e){if(ee.call(ne,e))return ne[e];var t=e,n=e[0];"/"===n?n="/"===e[1]?"//":"/":"_"!==n&&"*"!==n&&"$"!==n&&"#"!==n&&"+"!==n&&"&"!==n&&(n="");var r=re(t,n.length);if(!r&&(t=t.toLowerCase(),ee.call(ne,t)))return ne[e]=ne[t];var i=r?"":ie(t,n.length),a=t.substr(0,n.length+i.length);return ne[e]=Object.freeze({basename:t.substr(a.length),name:t.substr(n.length),hack:n,vendor:i,prefix:a,custom:r})},isCustomProperty:re,vendorPrefix:ie},oe="undefined"!=typeof Uint32Array?Uint32Array:Array,se=function(e,t){return null===e||e.length<t?new oe(Math.max(t+1024,16384)):e},le=h.TYPE,ce=z.isNewline,ue=z.isName,he=z.isValidEscape,pe=z.isNumberStart,de=z.isIdentifierStart,me=z.charCodeCategory,ge=z.isBOM,fe=M.cmpStr,be=M.getNewlineLength,ye=M.findWhiteSpaceEnd,ke=M.consumeEscaped,ve=M.consumeName,xe=M.consumeNumber,we=M.consumeBadUrlRemnants;function Se(e,t){function n(t){return t<o?e.charCodeAt(t):0}function r(){return h=xe(e,h),de(n(h),n(h+1),n(h+2))?(f=le.Dimension,void(h=ve(e,h))):37===n(h)?(f=le.Percentage,void h++):void(f=le.Number)}function i(){const t=h;return h=ve(e,h),fe(e,t,h,"url")&&40===n(h)?34===n(h=ye(e,h+1))||39===n(h)?(f=le.Function,void(h=t+4)):void function(){for(f=le.Url,h=ye(e,h);h<e.length;h++){var t=e.charCodeAt(h);switch(me(t)){case 41:return void h++;case me.Eof:return;case me.WhiteSpace:return 41===n(h=ye(e,h))||h>=e.length?void(h<e.length&&h++):(h=we(e,h),void(f=le.BadUrl));case 34:case 39:case 40:case me.NonPrintable:return h=we(e,h),void(f=le.BadUrl);case 92:if(he(t,n(h+1))){h=ke(e,h)-1;break}return h=we(e,h),void(f=le.BadUrl)}}}():40===n(h)?(f=le.Function,void h++):void(f=le.Ident)}function a(t){for(t||(t=n(h++)),f=le.String;h<e.length;h++){var r=e.charCodeAt(h);switch(me(r)){case t:return void h++;case me.Eof:return;case me.WhiteSpace:if(ce(r))return h+=be(e,h,r),void(f=le.BadString);break;case 92:if(h===e.length-1)break;var i=n(h+1);ce(i)?h+=be(e,h+1,i):he(r,i)&&(h=ke(e,h)-1)}}}t||(t=new H);for(var o=(e=String(e||"")).length,s=se(t.offsetAndType,o+1),l=se(t.balance,o+1),c=0,u=ge(n(0)),h=u,p=0,d=0,m=0;h<o;){var g=e.charCodeAt(h),f=0;switch(l[c]=o,me(g)){case me.WhiteSpace:f=le.WhiteSpace,h=ye(e,h+1);break;case 34:a();break;case 35:ue(n(h+1))||he(n(h+1),n(h+2))?(f=le.Hash,h=ve(e,h+1)):(f=le.Delim,h++);break;case 39:a();break;case 40:f=le.LeftParenthesis,h++;break;case 41:f=le.RightParenthesis,h++;break;case 43:pe(g,n(h+1),n(h+2))?r():(f=le.Delim,h++);break;case 44:f=le.Comma,h++;break;case 45:pe(g,n(h+1),n(h+2))?r():45===n(h+1)&&62===n(h+2)?(f=le.CDC,h+=3):de(g,n(h+1),n(h+2))?i():(f=le.Delim,h++);break;case 46:pe(g,n(h+1),n(h+2))?r():(f=le.Delim,h++);break;case 47:42===n(h+1)?(f=le.Comment,1===(h=e.indexOf("*/",h+2)+2)&&(h=e.length)):(f=le.Delim,h++);break;case 58:f=le.Colon,h++;break;case 59:f=le.Semicolon,h++;break;case 60:33===n(h+1)&&45===n(h+2)&&45===n(h+3)?(f=le.CDO,h+=4):(f=le.Delim,h++);break;case 64:de(n(h+1),n(h+2),n(h+3))?(f=le.AtKeyword,h=ve(e,h+1)):(f=le.Delim,h++);break;case 91:f=le.LeftSquareBracket,h++;break;case 92:he(g,n(h+1))?i():(f=le.Delim,h++);break;case 93:f=le.RightSquareBracket,h++;break;case 123:f=le.LeftCurlyBracket,h++;break;case 125:f=le.RightCurlyBracket,h++;break;case me.Digit:r();break;case me.NameStart:i();break;case me.Eof:break;default:f=le.Delim,h++}switch(f){case p:for(p=(d=l[m=16777215&d])>>24,l[c]=m,l[m++]=c;m<c;m++)l[m]===o&&(l[m]=c);break;case le.LeftParenthesis:case le.Function:l[c]=d,d=(p=le.RightParenthesis)<<24|c;break;case le.LeftSquareBracket:l[c]=d,d=(p=le.RightSquareBracket)<<24|c;break;case le.LeftCurlyBracket:l[c]=d,d=(p=le.RightCurlyBracket)<<24|c}s[c++]=f<<24|h}for(s[c]=le.EOF<<24|h,l[c]=o,l[o]=o;0!==d;)d=l[m=16777215&d],l[m]=o;return t.source=e,t.firstCharOffset=u,t.offsetAndType=s,t.tokenCount=c,t.balance=l,t.reset(),t.next(),t}Object.keys(h).forEach((function(e){Se[e]=h[e]})),Object.keys(z).forEach((function(e){Se[e]=z[e]})),Object.keys(M).forEach((function(e){Se[e]=M[e]}));var Ce=Se,ze=Ce.isDigit,Ae=Ce.cmpChar,Pe=Ce.TYPE,Te=Pe.Delim,Le=Pe.WhiteSpace,Ee=Pe.Comment,De=Pe.Ident,Oe=Pe.Number,Be=Pe.Dimension;function Ie(e,t){return null!==e&&e.type===Te&&e.value.charCodeAt(0)===t}function Ne(e,t,n){for(;null!==e&&(e.type===Le||e.type===Ee);)e=n(++t);return t}function Re(e,t,n,r){if(!e)return 0;var i=e.value.charCodeAt(t);if(43===i||45===i){if(n)return 0;t++}for(;t<e.value.length;t++)if(!ze(e.value.charCodeAt(t)))return 0;return r+1}function Me(e,t,n){var r=!1,i=Ne(e,t,n);if(null===(e=n(i)))return t;if(e.type!==Oe){if(!Ie(e,43)&&!Ie(e,45))return t;if(r=!0,i=Ne(n(++i),i,n),null===(e=n(i))&&e.type!==Oe)return 0}if(!r){var a=e.value.charCodeAt(0);if(43!==a&&45!==a)return 0}return Re(e,r?0:1,r,i)}var je=Ce.isHexDigit,_e=Ce.cmpChar,Fe=Ce.TYPE,We=Fe.Ident,qe=Fe.Delim,Ye=Fe.Number,Ue=Fe.Dimension;function He(e,t){return null!==e&&e.type===qe&&e.value.charCodeAt(0)===t}function Ve(e,t){return e.value.charCodeAt(0)===t}function Ke(e,t,n){for(var r=t,i=0;r<e.value.length;r++){var a=e.value.charCodeAt(r);if(45===a&&n&&0!==i)return Ke(e,t+i+1,!1)>0?6:0;if(!je(a))return 0;if(++i>6)return 0}return i}function Ge(e,t,n){if(!e)return 0;for(;He(n(t),63);){if(++e>6)return 0;t++}return t}var Qe=Ce.isIdentifierStart,Xe=Ce.isHexDigit,Ze=Ce.isDigit,$e=Ce.cmpStr,Je=Ce.consumeNumber,et=Ce.TYPE,tt=["unset","initial","inherit"],nt=["calc(","-moz-calc(","-webkit-calc("];function rt(e,t){return t<e.length?e.charCodeAt(t):0}function it(e,t){return $e(e,0,e.length,t)}function at(e,t){for(var n=0;n<t.length;n++)if(it(e,t[n]))return!0;return!1}function ot(e,t){return t===e.length-2&&(92===e.charCodeAt(t)&&Ze(e.charCodeAt(t+1)))}function st(e,t,n){if(e&&"Range"===e.type){var r=Number(void 0!==n&&n!==t.length?t.substr(0,n):t);if(isNaN(r))return!0;if(null!==e.min&&r<e.min)return!0;if(null!==e.max&&r>e.max)return!0}return!1}function lt(e,t){var n=e.index,r=0;do{if(r++,e.balance<=n)break}while(e=t(r));return r}function ct(e){return function(t,n,r){return null===t?0:t.type===et.Function&&at(t.value,nt)?lt(t,n):e(t,n,r)}}function ut(e){return function(t){return null===t||t.type!==e?0:1}}function ht(e){return function(t,n,r){if(null===t||t.type!==et.Dimension)return 0;var i=Je(t.value,0);if(null!==e){var a=t.value.indexOf("\\",i),o=-1!==a&&ot(t.value,a)?t.value.substring(i,a):t.value.substr(i);if(!1===e.hasOwnProperty(o.toLowerCase()))return 0}return st(r,t.value,i)?0:1}}function pt(e){return"function"!=typeof e&&(e=function(){return 0}),function(t,n,r){return null!==t&&t.type===et.Number&&0===Number(t.value)?1:e(t,n,r)}}var dt,mt={"ident-token":ut(et.Ident),"function-token":ut(et.Function),"at-keyword-token":ut(et.AtKeyword),"hash-token":ut(et.Hash),"string-token":ut(et.String),"bad-string-token":ut(et.BadString),"url-token":ut(et.Url),"bad-url-token":ut(et.BadUrl),"delim-token":ut(et.Delim),"number-token":ut(et.Number),"percentage-token":ut(et.Percentage),"dimension-token":ut(et.Dimension),"whitespace-token":ut(et.WhiteSpace),"CDO-token":ut(et.CDO),"CDC-token":ut(et.CDC),"colon-token":ut(et.Colon),"semicolon-token":ut(et.Semicolon),"comma-token":ut(et.Comma),"[-token":ut(et.LeftSquareBracket),"]-token":ut(et.RightSquareBracket),"(-token":ut(et.LeftParenthesis),")-token":ut(et.RightParenthesis),"{-token":ut(et.LeftCurlyBracket),"}-token":ut(et.RightCurlyBracket),string:ut(et.String),ident:ut(et.Ident),"custom-ident":function(e){if(null===e||e.type!==et.Ident)return 0;var t=e.value.toLowerCase();return at(t,tt)||it(t,"default")?0:1},"custom-property-name":function(e){return null===e||e.type!==et.Ident||45!==rt(e.value,0)||45!==rt(e.value,1)?0:1},"hex-color":function(e){if(null===e||e.type!==et.Hash)return 0;var t=e.value.length;if(4!==t&&5!==t&&7!==t&&9!==t)return 0;for(var n=1;n<t;n++)if(!Xe(e.value.charCodeAt(n)))return 0;return 1},"id-selector":function(e){return null===e||e.type!==et.Hash?0:Qe(rt(e.value,1),rt(e.value,2),rt(e.value,3))?1:0},"an-plus-b":function(e,t){var n=0;if(!e)return 0;if(e.type===Oe)return Re(e,0,!1,n);if(e.type===De&&45===e.value.charCodeAt(0)){if(!Ae(e.value,1,110))return 0;switch(e.value.length){case 2:return Me(t(++n),n,t);case 3:return 45!==e.value.charCodeAt(2)?0:(n=Ne(t(++n),n,t),Re(e=t(n),0,!0,n));default:return 45!==e.value.charCodeAt(2)?0:Re(e,3,!0,n)}}else if(e.type===De||Ie(e,43)&&t(n+1).type===De){if(e.type!==De&&(e=t(++n)),null===e||!Ae(e.value,0,110))return 0;switch(e.value.length){case 1:return Me(t(++n),n,t);case 2:return 45!==e.value.charCodeAt(1)?0:(n=Ne(t(++n),n,t),Re(e=t(n),0,!0,n));default:return 45!==e.value.charCodeAt(1)?0:Re(e,2,!0,n)}}else if(e.type===Be){for(var r=e.value.charCodeAt(0),i=43===r||45===r?1:0,a=i;a<e.value.length&&ze(e.value.charCodeAt(a));a++);return a===i?0:Ae(e.value,a,110)?a+1===e.value.length?Me(t(++n),n,t):45!==e.value.charCodeAt(a+1)?0:a+2===e.value.length?(n=Ne(t(++n),n,t),Re(e=t(n),0,!0,n)):Re(e,a+2,!0,n):0}return 0},urange:function(e,t){var n=0;if(null===e||e.type!==We||!_e(e.value,0,117))return 0;if(null===(e=t(++n)))return 0;if(He(e,43))return null===(e=t(++n))?0:e.type===We?Ge(Ke(e,0,!0),++n,t):He(e,63)?Ge(1,++n,t):0;if(e.type===Ye){if(!Ve(e,43))return 0;var r=Ke(e,1,!0);return 0===r?0:null===(e=t(++n))?n:e.type===Ue||e.type===Ye?Ve(e,45)&&Ke(e,1,!1)?n+1:0:Ge(r,n,t)}return e.type===Ue&&Ve(e,43)?Ge(Ke(e,1,!0),++n,t):0},"declaration-value":function(e,t){if(!e)return 0;var n=0,r=0,i=e.index;e:do{switch(e.type){case et.BadString:case et.BadUrl:break e;case et.RightCurlyBracket:case et.RightParenthesis:case et.RightSquareBracket:if(e.balance>e.index||e.balance<i)break e;r--;break;case et.Semicolon:if(0===r)break e;break;case et.Delim:if("!"===e.value&&0===r)break e;break;case et.Function:case et.LeftParenthesis:case et.LeftSquareBracket:case et.LeftCurlyBracket:r++}if(n++,e.balance<=i)break}while(e=t(n));return n},"any-value":function(e,t){if(!e)return 0;var n=e.index,r=0;e:do{switch(e.type){case et.BadString:case et.BadUrl:break e;case et.RightCurlyBracket:case et.RightParenthesis:case et.RightSquareBracket:if(e.balance>e.index||e.balance<n)break e}if(r++,e.balance<=n)break}while(e=t(r));return r},dimension:ct(ht(null)),angle:ct(ht({deg:!0,grad:!0,rad:!0,turn:!0})),decibel:ct(ht({db:!0})),frequency:ct(ht({hz:!0,khz:!0})),flex:ct(ht({fr:!0})),length:ct(pt(ht({px:!0,mm:!0,cm:!0,in:!0,pt:!0,pc:!0,q:!0,em:!0,ex:!0,ch:!0,rem:!0,vh:!0,vw:!0,vmin:!0,vmax:!0,vm:!0}))),resolution:ct(ht({dpi:!0,dpcm:!0,dppx:!0,x:!0})),semitones:ct(ht({st:!0})),time:ct(ht({s:!0,ms:!0})),percentage:ct((function(e,t,n){return null===e||e.type!==et.Percentage||st(n,e.value,e.value.length-1)?0:1})),zero:pt(),number:ct((function(e,t,n){if(null===e)return 0;var r=Je(e.value,0);return r===e.value.length||ot(e.value,r)?st(n,e.value,r)?0:1:0})),integer:ct((function(e,t,n){if(null===e||e.type!==et.Number)return 0;for(var r=43===e.value.charCodeAt(0)||45===e.value.charCodeAt(0)?1:0;r<e.value.length;r++)if(!Ze(e.value.charCodeAt(r)))return 0;return st(n,e.value,r)?0:1})),"-ms-legacy-expression":(dt="expression",dt+="(",function(e,t){return null!==e&&it(e.value,dt)?lt(e,t):0})},gt=function(e,t,n){var r=o("SyntaxError",e);return r.input=t,r.offset=n,r.rawMessage=e,r.message=r.rawMessage+"\n "+r.input+"\n--"+new Array((r.offset||r.input.length)+1).join("-")+"^",r},ft=function(e){this.str=e,this.pos=0};ft.prototype={charCodeAt:function(e){return e<this.str.length?this.str.charCodeAt(e):0},charCode:function(){return this.charCodeAt(this.pos)},nextCharCode:function(){return this.charCodeAt(this.pos+1)},nextNonWsCode:function(e){return this.charCodeAt(this.findWsEnd(e))},findWsEnd:function(e){for(;e<this.str.length;e++){var t=this.str.charCodeAt(e);if(13!==t&&10!==t&&12!==t&&32!==t&&9!==t)break}return e},substringToPos:function(e){return this.str.substring(this.pos,this.pos=e)},eat:function(e){this.charCode()!==e&&this.error("Expect `"+String.fromCharCode(e)+"`"),this.pos++},peek:function(){return this.pos<this.str.length?this.str.charAt(this.pos++):""},error:function(e){throw new gt(e,this.str,this.pos)}};var bt=ft,yt=function(e){for(var t="function"==typeof Uint32Array?new Uint32Array(128):new Array(128),n=0;n<128;n++)t[n]=e(String.fromCharCode(n))?1:0;return t}((function(e){return/[a-zA-Z0-9\-]/.test(e)})),kt={" ":1,"&&":2,"||":3,"|":4};function vt(e){return e.substringToPos(e.findWsEnd(e.pos))}function xt(e){for(var t=e.pos;t<e.str.length;t++){var n=e.str.charCodeAt(t);if(n>=128||0===yt[n])break}return e.pos===t&&e.error("Expect a keyword"),e.substringToPos(t)}function wt(e){for(var t=e.pos;t<e.str.length;t++){var n=e.str.charCodeAt(t);if(n<48||n>57)break}return e.pos===t&&e.error("Expect a number"),e.substringToPos(t)}function St(e){var t=e.str.indexOf("'",e.pos+1);return-1===t&&(e.pos=e.str.length,e.error("Expect an apostrophe")),e.substringToPos(t+1)}function Ct(e){var t,n=null;return e.eat(123),t=wt(e),44===e.charCode()?(e.pos++,125!==e.charCode()&&(n=wt(e))):n=t,e.eat(125),{min:Number(t),max:n?Number(n):0}}function zt(e,t){var n=function(e){var t=null,n=!1;switch(e.charCode()){case 42:e.pos++,t={min:0,max:0};break;case 43:e.pos++,t={min:1,max:0};break;case 63:e.pos++,t={min:0,max:1};break;case 35:e.pos++,n=!0,t=123===e.charCode()?Ct(e):{min:1,max:0};break;case 123:t=Ct(e);break;default:return null}return{type:"Multiplier",comma:n,min:t.min,max:t.max,term:null}}(e);return null!==n?(n.term=t,n):t}function At(e){var t=e.peek();return""===t?null:{type:"Token",value:t}}function Pt(e){var t,n=null;return e.eat(60),t=xt(e),40===e.charCode()&&41===e.nextCharCode()&&(e.pos+=2,t+="()"),91===e.charCodeAt(e.findWsEnd(e.pos))&&(vt(e),n=function(e){var t=null,n=null,r=1;return e.eat(91),45===e.charCode()&&(e.peek(),r=-1),-1==r&&8734===e.charCode()?e.peek():t=r*Number(wt(e)),vt(e),e.eat(44),vt(e),8734===e.charCode()?e.peek():(r=1,45===e.charCode()&&(e.peek(),r=-1),n=r*Number(wt(e))),e.eat(93),null===t&&null===n?null:{type:"Range",min:t,max:n}}(e)),e.eat(62),zt(e,{type:"Type",name:t,opts:n})}function Tt(e,t){function n(e,t){return{type:"Group",terms:e,combinator:t,disallowEmpty:!1,explicit:!1}}for(t=Object.keys(t).sort((function(e,t){return kt[e]-kt[t]}));t.length>0;){for(var r=t.shift(),i=0,a=0;i<e.length;i++){var o=e[i];"Combinator"===o.type&&(o.value===r?(-1===a&&(a=i-1),e.splice(i,1),i--):(-1!==a&&i-a>1&&(e.splice(a,i-a,n(e.slice(a,i),r)),i=a+1),a=-1))}-1!==a&&t.length&&e.splice(a,i-a,n(e.slice(a,i),r))}return r}function Lt(e){for(var t,n=[],r={},i=null,a=e.pos;t=Et(e);)"Spaces"!==t.type&&("Combinator"===t.type?(null!==i&&"Combinator"!==i.type||(e.pos=a,e.error("Unexpected combinator")),r[t.value]=!0):null!==i&&"Combinator"!==i.type&&(r[" "]=!0,n.push({type:"Combinator",value:" "})),n.push(t),i=t,a=e.pos);return null!==i&&"Combinator"===i.type&&(e.pos-=a,e.error("Unexpected combinator")),{type:"Group",terms:n,combinator:Tt(n,r)||" ",disallowEmpty:!1,explicit:!1}}function Et(e){var t=e.charCode();if(t<128&&1===yt[t])return function(e){var t;return t=xt(e),40===e.charCode()?(e.pos++,{type:"Function",name:t}):zt(e,{type:"Keyword",name:t})}(e);switch(t){case 93:break;case 91:return zt(e,function(e){var t;return e.eat(91),t=Lt(e),e.eat(93),t.explicit=!0,33===e.charCode()&&(e.pos++,t.disallowEmpty=!0),t}(e));case 60:return 39===e.nextCharCode()?function(e){var t;return e.eat(60),e.eat(39),t=xt(e),e.eat(39),e.eat(62),zt(e,{type:"Property",name:t})}(e):Pt(e);case 124:return{type:"Combinator",value:e.substringToPos(124===e.nextCharCode()?e.pos+2:e.pos+1)};case 38:return e.pos++,e.eat(38),{type:"Combinator",value:"&&"};case 44:return e.pos++,{type:"Comma"};case 39:return zt(e,{type:"String",value:St(e)});case 32:case 9:case 10:case 13:case 12:return{type:"Spaces",value:vt(e)};case 64:return(t=e.nextCharCode())<128&&1===yt[t]?(e.pos++,{type:"AtKeyword",name:xt(e)}):At(e);case 42:case 43:case 63:case 35:case 33:break;case 123:if((t=e.nextCharCode())<48||t>57)return At(e);break;default:return At(e)}}function Dt(e){var t=new bt(e),n=Lt(t);return t.pos!==e.length&&t.error("Unexpected input"),1===n.terms.length&&"Group"===n.terms[0].type&&(n=n.terms[0]),n}Dt("[a&&<b>#|<'c'>*||e() f{2} /,(% g#{1,2} h{2,})]!");var Ot=Dt,Bt=function(){};function It(e){return"function"==typeof e?e:Bt}var Nt=function(e,t,n){var r=Bt,i=Bt;if("function"==typeof t?r=t:t&&(r=It(t.enter),i=It(t.leave)),r===Bt&&i===Bt)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");!function e(t){switch(r.call(n,t),t.type){case"Group":t.terms.forEach(e);break;case"Multiplier":e(t.term);break;case"Type":case"Property":case"Keyword":case"AtKeyword":case"Function":case"String":case"Token":case"Comma":break;default:throw new Error("Unknown type: "+t.type)}i.call(n,t)}(e)},Rt=new H,Mt={decorator:function(e){var t=null,n={len:0,node:null},r=[n],i="";return{children:e.children,node:function(n){var r=t;t=n,e.node.call(this,n),t=r},chunk:function(e){i+=e,n.node!==t?r.push({len:e.length,node:t}):n.len+=e.length},result:function(){return jt(i,r)}}}};function jt(e,t){var n=[],r=0,i=0,a=t?t[i].node:null;for(Ce(e,Rt);!Rt.eof;){if(t)for(;i<t.length&&r+t[i].len<=Rt.tokenStart;)r+=t[i++].len,a=t[i].node;n.push({type:Rt.tokenType,value:Rt.getTokenValue(),index:Rt.tokenIndex,balance:Rt.balance[Rt.tokenIndex],node:a}),Rt.next()}return n}var _t={type:"Match"},Ft={type:"Mismatch"},Wt={type:"DisallowEmpty"};function qt(e,t,n){return t===_t&&n===Ft||e===_t&&t===_t&&n===_t?e:("If"===e.type&&e.else===Ft&&t===_t&&(t=e.then,e=e.match),{type:"If",match:e,then:t,else:n})}function Yt(e){return e.length>2&&40===e.charCodeAt(e.length-2)&&41===e.charCodeAt(e.length-1)}function Ut(e){return"Keyword"===e.type||"AtKeyword"===e.type||"Function"===e.type||"Type"===e.type&&Yt(e.name)}function Ht(e){if("function"==typeof e)return{type:"Generic",fn:e};switch(e.type){case"Group":var t=function e(t,n,r){switch(t){case" ":for(var i=_t,a=n.length-1;a>=0;a--){i=qt(l=n[a],i,Ft)}return i;case"|":i=Ft;var o=null;for(a=n.length-1;a>=0;a--){if(Ut(l=n[a])&&(null===o&&a>0&&Ut(n[a-1])&&(i=qt({type:"Enum",map:o=Object.create(null)},_t,i)),null!==o)){var s=(Yt(l.name)?l.name.slice(0,-1):l.name).toLowerCase();if(s in o==!1){o[s]=l;continue}}o=null,i=qt(l,_t,i)}return i;case"&&":if(n.length>5)return{type:"MatchOnce",terms:n,all:!0};for(i=Ft,a=n.length-1;a>=0;a--){var l=n[a];c=n.length>1?e(t,n.filter((function(e){return e!==l})),!1):_t,i=qt(l,c,i)}return i;case"||":if(n.length>5)return{type:"MatchOnce",terms:n,all:!1};for(i=r?_t:Ft,a=n.length-1;a>=0;a--){var c;l=n[a];c=n.length>1?e(t,n.filter((function(e){return e!==l})),!0):_t,i=qt(l,c,i)}return i}}(e.combinator,e.terms.map(Ht),!1);return e.disallowEmpty&&(t=qt(t,Wt,Ft)),t;case"Multiplier":return function(e){var t=_t,n=Ht(e.term);if(0===e.max)n=qt(n,Wt,Ft),(t=qt(n,null,Ft)).then=qt(_t,_t,t),e.comma&&(t.then.else=qt({type:"Comma",syntax:e},t,Ft));else for(var r=e.min||1;r<=e.max;r++)e.comma&&t!==_t&&(t=qt({type:"Comma",syntax:e},t,Ft)),t=qt(n,qt(_t,_t,t),Ft);if(0===e.min)t=qt(_t,_t,t);else for(r=0;r<e.min-1;r++)e.comma&&t!==_t&&(t=qt({type:"Comma",syntax:e},t,Ft)),t=qt(n,t,Ft);return t}(e);case"Type":case"Property":return{type:e.type,name:e.name,syntax:e};case"Keyword":return{type:e.type,name:e.name.toLowerCase(),syntax:e};case"AtKeyword":return{type:e.type,name:"@"+e.name.toLowerCase(),syntax:e};case"Function":return{type:e.type,name:e.name.toLowerCase()+"(",syntax:e};case"String":return 3===e.value.length?{type:"Token",value:e.value.charAt(1),syntax:e}:{type:e.type,value:e.value.substr(1,e.value.length-2).replace(/\\'/g,"'"),syntax:e};case"Token":return{type:e.type,value:e.value,syntax:e};case"Comma":return{type:e.type,syntax:e};default:throw new Error("Unknown node type:",e.type)}}var Vt=_t,Kt=Ft,Gt=Wt,Qt=function(e,t){return"string"==typeof e&&(e=Ot(e)),{type:"MatchGraph",match:Ht(e),syntax:t||null,source:e}},Xt=Object.prototype.hasOwnProperty,Zt=Vt,$t=Kt,Jt=Gt,en=h.TYPE;function tn(e){for(var t=null,n=null,r=e;null!==r;)n=r.prev,r.prev=t,t=r,r=n;return t}function nn(e,t){if(e.length!==t.length)return!1;for(var n=0;n<e.length;n++){var r=e.charCodeAt(n);if(r>=65&&r<=90&&(r|=32),r!==t.charCodeAt(n))return!1}return!0}function rn(e){return null===e||(e.type===en.Comma||e.type===en.Function||e.type===en.LeftParenthesis||e.type===en.LeftSquareBracket||e.type===en.LeftCurlyBracket||function(e){return e.type===en.Delim&&"?"!==e.value}(e))}function an(e){return null===e||(e.type===en.RightParenthesis||e.type===en.RightSquareBracket||e.type===en.RightCurlyBracket||e.type===en.Delim)}function on(e,t,n){function r(){do{b++,f=b<e.length?e[b]:null}while(null!==f&&(f.type===en.WhiteSpace||f.type===en.Comment))}function i(t){var n=b+t;return n<e.length?e[n]:null}function a(e,t){return{nextState:e,matchStack:k,syntaxStack:u,thenStack:h,tokenIndex:b,prev:t}}function o(e){h={nextState:e,matchStack:k,syntaxStack:u,prev:h}}function s(e){p=a(e,p)}function l(){k={type:1,syntax:t.syntax,token:f,prev:k},r(),d=null,b>y&&(y=b)}function c(){k=2===k.type?k.prev:{type:3,syntax:u.syntax,token:k.token,prev:k},u=u.prev}var u=null,h=null,p=null,d=null,m=0,g=null,f=null,b=-1,y=0,k={type:0,syntax:null,token:null,prev:null};for(r();null===g&&++m<15e3;)switch(t.type){case"Match":if(null===h){if(null!==f&&(b!==e.length-1||"\\0"!==f.value&&"\\9"!==f.value)){t=$t;break}g="Match";break}if((t=h.nextState)===Jt){if(h.matchStack===k){t=$t;break}t=Zt}for(;h.syntaxStack!==u;)c();h=h.prev;break;case"Mismatch":if(null!==d&&!1!==d)(null===p||b>p.tokenIndex)&&(p=d,d=!1);else if(null===p){g="Mismatch";break}t=p.nextState,h=p.thenStack,u=p.syntaxStack,k=p.matchStack,b=p.tokenIndex,f=b<e.length?e[b]:null,p=p.prev;break;case"MatchGraph":t=t.match;break;case"If":t.else!==$t&&s(t.else),t.then!==Zt&&o(t.then),t=t.match;break;case"MatchOnce":t={type:"MatchOnceBuffer",syntax:t,index:0,mask:0};break;case"MatchOnceBuffer":var v=t.syntax.terms;if(t.index===v.length){if(0===t.mask||t.syntax.all){t=$t;break}t=Zt;break}if(t.mask===(1<<v.length)-1){t=Zt;break}for(;t.index<v.length;t.index++){var x=1<<t.index;if(0==(t.mask&x)){s(t),o({type:"AddMatchOnce",syntax:t.syntax,mask:t.mask|x}),t=v[t.index++];break}}break;case"AddMatchOnce":t={type:"MatchOnceBuffer",syntax:t.syntax,index:0,mask:t.mask};break;case"Enum":if(null!==f)if(-1!==(A=f.value.toLowerCase()).indexOf("\\")&&(A=A.replace(/\\[09].*$/,"")),Xt.call(t.map,A)){t=t.map[A];break}t=$t;break;case"Generic":var w=null!==u?u.opts:null,S=b+Math.floor(t.fn(f,i,w));if(!isNaN(S)&&S>b){for(;b<S;)l();t=Zt}else t=$t;break;case"Type":case"Property":var C="Type"===t.type?"types":"properties",z=Xt.call(n,C)?n[C][t.name]:null;if(!z||!z.match)throw new Error("Bad syntax reference: "+("Type"===t.type?"<"+t.name+">":"<'"+t.name+"'>"));if(!1!==d&&null!==f&&"Type"===t.type)if("custom-ident"===t.name&&f.type===en.Ident||"length"===t.name&&"0"===f.value){null===d&&(d=a(t,p)),t=$t;break}u={syntax:t.syntax,opts:t.syntax.opts||null!==u&&u.opts||null,prev:u},k={type:2,syntax:t.syntax,token:k.token,prev:k},t=z.match;break;case"Keyword":var A=t.name;if(null!==f){var P=f.value;if(-1!==P.indexOf("\\")&&(P=P.replace(/\\[09].*$/,"")),nn(P,A)){l(),t=Zt;break}}t=$t;break;case"AtKeyword":case"Function":if(null!==f&&nn(f.value,t.name)){l(),t=Zt;break}t=$t;break;case"Token":if(null!==f&&f.value===t.value){l(),t=Zt;break}t=$t;break;case"Comma":null!==f&&f.type===en.Comma?rn(k.token)?t=$t:(l(),t=an(f)?$t:Zt):t=rn(k.token)||an(f)?Zt:$t;break;case"String":var T="";for(S=b;S<e.length&&T.length<t.value.length;S++)T+=e[S].value;if(nn(T,t.value)){for(;b<S;)l();t=Zt}else t=$t;break;default:throw new Error("Unknown node type: "+t.type)}switch(m,g){case null:console.warn("[csstree-match] BREAK after 15000 iterations"),g="Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)",k=null;break;case"Match":for(;null!==u;)c();break;default:k=null}return{tokens:e,reason:g,iterations:m,match:k,longestMatch:y}}var sn=function(e,t,n){var r=on(e,t,n||{});if(null===r.match)return r;var i=r.match,a=r.match={syntax:t.syntax||null,match:[]},o=[a];for(i=tn(i).prev;null!==i;){switch(i.type){case 2:a.match.push(a={syntax:i.syntax,match:[]}),o.push(a);break;case 3:o.pop(),a=o[o.length-1];break;default:a.match.push({syntax:i.syntax||null,token:i.token.value,node:i.token.node})}i=i.prev}return r};function ln(e){function t(e){return null!==e&&("Type"===e.type||"Property"===e.type||"Keyword"===e.type)}var n=null;return null!==this.matched&&function r(i){if(Array.isArray(i.match)){for(var a=0;a<i.match.length;a++)if(r(i.match[a]))return t(i.syntax)&&n.unshift(i.syntax),!0}else if(i.node===e)return n=t(i.syntax)?[i.syntax]:[],!0;return!1}(this.matched),n}function cn(e,t,n){var r=ln.call(e,t);return null!==r&&r.some(n)}var un={getTrace:ln,isType:function(e,t){return cn(this,e,(function(e){return"Type"===e.type&&e.name===t}))},isProperty:function(e,t){return cn(this,e,(function(e){return"Property"===e.type&&e.name===t}))},isKeyword:function(e){return cn(this,e,(function(e){return"Keyword"===e.type}))}};var hn={matchFragments:function(e,t,n,r,i){var o=[];return null!==n.matched&&function n(s){if(null!==s.syntax&&s.syntax.type===r&&s.syntax.name===i){var l=function e(t){return"node"in t?t.node:e(t.match[0])}(s),c=function e(t){return"node"in t?t.node:e(t.match[t.match.length-1])}(s);e.syntax.walk(t,(function(e,t,n){if(e===l){var r=new a;do{if(r.appendData(t.data),t.data===c)break;t=t.next}while(null!==t);o.push({parent:n,nodes:r})}}))}Array.isArray(s.match)&&s.match.forEach(n)}(n.matched),o}},pn=Object.prototype.hasOwnProperty;function dn(e){return"number"==typeof e&&isFinite(e)&&Math.floor(e)===e&&e>=0}function mn(e){return Boolean(e)&&dn(e.offset)&&dn(e.line)&&dn(e.column)}function gn(e,t){return function(n,r){if(!n||n.constructor!==Object)return r(n,"Type of node should be an Object");for(var i in n){var o=!0;if(!1!==pn.call(n,i)){if("type"===i)n.type!==e&&r(n,"Wrong node type `"+n.type+"`, expected `"+e+"`");else if("loc"===i){if(null===n.loc)continue;if(n.loc&&n.loc.constructor===Object)if("string"!=typeof n.loc.source)i+=".source";else if(mn(n.loc.start)){if(mn(n.loc.end))continue;i+=".end"}else i+=".start";o=!1}else if(t.hasOwnProperty(i)){var s=0;for(o=!1;!o&&s<t[i].length;s++){var l=t[i][s];switch(l){case String:o="string"==typeof n[i];break;case Boolean:o="boolean"==typeof n[i];break;case null:o=null===n[i];break;default:"string"==typeof l?o=n[i]&&n[i].type===l:Array.isArray(l)&&(o=n[i]instanceof a)}}}else r(n,"Unknown field `"+i+"` for "+e+" node type");o||r(n,"Bad value for `"+e+"."+i+"`")}}for(var i in t)pn.call(t,i)&&!1===pn.call(n,i)&&r(n,"Field `"+e+"."+i+"` is missed")}}function fn(e,t){var n=t.structure,r={type:String,loc:!0},i={type:'"'+e+'"'};for(var a in n)if(!1!==pn.call(n,a)){for(var o=[],s=r[a]=Array.isArray(n[a])?n[a].slice():[n[a]],l=0;l<s.length;l++){var c=s[l];if(c===String||c===Boolean)o.push(c.name);else if(null===c)o.push("null");else if("string"==typeof c)o.push("<"+c+">");else{if(!Array.isArray(c))throw new Error("Wrong value `"+c+"` in `"+e+"."+a+"` structure definition");o.push("List")}}i[a]=o.join(" | ")}return{docs:i,check:gn(e,r)}}var bn=$,yn=J,kn=Qt,vn=sn,xn=function(e){var t={};if(e.node)for(var n in e.node)if(pn.call(e.node,n)){var r=e.node[n];if(!r.structure)throw new Error("Missed `structure` field in `"+n+"` node type definition");t[n]=fn(n,r)}return t},wn=kn("inherit | initial | unset"),Sn=kn("inherit | initial | unset | <-ms-legacy-expression>");function Cn(e,t,n){var r={};for(var i in e)e[i].syntax&&(r[i]=n?e[i].syntax:G(e[i].syntax,{compact:t}));return r}function zn(e,t,n){const r={};for(const[i,a]of Object.entries(e))r[i]={prelude:a.prelude&&(n?a.prelude.syntax:G(a.prelude.syntax,{compact:t})),descriptors:a.descriptors&&Cn(a.descriptors,t,n)};return r}function An(e,t,n){return{matched:e,iterations:n,error:t,getTrace:un.getTrace,isType:un.isType,isProperty:un.isProperty,isKeyword:un.isKeyword}}function Pn(e,t,n,r){var i,a=function(e,t){return"string"==typeof e?jt(e,null):t.generate(e,Mt)}(n,e.syntax);return function(e){for(var t=0;t<e.length;t++)if("var("===e[t].value.toLowerCase())return!0;return!1}(a)?An(null,new Error("Matching for a tree with var() is not supported")):(r&&(i=vn(a,e.valueCommonSyntax,e)),r&&i.match||(i=vn(a,t.match,e)).match?An(i.match,null,i.iterations):An(null,new yn(i.reason,t.syntax,n,i),i.iterations))}var Tn=function(e,t,n){if(this.valueCommonSyntax=wn,this.syntax=t,this.generic=!1,this.atrules={},this.properties={},this.types={},this.structure=n||xn(e),e){if(e.types)for(var r in e.types)this.addType_(r,e.types[r]);if(e.generic)for(var r in this.generic=!0,mt)this.addType_(r,mt[r]);if(e.atrules)for(var r in e.atrules)this.addAtrule_(r,e.atrules[r]);if(e.properties)for(var r in e.properties)this.addProperty_(r,e.properties[r])}};Tn.prototype={structure:{},checkStructure:function(e){function t(e,t){r.push({node:e,message:t})}var n=this.structure,r=[];return this.syntax.walk(e,(function(e){n.hasOwnProperty(e.type)?n[e.type].check(e,t):t(e,"Unknown node type `"+e.type+"`")})),!!r.length&&r},createDescriptor:function(e,t,n,r=null){var i={type:t,name:n},a={type:t,name:n,parent:r,syntax:null,match:null};return"function"==typeof e?a.match=kn(e,i):("string"==typeof e?Object.defineProperty(a,"syntax",{get:function(){return Object.defineProperty(a,"syntax",{value:Ot(e)}),a.syntax}}):a.syntax=e,Object.defineProperty(a,"match",{get:function(){return Object.defineProperty(a,"match",{value:kn(a.syntax,i)}),a.match}})),a},addAtrule_:function(e,t){t&&(this.atrules[e]={type:"Atrule",name:e,prelude:t.prelude?this.createDescriptor(t.prelude,"AtrulePrelude",e):null,descriptors:t.descriptors?Object.keys(t.descriptors).reduce((n,r)=>(n[r]=this.createDescriptor(t.descriptors[r],"AtruleDescriptor",r,e),n),{}):null})},addProperty_:function(e,t){t&&(this.properties[e]=this.createDescriptor(t,"Property",e))},addType_:function(e,t){t&&(this.types[e]=this.createDescriptor(t,"Type",e),t===mt["-ms-legacy-expression"]&&(this.valueCommonSyntax=Sn))},checkAtruleName:function(e){if(!this.getAtrule(e))return new bn("Unknown at-rule","@"+e)},checkAtrulePrelude:function(e,t){let n=this.checkAtruleName(e);if(n)return n;var r=this.getAtrule(e);return!r.prelude&&t?new SyntaxError("At-rule `@"+e+"` should not contain a prelude"):r.prelude&&!t?new SyntaxError("At-rule `@"+e+"` should contain a prelude"):void 0},checkAtruleDescriptorName:function(e,t){let n=this.checkAtruleName(e);if(n)return n;var r=this.getAtrule(e),i=ae.keyword(t);return r.descriptors?r.descriptors[i.name]||r.descriptors[i.basename]?void 0:new bn("Unknown at-rule descriptor",t):new SyntaxError("At-rule `@"+e+"` has no known descriptors")},checkPropertyName:function(e){return ae.property(e).custom?new Error("Lexer matching doesn't applicable for custom properties"):this.getProperty(e)?void 0:new bn("Unknown property",e)},matchAtrulePrelude:function(e,t){var n=this.checkAtrulePrelude(e,t);return n?An(null,n):t?Pn(this,this.getAtrule(e).prelude,t,!1):An(null,null)},matchAtruleDescriptor:function(e,t,n){var r=this.checkAtruleDescriptorName(e,t);if(r)return An(null,r);var i=this.getAtrule(e),a=ae.keyword(t);return Pn(this,i.descriptors[a.name]||i.descriptors[a.basename],n,!1)},matchDeclaration:function(e){return"Declaration"!==e.type?An(null,new Error("Not a Declaration node")):this.matchProperty(e.property,e.value)},matchProperty:function(e,t){var n=this.checkPropertyName(e);return n?An(null,n):Pn(this,this.getProperty(e),t,!0)},matchType:function(e,t){var n=this.getType(e);return n?Pn(this,n,t,!1):An(null,new bn("Unknown type",e))},match:function(e,t){return"string"==typeof e||e&&e.type?("string"!=typeof e&&e.match||(e=this.createDescriptor(e,"Type","anonymous")),Pn(this,e,t,!1)):An(null,new bn("Bad syntax"))},findValueFragments:function(e,t,n,r){return hn.matchFragments(this,t,this.matchProperty(e,t),n,r)},findDeclarationValueFragments:function(e,t,n){return hn.matchFragments(this,e.value,this.matchDeclaration(e),t,n)},findAllFragments:function(e,t,n){var r=[];return this.syntax.walk(e,{visit:"Declaration",enter:function(e){r.push.apply(r,this.findDeclarationValueFragments(e,t,n))}.bind(this)}),r},getAtrule:function(e,t=!0){var n=ae.keyword(e);return(n.vendor&&t?this.atrules[n.name]||this.atrules[n.basename]:this.atrules[n.name])||null},getAtrulePrelude:function(e,t=!0){const n=this.getAtrule(e,t);return n&&n.prelude||null},getAtruleDescriptor:function(e,t){return this.atrules.hasOwnProperty(e)&&this.atrules.declarators&&this.atrules[e].declarators[t]||null},getProperty:function(e,t=!0){var n=ae.property(e);return(n.vendor&&t?this.properties[n.name]||this.properties[n.basename]:this.properties[n.name])||null},getType:function(e){return this.types.hasOwnProperty(e)?this.types[e]:null},validate:function(){function e(r,i,a,o){if(a.hasOwnProperty(i))return a[i];a[i]=!1,null!==o.syntax&&Nt(o.syntax,(function(o){if("Type"===o.type||"Property"===o.type){var s="Type"===o.type?r.types:r.properties,l="Type"===o.type?t:n;s.hasOwnProperty(o.name)&&!e(r,o.name,l,s[o.name])||(a[i]=!0)}}),this)}var t={},n={};for(var r in this.types)e(this,r,t,this.types[r]);for(var r in this.properties)e(this,r,n,this.properties[r]);return t=Object.keys(t).filter((function(e){return t[e]})),n=Object.keys(n).filter((function(e){return n[e]})),t.length||n.length?{types:t,properties:n}:null},dump:function(e,t){return{generic:this.generic,types:Cn(this.types,!t,e),properties:Cn(this.properties,!t,e),atrules:zn(this.atrules,!t,e)}},toString:function(){return JSON.stringify(this.dump())}};var Ln=Tn,En={SyntaxError:gt,parse:Ot,generate:G,walk:Nt},Dn=Ce.isBOM;var On=function(){this.lines=null,this.columns=null,this.linesAndColumnsComputed=!1};On.prototype={setSource:function(e,t,n,r){this.source=e,this.startOffset=void 0===t?0:t,this.startLine=void 0===n?1:n,this.startColumn=void 0===r?1:r,this.linesAndColumnsComputed=!1},ensureLinesAndColumnsComputed:function(){this.linesAndColumnsComputed||(!function(e,t){for(var n=t.length,r=se(e.lines,n),i=e.startLine,a=se(e.columns,n),o=e.startColumn,s=t.length>0?Dn(t.charCodeAt(0)):0;s<n;s++){var l=t.charCodeAt(s);r[s]=i,a[s]=o++,10!==l&&13!==l&&12!==l||(13===l&&s+1<n&&10===t.charCodeAt(s+1)&&(r[++s]=i,a[s]=o),i++,o=1)}r[s]=i,a[s]=o,e.lines=r,e.columns=a}(this,this.source),this.linesAndColumnsComputed=!0)},getLocation:function(e,t){return this.ensureLinesAndColumnsComputed(),{source:t,offset:this.startOffset+e,line:this.lines[e],column:this.columns[e]}},getLocationRange:function(e,t,n){return this.ensureLinesAndColumnsComputed(),{source:n,start:{offset:this.startOffset+e,line:this.lines[e],column:this.columns[e]},end:{offset:this.startOffset+t,line:this.lines[t],column:this.columns[t]}}}};var Bn=On,In=Ce.TYPE,Nn=In.WhiteSpace,Rn=In.Comment,Mn=function(e){var t=this.createList(),n=null,r={recognizer:e,space:null,ignoreWS:!1,ignoreWSAfter:!1};for(this.scanner.skipSC();!this.scanner.eof;){switch(this.scanner.tokenType){case Rn:this.scanner.next();continue;case Nn:r.ignoreWS?this.scanner.next():r.space=this.WhiteSpace();continue}if(void 0===(n=e.getNode.call(this,r)))break;null!==r.space&&(t.push(r.space),r.space=null),t.push(n),r.ignoreWSAfter?(r.ignoreWSAfter=!1,r.ignoreWS=!0):r.ignoreWS=!1}return t},{findWhiteSpaceStart:jn,cmpStr:_n}=M,Fn=function(){},Wn=h.TYPE,qn=h.NAME,Yn=Wn.WhiteSpace,Un=Wn.Comment,Hn=Wn.Ident,Vn=Wn.Function,Kn=Wn.Url,Gn=Wn.Hash,Qn=Wn.Percentage,Xn=Wn.Number;function Zn(e){return function(){return this[e]()}}var $n=function(e){var t={scanner:new H,locationMap:new Bn,filename:"<unknown>",needPositions:!1,onParseError:Fn,onParseErrorThrow:!1,parseAtrulePrelude:!0,parseRulePrelude:!0,parseValue:!0,parseCustomProperty:!1,readSequence:Mn,createList:function(){return new a},createSingleNodeList:function(e){return(new a).appendData(e)},getFirstListNode:function(e){return e&&e.first()},getLastListNode:function(e){return e.last()},parseWithFallback:function(e,t){var n=this.scanner.tokenIndex;try{return e.call(this)}catch(e){if(this.onParseErrorThrow)throw e;var r=t.call(this,n);return this.onParseErrorThrow=!0,this.onParseError(e,r),this.onParseErrorThrow=!1,r}},lookupNonWSType:function(e){do{var t=this.scanner.lookupType(e++);if(t!==Yn)return t}while(0!==t);return 0},eat:function(e){if(this.scanner.tokenType!==e){var t=this.scanner.tokenStart,n=qn[e]+" is expected";switch(e){case Hn:this.scanner.tokenType===Vn||this.scanner.tokenType===Kn?(t=this.scanner.tokenEnd-1,n="Identifier is expected but function found"):n="Identifier is expected";break;case Gn:this.scanner.isDelim(35)&&(this.scanner.next(),t++,n="Name is expected");break;case Qn:this.scanner.tokenType===Xn&&(t=this.scanner.tokenEnd,n="Percent sign is expected");break;default:this.scanner.source.charCodeAt(this.scanner.tokenStart)===e&&(t+=1)}this.error(n,t)}this.scanner.next()},consume:function(e){var t=this.scanner.getTokenValue();return this.eat(e),t},consumeFunctionName:function(){var e=this.scanner.source.substring(this.scanner.tokenStart,this.scanner.tokenEnd-1);return this.eat(Vn),e},getLocation:function(e,t){return this.needPositions?this.locationMap.getLocationRange(e,t,this.filename):null},getLocationFromList:function(e){if(this.needPositions){var t=this.getFirstListNode(e),n=this.getLastListNode(e);return this.locationMap.getLocationRange(null!==t?t.loc.start.offset-this.locationMap.startOffset:this.scanner.tokenStart,null!==n?n.loc.end.offset-this.locationMap.startOffset:this.scanner.tokenStart,this.filename)}return null},error:function(e,t){var n=void 0!==t&&t<this.scanner.source.length?this.locationMap.getLocation(t):this.scanner.eof?this.locationMap.getLocation(jn(this.scanner.source,this.scanner.source.length-1)):this.locationMap.getLocation(this.scanner.tokenStart);throw new l(e||"Unexpected input",this.scanner.source,n.offset,n.line,n.column)}};for(var n in e=function(e){var t={context:{},scope:{},atrule:{},pseudo:{}};if(e.parseContext)for(var n in e.parseContext)switch(typeof e.parseContext[n]){case"function":t.context[n]=e.parseContext[n];break;case"string":t.context[n]=Zn(e.parseContext[n])}if(e.scope)for(var n in e.scope)t.scope[n]=e.scope[n];if(e.atrule)for(var n in e.atrule){var r=e.atrule[n];r.parse&&(t.atrule[n]=r.parse)}if(e.pseudo)for(var n in e.pseudo){var i=e.pseudo[n];i.parse&&(t.pseudo[n]=i.parse)}if(e.node)for(var n in e.node)t[n]=e.node[n].parse;return t}(e||{}))t[n]=e[n];return function(e,n){var r,i=(n=n||{}).context||"default",a=n.onComment;if(Ce(e,t.scanner),t.locationMap.setSource(e,n.offset,n.line,n.column),t.filename=n.filename||"<unknown>",t.needPositions=Boolean(n.positions),t.onParseError="function"==typeof n.onParseError?n.onParseError:Fn,t.onParseErrorThrow=!1,t.parseAtrulePrelude=!("parseAtrulePrelude"in n)||Boolean(n.parseAtrulePrelude),t.parseRulePrelude=!("parseRulePrelude"in n)||Boolean(n.parseRulePrelude),t.parseValue=!("parseValue"in n)||Boolean(n.parseValue),t.parseCustomProperty="parseCustomProperty"in n&&Boolean(n.parseCustomProperty),!t.context.hasOwnProperty(i))throw new Error("Unknown context `"+i+"`");return"function"==typeof a&&t.scanner.forEachToken((n,r,i)=>{if(n===Un){const n=t.getLocation(r,i),o=_n(e,i-2,i,"*/")?e.slice(r+2,i-2):e.slice(r+2,i);a(o,n)}}),r=t.context[i].call(t,n),t.scanner.eof||t.error(),r}},Jn="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""),er=function(e){if(0<=e&&e<Jn.length)return Jn[e];throw new TypeError("Must be between 0 and 63: "+e)};var tr=function(e){var t,n="",r=function(e){return e<0?1+(-e<<1):0+(e<<1)}(e);do{t=31&r,(r>>>=5)>0&&(t|=32),n+=er(t)}while(r>0);return n};var nr=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e,t){t.getArg=function(e,t,n){if(t in e)return e[t];if(3===arguments.length)return n;throw new Error('"'+t+'" is a required argument.')};var n=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/,r=/^data:.+\,.+$/;function i(e){var t=e.match(n);return t?{scheme:t[1],auth:t[2],host:t[3],port:t[4],path:t[5]}:null}function a(e){var t="";return e.scheme&&(t+=e.scheme+":"),t+="//",e.auth&&(t+=e.auth+"@"),e.host&&(t+=e.host),e.port&&(t+=":"+e.port),e.path&&(t+=e.path),t}function o(e){var n=e,r=i(e);if(r){if(!r.path)return e;n=r.path}for(var o,s=t.isAbsolute(n),l=n.split(/\/+/),c=0,u=l.length-1;u>=0;u--)"."===(o=l[u])?l.splice(u,1):".."===o?c++:c>0&&(""===o?(l.splice(u+1,c),c=0):(l.splice(u,2),c--));return""===(n=l.join("/"))&&(n=s?"/":"."),r?(r.path=n,a(r)):n}function s(e,t){""===e&&(e="."),""===t&&(t=".");var n=i(t),s=i(e);if(s&&(e=s.path||"/"),n&&!n.scheme)return s&&(n.scheme=s.scheme),a(n);if(n||t.match(r))return t;if(s&&!s.host&&!s.path)return s.host=t,a(s);var l="/"===t.charAt(0)?t:o(e.replace(/\/+$/,"")+"/"+t);return s?(s.path=l,a(s)):l}t.urlParse=i,t.urlGenerate=a,t.normalize=o,t.join=s,t.isAbsolute=function(e){return"/"===e.charAt(0)||n.test(e)},t.relative=function(e,t){""===e&&(e="."),e=e.replace(/\/$/,"");for(var n=0;0!==t.indexOf(e+"/");){var r=e.lastIndexOf("/");if(r<0)return t;if((e=e.slice(0,r)).match(/^([^\/]+:\/)?\/*$/))return t;++n}return Array(n+1).join("../")+t.substr(e.length+1)};var l=!("__proto__"in Object.create(null));function c(e){return e}function u(e){if(!e)return!1;var t=e.length;if(t<9)return!1;if(95!==e.charCodeAt(t-1)||95!==e.charCodeAt(t-2)||111!==e.charCodeAt(t-3)||116!==e.charCodeAt(t-4)||111!==e.charCodeAt(t-5)||114!==e.charCodeAt(t-6)||112!==e.charCodeAt(t-7)||95!==e.charCodeAt(t-8)||95!==e.charCodeAt(t-9))return!1;for(var n=t-10;n>=0;n--)if(36!==e.charCodeAt(n))return!1;return!0}function h(e,t){return e===t?0:null===e?1:null===t?-1:e>t?1:-1}t.toSetString=l?c:function(e){return u(e)?"$"+e:e},t.fromSetString=l?c:function(e){return u(e)?e.slice(1):e},t.compareByOriginalPositions=function(e,t,n){var r=h(e.source,t.source);return 0!==r||0!==(r=e.originalLine-t.originalLine)||0!==(r=e.originalColumn-t.originalColumn)||n||0!==(r=e.generatedColumn-t.generatedColumn)||0!==(r=e.generatedLine-t.generatedLine)?r:h(e.name,t.name)},t.compareByGeneratedPositionsDeflated=function(e,t,n){var r=e.generatedLine-t.generatedLine;return 0!==r||0!==(r=e.generatedColumn-t.generatedColumn)||n||0!==(r=h(e.source,t.source))||0!==(r=e.originalLine-t.originalLine)||0!==(r=e.originalColumn-t.originalColumn)?r:h(e.name,t.name)},t.compareByGeneratedPositionsInflated=function(e,t){var n=e.generatedLine-t.generatedLine;return 0!==n||0!==(n=e.generatedColumn-t.generatedColumn)||0!==(n=h(e.source,t.source))||0!==(n=e.originalLine-t.originalLine)||0!==(n=e.originalColumn-t.originalColumn)?n:h(e.name,t.name)},t.parseSourceMapInput=function(e){return JSON.parse(e.replace(/^\)]}'[^\n]*\n/,""))},t.computeSourceURL=function(e,t,n){if(t=t||"",e&&("/"!==e[e.length-1]&&"/"!==t[0]&&(e+="/"),t=e+t),n){var r=i(n);if(!r)throw new Error("sourceMapURL could not be parsed");if(r.path){var l=r.path.lastIndexOf("/");l>=0&&(r.path=r.path.substring(0,l+1))}t=s(a(r),t)}return o(t)}})),rr=(nr.getArg,nr.urlParse,nr.urlGenerate,nr.normalize,nr.join,nr.isAbsolute,nr.relative,nr.toSetString,nr.fromSetString,nr.compareByOriginalPositions,nr.compareByGeneratedPositionsDeflated,nr.compareByGeneratedPositionsInflated,nr.parseSourceMapInput,nr.computeSourceURL,Object.prototype.hasOwnProperty),ir="undefined"!=typeof Map;function ar(){this._array=[],this._set=ir?new Map:Object.create(null)}ar.fromArray=function(e,t){for(var n=new ar,r=0,i=e.length;r<i;r++)n.add(e[r],t);return n},ar.prototype.size=function(){return ir?this._set.size:Object.getOwnPropertyNames(this._set).length},ar.prototype.add=function(e,t){var n=ir?e:nr.toSetString(e),r=ir?this.has(e):rr.call(this._set,n),i=this._array.length;r&&!t||this._array.push(e),r||(ir?this._set.set(e,i):this._set[n]=i)},ar.prototype.has=function(e){if(ir)return this._set.has(e);var t=nr.toSetString(e);return rr.call(this._set,t)},ar.prototype.indexOf=function(e){if(ir){var t=this._set.get(e);if(t>=0)return t}else{var n=nr.toSetString(e);if(rr.call(this._set,n))return this._set[n]}throw new Error('"'+e+'" is not in the set.')},ar.prototype.at=function(e){if(e>=0&&e<this._array.length)return this._array[e];throw new Error("No element indexed by "+e)},ar.prototype.toArray=function(){return this._array.slice()};var or={ArraySet:ar};function sr(){this._array=[],this._sorted=!0,this._last={generatedLine:-1,generatedColumn:0}}sr.prototype.unsortedForEach=function(e,t){this._array.forEach(e,t)},sr.prototype.add=function(e){var t,n,r,i,a,o;t=this._last,n=e,r=t.generatedLine,i=n.generatedLine,a=t.generatedColumn,o=n.generatedColumn,i>r||i==r&&o>=a||nr.compareByGeneratedPositionsInflated(t,n)<=0?(this._last=e,this._array.push(e)):(this._sorted=!1,this._array.push(e))},sr.prototype.toArray=function(){return this._sorted||(this._array.sort(nr.compareByGeneratedPositionsInflated),this._sorted=!0),this._array};var lr=or.ArraySet,cr={MappingList:sr}.MappingList;function ur(e){e||(e={}),this._file=nr.getArg(e,"file",null),this._sourceRoot=nr.getArg(e,"sourceRoot",null),this._skipValidation=nr.getArg(e,"skipValidation",!1),this._sources=new lr,this._names=new lr,this._mappings=new cr,this._sourcesContents=null}ur.prototype._version=3,ur.fromSourceMap=function(e){var t=e.sourceRoot,n=new ur({file:e.file,sourceRoot:t});return e.eachMapping((function(e){var r={generated:{line:e.generatedLine,column:e.generatedColumn}};null!=e.source&&(r.source=e.source,null!=t&&(r.source=nr.relative(t,r.source)),r.original={line:e.originalLine,column:e.originalColumn},null!=e.name&&(r.name=e.name)),n.addMapping(r)})),e.sources.forEach((function(r){var i=r;null!==t&&(i=nr.relative(t,r)),n._sources.has(i)||n._sources.add(i);var a=e.sourceContentFor(r);null!=a&&n.setSourceContent(r,a)})),n},ur.prototype.addMapping=function(e){var t=nr.getArg(e,"generated"),n=nr.getArg(e,"original",null),r=nr.getArg(e,"source",null),i=nr.getArg(e,"name",null);this._skipValidation||this._validateMapping(t,n,r,i),null!=r&&(r=String(r),this._sources.has(r)||this._sources.add(r)),null!=i&&(i=String(i),this._names.has(i)||this._names.add(i)),this._mappings.add({generatedLine:t.line,generatedColumn:t.column,originalLine:null!=n&&n.line,originalColumn:null!=n&&n.column,source:r,name:i})},ur.prototype.setSourceContent=function(e,t){var n=e;null!=this._sourceRoot&&(n=nr.relative(this._sourceRoot,n)),null!=t?(this._sourcesContents||(this._sourcesContents=Object.create(null)),this._sourcesContents[nr.toSetString(n)]=t):this._sourcesContents&&(delete this._sourcesContents[nr.toSetString(n)],0===Object.keys(this._sourcesContents).length&&(this._sourcesContents=null))},ur.prototype.applySourceMap=function(e,t,n){var r=t;if(null==t){if(null==e.file)throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map\'s "file" property. Both were omitted.');r=e.file}var i=this._sourceRoot;null!=i&&(r=nr.relative(i,r));var a=new lr,o=new lr;this._mappings.unsortedForEach((function(t){if(t.source===r&&null!=t.originalLine){var s=e.originalPositionFor({line:t.originalLine,column:t.originalColumn});null!=s.source&&(t.source=s.source,null!=n&&(t.source=nr.join(n,t.source)),null!=i&&(t.source=nr.relative(i,t.source)),t.originalLine=s.line,t.originalColumn=s.column,null!=s.name&&(t.name=s.name))}var l=t.source;null==l||a.has(l)||a.add(l);var c=t.name;null==c||o.has(c)||o.add(c)}),this),this._sources=a,this._names=o,e.sources.forEach((function(t){var r=e.sourceContentFor(t);null!=r&&(null!=n&&(t=nr.join(n,t)),null!=i&&(t=nr.relative(i,t)),this.setSourceContent(t,r))}),this)},ur.prototype._validateMapping=function(e,t,n,r){if(t&&"number"!=typeof t.line&&"number"!=typeof t.column)throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");if((!(e&&"line"in e&&"column"in e&&e.line>0&&e.column>=0)||t||n||r)&&!(e&&"line"in e&&"column"in e&&t&&"line"in t&&"column"in t&&e.line>0&&e.column>=0&&t.line>0&&t.column>=0&&n))throw new Error("Invalid mapping: "+JSON.stringify({generated:e,source:n,original:t,name:r}))},ur.prototype._serializeMappings=function(){for(var e,t,n,r,i=0,a=1,o=0,s=0,l=0,c=0,u="",h=this._mappings.toArray(),p=0,d=h.length;p<d;p++){if(e="",(t=h[p]).generatedLine!==a)for(i=0;t.generatedLine!==a;)e+=";",a++;else if(p>0){if(!nr.compareByGeneratedPositionsInflated(t,h[p-1]))continue;e+=","}e+=tr(t.generatedColumn-i),i=t.generatedColumn,null!=t.source&&(r=this._sources.indexOf(t.source),e+=tr(r-c),c=r,e+=tr(t.originalLine-1-s),s=t.originalLine-1,e+=tr(t.originalColumn-o),o=t.originalColumn,null!=t.name&&(n=this._names.indexOf(t.name),e+=tr(n-l),l=n)),u+=e}return u},ur.prototype._generateSourcesContent=function(e,t){return e.map((function(e){if(!this._sourcesContents)return null;null!=t&&(e=nr.relative(t,e));var n=nr.toSetString(e);return Object.prototype.hasOwnProperty.call(this._sourcesContents,n)?this._sourcesContents[n]:null}),this)},ur.prototype.toJSON=function(){var e={version:this._version,sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()};return null!=this._file&&(e.file=this._file),null!=this._sourceRoot&&(e.sourceRoot=this._sourceRoot),this._sourcesContents&&(e.sourcesContent=this._generateSourcesContent(e.sources,e.sourceRoot)),e},ur.prototype.toString=function(){return JSON.stringify(this.toJSON())};var hr={SourceMapGenerator:ur}.SourceMapGenerator,pr={Atrule:!0,Selector:!0,Declaration:!0},dr=Object.prototype.hasOwnProperty;function mr(e,t){var n=e.children,r=null;"function"!=typeof t?n.forEach(this.node,this):n.forEach((function(e){null!==r&&t.call(this,r),this.node(e),r=e}),this)}var gr=function(e){function t(e){if(!dr.call(n,e.type))throw new Error("Unknown node type: "+e.type);n[e.type].call(this,e)}var n={};if(e.node)for(var r in e.node)n[r]=e.node[r].generate;return function(e,n){var r="",i={children:mr,node:t,chunk:function(e){r+=e},result:function(){return r}};return n&&("function"==typeof n.decorator&&(i=n.decorator(i)),n.sourceMap&&(i=function(e){var t=new hr,n=1,r=0,i={line:1,column:0},a={line:0,column:0},o=!1,s={line:1,column:0},l={generated:s},c=e.node;e.node=function(e){if(e.loc&&e.loc.start&&pr.hasOwnProperty(e.type)){var u=e.loc.start.line,h=e.loc.start.column-1;a.line===u&&a.column===h||(a.line=u,a.column=h,i.line=n,i.column=r,o&&(o=!1,i.line===s.line&&i.column===s.column||t.addMapping(l)),o=!0,t.addMapping({source:e.loc.source,original:a,generated:i}))}c.call(this,e),o&&pr.hasOwnProperty(e.type)&&(s.line=n,s.column=r)};var u=e.chunk;e.chunk=function(e){for(var t=0;t<e.length;t++)10===e.charCodeAt(t)?(n++,r=0):r++;u(e)};var h=e.result;return e.result=function(){return o&&t.addMapping(l),{css:h(),map:t}},e}(i))),i.node(e),i.result()}},fr=Object.prototype.hasOwnProperty,br=function(){};function yr(e){return"function"==typeof e?e:br}function kr(e,t){return function(n,r,i){n.type===t&&e.call(this,n,r,i)}}function vr(e,t){var n=t.structure,r=[];for(var i in n)if(!1!==fr.call(n,i)){var a=n[i],o={name:i,type:!1,nullable:!1};Array.isArray(n[i])||(a=[n[i]]);for(var s=0;s<a.length;s++){var l=a[s];null===l?o.nullable=!0:"string"==typeof l?o.type="node":Array.isArray(l)&&(o.type="list")}o.type&&r.push(o)}return r.length?{context:t.walkContext,fields:r}:null}function xr(e,t){var n=e.fields.slice(),r=e.context,i="string"==typeof r;return t&&n.reverse(),function(e,a,o,s){var l;i&&(l=a[r],a[r]=e);for(var c=0;c<n.length;c++){var u=n[c],h=e[u.name];if(!u.nullable||h)if("list"===u.type){if(t?h.reduceRight(s,!1):h.reduce(s,!1))return!0}else if(o(h))return!0}i&&(a[r]=l)}}function wr(e){return{Atrule:{StyleSheet:e.StyleSheet,Atrule:e.Atrule,Rule:e.Rule,Block:e.Block},Rule:{StyleSheet:e.StyleSheet,Atrule:e.Atrule,Rule:e.Rule,Block:e.Block},Declaration:{StyleSheet:e.StyleSheet,Atrule:e.Atrule,Rule:e.Rule,Block:e.Block,DeclarationList:e.DeclarationList}}}var Sr=function(e){var t=function(e){var t={};for(var n in e.node)if(fr.call(e.node,n)){var r=e.node[n];if(!r.structure)throw new Error("Missed `structure` field in `"+n+"` node type definition");t[n]=vr(0,r)}return t}(e),n={},r={},i=Symbol("break-walk"),a=Symbol("skip-node");for(var o in t)fr.call(t,o)&&null!==t[o]&&(n[o]=xr(t[o],!1),r[o]=xr(t[o],!0));var s=wr(n),l=wr(r),c=function(e,o){function c(e,t,n){var r=h.call(m,e,t,n);return r===i||r!==a&&(!(!d.hasOwnProperty(e.type)||!d[e.type](e,m,c,u))||p.call(m,e,t,n)===i)}var u=(e,t,n,r)=>e||c(t,n,r),h=br,p=br,d=n,m={break:i,skip:a,root:e,stylesheet:null,atrule:null,atrulePrelude:null,rule:null,selector:null,block:null,declaration:null,function:null};if("function"==typeof o)h=o;else if(o&&(h=yr(o.enter),p=yr(o.leave),o.reverse&&(d=r),o.visit)){if(s.hasOwnProperty(o.visit))d=o.reverse?l[o.visit]:s[o.visit];else if(!t.hasOwnProperty(o.visit))throw new Error("Bad value `"+o.visit+"` for `visit` option (should be: "+Object.keys(t).join(", ")+")");h=kr(h,o.visit),p=kr(p,o.visit)}if(h===br&&p===br)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");c(e)};return c.break=i,c.skip=a,c.find=function(e,t){var n=null;return c(e,(function(e,r,a){if(t.call(this,e,r,a))return n=e,i})),n},c.findLast=function(e,t){var n=null;return c(e,{reverse:!0,enter:function(e,r,a){if(t.call(this,e,r,a))return n=e,i}}),n},c.findAll=function(e,t){var n=[];return c(e,(function(e,r,i){t.call(this,e,r,i)&&n.push(e)})),n},c},Cr=function e(t){var n={};for(var r in t){var i=t[r];i&&(Array.isArray(i)||i instanceof a?i=i.map(e):i.constructor===Object&&(i=e(i))),n[r]=i}return n};const zr=Object.prototype.hasOwnProperty,Ar={generic:!0,types:Er,atrules:{prelude:Dr,descriptors:Dr},properties:Er,parseContext:function(e,t){return Object.assign(e,t)},scope:function e(t,n){for(const r in n)zr.call(n,r)&&(Pr(t[r])?e(t[r],Tr(n[r])):t[r]=Tr(n[r]));return t},atrule:["parse"],pseudo:["parse"],node:["name","structure","parse","generate","walkContext"]};function Pr(e){return e&&e.constructor===Object}function Tr(e){return Pr(e)?Object.assign({},e):e}function Lr(e,t){return"string"==typeof t&&/^\s*\|/.test(t)?"string"==typeof e?e+t:t.replace(/^\s*\|\s*/,""):t||null}function Er(e,t){if("string"==typeof t)return Lr(e,t);const n=Object.assign({},e);for(let r in t)zr.call(t,r)&&(n[r]=Lr(zr.call(e,r)?e[r]:void 0,t[r]));return n}function Dr(e,t){const n=Er(e,t);return!Pr(n)||Object.keys(n).length?n:null}var Or=(e,t)=>function e(t,n,r){for(const i in r)if(!1!==zr.call(r,i))if(!0===r[i])i in n&&zr.call(n,i)&&(t[i]=Tr(n[i]));else if(r[i])if("function"==typeof r[i]){const e=r[i];t[i]=e({},t[i]),t[i]=e(t[i]||{},n[i])}else if(Pr(r[i])){const a={};for(let n in t[i])a[n]=e({},t[i][n],r[i]);for(let t in n[i])a[t]=e(a[t]||{},n[i][t],r[i]);t[i]=a}else if(Array.isArray(r[i])){const a={},o=r[i].reduce((function(e,t){return e[t]=!0,e}),{});for(const[n,r]of Object.entries(t[i]||{}))a[n]={},r&&e(a[n],r,o);for(const t in n[i])zr.call(n[i],t)&&(a[t]||(a[t]={}),n[i]&&n[i][t]&&e(a[t],n[i][t],o));t[i]=a}return t}(e,t,Ar);function Br(e){var t=$n(e),n=Sr(e),r=gr(e),i=function(e){return{fromPlainObject:function(t){return e(t,{enter:function(e){e.children&&e.children instanceof a==!1&&(e.children=(new a).fromArray(e.children))}}),t},toPlainObject:function(t){return e(t,{leave:function(e){e.children&&e.children instanceof a&&(e.children=e.children.toArray())}}),t}}}(n),o={List:a,SyntaxError:l,TokenStream:H,Lexer:Ln,vendorPrefix:ae.vendorPrefix,keyword:ae.keyword,property:ae.property,isCustomProperty:ae.isCustomProperty,definitionSyntax:En,lexer:null,createLexer:function(e){return new Ln(e,o,o.lexer.structure)},tokenize:Ce,parse:t,walk:n,generate:r,find:n.find,findLast:n.findLast,findAll:n.findAll,clone:Cr,fromPlainObject:i.fromPlainObject,toPlainObject:i.toPlainObject,createSyntax:function(e){return Br(Or({},e))},fork:function(t){var n=Or({},e);return Br("function"==typeof t?t(n,Object.assign):Or(n,t))}};return o.lexer=new Ln({generic:!0,types:e.types,atrules:e.atrules,properties:e.properties,node:e.node},o),o}var Ir=function(e){return Br(Or({},e))},Nr={generic:!0,types:{"absolute-size":"xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large","alpha-value":"<number>|<percentage>","angle-percentage":"<angle>|<percentage>","angular-color-hint":"<angle-percentage>","angular-color-stop":"<color>&&<color-stop-angle>?","angular-color-stop-list":"[<angular-color-stop> [, <angular-color-hint>]?]# , <angular-color-stop>","animateable-feature":"scroll-position|contents|<custom-ident>",attachment:"scroll|fixed|local","attr()":"attr( <attr-name> <type-or-unit>? [, <attr-fallback>]? )","attr-matcher":"['~'|'|'|'^'|'$'|'*']? '='","attr-modifier":"i|s","attribute-selector":"'[' <wq-name> ']'|'[' <wq-name> <attr-matcher> [<string-token>|<ident-token>] <attr-modifier>? ']'","auto-repeat":"repeat( [auto-fill|auto-fit] , [<line-names>? <fixed-size>]+ <line-names>? )","auto-track-list":"[<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>? <auto-repeat> [<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>?","baseline-position":"[first|last]? baseline","basic-shape":"<inset()>|<circle()>|<ellipse()>|<polygon()>|<path()>","bg-image":"none|<image>","bg-layer":"<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>","bg-position":"[[left|center|right|top|bottom|<length-percentage>]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]|[center|[left|right] <length-percentage>?]&&[center|[top|bottom] <length-percentage>?]]","bg-size":"[<length-percentage>|auto]{1,2}|cover|contain","blur()":"blur( <length> )","blend-mode":"normal|multiply|screen|overlay|darken|lighten|color-dodge|color-burn|hard-light|soft-light|difference|exclusion|hue|saturation|color|luminosity",box:"border-box|padding-box|content-box","brightness()":"brightness( <number-percentage> )","calc()":"calc( <calc-sum> )","calc-sum":"<calc-product> [['+'|'-'] <calc-product>]*","calc-product":"<calc-value> ['*' <calc-value>|'/' <number>]*","calc-value":"<number>|<dimension>|<percentage>|( <calc-sum> )","cf-final-image":"<image>|<color>","cf-mixing-image":"<percentage>?&&<image>","circle()":"circle( [<shape-radius>]? [at <position>]? )","clamp()":"clamp( <calc-sum>#{3} )","class-selector":"'.' <ident-token>","clip-source":"<url>",color:"<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hex-color>|<named-color>|currentcolor|<deprecated-system-color>","color-stop":"<color-stop-length>|<color-stop-angle>","color-stop-angle":"<angle-percentage>{1,2}","color-stop-length":"<length-percentage>{1,2}","color-stop-list":"[<linear-color-stop> [, <linear-color-hint>]?]# , <linear-color-stop>",combinator:"'>'|'+'|'~'|['||']","common-lig-values":"[common-ligatures|no-common-ligatures]","compat-auto":"searchfield|textarea|push-button|slider-horizontal|checkbox|radio|square-button|menulist|listbox|meter|progress-bar|button","composite-style":"clear|copy|source-over|source-in|source-out|source-atop|destination-over|destination-in|destination-out|destination-atop|xor","compositing-operator":"add|subtract|intersect|exclude","compound-selector":"[<type-selector>? <subclass-selector>* [<pseudo-element-selector> <pseudo-class-selector>*]*]!","compound-selector-list":"<compound-selector>#","complex-selector":"<compound-selector> [<combinator>? <compound-selector>]*","complex-selector-list":"<complex-selector>#","conic-gradient()":"conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )","contextual-alt-values":"[contextual|no-contextual]","content-distribution":"space-between|space-around|space-evenly|stretch","content-list":"[<string>|contents|<image>|<quote>|<target>|<leader()>|<attr()>|counter( <ident> , <'list-style-type'>? )]+","content-position":"center|start|end|flex-start|flex-end","content-replacement":"<image>","contrast()":"contrast( [<number-percentage>] )","counter()":"counter( <custom-ident> , <counter-style>? )","counter-style":"<counter-style-name>|symbols( )","counter-style-name":"<custom-ident>","counters()":"counters( <custom-ident> , <string> , <counter-style>? )","cross-fade()":"cross-fade( <cf-mixing-image> , <cf-final-image>? )","cubic-bezier-timing-function":"ease|ease-in|ease-out|ease-in-out|cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )","deprecated-system-color":"ActiveBorder|ActiveCaption|AppWorkspace|Background|ButtonFace|ButtonHighlight|ButtonShadow|ButtonText|CaptionText|GrayText|Highlight|HighlightText|InactiveBorder|InactiveCaption|InactiveCaptionText|InfoBackground|InfoText|Menu|MenuText|Scrollbar|ThreeDDarkShadow|ThreeDFace|ThreeDHighlight|ThreeDLightShadow|ThreeDShadow|Window|WindowFrame|WindowText","discretionary-lig-values":"[discretionary-ligatures|no-discretionary-ligatures]","display-box":"contents|none","display-inside":"flow|flow-root|table|flex|grid|ruby","display-internal":"table-row-group|table-header-group|table-footer-group|table-row|table-cell|table-column-group|table-column|table-caption|ruby-base|ruby-text|ruby-base-container|ruby-text-container","display-legacy":"inline-block|inline-list-item|inline-table|inline-flex|inline-grid","display-listitem":"<display-outside>?&&[flow|flow-root]?&&list-item","display-outside":"block|inline|run-in","drop-shadow()":"drop-shadow( <length>{2,3} <color>? )","east-asian-variant-values":"[jis78|jis83|jis90|jis04|simplified|traditional]","east-asian-width-values":"[full-width|proportional-width]","element()":"element( <custom-ident> , [first|start|last|first-except]? )|element( <id-selector> )","ellipse()":"ellipse( [<shape-radius>{2}]? [at <position>]? )","ending-shape":"circle|ellipse","env()":"env( <custom-ident> , <declaration-value>? )","explicit-track-list":"[<line-names>? <track-size>]+ <line-names>?","family-name":"<string>|<custom-ident>+","feature-tag-value":"<string> [<integer>|on|off]?","feature-type":"@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation","feature-value-block":"<feature-type> '{' <feature-value-declaration-list> '}'","feature-value-block-list":"<feature-value-block>+","feature-value-declaration":"<custom-ident> : <integer>+ ;","feature-value-declaration-list":"<feature-value-declaration>","feature-value-name":"<custom-ident>","fill-rule":"nonzero|evenodd","filter-function":"<blur()>|<brightness()>|<contrast()>|<drop-shadow()>|<grayscale()>|<hue-rotate()>|<invert()>|<opacity()>|<saturate()>|<sepia()>","filter-function-list":"[<filter-function>|<url>]+","final-bg-layer":"<'background-color'>||<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>","fit-content()":"fit-content( [<length>|<percentage>] )","fixed-breadth":"<length-percentage>","fixed-repeat":"repeat( [<positive-integer>] , [<line-names>? <fixed-size>]+ <line-names>? )","fixed-size":"<fixed-breadth>|minmax( <fixed-breadth> , <track-breadth> )|minmax( <inflexible-breadth> , <fixed-breadth> )","font-stretch-absolute":"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|<percentage>","font-variant-css21":"[normal|small-caps]","font-weight-absolute":"normal|bold|<number [1,1000]>","frequency-percentage":"<frequency>|<percentage>","general-enclosed":"[<function-token> <any-value> )]|( <ident> <any-value> )","generic-family":"serif|sans-serif|cursive|fantasy|monospace|-apple-system","generic-name":"serif|sans-serif|cursive|fantasy|monospace","geometry-box":"<shape-box>|fill-box|stroke-box|view-box",gradient:"<linear-gradient()>|<repeating-linear-gradient()>|<radial-gradient()>|<repeating-radial-gradient()>|<conic-gradient()>|<-legacy-gradient>","grayscale()":"grayscale( <number-percentage> )","grid-line":"auto|<custom-ident>|[<integer>&&<custom-ident>?]|[span&&[<integer>||<custom-ident>]]","historical-lig-values":"[historical-ligatures|no-historical-ligatures]","hsl()":"hsl( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsl( <hue> , <percentage> , <percentage> , <alpha-value>? )","hsla()":"hsla( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsla( <hue> , <percentage> , <percentage> , <alpha-value>? )",hue:"<number>|<angle>","hue-rotate()":"hue-rotate( <angle> )",image:"<url>|<image()>|<image-set()>|<element()>|<paint()>|<cross-fade()>|<gradient>","image()":"image( <image-tags>? [<image-src>? , <color>?]! )","image-set()":"image-set( <image-set-option># )","image-set-option":"[<image>|<string>] <resolution>","image-src":"<url>|<string>","image-tags":"ltr|rtl","inflexible-breadth":"<length>|<percentage>|min-content|max-content|auto","inset()":"inset( <length-percentage>{1,4} [round <'border-radius'>]? )","invert()":"invert( <number-percentage> )","keyframes-name":"<custom-ident>|<string>","keyframe-block":"<keyframe-selector># { <declaration-list> }","keyframe-block-list":"<keyframe-block>+","keyframe-selector":"from|to|<percentage>","leader()":"leader( <leader-type> )","leader-type":"dotted|solid|space|<string>","length-percentage":"<length>|<percentage>","line-names":"'[' <custom-ident>* ']'","line-name-list":"[<line-names>|<name-repeat>]+","line-style":"none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset","line-width":"<length>|thin|medium|thick","linear-color-hint":"<length-percentage>","linear-color-stop":"<color> <color-stop-length>?","linear-gradient()":"linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )","mask-layer":"<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||<geometry-box>||[<geometry-box>|no-clip]||<compositing-operator>||<masking-mode>","mask-position":"[<length-percentage>|left|center|right] [<length-percentage>|top|center|bottom]?","mask-reference":"none|<image>|<mask-source>","mask-source":"<url>","masking-mode":"alpha|luminance|match-source","matrix()":"matrix( <number>#{6} )","matrix3d()":"matrix3d( <number>#{16} )","max()":"max( <calc-sum># )","media-and":"<media-in-parens> [and <media-in-parens>]+","media-condition":"<media-not>|<media-and>|<media-or>|<media-in-parens>","media-condition-without-or":"<media-not>|<media-and>|<media-in-parens>","media-feature":"( [<mf-plain>|<mf-boolean>|<mf-range>] )","media-in-parens":"( <media-condition> )|<media-feature>|<general-enclosed>","media-not":"not <media-in-parens>","media-or":"<media-in-parens> [or <media-in-parens>]+","media-query":"<media-condition>|[not|only]? <media-type> [and <media-condition-without-or>]?","media-query-list":"<media-query>#","media-type":"<ident>","mf-boolean":"<mf-name>","mf-name":"<ident>","mf-plain":"<mf-name> : <mf-value>","mf-range":"<mf-name> ['<'|'>']? '='? <mf-value>|<mf-value> ['<'|'>']? '='? <mf-name>|<mf-value> '<' '='? <mf-name> '<' '='? <mf-value>|<mf-value> '>' '='? <mf-name> '>' '='? <mf-value>","mf-value":"<number>|<dimension>|<ident>|<ratio>","min()":"min( <calc-sum># )","minmax()":"minmax( [<length>|<percentage>|min-content|max-content|auto] , [<length>|<percentage>|<flex>|min-content|max-content|auto] )","named-color":"transparent|aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|<-non-standard-color>","namespace-prefix":"<ident>","ns-prefix":"[<ident-token>|'*']? '|'","number-percentage":"<number>|<percentage>","numeric-figure-values":"[lining-nums|oldstyle-nums]","numeric-fraction-values":"[diagonal-fractions|stacked-fractions]","numeric-spacing-values":"[proportional-nums|tabular-nums]",nth:"<an-plus-b>|even|odd","opacity()":"opacity( [<number-percentage>] )","overflow-position":"unsafe|safe","outline-radius":"<length>|<percentage>","page-body":"<declaration>? [; <page-body>]?|<page-margin-box> <page-body>","page-margin-box":"<page-margin-box-type> '{' <declaration-list> '}'","page-margin-box-type":"@top-left-corner|@top-left|@top-center|@top-right|@top-right-corner|@bottom-left-corner|@bottom-left|@bottom-center|@bottom-right|@bottom-right-corner|@left-top|@left-middle|@left-bottom|@right-top|@right-middle|@right-bottom","page-selector-list":"[<page-selector>#]?","page-selector":"<pseudo-page>+|<ident> <pseudo-page>*","path()":"path( [<fill-rule> ,]? <string> )","paint()":"paint( <ident> , <declaration-value>? )","perspective()":"perspective( <length> )","polygon()":"polygon( <fill-rule>? , [<length-percentage> <length-percentage>]# )",position:"[[left|center|right]||[top|center|bottom]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]?|[[left|right] <length-percentage>]&&[[top|bottom] <length-percentage>]]","pseudo-class-selector":"':' <ident-token>|':' <function-token> <any-value> ')'","pseudo-element-selector":"':' <pseudo-class-selector>","pseudo-page":": [left|right|first|blank]",quote:"open-quote|close-quote|no-open-quote|no-close-quote","radial-gradient()":"radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )","relative-selector":"<combinator>? <complex-selector>","relative-selector-list":"<relative-selector>#","relative-size":"larger|smaller","repeat-style":"repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}","repeating-linear-gradient()":"repeating-linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )","repeating-radial-gradient()":"repeating-radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )","rgb()":"rgb( <percentage>{3} [/ <alpha-value>]? )|rgb( <number>{3} [/ <alpha-value>]? )|rgb( <percentage>#{3} , <alpha-value>? )|rgb( <number>#{3} , <alpha-value>? )","rgba()":"rgba( <percentage>{3} [/ <alpha-value>]? )|rgba( <number>{3} [/ <alpha-value>]? )|rgba( <percentage>#{3} , <alpha-value>? )|rgba( <number>#{3} , <alpha-value>? )","rotate()":"rotate( [<angle>|<zero>] )","rotate3d()":"rotate3d( <number> , <number> , <number> , [<angle>|<zero>] )","rotateX()":"rotateX( [<angle>|<zero>] )","rotateY()":"rotateY( [<angle>|<zero>] )","rotateZ()":"rotateZ( [<angle>|<zero>] )","saturate()":"saturate( <number-percentage> )","scale()":"scale( <number> , <number>? )","scale3d()":"scale3d( <number> , <number> , <number> )","scaleX()":"scaleX( <number> )","scaleY()":"scaleY( <number> )","scaleZ()":"scaleZ( <number> )","self-position":"center|start|end|self-start|self-end|flex-start|flex-end","shape-radius":"<length-percentage>|closest-side|farthest-side","skew()":"skew( [<angle>|<zero>] , [<angle>|<zero>]? )","skewX()":"skewX( [<angle>|<zero>] )","skewY()":"skewY( [<angle>|<zero>] )","sepia()":"sepia( <number-percentage> )",shadow:"inset?&&<length>{2,4}&&<color>?","shadow-t":"[<length>{2,3}&&<color>?]",shape:"rect( <top> , <right> , <bottom> , <left> )|rect( <top> <right> <bottom> <left> )","shape-box":"<box>|margin-box","side-or-corner":"[left|right]||[top|bottom]","single-animation":"<time>||<timing-function>||<time>||<single-animation-iteration-count>||<single-animation-direction>||<single-animation-fill-mode>||<single-animation-play-state>||[none|<keyframes-name>]","single-animation-direction":"normal|reverse|alternate|alternate-reverse","single-animation-fill-mode":"none|forwards|backwards|both","single-animation-iteration-count":"infinite|<number>","single-animation-play-state":"running|paused","single-transition":"[none|<single-transition-property>]||<time>||<timing-function>||<time>","single-transition-property":"all|<custom-ident>",size:"closest-side|farthest-side|closest-corner|farthest-corner|<length>|<length-percentage>{2}","step-position":"jump-start|jump-end|jump-none|jump-both|start|end","step-timing-function":"step-start|step-end|steps( <integer> [, <step-position>]? )","subclass-selector":"<id-selector>|<class-selector>|<attribute-selector>|<pseudo-class-selector>","supports-condition":"not <supports-in-parens>|<supports-in-parens> [and <supports-in-parens>]*|<supports-in-parens> [or <supports-in-parens>]*","supports-in-parens":"( <supports-condition> )|<supports-feature>|<general-enclosed>","supports-feature":"<supports-decl>|<supports-selector-fn>","supports-decl":"( <declaration> )","supports-selector-fn":"selector( <complex-selector> )",symbol:"<string>|<image>|<custom-ident>",target:"<target-counter()>|<target-counters()>|<target-text()>","target-counter()":"target-counter( [<string>|<url>] , <custom-ident> , <counter-style>? )","target-counters()":"target-counters( [<string>|<url>] , <custom-ident> , <string> , <counter-style>? )","target-text()":"target-text( [<string>|<url>] , [content|before|after|first-letter]? )","time-percentage":"<time>|<percentage>","timing-function":"linear|<cubic-bezier-timing-function>|<step-timing-function>","track-breadth":"<length-percentage>|<flex>|min-content|max-content|auto","track-list":"[<line-names>? [<track-size>|<track-repeat>]]+ <line-names>?","track-repeat":"repeat( [<positive-integer>] , [<line-names>? <track-size>]+ <line-names>? )","track-size":"<track-breadth>|minmax( <inflexible-breadth> , <track-breadth> )|fit-content( [<length>|<percentage>] )","transform-function":"<matrix()>|<translate()>|<translateX()>|<translateY()>|<scale()>|<scaleX()>|<scaleY()>|<rotate()>|<skew()>|<skewX()>|<skewY()>|<matrix3d()>|<translate3d()>|<translateZ()>|<scale3d()>|<scaleZ()>|<rotate3d()>|<rotateX()>|<rotateY()>|<rotateZ()>|<perspective()>","transform-list":"<transform-function>+","translate()":"translate( <length-percentage> , <length-percentage>? )","translate3d()":"translate3d( <length-percentage> , <length-percentage> , <length> )","translateX()":"translateX( <length-percentage> )","translateY()":"translateY( <length-percentage> )","translateZ()":"translateZ( <length> )","type-or-unit":"string|color|url|integer|number|length|angle|time|frequency|cap|ch|em|ex|ic|lh|rlh|rem|vb|vi|vw|vh|vmin|vmax|mm|Q|cm|in|pt|pc|px|deg|grad|rad|turn|ms|s|Hz|kHz|%","type-selector":"<wq-name>|<ns-prefix>? '*'","var()":"var( <custom-property-name> , <declaration-value>? )","viewport-length":"auto|<length-percentage>","wq-name":"<ns-prefix>? <ident-token>","-legacy-gradient":"<-webkit-gradient()>|<-legacy-linear-gradient>|<-legacy-repeating-linear-gradient>|<-legacy-radial-gradient>|<-legacy-repeating-radial-gradient>","-legacy-linear-gradient":"-moz-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-linear-gradient( <-legacy-linear-gradient-arguments> )","-legacy-repeating-linear-gradient":"-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )","-legacy-linear-gradient-arguments":"[<angle>|<side-or-corner>]? , <color-stop-list>","-legacy-radial-gradient":"-moz-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-radial-gradient( <-legacy-radial-gradient-arguments> )","-legacy-repeating-radial-gradient":"-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )","-legacy-radial-gradient-arguments":"[<position> ,]? [[[<-legacy-radial-gradient-shape>||<-legacy-radial-gradient-size>]|[<length>|<percentage>]{2}] ,]? <color-stop-list>","-legacy-radial-gradient-size":"closest-side|closest-corner|farthest-side|farthest-corner|contain|cover","-legacy-radial-gradient-shape":"circle|ellipse","-non-standard-font":"-apple-system-body|-apple-system-headline|-apple-system-subheadline|-apple-system-caption1|-apple-system-caption2|-apple-system-footnote|-apple-system-short-body|-apple-system-short-headline|-apple-system-short-subheadline|-apple-system-short-caption1|-apple-system-short-footnote|-apple-system-tall-body","-non-standard-color":"-moz-ButtonDefault|-moz-ButtonHoverFace|-moz-ButtonHoverText|-moz-CellHighlight|-moz-CellHighlightText|-moz-Combobox|-moz-ComboboxText|-moz-Dialog|-moz-DialogText|-moz-dragtargetzone|-moz-EvenTreeRow|-moz-Field|-moz-FieldText|-moz-html-CellHighlight|-moz-html-CellHighlightText|-moz-mac-accentdarkestshadow|-moz-mac-accentdarkshadow|-moz-mac-accentface|-moz-mac-accentlightesthighlight|-moz-mac-accentlightshadow|-moz-mac-accentregularhighlight|-moz-mac-accentregularshadow|-moz-mac-chrome-active|-moz-mac-chrome-inactive|-moz-mac-focusring|-moz-mac-menuselect|-moz-mac-menushadow|-moz-mac-menutextselect|-moz-MenuHover|-moz-MenuHoverText|-moz-MenuBarText|-moz-MenuBarHoverText|-moz-nativehyperlinktext|-moz-OddTreeRow|-moz-win-communicationstext|-moz-win-mediatext|-moz-activehyperlinktext|-moz-default-background-color|-moz-default-color|-moz-hyperlinktext|-moz-visitedhyperlinktext|-webkit-activelink|-webkit-focus-ring-color|-webkit-link|-webkit-text","-non-standard-image-rendering":"optimize-contrast|-moz-crisp-edges|-o-crisp-edges|-webkit-optimize-contrast","-non-standard-overflow":"-moz-scrollbars-none|-moz-scrollbars-horizontal|-moz-scrollbars-vertical|-moz-hidden-unscrollable","-non-standard-width":"fill-available|min-intrinsic|intrinsic|-moz-available|-moz-fit-content|-moz-min-content|-moz-max-content|-webkit-min-content|-webkit-max-content","-webkit-gradient()":"-webkit-gradient( <-webkit-gradient-type> , <-webkit-gradient-point> [, <-webkit-gradient-point>|, <-webkit-gradient-radius> , <-webkit-gradient-point>] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )","-webkit-gradient-color-stop":"from( <color> )|color-stop( [<number-zero-one>|<percentage>] , <color> )|to( <color> )","-webkit-gradient-point":"[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]","-webkit-gradient-radius":"<length>|<percentage>","-webkit-gradient-type":"linear|radial","-webkit-mask-box-repeat":"repeat|stretch|round","-webkit-mask-clip-style":"border|border-box|padding|padding-box|content|content-box|text","-ms-filter-function-list":"<-ms-filter-function>+","-ms-filter-function":"<-ms-filter-function-progid>|<-ms-filter-function-legacy>","-ms-filter-function-progid":"'progid:' [<ident-token> '.']* [<ident-token>|<function-token> <any-value>? )]","-ms-filter-function-legacy":"<ident-token>|<function-token> <any-value>? )","-ms-filter":"<string>",age:"child|young|old","attr-name":"<wq-name>","attr-fallback":"<any-value>","border-radius":"<length-percentage>{1,2}",bottom:"<length>|auto","generic-voice":"[<age>? <gender> <integer>?]",gender:"male|female|neutral",left:"<length>|auto","mask-image":"<mask-reference>#","name-repeat":"repeat( [<positive-integer>|auto-fill] , <line-names>+ )",paint:"none|<color>|<url> [none|<color>]?|context-fill|context-stroke","page-size":"A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger",ratio:"<integer> / <integer>",right:"<length>|auto","svg-length":"<percentage>|<length>|<number>","svg-writing-mode":"lr-tb|rl-tb|tb-rl|lr|rl|tb",top:"<length>|auto","track-group":"'(' [<string>* <track-minmax> <string>*]+ ')' ['[' <positive-integer> ']']?|<track-minmax>","track-list-v0":"[<string>* <track-group> <string>*]+|none","track-minmax":"minmax( <track-breadth> , <track-breadth> )|auto|<track-breadth>|fit-content",x:"<number>",y:"<number>",declaration:"<ident-token> : <declaration-value>? ['!' important]?","declaration-list":"[<declaration>? ';']* <declaration>?",url:"url( <string> <url-modifier>* )|<url-token>","url-modifier":"<ident>|<function-token> <any-value> )","number-zero-one":"<number [0,1]>","number-one-or-greater":"<number [1,∞]>","positive-integer":"<integer [0,∞]>","-non-standard-display":"-ms-inline-flexbox|-ms-grid|-ms-inline-grid|-webkit-flex|-webkit-inline-flex|-webkit-box|-webkit-inline-box|-moz-inline-stack|-moz-box|-moz-inline-box"},properties:{"--*":"<declaration-value>","-ms-accelerator":"false|true","-ms-block-progression":"tb|rl|bt|lr","-ms-content-zoom-chaining":"none|chained","-ms-content-zooming":"none|zoom","-ms-content-zoom-limit":"<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>","-ms-content-zoom-limit-max":"<percentage>","-ms-content-zoom-limit-min":"<percentage>","-ms-content-zoom-snap":"<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>","-ms-content-zoom-snap-points":"snapInterval( <percentage> , <percentage> )|snapList( <percentage># )","-ms-content-zoom-snap-type":"none|proximity|mandatory","-ms-filter":"<string>","-ms-flow-from":"[none|<custom-ident>]#","-ms-flow-into":"[none|<custom-ident>]#","-ms-grid-columns":"none|<track-list>|<auto-track-list>","-ms-grid-rows":"none|<track-list>|<auto-track-list>","-ms-high-contrast-adjust":"auto|none","-ms-hyphenate-limit-chars":"auto|<integer>{1,3}","-ms-hyphenate-limit-lines":"no-limit|<integer>","-ms-hyphenate-limit-zone":"<percentage>|<length>","-ms-ime-align":"auto|after","-ms-overflow-style":"auto|none|scrollbar|-ms-autohiding-scrollbar","-ms-scrollbar-3dlight-color":"<color>","-ms-scrollbar-arrow-color":"<color>","-ms-scrollbar-base-color":"<color>","-ms-scrollbar-darkshadow-color":"<color>","-ms-scrollbar-face-color":"<color>","-ms-scrollbar-highlight-color":"<color>","-ms-scrollbar-shadow-color":"<color>","-ms-scrollbar-track-color":"<color>","-ms-scroll-chaining":"chained|none","-ms-scroll-limit":"<'-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":"auto|<length>","-ms-scroll-limit-x-min":"<length>","-ms-scroll-limit-y-max":"auto|<length>","-ms-scroll-limit-y-min":"<length>","-ms-scroll-rails":"none|railed","-ms-scroll-snap-points-x":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-points-y":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-type":"none|proximity|mandatory","-ms-scroll-snap-x":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>","-ms-scroll-snap-y":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>","-ms-scroll-translation":"none|vertical-to-horizontal","-ms-text-autospace":"none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space","-ms-touch-select":"grippers|none","-ms-user-select":"none|element|text","-ms-wrap-flow":"auto|both|start|end|maximum|clear","-ms-wrap-margin":"<length>","-ms-wrap-through":"wrap|none","-moz-appearance":"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":"<url>|none","-moz-border-bottom-colors":"<color>+|none","-moz-border-left-colors":"<color>+|none","-moz-border-right-colors":"<color>+|none","-moz-border-top-colors":"<color>+|none","-moz-context-properties":"none|[fill|fill-opacity|stroke|stroke-opacity]#","-moz-float-edge":"border-box|content-box|margin-box|padding-box","-moz-force-broken-image-icon":"<integer [0,1]>","-moz-image-region":"<shape>|auto","-moz-orient":"inline|block|horizontal|vertical","-moz-outline-radius":"<outline-radius>{1,4} [/ <outline-radius>{1,4}]?","-moz-outline-radius-bottomleft":"<outline-radius>","-moz-outline-radius-bottomright":"<outline-radius>","-moz-outline-radius-topleft":"<outline-radius>","-moz-outline-radius-topright":"<outline-radius>","-moz-stack-sizing":"ignore|stretch-to-fit","-moz-text-blink":"none|blink","-moz-user-focus":"ignore|normal|select-after|select-before|select-menu|select-same|select-all|none","-moz-user-input":"auto|none|enabled|disabled","-moz-user-modify":"read-only|read-write|write-only","-moz-window-dragging":"drag|no-drag","-moz-window-shadow":"default|menu|tooltip|sheet|none","-webkit-appearance":"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-before":"<'border-width'>||<'border-style'>||<'color'>","-webkit-border-before-color":"<'color'>","-webkit-border-before-style":"<'border-style'>","-webkit-border-before-width":"<'border-width'>","-webkit-box-reflect":"[above|below|right|left]? <length>? <image>?","-webkit-line-clamp":"none|<integer>","-webkit-mask":"[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<box>|border|padding|content|text]||[<box>|border|padding|content]]#","-webkit-mask-attachment":"<attachment>#","-webkit-mask-clip":"[<box>|border|padding|content|text]#","-webkit-mask-composite":"<composite-style>#","-webkit-mask-image":"<mask-reference>#","-webkit-mask-origin":"[<box>|border|padding|content]#","-webkit-mask-position":"<position>#","-webkit-mask-position-x":"[<length-percentage>|left|center|right]#","-webkit-mask-position-y":"[<length-percentage>|top|center|bottom]#","-webkit-mask-repeat":"<repeat-style>#","-webkit-mask-repeat-x":"repeat|no-repeat|space|round","-webkit-mask-repeat-y":"repeat|no-repeat|space|round","-webkit-mask-size":"<bg-size>#","-webkit-overflow-scrolling":"auto|touch","-webkit-tap-highlight-color":"<color>","-webkit-text-fill-color":"<color>","-webkit-text-stroke":"<length>||<color>","-webkit-text-stroke-color":"<color>","-webkit-text-stroke-width":"<length>","-webkit-touch-callout":"default|none","-webkit-user-modify":"read-only|read-write|read-write-plaintext-only","align-content":"normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>","align-items":"normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]","align-self":"auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>","align-tracks":"[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#",all:"initial|inherit|unset|revert",animation:"<single-animation>#","animation-delay":"<time>#","animation-direction":"<single-animation-direction>#","animation-duration":"<time>#","animation-fill-mode":"<single-animation-fill-mode>#","animation-iteration-count":"<single-animation-iteration-count>#","animation-name":"[none|<keyframes-name>]#","animation-play-state":"<single-animation-play-state>#","animation-timing-function":"<timing-function>#",appearance:"none|auto|textfield|menulist-button|<compat-auto>","aspect-ratio":"auto|<ratio>",azimuth:"<angle>|[[left-side|far-left|left|center-left|center|center-right|right|far-right|right-side]||behind]|leftwards|rightwards","backdrop-filter":"none|<filter-function-list>","backface-visibility":"visible|hidden",background:"[<bg-layer> ,]* <final-bg-layer>","background-attachment":"<attachment>#","background-blend-mode":"<blend-mode>#","background-clip":"<box>#","background-color":"<color>","background-image":"<bg-image>#","background-origin":"<box>#","background-position":"<bg-position>#","background-position-x":"[center|[[left|right|x-start|x-end]? <length-percentage>?]!]#","background-position-y":"[center|[[top|bottom|y-start|y-end]? <length-percentage>?]!]#","background-repeat":"<repeat-style>#","background-size":"<bg-size>#","block-overflow":"clip|ellipsis|<string>","block-size":"<'width'>",border:"<line-width>||<line-style>||<color>","border-block":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-block-color":"<'border-top-color'>{1,2}","border-block-style":"<'border-top-style'>","border-block-width":"<'border-top-width'>","border-block-end":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-block-end-color":"<'border-top-color'>","border-block-end-style":"<'border-top-style'>","border-block-end-width":"<'border-top-width'>","border-block-start":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-block-start-color":"<'border-top-color'>","border-block-start-style":"<'border-top-style'>","border-block-start-width":"<'border-top-width'>","border-bottom":"<line-width>||<line-style>||<color>","border-bottom-color":"<'border-top-color'>","border-bottom-left-radius":"<length-percentage>{1,2}","border-bottom-right-radius":"<length-percentage>{1,2}","border-bottom-style":"<line-style>","border-bottom-width":"<line-width>","border-collapse":"collapse|separate","border-color":"<color>{1,4}","border-end-end-radius":"<length-percentage>{1,2}","border-end-start-radius":"<length-percentage>{1,2}","border-image":"<'border-image-source'>||<'border-image-slice'> [/ <'border-image-width'>|/ <'border-image-width'>? / <'border-image-outset'>]?||<'border-image-repeat'>","border-image-outset":"[<length>|<number>]{1,4}","border-image-repeat":"[stretch|repeat|round|space]{1,2}","border-image-slice":"<number-percentage>{1,4}&&fill?","border-image-source":"none|<image>","border-image-width":"[<length-percentage>|<number>|auto]{1,4}","border-inline":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-inline-end":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-inline-color":"<'border-top-color'>{1,2}","border-inline-style":"<'border-top-style'>","border-inline-width":"<'border-top-width'>","border-inline-end-color":"<'border-top-color'>","border-inline-end-style":"<'border-top-style'>","border-inline-end-width":"<'border-top-width'>","border-inline-start":"<'border-top-width'>||<'border-top-style'>||<'color'>","border-inline-start-color":"<'border-top-color'>","border-inline-start-style":"<'border-top-style'>","border-inline-start-width":"<'border-top-width'>","border-left":"<line-width>||<line-style>||<color>","border-left-color":"<color>","border-left-style":"<line-style>","border-left-width":"<line-width>","border-radius":"<length-percentage>{1,4} [/ <length-percentage>{1,4}]?","border-right":"<line-width>||<line-style>||<color>","border-right-color":"<color>","border-right-style":"<line-style>","border-right-width":"<line-width>","border-spacing":"<length> <length>?","border-start-end-radius":"<length-percentage>{1,2}","border-start-start-radius":"<length-percentage>{1,2}","border-style":"<line-style>{1,4}","border-top":"<line-width>||<line-style>||<color>","border-top-color":"<color>","border-top-left-radius":"<length-percentage>{1,2}","border-top-right-radius":"<length-percentage>{1,2}","border-top-style":"<line-style>","border-top-width":"<line-width>","border-width":"<line-width>{1,4}",bottom:"<length>|<percentage>|auto","box-align":"start|center|end|baseline|stretch","box-decoration-break":"slice|clone","box-direction":"normal|reverse|inherit","box-flex":"<number>","box-flex-group":"<integer>","box-lines":"single|multiple","box-ordinal-group":"<integer>","box-orient":"horizontal|vertical|inline-axis|block-axis|inherit","box-pack":"start|center|end|justify","box-shadow":"none|<shadow>#","box-sizing":"content-box|border-box","break-after":"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region","break-before":"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region","break-inside":"auto|avoid|avoid-page|avoid-column|avoid-region","caption-side":"top|bottom|block-start|block-end|inline-start|inline-end","caret-color":"auto|<color>",clear:"none|left|right|both|inline-start|inline-end",clip:"<shape>|auto","clip-path":"<clip-source>|[<basic-shape>||<geometry-box>]|none",color:"<color>","color-adjust":"economy|exact","column-count":"<integer>|auto","column-fill":"auto|balance|balance-all","column-gap":"normal|<length-percentage>","column-rule":"<'column-rule-width'>||<'column-rule-style'>||<'column-rule-color'>","column-rule-color":"<color>","column-rule-style":"<'border-style'>","column-rule-width":"<'border-width'>","column-span":"none|all","column-width":"<length>|auto",columns:"<'column-width'>||<'column-count'>",contain:"none|strict|content|[size||layout||style||paint]",content:"normal|none|[<content-replacement>|<content-list>] [/ <string>]?","counter-increment":"[<custom-ident> <integer>?]+|none","counter-reset":"[<custom-ident> <integer>?]+|none","counter-set":"[<custom-ident> <integer>?]+|none",cursor:"[[<url> [<x> <y>]? ,]* [auto|default|none|context-menu|help|pointer|progress|wait|cell|crosshair|text|vertical-text|alias|copy|move|no-drop|not-allowed|e-resize|n-resize|ne-resize|nw-resize|s-resize|se-resize|sw-resize|w-resize|ew-resize|ns-resize|nesw-resize|nwse-resize|col-resize|row-resize|all-scroll|zoom-in|zoom-out|grab|grabbing|hand|-webkit-grab|-webkit-grabbing|-webkit-zoom-in|-webkit-zoom-out|-moz-grab|-moz-grabbing|-moz-zoom-in|-moz-zoom-out]]",direction:"ltr|rtl",display:"[<display-outside>||<display-inside>]|<display-listitem>|<display-internal>|<display-box>|<display-legacy>|<-non-standard-display>","empty-cells":"show|hide",filter:"none|<filter-function-list>|<-ms-filter-function-list>",flex:"none|[<'flex-grow'> <'flex-shrink'>?||<'flex-basis'>]","flex-basis":"content|<'width'>","flex-direction":"row|row-reverse|column|column-reverse","flex-flow":"<'flex-direction'>||<'flex-wrap'>","flex-grow":"<number>","flex-shrink":"<number>","flex-wrap":"nowrap|wrap|wrap-reverse",float:"left|right|none|inline-start|inline-end",font:"[[<'font-style'>||<font-variant-css21>||<'font-weight'>||<'font-stretch'>]? <'font-size'> [/ <'line-height'>]? <'font-family'>]|caption|icon|menu|message-box|small-caption|status-bar","font-family":"[<family-name>|<generic-family>]#","font-feature-settings":"normal|<feature-tag-value>#","font-kerning":"auto|normal|none","font-language-override":"normal|<string>","font-optical-sizing":"auto|none","font-variation-settings":"normal|[<string> <number>]#","font-size":"<absolute-size>|<relative-size>|<length-percentage>","font-size-adjust":"none|<number>","font-smooth":"auto|never|always|<absolute-size>|<length>","font-stretch":"<font-stretch-absolute>","font-style":"normal|italic|oblique <angle>?","font-synthesis":"none|[weight||style]","font-variant":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]","font-variant-alternates":"normal|[stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )]","font-variant-caps":"normal|small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps","font-variant-east-asian":"normal|[<east-asian-variant-values>||<east-asian-width-values>||ruby]","font-variant-ligatures":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>]","font-variant-numeric":"normal|[<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero]","font-variant-position":"normal|sub|super","font-weight":"<font-weight-absolute>|bolder|lighter",gap:"<'row-gap'> <'column-gap'>?",grid:"<'grid-template'>|<'grid-template-rows'> / [auto-flow&&dense?] <'grid-auto-columns'>?|[auto-flow&&dense?] <'grid-auto-rows'>? / <'grid-template-columns'>","grid-area":"<grid-line> [/ <grid-line>]{0,3}","grid-auto-columns":"<track-size>+","grid-auto-flow":"[row|column]||dense","grid-auto-rows":"<track-size>+","grid-column":"<grid-line> [/ <grid-line>]?","grid-column-end":"<grid-line>","grid-column-gap":"<length-percentage>","grid-column-start":"<grid-line>","grid-gap":"<'grid-row-gap'> <'grid-column-gap'>?","grid-row":"<grid-line> [/ <grid-line>]?","grid-row-end":"<grid-line>","grid-row-gap":"<length-percentage>","grid-row-start":"<grid-line>","grid-template":"none|[<'grid-template-rows'> / <'grid-template-columns'>]|[<line-names>? <string> <track-size>? <line-names>?]+ [/ <explicit-track-list>]?","grid-template-areas":"none|<string>+","grid-template-columns":"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?","grid-template-rows":"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?","hanging-punctuation":"none|[first||[force-end|allow-end]||last]",height:"auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )",hyphens:"none|manual|auto","image-orientation":"from-image|<angle>|[<angle>? flip]","image-rendering":"auto|crisp-edges|pixelated|optimizeSpeed|optimizeQuality|<-non-standard-image-rendering>","image-resolution":"[from-image||<resolution>]&&snap?","ime-mode":"auto|normal|active|inactive|disabled","initial-letter":"normal|[<number> <integer>?]","initial-letter-align":"[auto|alphabetic|hanging|ideographic]","inline-size":"<'width'>",inset:"<'top'>{1,4}","inset-block":"<'top'>{1,2}","inset-block-end":"<'top'>","inset-block-start":"<'top'>","inset-inline":"<'top'>{1,2}","inset-inline-end":"<'top'>","inset-inline-start":"<'top'>",isolation:"auto|isolate","justify-content":"normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]","justify-items":"normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|legacy|legacy&&[left|right|center]","justify-self":"auto|normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]","justify-tracks":"[normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]]#",left:"<length>|<percentage>|auto","letter-spacing":"normal|<length-percentage>","line-break":"auto|loose|normal|strict|anywhere","line-clamp":"none|<integer>","line-height":"normal|<number>|<length>|<percentage>","line-height-step":"<length>","list-style":"<'list-style-type'>||<'list-style-position'>||<'list-style-image'>","list-style-image":"<url>|none","list-style-position":"inside|outside","list-style-type":"<counter-style>|<string>|none",margin:"[<length>|<percentage>|auto]{1,4}","margin-block":"<'margin-left'>{1,2}","margin-block-end":"<'margin-left'>","margin-block-start":"<'margin-left'>","margin-bottom":"<length>|<percentage>|auto","margin-inline":"<'margin-left'>{1,2}","margin-inline-end":"<'margin-left'>","margin-inline-start":"<'margin-left'>","margin-left":"<length>|<percentage>|auto","margin-right":"<length>|<percentage>|auto","margin-top":"<length>|<percentage>|auto","margin-trim":"none|in-flow|all",mask:"<mask-layer>#","mask-border":"<'mask-border-source'>||<'mask-border-slice'> [/ <'mask-border-width'>? [/ <'mask-border-outset'>]?]?||<'mask-border-repeat'>||<'mask-border-mode'>","mask-border-mode":"luminance|alpha","mask-border-outset":"[<length>|<number>]{1,4}","mask-border-repeat":"[stretch|repeat|round|space]{1,2}","mask-border-slice":"<number-percentage>{1,4} fill?","mask-border-source":"none|<image>","mask-border-width":"[<length-percentage>|<number>|auto]{1,4}","mask-clip":"[<geometry-box>|no-clip]#","mask-composite":"<compositing-operator>#","mask-image":"<mask-reference>#","mask-mode":"<masking-mode>#","mask-origin":"<geometry-box>#","mask-position":"<position>#","mask-repeat":"<repeat-style>#","mask-size":"<bg-size>#","mask-type":"luminance|alpha","masonry-auto-flow":"[pack|next]||[definite-first|ordered]","math-style":"normal|compact","max-block-size":"<'max-width'>","max-height":"none|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )","max-inline-size":"<'max-width'>","max-lines":"none|<integer>","max-width":"none|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )|<-non-standard-width>","min-block-size":"<'min-width'>","min-height":"auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )","min-inline-size":"<'min-width'>","min-width":"auto|<length-percentage>|min-content|max-content|fit-content( <length-percentage> )|<-non-standard-width>","mix-blend-mode":"<blend-mode>","object-fit":"fill|contain|cover|none|scale-down","object-position":"<position>",offset:"[<'offset-position'>? [<'offset-path'> [<'offset-distance'>||<'offset-rotate'>]?]?]! [/ <'offset-anchor'>]?","offset-anchor":"auto|<position>","offset-distance":"<length-percentage>","offset-path":"none|ray( [<angle>&&<size>&&contain?] )|<path()>|<url>|[<basic-shape>||<geometry-box>]","offset-position":"auto|<position>","offset-rotate":"[auto|reverse]||<angle>",opacity:"<alpha-value>",order:"<integer>",orphans:"<integer>",outline:"[<'outline-color'>||<'outline-style'>||<'outline-width'>]","outline-color":"<color>|invert","outline-offset":"<length>","outline-style":"auto|<'border-style'>","outline-width":"<line-width>",overflow:"[visible|hidden|clip|scroll|auto]{1,2}|<-non-standard-overflow>","overflow-anchor":"auto|none","overflow-block":"visible|hidden|clip|scroll|auto","overflow-clip-box":"padding-box|content-box","overflow-inline":"visible|hidden|clip|scroll|auto","overflow-wrap":"normal|break-word|anywhere","overflow-x":"visible|hidden|clip|scroll|auto","overflow-y":"visible|hidden|clip|scroll|auto","overscroll-behavior":"[contain|none|auto]{1,2}","overscroll-behavior-block":"contain|none|auto","overscroll-behavior-inline":"contain|none|auto","overscroll-behavior-x":"contain|none|auto","overscroll-behavior-y":"contain|none|auto",padding:"[<length>|<percentage>]{1,4}","padding-block":"<'padding-left'>{1,2}","padding-block-end":"<'padding-left'>","padding-block-start":"<'padding-left'>","padding-bottom":"<length>|<percentage>","padding-inline":"<'padding-left'>{1,2}","padding-inline-end":"<'padding-left'>","padding-inline-start":"<'padding-left'>","padding-left":"<length>|<percentage>","padding-right":"<length>|<percentage>","padding-top":"<length>|<percentage>","page-break-after":"auto|always|avoid|left|right|recto|verso","page-break-before":"auto|always|avoid|left|right|recto|verso","page-break-inside":"auto|avoid","paint-order":"normal|[fill||stroke||markers]",perspective:"none|<length>","perspective-origin":"<position>","place-content":"<'align-content'> <'justify-content'>?","place-items":"<'align-items'> <'justify-items'>?","place-self":"<'align-self'> <'justify-self'>?","pointer-events":"auto|none|visiblePainted|visibleFill|visibleStroke|visible|painted|fill|stroke|all|inherit",position:"static|relative|absolute|sticky|fixed|-webkit-sticky",quotes:"none|auto|[<string> <string>]+",resize:"none|both|horizontal|vertical|block|inline",right:"<length>|<percentage>|auto",rotate:"none|<angle>|[x|y|z|<number>{3}]&&<angle>","row-gap":"normal|<length-percentage>","ruby-align":"start|center|space-between|space-around","ruby-merge":"separate|collapse|auto","ruby-position":"over|under|inter-character",scale:"none|<number>{1,3}","scrollbar-color":"auto|dark|light|<color>{2}","scrollbar-gutter":"auto|[stable|always]&&both?&&force?","scrollbar-width":"auto|thin|none","scroll-behavior":"auto|smooth","scroll-margin":"<length>{1,4}","scroll-margin-block":"<length>{1,2}","scroll-margin-block-start":"<length>","scroll-margin-block-end":"<length>","scroll-margin-bottom":"<length>","scroll-margin-inline":"<length>{1,2}","scroll-margin-inline-start":"<length>","scroll-margin-inline-end":"<length>","scroll-margin-left":"<length>","scroll-margin-right":"<length>","scroll-margin-top":"<length>","scroll-padding":"[auto|<length-percentage>]{1,4}","scroll-padding-block":"[auto|<length-percentage>]{1,2}","scroll-padding-block-start":"auto|<length-percentage>","scroll-padding-block-end":"auto|<length-percentage>","scroll-padding-bottom":"auto|<length-percentage>","scroll-padding-inline":"[auto|<length-percentage>]{1,2}","scroll-padding-inline-start":"auto|<length-percentage>","scroll-padding-inline-end":"auto|<length-percentage>","scroll-padding-left":"auto|<length-percentage>","scroll-padding-right":"auto|<length-percentage>","scroll-padding-top":"auto|<length-percentage>","scroll-snap-align":"[none|start|end|center]{1,2}","scroll-snap-coordinate":"none|<position>#","scroll-snap-destination":"<position>","scroll-snap-points-x":"none|repeat( <length-percentage> )","scroll-snap-points-y":"none|repeat( <length-percentage> )","scroll-snap-stop":"normal|always","scroll-snap-type":"none|[x|y|block|inline|both] [mandatory|proximity]?","scroll-snap-type-x":"none|mandatory|proximity","scroll-snap-type-y":"none|mandatory|proximity","shape-image-threshold":"<alpha-value>","shape-margin":"<length-percentage>","shape-outside":"none|<shape-box>||<basic-shape>|<image>","tab-size":"<integer>|<length>","table-layout":"auto|fixed","text-align":"start|end|left|right|center|justify|match-parent","text-align-last":"auto|start|end|left|right|center|justify","text-combine-upright":"none|all|[digits <integer>?]","text-decoration":"<'text-decoration-line'>||<'text-decoration-style'>||<'text-decoration-color'>||<'text-decoration-thickness'>","text-decoration-color":"<color>","text-decoration-line":"none|[underline||overline||line-through||blink]|spelling-error|grammar-error","text-decoration-skip":"none|[objects||[spaces|[leading-spaces||trailing-spaces]]||edges||box-decoration]","text-decoration-skip-ink":"auto|all|none","text-decoration-style":"solid|double|dotted|dashed|wavy","text-decoration-thickness":"auto|from-font|<length>|<percentage>","text-emphasis":"<'text-emphasis-style'>||<'text-emphasis-color'>","text-emphasis-color":"<color>","text-emphasis-position":"[over|under]&&[right|left]","text-emphasis-style":"none|[[filled|open]||[dot|circle|double-circle|triangle|sesame]]|<string>","text-indent":"<length-percentage>&&hanging?&&each-line?","text-justify":"auto|inter-character|inter-word|none","text-orientation":"mixed|upright|sideways","text-overflow":"[clip|ellipsis|<string>]{1,2}","text-rendering":"auto|optimizeSpeed|optimizeLegibility|geometricPrecision","text-shadow":"none|<shadow-t>#","text-size-adjust":"none|auto|<percentage>","text-transform":"none|capitalize|uppercase|lowercase|full-width|full-size-kana","text-underline-offset":"auto|<length>|<percentage>","text-underline-position":"auto|from-font|[under||[left|right]]",top:"<length>|<percentage>|auto","touch-action":"auto|none|[[pan-x|pan-left|pan-right]||[pan-y|pan-up|pan-down]||pinch-zoom]|manipulation",transform:"none|<transform-list>","transform-box":"content-box|border-box|fill-box|stroke-box|view-box","transform-origin":"[<length-percentage>|left|center|right|top|bottom]|[[<length-percentage>|left|center|right]&&[<length-percentage>|top|center|bottom]] <length>?","transform-style":"flat|preserve-3d",transition:"<single-transition>#","transition-delay":"<time>#","transition-duration":"<time>#","transition-property":"none|<single-transition-property>#","transition-timing-function":"<timing-function>#",translate:"none|<length-percentage> [<length-percentage> <length>?]?","unicode-bidi":"normal|embed|isolate|bidi-override|isolate-override|plaintext|-moz-isolate|-moz-isolate-override|-moz-plaintext|-webkit-isolate|-webkit-isolate-override|-webkit-plaintext","user-select":"auto|text|none|contain|all","vertical-align":"baseline|sub|super|text-top|text-bottom|middle|top|bottom|<percentage>|<length>",visibility:"visible|hidden|collapse","white-space":"normal|pre|nowrap|pre-wrap|pre-line|break-spaces",widows:"<integer>",width:"auto|<length>|<percentage>|min-content|max-content|fit-content( <length-percentage> )|fit-content|-moz-fit-content|-webkit-fit-content","will-change":"auto|<animateable-feature>#","word-break":"normal|break-all|keep-all|break-word","word-spacing":"normal|<length-percentage>","word-wrap":"normal|break-word","writing-mode":"horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr|<svg-writing-mode>","z-index":"auto|<integer>",zoom:"normal|reset|<number>|<percentage>","-moz-background-clip":"padding|border","-moz-border-radius-bottomleft":"<'border-bottom-left-radius'>","-moz-border-radius-bottomright":"<'border-bottom-right-radius'>","-moz-border-radius-topleft":"<'border-top-left-radius'>","-moz-border-radius-topright":"<'border-bottom-right-radius'>","-moz-control-character-visibility":"visible|hidden","-moz-osx-font-smoothing":"auto|grayscale","-moz-user-select":"none|text|all|-moz-none","-ms-flex-align":"start|end|center|baseline|stretch","-ms-flex-item-align":"auto|start|end|center|baseline|stretch","-ms-flex-line-pack":"start|end|center|justify|distribute|stretch","-ms-flex-negative":"<'flex-shrink'>","-ms-flex-pack":"start|end|center|justify|distribute","-ms-flex-order":"<integer>","-ms-flex-positive":"<'flex-grow'>","-ms-flex-preferred-size":"<'flex-basis'>","-ms-interpolation-mode":"nearest-neighbor|bicubic","-ms-grid-column-align":"start|end|center|stretch","-ms-grid-row-align":"start|end|center|stretch","-ms-hyphenate-limit-last":"none|always|column|page|spread","-webkit-background-clip":"[<box>|border|padding|content|text]#","-webkit-column-break-after":"always|auto|avoid","-webkit-column-break-before":"always|auto|avoid","-webkit-column-break-inside":"always|auto|avoid","-webkit-font-smoothing":"auto|none|antialiased|subpixel-antialiased","-webkit-mask-box-image":"[<url>|<gradient>|none] [<length-percentage>{4} <-webkit-mask-box-repeat>{2}]?","-webkit-print-color-adjust":"economy|exact","-webkit-text-security":"none|circle|disc|square","-webkit-user-drag":"none|element|auto","-webkit-user-select":"auto|none|text|all","alignment-baseline":"auto|baseline|before-edge|text-before-edge|middle|central|after-edge|text-after-edge|ideographic|alphabetic|hanging|mathematical","baseline-shift":"baseline|sub|super|<svg-length>",behavior:"<url>+","clip-rule":"nonzero|evenodd",cue:"<'cue-before'> <'cue-after'>?","cue-after":"<url> <decibel>?|none","cue-before":"<url> <decibel>?|none","dominant-baseline":"auto|use-script|no-change|reset-size|ideographic|alphabetic|hanging|mathematical|central|middle|text-after-edge|text-before-edge",fill:"<paint>","fill-opacity":"<number-zero-one>","fill-rule":"nonzero|evenodd","glyph-orientation-horizontal":"<angle>","glyph-orientation-vertical":"<angle>",kerning:"auto|<svg-length>",marker:"none|<url>","marker-end":"none|<url>","marker-mid":"none|<url>","marker-start":"none|<url>",pause:"<'pause-before'> <'pause-after'>?","pause-after":"<time>|none|x-weak|weak|medium|strong|x-strong","pause-before":"<time>|none|x-weak|weak|medium|strong|x-strong",rest:"<'rest-before'> <'rest-after'>?","rest-after":"<time>|none|x-weak|weak|medium|strong|x-strong","rest-before":"<time>|none|x-weak|weak|medium|strong|x-strong","shape-rendering":"auto|optimizeSpeed|crispEdges|geometricPrecision",src:"[<url> [format( <string># )]?|local( <family-name> )]#",speak:"auto|none|normal","speak-as":"normal|spell-out||digits||[literal-punctuation|no-punctuation]",stroke:"<paint>","stroke-dasharray":"none|[<svg-length>+]#","stroke-dashoffset":"<svg-length>","stroke-linecap":"butt|round|square","stroke-linejoin":"miter|round|bevel","stroke-miterlimit":"<number-one-or-greater>","stroke-opacity":"<number-zero-one>","stroke-width":"<svg-length>","text-anchor":"start|middle|end","unicode-range":"<urange>#","voice-balance":"<number>|left|center|right|leftwards|rightwards","voice-duration":"auto|<time>","voice-family":"[[<family-name>|<generic-voice>] ,]* [<family-name>|<generic-voice>]|preserve","voice-pitch":"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]","voice-range":"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]","voice-rate":"[normal|x-slow|slow|medium|fast|x-fast]||<percentage>","voice-stress":"normal|strong|moderate|none|reduced","voice-volume":"silent|[[x-soft|soft|medium|loud|x-loud]||<decibel>]"},atrules:{charset:{prelude:"<string>",descriptors:null},"counter-style":{prelude:"<counter-style-name>",descriptors:{"additive-symbols":"[<integer>&&<symbol>]#",fallback:"<counter-style-name>",negative:"<symbol> <symbol>?",pad:"<integer>&&<symbol>",prefix:"<symbol>",range:"[[<integer>|infinite]{2}]#|auto","speak-as":"auto|bullets|numbers|words|spell-out|<counter-style-name>",suffix:"<symbol>",symbols:"<symbol>+",system:"cyclic|numeric|alphabetic|symbolic|additive|[fixed <integer>?]|[extends <counter-style-name>]"}},document:{prelude:"[<url>|url-prefix( <string> )|domain( <string> )|media-document( <string> )|regexp( <string> )]#",descriptors:null},"font-face":{prelude:null,descriptors:{"font-display":"[auto|block|swap|fallback|optional]","font-family":"<family-name>","font-feature-settings":"normal|<feature-tag-value>#","font-variation-settings":"normal|[<string> <number>]#","font-stretch":"<font-stretch-absolute>{1,2}","font-style":"normal|italic|oblique <angle>{0,2}","font-weight":"<font-weight-absolute>{1,2}","font-variant":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]",src:"[<url> [format( <string># )]?|local( <family-name> )]#","unicode-range":"<urange>#"}},"font-feature-values":{prelude:"<family-name>#",descriptors:null},import:{prelude:"[<string>|<url>] [<media-query-list>]?",descriptors:null},keyframes:{prelude:"<keyframes-name>",descriptors:null},media:{prelude:"<media-query-list>",descriptors:null},namespace:{prelude:"<namespace-prefix>? [<string>|<url>]",descriptors:null},page:{prelude:"<page-selector-list>",descriptors:{bleed:"auto|<length>",marks:"none|[crop||cross]",size:"<length>{1,2}|auto|[<page-size>||[portrait|landscape]]"}},property:{prelude:"<custom-property-name>",descriptors:{syntax:"<string>",inherits:"true|false","initial-value":"<string>"}},supports:{prelude:"<supports-condition>",descriptors:null},viewport:{prelude:null,descriptors:{height:"<viewport-length>{1,2}","max-height":"<viewport-length>","max-width":"<viewport-length>","max-zoom":"auto|<number>|<percentage>","min-height":"<viewport-length>","min-width":"<viewport-length>","min-zoom":"auto|<number>|<percentage>",orientation:"auto|portrait|landscape","user-zoom":"zoom|fixed","viewport-fit":"auto|contain|cover",width:"<viewport-length>{1,2}",zoom:"auto|<number>|<percentage>"}}}},Rr=Ce.cmpChar,Mr=Ce.isDigit,jr=Ce.TYPE,_r=jr.WhiteSpace,Fr=jr.Comment,Wr=jr.Ident,qr=jr.Number,Yr=jr.Dimension;function Ur(e,t){var n=this.scanner.tokenStart+e,r=this.scanner.source.charCodeAt(n);for(43!==r&&45!==r||(t&&this.error("Number sign is not allowed"),n++);n<this.scanner.tokenEnd;n++)Mr(this.scanner.source.charCodeAt(n))||this.error("Integer is expected",n)}function Hr(e){return Ur.call(this,0,e)}function Vr(e,t){if(!Rr(this.scanner.source,this.scanner.tokenStart+e,t)){var n="";switch(t){case 110:n="N is expected";break;case 45:n="HyphenMinus is expected"}this.error(n,this.scanner.tokenStart+e)}}function Kr(){for(var e=0,t=0,n=this.scanner.tokenType;n===_r||n===Fr;)n=this.scanner.lookupType(++e);if(n!==qr){if(!this.scanner.isDelim(43,e)&&!this.scanner.isDelim(45,e))return null;t=this.scanner.isDelim(43,e)?43:45;do{n=this.scanner.lookupType(++e)}while(n===_r||n===Fr);n!==qr&&(this.scanner.skip(e),Hr.call(this,!0))}return e>0&&this.scanner.skip(e),0===t&&43!==(n=this.scanner.source.charCodeAt(this.scanner.tokenStart))&&45!==n&&this.error("Number sign is expected"),Hr.call(this,0!==t),45===t?"-"+this.consume(qr):this.consume(qr)}var Gr={name:"AnPlusB",structure:{a:[String,null],b:[String,null]},parse:function(){var e=this.scanner.tokenStart,t=null,n=null;if(this.scanner.tokenType===qr)Hr.call(this,!1),n=this.consume(qr);else if(this.scanner.tokenType===Wr&&Rr(this.scanner.source,this.scanner.tokenStart,45))switch(t="-1",Vr.call(this,1,110),this.scanner.getTokenLength()){case 2:this.scanner.next(),n=Kr.call(this);break;case 3:Vr.call(this,2,45),this.scanner.next(),this.scanner.skipSC(),Hr.call(this,!0),n="-"+this.consume(qr);break;default:Vr.call(this,2,45),Ur.call(this,3,!0),this.scanner.next(),n=this.scanner.substrToCursor(e+2)}else if(this.scanner.tokenType===Wr||this.scanner.isDelim(43)&&this.scanner.lookupType(1)===Wr){var r=0;switch(t="1",this.scanner.isDelim(43)&&(r=1,this.scanner.next()),Vr.call(this,0,110),this.scanner.getTokenLength()){case 1:this.scanner.next(),n=Kr.call(this);break;case 2:Vr.call(this,1,45),this.scanner.next(),this.scanner.skipSC(),Hr.call(this,!0),n="-"+this.consume(qr);break;default:Vr.call(this,1,45),Ur.call(this,2,!0),this.scanner.next(),n=this.scanner.substrToCursor(e+r+1)}}else if(this.scanner.tokenType===Yr){for(var i=this.scanner.source.charCodeAt(this.scanner.tokenStart),a=(r=43===i||45===i,this.scanner.tokenStart+r);a<this.scanner.tokenEnd&&Mr(this.scanner.source.charCodeAt(a));a++);a===this.scanner.tokenStart+r&&this.error("Integer is expected",this.scanner.tokenStart+r),Vr.call(this,a-this.scanner.tokenStart,110),t=this.scanner.source.substring(e,a),a+1===this.scanner.tokenEnd?(this.scanner.next(),n=Kr.call(this)):(Vr.call(this,a-this.scanner.tokenStart+1,45),a+2===this.scanner.tokenEnd?(this.scanner.next(),this.scanner.skipSC(),Hr.call(this,!0),n="-"+this.consume(qr)):(Ur.call(this,a-this.scanner.tokenStart+2,!0),this.scanner.next(),n=this.scanner.substrToCursor(a+1)))}else this.error();return null!==t&&43===t.charCodeAt(0)&&(t=t.substr(1)),null!==n&&43===n.charCodeAt(0)&&(n=n.substr(1)),{type:"AnPlusB",loc:this.getLocation(e,this.scanner.tokenStart),a:t,b:n}},generate:function(e){var t=null!==e.a&&void 0!==e.a,n=null!==e.b&&void 0!==e.b;t?(this.chunk("+1"===e.a?"+n":"1"===e.a?"n":"-1"===e.a?"-n":e.a+"n"),n&&("-"===(n=String(e.b)).charAt(0)||"+"===n.charAt(0)?(this.chunk(n.charAt(0)),this.chunk(n.substr(1))):(this.chunk("+"),this.chunk(n)))):this.chunk(String(e.b))}},Qr=Ce.TYPE,Xr=Qr.WhiteSpace,Zr=Qr.Semicolon,$r=Qr.LeftCurlyBracket,Jr=Qr.Delim;function ei(){return this.scanner.tokenIndex>0&&this.scanner.lookupType(-1)===Xr?this.scanner.tokenIndex>1?this.scanner.getTokenStart(this.scanner.tokenIndex-1):this.scanner.firstCharOffset:this.scanner.tokenStart}function ti(){return 0}var ni={name:"Raw",structure:{value:String},parse:function(e,t,n){var r,i=this.scanner.getTokenStart(e);return this.scanner.skip(this.scanner.getRawLength(e,t||ti)),r=n&&this.scanner.tokenStart>i?ei.call(this):this.scanner.tokenStart,{type:"Raw",loc:this.getLocation(i,r),value:this.scanner.source.substring(i,r)}},generate:function(e){this.chunk(e.value)},mode:{default:ti,leftCurlyBracket:function(e){return e===$r?1:0},leftCurlyBracketOrSemicolon:function(e){return e===$r||e===Zr?1:0},exclamationMarkOrSemicolon:function(e,t,n){return e===Jr&&33===t.charCodeAt(n)||e===Zr?1:0},semicolonIncluded:function(e){return e===Zr?2:0}}},ri=Ce.TYPE,ii=ni.mode,ai=ri.AtKeyword,oi=ri.Semicolon,si=ri.LeftCurlyBracket,li=ri.RightCurlyBracket;function ci(e){return this.Raw(e,ii.leftCurlyBracketOrSemicolon,!0)}function ui(){for(var e,t=1;e=this.scanner.lookupType(t);t++){if(e===li)return!0;if(e===si||e===ai)return!1}return!1}var hi={name:"Atrule",structure:{name:String,prelude:["AtrulePrelude","Raw",null],block:["Block",null]},parse:function(){var e,t,n=this.scanner.tokenStart,r=null,i=null;switch(this.eat(ai),t=(e=this.scanner.substrToCursor(n+1)).toLowerCase(),this.scanner.skipSC(),!1===this.scanner.eof&&this.scanner.tokenType!==si&&this.scanner.tokenType!==oi&&(this.parseAtrulePrelude?"AtrulePrelude"===(r=this.parseWithFallback(this.AtrulePrelude.bind(this,e),ci)).type&&null===r.children.head&&(r=null):r=ci.call(this,this.scanner.tokenIndex),this.scanner.skipSC()),this.scanner.tokenType){case oi:this.scanner.next();break;case si:i=this.atrule.hasOwnProperty(t)&&"function"==typeof this.atrule[t].block?this.atrule[t].block.call(this):this.Block(ui.call(this))}return{type:"Atrule",loc:this.getLocation(n,this.scanner.tokenStart),name:e,prelude:r,block:i}},generate:function(e){this.chunk("@"),this.chunk(e.name),null!==e.prelude&&(this.chunk(" "),this.node(e.prelude)),e.block?this.node(e.block):this.chunk(";")},walkContext:"atrule"},pi=Ce.TYPE,di=pi.Semicolon,mi=pi.LeftCurlyBracket,gi={name:"AtrulePrelude",structure:{children:[[]]},parse:function(e){var t=null;return null!==e&&(e=e.toLowerCase()),this.scanner.skipSC(),t=this.atrule.hasOwnProperty(e)&&"function"==typeof this.atrule[e].prelude?this.atrule[e].prelude.call(this):this.readSequence(this.scope.AtrulePrelude),this.scanner.skipSC(),!0!==this.scanner.eof&&this.scanner.tokenType!==mi&&this.scanner.tokenType!==di&&this.error("Semicolon or block is expected"),null===t&&(t=this.createList()),{type:"AtrulePrelude",loc:this.getLocationFromList(t),children:t}},generate:function(e){this.children(e)},walkContext:"atrulePrelude"},fi=Ce.TYPE,bi=fi.Ident,yi=fi.String,ki=fi.Colon,vi=fi.LeftSquareBracket,xi=fi.RightSquareBracket;function wi(){this.scanner.eof&&this.error("Unexpected end of input");var e=this.scanner.tokenStart,t=!1,n=!0;return this.scanner.isDelim(42)?(t=!0,n=!1,this.scanner.next()):this.scanner.isDelim(124)||this.eat(bi),this.scanner.isDelim(124)?61!==this.scanner.source.charCodeAt(this.scanner.tokenStart+1)?(this.scanner.next(),this.eat(bi)):t&&this.error("Identifier is expected",this.scanner.tokenEnd):t&&this.error("Vertical line is expected"),n&&this.scanner.tokenType===ki&&(this.scanner.next(),this.eat(bi)),{type:"Identifier",loc:this.getLocation(e,this.scanner.tokenStart),name:this.scanner.substrToCursor(e)}}function Si(){var e=this.scanner.tokenStart,t=this.scanner.source.charCodeAt(e);return 61!==t&&126!==t&&94!==t&&36!==t&&42!==t&&124!==t&&this.error("Attribute selector (=, ~=, ^=, $=, *=, |=) is expected"),this.scanner.next(),61!==t&&(this.scanner.isDelim(61)||this.error("Equal sign is expected"),this.scanner.next()),this.scanner.substrToCursor(e)}var Ci={name:"AttributeSelector",structure:{name:"Identifier",matcher:[String,null],value:["String","Identifier",null],flags:[String,null]},parse:function(){var e,t=this.scanner.tokenStart,n=null,r=null,i=null;return this.eat(vi),this.scanner.skipSC(),e=wi.call(this),this.scanner.skipSC(),this.scanner.tokenType!==xi&&(this.scanner.tokenType!==bi&&(n=Si.call(this),this.scanner.skipSC(),r=this.scanner.tokenType===yi?this.String():this.Identifier(),this.scanner.skipSC()),this.scanner.tokenType===bi&&(i=this.scanner.getTokenValue(),this.scanner.next(),this.scanner.skipSC())),this.eat(xi),{type:"AttributeSelector",loc:this.getLocation(t,this.scanner.tokenStart),name:e,matcher:n,value:r,flags:i}},generate:function(e){var t=" ";this.chunk("["),this.node(e.name),null!==e.matcher&&(this.chunk(e.matcher),null!==e.value&&(this.node(e.value),"String"===e.value.type&&(t=""))),null!==e.flags&&(this.chunk(t),this.chunk(e.flags)),this.chunk("]")}},zi=Ce.TYPE,Ai=ni.mode,Pi=zi.WhiteSpace,Ti=zi.Comment,Li=zi.Semicolon,Ei=zi.AtKeyword,Di=zi.LeftCurlyBracket,Oi=zi.RightCurlyBracket;function Bi(e){return this.Raw(e,null,!0)}function Ii(){return this.parseWithFallback(this.Rule,Bi)}function Ni(e){return this.Raw(e,Ai.semicolonIncluded,!0)}function Ri(){if(this.scanner.tokenType===Li)return Ni.call(this,this.scanner.tokenIndex);var e=this.parseWithFallback(this.Declaration,Ni);return this.scanner.tokenType===Li&&this.scanner.next(),e}var Mi={name:"Block",structure:{children:[["Atrule","Rule","Declaration"]]},parse:function(e){var t=e?Ri:Ii,n=this.scanner.tokenStart,r=this.createList();this.eat(Di);e:for(;!this.scanner.eof;)switch(this.scanner.tokenType){case Oi:break e;case Pi:case Ti:this.scanner.next();break;case Ei:r.push(this.parseWithFallback(this.Atrule,Bi));break;default:r.push(t.call(this))}return this.scanner.eof||this.eat(Oi),{type:"Block",loc:this.getLocation(n,this.scanner.tokenStart),children:r}},generate:function(e){this.chunk("{"),this.children(e,(function(e){"Declaration"===e.type&&this.chunk(";")})),this.chunk("}")},walkContext:"block"},ji=Ce.TYPE,_i=ji.LeftSquareBracket,Fi=ji.RightSquareBracket,Wi={name:"Brackets",structure:{children:[[]]},parse:function(e,t){var n,r=this.scanner.tokenStart;return this.eat(_i),n=e.call(this,t),this.scanner.eof||this.eat(Fi),{type:"Brackets",loc:this.getLocation(r,this.scanner.tokenStart),children:n}},generate:function(e){this.chunk("["),this.children(e),this.chunk("]")}},qi=Ce.TYPE.CDC,Yi={name:"CDC",structure:[],parse:function(){var e=this.scanner.tokenStart;return this.eat(qi),{type:"CDC",loc:this.getLocation(e,this.scanner.tokenStart)}},generate:function(){this.chunk("--\x3e")}},Ui=Ce.TYPE.CDO,Hi={name:"CDO",structure:[],parse:function(){var e=this.scanner.tokenStart;return this.eat(Ui),{type:"CDO",loc:this.getLocation(e,this.scanner.tokenStart)}},generate:function(){this.chunk("\x3c!--")}},Vi=Ce.TYPE.Ident,Ki={name:"ClassSelector",structure:{name:String},parse:function(){return this.scanner.isDelim(46)||this.error("Full stop is expected"),this.scanner.next(),{type:"ClassSelector",loc:this.getLocation(this.scanner.tokenStart-1,this.scanner.tokenEnd),name:this.consume(Vi)}},generate:function(e){this.chunk("."),this.chunk(e.name)}},Gi=Ce.TYPE.Ident,Qi={name:"Combinator",structure:{name:String},parse:function(){var e=this.scanner.tokenStart;switch(this.scanner.source.charCodeAt(this.scanner.tokenStart)){case 62:case 43:case 126:this.scanner.next();break;case 47:this.scanner.next(),this.scanner.tokenType===Gi&&!1!==this.scanner.lookupValue(0,"deep")||this.error("Identifier `deep` is expected"),this.scanner.next(),this.scanner.isDelim(47)||this.error("Solidus is expected"),this.scanner.next();break;default:this.error("Combinator is expected")}return{type:"Combinator",loc:this.getLocation(e,this.scanner.tokenStart),name:this.scanner.substrToCursor(e)}},generate:function(e){this.chunk(e.name)}},Xi=Ce.TYPE.Comment,Zi={name:"Comment",structure:{value:String},parse:function(){var e=this.scanner.tokenStart,t=this.scanner.tokenEnd;return this.eat(Xi),t-e+2>=2&&42===this.scanner.source.charCodeAt(t-2)&&47===this.scanner.source.charCodeAt(t-1)&&(t-=2),{type:"Comment",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.source.substring(e+2,t)}},generate:function(e){this.chunk("/*"),this.chunk(e.value),this.chunk("*/")}},$i=ae.isCustomProperty,Ji=Ce.TYPE,ea=ni.mode,ta=Ji.Ident,na=Ji.Hash,ra=Ji.Colon,ia=Ji.Semicolon,aa=Ji.Delim,oa=Ji.WhiteSpace;function sa(e){return this.Raw(e,ea.exclamationMarkOrSemicolon,!0)}function la(e){return this.Raw(e,ea.exclamationMarkOrSemicolon,!1)}function ca(){var e=this.scanner.tokenIndex,t=this.Value();return"Raw"!==t.type&&!1===this.scanner.eof&&this.scanner.tokenType!==ia&&!1===this.scanner.isDelim(33)&&!1===this.scanner.isBalanceEdge(e)&&this.error(),t}var ua={name:"Declaration",structure:{important:[Boolean,String],property:String,value:["Value","Raw"]},parse:function(){var e,t=this.scanner.tokenStart,n=this.scanner.tokenIndex,r=ha.call(this),i=$i(r),a=i?this.parseCustomProperty:this.parseValue,o=i?la:sa,s=!1;this.scanner.skipSC(),this.eat(ra);const l=this.scanner.tokenIndex;if(i||this.scanner.skipSC(),e=a?this.parseWithFallback(ca,o):o.call(this,this.scanner.tokenIndex),i&&"Value"===e.type&&e.children.isEmpty())for(let t=l-this.scanner.tokenIndex;t<=0;t++)if(this.scanner.lookupType(t)===oa){e.children.appendData({type:"WhiteSpace",loc:null,value:" "});break}return this.scanner.isDelim(33)&&(s=pa.call(this),this.scanner.skipSC()),!1===this.scanner.eof&&this.scanner.tokenType!==ia&&!1===this.scanner.isBalanceEdge(n)&&this.error(),{type:"Declaration",loc:this.getLocation(t,this.scanner.tokenStart),important:s,property:r,value:e}},generate:function(e){this.chunk(e.property),this.chunk(":"),this.node(e.value),e.important&&this.chunk(!0===e.important?"!important":"!"+e.important)},walkContext:"declaration"};function ha(){var e=this.scanner.tokenStart;if(this.scanner.tokenType===aa)switch(this.scanner.source.charCodeAt(this.scanner.tokenStart)){case 42:case 36:case 43:case 35:case 38:this.scanner.next();break;case 47:this.scanner.next(),this.scanner.isDelim(47)&&this.scanner.next()}return this.scanner.tokenType===na?this.eat(na):this.eat(ta),this.scanner.substrToCursor(e)}function pa(){this.eat(aa),this.scanner.skipSC();var e=this.consume(ta);return"important"===e||e}var da=Ce.TYPE,ma=ni.mode,ga=da.WhiteSpace,fa=da.Comment,ba=da.Semicolon;function ya(e){return this.Raw(e,ma.semicolonIncluded,!0)}var ka={name:"DeclarationList",structure:{children:[["Declaration"]]},parse:function(){for(var e=this.createList();!this.scanner.eof;)switch(this.scanner.tokenType){case ga:case fa:case ba:this.scanner.next();break;default:e.push(this.parseWithFallback(this.Declaration,ya))}return{type:"DeclarationList",loc:this.getLocationFromList(e),children:e}},generate:function(e){this.children(e,(function(e){"Declaration"===e.type&&this.chunk(";")}))}},va=M.consumeNumber,xa=Ce.TYPE.Dimension,wa={name:"Dimension",structure:{value:String,unit:String},parse:function(){var e=this.scanner.tokenStart,t=va(this.scanner.source,e);return this.eat(xa),{type:"Dimension",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.source.substring(e,t),unit:this.scanner.source.substring(t,this.scanner.tokenStart)}},generate:function(e){this.chunk(e.value),this.chunk(e.unit)}},Sa=Ce.TYPE.RightParenthesis,Ca={name:"Function",structure:{name:String,children:[[]]},parse:function(e,t){var n,r=this.scanner.tokenStart,i=this.consumeFunctionName(),a=i.toLowerCase();return n=t.hasOwnProperty(a)?t[a].call(this,t):e.call(this,t),this.scanner.eof||this.eat(Sa),{type:"Function",loc:this.getLocation(r,this.scanner.tokenStart),name:i,children:n}},generate:function(e){this.chunk(e.name),this.chunk("("),this.children(e),this.chunk(")")},walkContext:"function"},za=Ce.TYPE.Hash,Aa={name:"Hash",structure:{value:String},parse:function(){var e=this.scanner.tokenStart;return this.eat(za),{type:"Hash",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.substrToCursor(e+1)}},generate:function(e){this.chunk("#"),this.chunk(e.value)}},Pa=Ce.TYPE.Ident,Ta={name:"Identifier",structure:{name:String},parse:function(){return{type:"Identifier",loc:this.getLocation(this.scanner.tokenStart,this.scanner.tokenEnd),name:this.consume(Pa)}},generate:function(e){this.chunk(e.name)}},La=Ce.TYPE.Hash,Ea={name:"IdSelector",structure:{name:String},parse:function(){var e=this.scanner.tokenStart;return this.eat(La),{type:"IdSelector",loc:this.getLocation(e,this.scanner.tokenStart),name:this.scanner.substrToCursor(e+1)}},generate:function(e){this.chunk("#"),this.chunk(e.name)}},Da=Ce.TYPE,Oa=Da.Ident,Ba=Da.Number,Ia=Da.Dimension,Na=Da.LeftParenthesis,Ra=Da.RightParenthesis,Ma=Da.Colon,ja=Da.Delim,_a={name:"MediaFeature",structure:{name:String,value:["Identifier","Number","Dimension","Ratio",null]},parse:function(){var e,t=this.scanner.tokenStart,n=null;if(this.eat(Na),this.scanner.skipSC(),e=this.consume(Oa),this.scanner.skipSC(),this.scanner.tokenType!==Ra){switch(this.eat(Ma),this.scanner.skipSC(),this.scanner.tokenType){case Ba:n=this.lookupNonWSType(1)===ja?this.Ratio():this.Number();break;case Ia:n=this.Dimension();break;case Oa:n=this.Identifier();break;default:this.error("Number, dimension, ratio or identifier is expected")}this.scanner.skipSC()}return this.eat(Ra),{type:"MediaFeature",loc:this.getLocation(t,this.scanner.tokenStart),name:e,value:n}},generate:function(e){this.chunk("("),this.chunk(e.name),null!==e.value&&(this.chunk(":"),this.node(e.value)),this.chunk(")")}},Fa=Ce.TYPE,Wa=Fa.WhiteSpace,qa=Fa.Comment,Ya=Fa.Ident,Ua=Fa.LeftParenthesis,Ha={name:"MediaQuery",structure:{children:[["Identifier","MediaFeature","WhiteSpace"]]},parse:function(){this.scanner.skipSC();var e=this.createList(),t=null,n=null;e:for(;!this.scanner.eof;){switch(this.scanner.tokenType){case qa:this.scanner.next();continue;case Wa:n=this.WhiteSpace();continue;case Ya:t=this.Identifier();break;case Ua:t=this.MediaFeature();break;default:break e}null!==n&&(e.push(n),n=null),e.push(t)}return null===t&&this.error("Identifier or parenthesis is expected"),{type:"MediaQuery",loc:this.getLocationFromList(e),children:e}},generate:function(e){this.children(e)}},Va=Ce.TYPE.Comma,Ka={name:"MediaQueryList",structure:{children:[["MediaQuery"]]},parse:function(e){var t=this.createList();for(this.scanner.skipSC();!this.scanner.eof&&(t.push(this.MediaQuery(e)),this.scanner.tokenType===Va);)this.scanner.next();return{type:"MediaQueryList",loc:this.getLocationFromList(t),children:t}},generate:function(e){this.children(e,(function(){this.chunk(",")}))}},Ga=Ce.TYPE.Number,Qa={name:"Number",structure:{value:String},parse:function(){return{type:"Number",loc:this.getLocation(this.scanner.tokenStart,this.scanner.tokenEnd),value:this.consume(Ga)}},generate:function(e){this.chunk(e.value)}},Xa={name:"Operator",structure:{value:String},parse:function(){var e=this.scanner.tokenStart;return this.scanner.next(),{type:"Operator",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.substrToCursor(e)}},generate:function(e){this.chunk(e.value)}},Za=Ce.TYPE,$a=Za.LeftParenthesis,Ja=Za.RightParenthesis,eo={name:"Parentheses",structure:{children:[[]]},parse:function(e,t){var n,r=this.scanner.tokenStart;return this.eat($a),n=e.call(this,t),this.scanner.eof||this.eat(Ja),{type:"Parentheses",loc:this.getLocation(r,this.scanner.tokenStart),children:n}},generate:function(e){this.chunk("("),this.children(e),this.chunk(")")}},to=M.consumeNumber,no=Ce.TYPE.Percentage,ro={name:"Percentage",structure:{value:String},parse:function(){var e=this.scanner.tokenStart,t=to(this.scanner.source,e);return this.eat(no),{type:"Percentage",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.source.substring(e,t)}},generate:function(e){this.chunk(e.value),this.chunk("%")}},io=Ce.TYPE,ao=io.Ident,oo=io.Function,so=io.Colon,lo=io.RightParenthesis,co={name:"PseudoClassSelector",structure:{name:String,children:[["Raw"],null]},parse:function(){var e,t,n=this.scanner.tokenStart,r=null;return this.eat(so),this.scanner.tokenType===oo?(t=(e=this.consumeFunctionName()).toLowerCase(),this.pseudo.hasOwnProperty(t)?(this.scanner.skipSC(),r=this.pseudo[t].call(this),this.scanner.skipSC()):(r=this.createList()).push(this.Raw(this.scanner.tokenIndex,null,!1)),this.eat(lo)):e=this.consume(ao),{type:"PseudoClassSelector",loc:this.getLocation(n,this.scanner.tokenStart),name:e,children:r}},generate:function(e){this.chunk(":"),this.chunk(e.name),null!==e.children&&(this.chunk("("),this.children(e),this.chunk(")"))},walkContext:"function"},uo=Ce.TYPE,ho=uo.Ident,po=uo.Function,mo=uo.Colon,go=uo.RightParenthesis,fo={name:"PseudoElementSelector",structure:{name:String,children:[["Raw"],null]},parse:function(){var e,t,n=this.scanner.tokenStart,r=null;return this.eat(mo),this.eat(mo),this.scanner.tokenType===po?(t=(e=this.consumeFunctionName()).toLowerCase(),this.pseudo.hasOwnProperty(t)?(this.scanner.skipSC(),r=this.pseudo[t].call(this),this.scanner.skipSC()):(r=this.createList()).push(this.Raw(this.scanner.tokenIndex,null,!1)),this.eat(go)):e=this.consume(ho),{type:"PseudoElementSelector",loc:this.getLocation(n,this.scanner.tokenStart),name:e,children:r}},generate:function(e){this.chunk("::"),this.chunk(e.name),null!==e.children&&(this.chunk("("),this.children(e),this.chunk(")"))},walkContext:"function"},bo=Ce.isDigit,yo=Ce.TYPE,ko=yo.Number,vo=yo.Delim;function xo(){this.scanner.skipWS();for(var e=this.consume(ko),t=0;t<e.length;t++){var n=e.charCodeAt(t);bo(n)||46===n||this.error("Unsigned number is expected",this.scanner.tokenStart-e.length+t)}return 0===Number(e)&&this.error("Zero number is not allowed",this.scanner.tokenStart-e.length),e}var wo={name:"Ratio",structure:{left:String,right:String},parse:function(){var e,t=this.scanner.tokenStart,n=xo.call(this);return this.scanner.skipWS(),this.scanner.isDelim(47)||this.error("Solidus is expected"),this.eat(vo),e=xo.call(this),{type:"Ratio",loc:this.getLocation(t,this.scanner.tokenStart),left:n,right:e}},generate:function(e){this.chunk(e.left),this.chunk("/"),this.chunk(e.right)}},So=Ce.TYPE,Co=ni.mode,zo=So.LeftCurlyBracket;function Ao(e){return this.Raw(e,Co.leftCurlyBracket,!0)}function Po(){var e=this.SelectorList();return"Raw"!==e.type&&!1===this.scanner.eof&&this.scanner.tokenType!==zo&&this.error(),e}var To={name:"Rule",structure:{prelude:["SelectorList","Raw"],block:["Block"]},parse:function(){var e,t,n=this.scanner.tokenIndex,r=this.scanner.tokenStart;return e=this.parseRulePrelude?this.parseWithFallback(Po,Ao):Ao.call(this,n),t=this.Block(!0),{type:"Rule",loc:this.getLocation(r,this.scanner.tokenStart),prelude:e,block:t}},generate:function(e){this.node(e.prelude),this.node(e.block)},walkContext:"rule"},Lo=Ce.TYPE.Comma,Eo={name:"SelectorList",structure:{children:[["Selector","Raw"]]},parse:function(){for(var e=this.createList();!this.scanner.eof&&(e.push(this.Selector()),this.scanner.tokenType===Lo);)this.scanner.next();return{type:"SelectorList",loc:this.getLocationFromList(e),children:e}},generate:function(e){this.children(e,(function(){this.chunk(",")}))},walkContext:"selector"},Do=Ce.TYPE.String,Oo={name:"String",structure:{value:String},parse:function(){return{type:"String",loc:this.getLocation(this.scanner.tokenStart,this.scanner.tokenEnd),value:this.consume(Do)}},generate:function(e){this.chunk(e.value)}},Bo=Ce.TYPE,Io=Bo.WhiteSpace,No=Bo.Comment,Ro=Bo.AtKeyword,Mo=Bo.CDO,jo=Bo.CDC;function _o(e){return this.Raw(e,null,!1)}var Fo={name:"StyleSheet",structure:{children:[["Comment","CDO","CDC","Atrule","Rule","Raw"]]},parse:function(){for(var e,t=this.scanner.tokenStart,n=this.createList();!this.scanner.eof;){switch(this.scanner.tokenType){case Io:this.scanner.next();continue;case No:if(33!==this.scanner.source.charCodeAt(this.scanner.tokenStart+2)){this.scanner.next();continue}e=this.Comment();break;case Mo:e=this.CDO();break;case jo:e=this.CDC();break;case Ro:e=this.parseWithFallback(this.Atrule,_o);break;default:e=this.parseWithFallback(this.Rule,_o)}n.push(e)}return{type:"StyleSheet",loc:this.getLocation(t,this.scanner.tokenStart),children:n}},generate:function(e){this.children(e)},walkContext:"stylesheet"},Wo=Ce.TYPE.Ident;function qo(){this.scanner.tokenType!==Wo&&!1===this.scanner.isDelim(42)&&this.error("Identifier or asterisk is expected"),this.scanner.next()}var Yo={name:"TypeSelector",structure:{name:String},parse:function(){var e=this.scanner.tokenStart;return this.scanner.isDelim(124)?(this.scanner.next(),qo.call(this)):(qo.call(this),this.scanner.isDelim(124)&&(this.scanner.next(),qo.call(this))),{type:"TypeSelector",loc:this.getLocation(e,this.scanner.tokenStart),name:this.scanner.substrToCursor(e)}},generate:function(e){this.chunk(e.name)}},Uo=Ce.isHexDigit,Ho=Ce.cmpChar,Vo=Ce.TYPE,Ko=Ce.NAME,Go=Vo.Ident,Qo=Vo.Number,Xo=Vo.Dimension;function Zo(e,t){for(var n=this.scanner.tokenStart+e,r=0;n<this.scanner.tokenEnd;n++){var i=this.scanner.source.charCodeAt(n);if(45===i&&t&&0!==r)return 0===Zo.call(this,e+r+1,!1)&&this.error(),-1;Uo(i)||this.error(t&&0!==r?"HyphenMinus"+(r<6?" or hex digit":"")+" is expected":r<6?"Hex digit is expected":"Unexpected input",n),++r>6&&this.error("Too many hex digits",n)}return this.scanner.next(),r}function $o(e){for(var t=0;this.scanner.isDelim(63);)++t>e&&this.error("Too many question marks"),this.scanner.next()}function Jo(e){this.scanner.source.charCodeAt(this.scanner.tokenStart)!==e&&this.error(Ko[e]+" is expected")}function es(){var e=0;return this.scanner.isDelim(43)?(this.scanner.next(),this.scanner.tokenType===Go?void((e=Zo.call(this,0,!0))>0&&$o.call(this,6-e)):this.scanner.isDelim(63)?(this.scanner.next(),void $o.call(this,5)):void this.error("Hex digit or question mark is expected")):this.scanner.tokenType===Qo?(Jo.call(this,43),e=Zo.call(this,1,!0),this.scanner.isDelim(63)?void $o.call(this,6-e):this.scanner.tokenType===Xo||this.scanner.tokenType===Qo?(Jo.call(this,45),void Zo.call(this,1,!1)):void 0):this.scanner.tokenType===Xo?(Jo.call(this,43),void((e=Zo.call(this,1,!0))>0&&$o.call(this,6-e))):void this.error()}var ts={name:"UnicodeRange",structure:{value:String},parse:function(){var e=this.scanner.tokenStart;return Ho(this.scanner.source,e,117)||this.error("U is expected"),Ho(this.scanner.source,e+1,43)||this.error("Plus sign is expected"),this.scanner.next(),es.call(this),{type:"UnicodeRange",loc:this.getLocation(e,this.scanner.tokenStart),value:this.scanner.substrToCursor(e)}},generate:function(e){this.chunk(e.value)}},ns=Ce.isWhiteSpace,rs=Ce.cmpStr,is=Ce.TYPE,as=is.Function,os=is.Url,ss=is.RightParenthesis,ls={name:"Url",structure:{value:["String","Raw"]},parse:function(){var e,t=this.scanner.tokenStart;switch(this.scanner.tokenType){case os:for(var n=t+4,r=this.scanner.tokenEnd-1;n<r&&ns(this.scanner.source.charCodeAt(n));)n++;for(;n<r&&ns(this.scanner.source.charCodeAt(r-1));)r--;e={type:"Raw",loc:this.getLocation(n,r),value:this.scanner.source.substring(n,r)},this.eat(os);break;case as:rs(this.scanner.source,this.scanner.tokenStart,this.scanner.tokenEnd,"url(")||this.error("Function name must be `url`"),this.eat(as),this.scanner.skipSC(),e=this.String(),this.scanner.skipSC(),this.eat(ss);break;default:this.error("Url or Function is expected")}return{type:"Url",loc:this.getLocation(t,this.scanner.tokenStart),value:e}},generate:function(e){this.chunk("url"),this.chunk("("),this.node(e.value),this.chunk(")")}},cs=Ce.TYPE.WhiteSpace,us=Object.freeze({type:"WhiteSpace",loc:null,value:" "}),hs={AnPlusB:Gr,Atrule:hi,AtrulePrelude:gi,AttributeSelector:Ci,Block:Mi,Brackets:Wi,CDC:Yi,CDO:Hi,ClassSelector:Ki,Combinator:Qi,Comment:Zi,Declaration:ua,DeclarationList:ka,Dimension:wa,Function:Ca,Hash:Aa,Identifier:Ta,IdSelector:Ea,MediaFeature:_a,MediaQuery:Ha,MediaQueryList:Ka,Nth:{name:"Nth",structure:{nth:["AnPlusB","Identifier"],selector:["SelectorList",null]},parse:function(e){this.scanner.skipSC();var t,n=this.scanner.tokenStart,r=n,i=null;return t=this.scanner.lookupValue(0,"odd")||this.scanner.lookupValue(0,"even")?this.Identifier():this.AnPlusB(),this.scanner.skipSC(),e&&this.scanner.lookupValue(0,"of")?(this.scanner.next(),i=this.SelectorList(),this.needPositions&&(r=this.getLastListNode(i.children).loc.end.offset)):this.needPositions&&(r=t.loc.end.offset),{type:"Nth",loc:this.getLocation(n,r),nth:t,selector:i}},generate:function(e){this.node(e.nth),null!==e.selector&&(this.chunk(" of "),this.node(e.selector))}},Number:Qa,Operator:Xa,Parentheses:eo,Percentage:ro,PseudoClassSelector:co,PseudoElementSelector:fo,Ratio:wo,Raw:ni,Rule:To,Selector:{name:"Selector",structure:{children:[["TypeSelector","IdSelector","ClassSelector","AttributeSelector","PseudoClassSelector","PseudoElementSelector","Combinator","WhiteSpace"]]},parse:function(){var e=this.readSequence(this.scope.Selector);return null===this.getFirstListNode(e)&&this.error("Selector is expected"),{type:"Selector",loc:this.getLocationFromList(e),children:e}},generate:function(e){this.children(e)}},SelectorList:Eo,String:Oo,StyleSheet:Fo,TypeSelector:Yo,UnicodeRange:ts,Url:ls,Value:{name:"Value",structure:{children:[[]]},parse:function(){var e=this.scanner.tokenStart,t=this.readSequence(this.scope.Value);return{type:"Value",loc:this.getLocation(e,this.scanner.tokenStart),children:t}},generate:function(e){this.children(e)}},WhiteSpace:{name:"WhiteSpace",structure:{value:String},parse:function(){return this.eat(cs),us},generate:function(e){this.chunk(e.value)}}},ps={generic:!0,types:Nr.types,atrules:Nr.atrules,properties:Nr.properties,node:hs},ds=Ce.cmpChar,ms=Ce.cmpStr,gs=Ce.TYPE,fs=gs.Ident,bs=gs.String,ys=gs.Number,ks=gs.Function,vs=gs.Url,xs=gs.Hash,ws=gs.Dimension,Ss=gs.Percentage,Cs=gs.LeftParenthesis,zs=gs.LeftSquareBracket,As=gs.Comma,Ps=gs.Delim,Ts=function(e){switch(this.scanner.tokenType){case xs:return this.Hash();case As:return e.space=null,e.ignoreWSAfter=!0,this.Operator();case Cs:return this.Parentheses(this.readSequence,e.recognizer);case zs:return this.Brackets(this.readSequence,e.recognizer);case bs:return this.String();case ws:return this.Dimension();case Ss:return this.Percentage();case ys:return this.Number();case ks:return ms(this.scanner.source,this.scanner.tokenStart,this.scanner.tokenEnd,"url(")?this.Url():this.Function(this.readSequence,e.recognizer);case vs:return this.Url();case fs:return ds(this.scanner.source,this.scanner.tokenStart,117)&&ds(this.scanner.source,this.scanner.tokenStart+1,43)?this.UnicodeRange():this.Identifier();case Ps:var t=this.scanner.source.charCodeAt(this.scanner.tokenStart);if(47===t||42===t||43===t||45===t)return this.Operator();35===t&&this.error("Hex or identifier is expected",this.scanner.tokenStart+1)}},Ls={getNode:Ts},Es=Ce.TYPE,Ds=Es.Delim,Os=Es.Ident,Bs=Es.Dimension,Is=Es.Percentage,Ns=Es.Number,Rs=Es.Hash,Ms=Es.Colon,js=Es.LeftSquareBracket;var _s={getNode:function(e){switch(this.scanner.tokenType){case js:return this.AttributeSelector();case Rs:return this.IdSelector();case Ms:return this.scanner.lookupType(1)===Ms?this.PseudoElementSelector():this.PseudoClassSelector();case Os:return this.TypeSelector();case Ns:case Is:return this.Percentage();case Bs:46===this.scanner.source.charCodeAt(this.scanner.tokenStart)&&this.error("Identifier is expected",this.scanner.tokenStart+1);break;case Ds:switch(this.scanner.source.charCodeAt(this.scanner.tokenStart)){case 43:case 62:case 126:return e.space=null,e.ignoreWSAfter=!0,this.Combinator();case 47:return this.Combinator();case 46:return this.ClassSelector();case 42:case 124:return this.TypeSelector();case 35:return this.IdSelector()}}}},Fs=Ce.TYPE,Ws=ni.mode,qs=Fs.Comma,Ys=Fs.WhiteSpace,Us={AtrulePrelude:Ls,Selector:_s,Value:{getNode:Ts,expression:function(){return this.createSingleNodeList(this.Raw(this.scanner.tokenIndex,null,!1))},var:function(){var e=this.createList();if(this.scanner.skipSC(),e.push(this.Identifier()),this.scanner.skipSC(),this.scanner.tokenType===qs){e.push(this.Operator());const t=this.scanner.tokenIndex,n=this.parseCustomProperty?this.Value(null):this.Raw(this.scanner.tokenIndex,Ws.exclamationMarkOrSemicolon,!1);if("Value"===n.type&&n.children.isEmpty())for(let e=t-this.scanner.tokenIndex;e<=0;e++)if(this.scanner.lookupType(e)===Ys){n.children.appendData({type:"WhiteSpace",loc:null,value:" "});break}e.push(n)}return e}}},Hs=Ce.TYPE,Vs=Hs.String,Ks=Hs.Ident,Gs=Hs.Url,Qs=Hs.Function,Xs=Hs.LeftParenthesis,Zs={parse:{prelude:function(){var e=this.createList();switch(this.scanner.skipSC(),this.scanner.tokenType){case Vs:e.push(this.String());break;case Gs:case Qs:e.push(this.Url());break;default:this.error("String or url() is expected")}return this.lookupNonWSType(0)!==Ks&&this.lookupNonWSType(0)!==Xs||(e.push(this.WhiteSpace()),e.push(this.MediaQueryList())),e},block:null}},$s=Ce.TYPE,Js=$s.WhiteSpace,el=$s.Comment,tl=$s.Ident,nl=$s.Function,rl=$s.Colon,il=$s.LeftParenthesis;function al(){return this.createSingleNodeList(this.Raw(this.scanner.tokenIndex,null,!1))}function ol(){return this.scanner.skipSC(),this.scanner.tokenType===tl&&this.lookupNonWSType(1)===rl?this.createSingleNodeList(this.Declaration()):sl.call(this)}function sl(){var e,t=this.createList(),n=null;this.scanner.skipSC();e:for(;!this.scanner.eof;){switch(this.scanner.tokenType){case Js:n=this.WhiteSpace();continue;case el:this.scanner.next();continue;case nl:e=this.Function(al,this.scope.AtrulePrelude);break;case tl:e=this.Identifier();break;case il:e=this.Parentheses(ol,this.scope.AtrulePrelude);break;default:break e}null!==n&&(t.push(n),n=null),t.push(e)}return t}var ll,cl={parse:function(){return this.createSingleNodeList(this.SelectorList())}},ul={parse:function(){return this.createSingleNodeList(this.Nth(!0))}},hl={parse:function(){return this.createSingleNodeList(this.Nth(!1))}},pl={parseContext:{default:"StyleSheet",stylesheet:"StyleSheet",atrule:"Atrule",atrulePrelude:function(e){return this.AtrulePrelude(e.atrule?String(e.atrule):null)},mediaQueryList:"MediaQueryList",mediaQuery:"MediaQuery",rule:"Rule",selectorList:"SelectorList",selector:"Selector",block:function(){return this.Block(!0)},declarationList:"DeclarationList",declaration:"Declaration",value:"Value"},scope:Us,atrule:{"font-face":{parse:{prelude:null,block:function(){return this.Block(!0)}}},import:Zs,media:{parse:{prelude:function(){return this.createSingleNodeList(this.MediaQueryList())},block:function(){return this.Block(!1)}}},page:{parse:{prelude:function(){return this.createSingleNodeList(this.SelectorList())},block:function(){return this.Block(!0)}}},supports:{parse:{prelude:function(){var e=sl.call(this);return null===this.getFirstListNode(e)&&this.error("Condition is expected"),e},block:function(){return this.Block(!1)}}}},pseudo:{dir:{parse:function(){return this.createSingleNodeList(this.Identifier())}},has:{parse:function(){return this.createSingleNodeList(this.SelectorList())}},lang:{parse:function(){return this.createSingleNodeList(this.Identifier())}},matches:cl,not:cl,"nth-child":ul,"nth-last-child":ul,"nth-last-of-type":hl,"nth-of-type":hl,slotted:{parse:function(){return this.createSingleNodeList(this.Selector())}}},node:hs},dl={node:hs},ml={version:"1.1.3"},gl=(ll=Object.freeze({__proto__:null,version:"1.1.3",default:ml}))&&ll.default||ll;var fl=Ir(function(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];for(var r in n)e[r]=n[r]}return e}(ps,pl,dl)),bl=gl.version;return fl.version=bl,fl}));
diff --git a/node_modules/css-tree/lib/common/List.js b/node_modules/css-tree/lib/common/List.js
new file mode 100644
index 0000000..5da834a
--- /dev/null
+++ b/node_modules/css-tree/lib/common/List.js
@@ -0,0 +1,576 @@
+//
+// list
+// ┌──────┐
+// ┌──────────────┼─head │
+// │ │ tail─┼──────────────┐
+// │ └──────┘ │
+// ▼ ▼
+// item item item item
+// ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
+// null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │
+// │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null
+// ├──────┤ ├──────┤ ├──────┤ ├──────┤
+// │ data │ │ data │ │ data │ │ data │
+// └──────┘ └──────┘ └──────┘ └──────┘
+//
+
+function createItem(data) {
+ return {
+ prev: null,
+ next: null,
+ data: data
+ };
+}
+
+function allocateCursor(node, prev, next) {
+ var cursor;
+
+ if (cursors !== null) {
+ cursor = cursors;
+ cursors = cursors.cursor;
+ cursor.prev = prev;
+ cursor.next = next;
+ cursor.cursor = node.cursor;
+ } else {
+ cursor = {
+ prev: prev,
+ next: next,
+ cursor: node.cursor
+ };
+ }
+
+ node.cursor = cursor;
+
+ return cursor;
+}
+
+function releaseCursor(node) {
+ var cursor = node.cursor;
+
+ node.cursor = cursor.cursor;
+ cursor.prev = null;
+ cursor.next = null;
+ cursor.cursor = cursors;
+ cursors = cursor;
+}
+
+var cursors = null;
+var List = function() {
+ this.cursor = null;
+ this.head = null;
+ this.tail = null;
+};
+
+List.createItem = createItem;
+List.prototype.createItem = createItem;
+
+List.prototype.updateCursors = function(prevOld, prevNew, nextOld, nextNew) {
+ var cursor = this.cursor;
+
+ while (cursor !== null) {
+ if (cursor.prev === prevOld) {
+ cursor.prev = prevNew;
+ }
+
+ if (cursor.next === nextOld) {
+ cursor.next = nextNew;
+ }
+
+ cursor = cursor.cursor;
+ }
+};
+
+List.prototype.getSize = function() {
+ var size = 0;
+ var cursor = this.head;
+
+ while (cursor) {
+ size++;
+ cursor = cursor.next;
+ }
+
+ return size;
+};
+
+List.prototype.fromArray = function(array) {
+ var cursor = null;
+
+ this.head = null;
+
+ for (var i = 0; i < array.length; i++) {
+ var item = createItem(array[i]);
+
+ if (cursor !== null) {
+ cursor.next = item;
+ } else {
+ this.head = item;
+ }
+
+ item.prev = cursor;
+ cursor = item;
+ }
+
+ this.tail = cursor;
+
+ return this;
+};
+
+List.prototype.toArray = function() {
+ var cursor = this.head;
+ var result = [];
+
+ while (cursor) {
+ result.push(cursor.data);
+ cursor = cursor.next;
+ }
+
+ return result;
+};
+
+List.prototype.toJSON = List.prototype.toArray;
+
+List.prototype.isEmpty = function() {
+ return this.head === null;
+};
+
+List.prototype.first = function() {
+ return this.head && this.head.data;
+};
+
+List.prototype.last = function() {
+ return this.tail && this.tail.data;
+};
+
+List.prototype.each = function(fn, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, this.head);
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ fn.call(context, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+};
+
+List.prototype.forEach = List.prototype.each;
+
+List.prototype.eachRight = function(fn, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, this.tail, null);
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ fn.call(context, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+};
+
+List.prototype.forEachRight = List.prototype.eachRight;
+
+List.prototype.reduce = function(fn, initialValue, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, this.head);
+ var acc = initialValue;
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ acc = fn.call(context, acc, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+
+ return acc;
+};
+
+List.prototype.reduceRight = function(fn, initialValue, context) {
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, this.tail, null);
+ var acc = initialValue;
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ acc = fn.call(context, acc, item.data, item, this);
+ }
+
+ // pop cursor
+ releaseCursor(this);
+
+ return acc;
+};
+
+List.prototype.nextUntil = function(start, fn, context) {
+ if (start === null) {
+ return;
+ }
+
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, null, start);
+
+ while (cursor.next !== null) {
+ item = cursor.next;
+ cursor.next = item.next;
+
+ if (fn.call(context, item.data, item, this)) {
+ break;
+ }
+ }
+
+ // pop cursor
+ releaseCursor(this);
+};
+
+List.prototype.prevUntil = function(start, fn, context) {
+ if (start === null) {
+ return;
+ }
+
+ var item;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ // push cursor
+ var cursor = allocateCursor(this, start, null);
+
+ while (cursor.prev !== null) {
+ item = cursor.prev;
+ cursor.prev = item.prev;
+
+ if (fn.call(context, item.data, item, this)) {
+ break;
+ }
+ }
+
+ // pop cursor
+ releaseCursor(this);
+};
+
+List.prototype.some = function(fn, context) {
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ if (fn.call(context, cursor.data, cursor, this)) {
+ return true;
+ }
+
+ cursor = cursor.next;
+ }
+
+ return false;
+};
+
+List.prototype.map = function(fn, context) {
+ var result = new List();
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ result.appendData(fn.call(context, cursor.data, cursor, this));
+ cursor = cursor.next;
+ }
+
+ return result;
+};
+
+List.prototype.filter = function(fn, context) {
+ var result = new List();
+ var cursor = this.head;
+
+ if (context === undefined) {
+ context = this;
+ }
+
+ while (cursor !== null) {
+ if (fn.call(context, cursor.data, cursor, this)) {
+ result.appendData(cursor.data);
+ }
+ cursor = cursor.next;
+ }
+
+ return result;
+};
+
+List.prototype.clear = function() {
+ this.head = null;
+ this.tail = null;
+};
+
+List.prototype.copy = function() {
+ var result = new List();
+ var cursor = this.head;
+
+ while (cursor !== null) {
+ result.insert(createItem(cursor.data));
+ cursor = cursor.next;
+ }
+
+ return result;
+};
+
+List.prototype.prepend = function(item) {
+ // head
+ // ^
+ // item
+ this.updateCursors(null, item, this.head, item);
+
+ // insert to the beginning of the list
+ if (this.head !== null) {
+ // new item <- first item
+ this.head.prev = item;
+
+ // new item -> first item
+ item.next = this.head;
+ } else {
+ // if list has no head, then it also has no tail
+ // in this case tail points to the new item
+ this.tail = item;
+ }
+
+ // head always points to new item
+ this.head = item;
+
+ return this;
+};
+
+List.prototype.prependData = function(data) {
+ return this.prepend(createItem(data));
+};
+
+List.prototype.append = function(item) {
+ return this.insert(item);
+};
+
+List.prototype.appendData = function(data) {
+ return this.insert(createItem(data));
+};
+
+List.prototype.insert = function(item, before) {
+ if (before !== undefined && before !== null) {
+ // prev before
+ // ^
+ // item
+ this.updateCursors(before.prev, item, before, item);
+
+ if (before.prev === null) {
+ // insert to the beginning of list
+ if (this.head !== before) {
+ throw new Error('before doesn\'t belong to list');
+ }
+
+ // since head points to before therefore list doesn't empty
+ // no need to check tail
+ this.head = item;
+ before.prev = item;
+ item.next = before;
+
+ this.updateCursors(null, item);
+ } else {
+
+ // insert between two items
+ before.prev.next = item;
+ item.prev = before.prev;
+
+ before.prev = item;
+ item.next = before;
+ }
+ } else {
+ // tail
+ // ^
+ // item
+ this.updateCursors(this.tail, item, null, item);
+
+ // insert to the ending of the list
+ if (this.tail !== null) {
+ // last item -> new item
+ this.tail.next = item;
+
+ // last item <- new item
+ item.prev = this.tail;
+ } else {
+ // if list has no tail, then it also has no head
+ // in this case head points to new item
+ this.head = item;
+ }
+
+ // tail always points to new item
+ this.tail = item;
+ }
+
+ return this;
+};
+
+List.prototype.insertData = function(data, before) {
+ return this.insert(createItem(data), before);
+};
+
+List.prototype.remove = function(item) {
+ // item
+ // ^
+ // prev next
+ this.updateCursors(item, item.prev, item, item.next);
+
+ if (item.prev !== null) {
+ item.prev.next = item.next;
+ } else {
+ if (this.head !== item) {
+ throw new Error('item doesn\'t belong to list');
+ }
+
+ this.head = item.next;
+ }
+
+ if (item.next !== null) {
+ item.next.prev = item.prev;
+ } else {
+ if (this.tail !== item) {
+ throw new Error('item doesn\'t belong to list');
+ }
+
+ this.tail = item.prev;
+ }
+
+ item.prev = null;
+ item.next = null;
+
+ return item;
+};
+
+List.prototype.push = function(data) {
+ this.insert(createItem(data));
+};
+
+List.prototype.pop = function() {
+ if (this.tail !== null) {
+ return this.remove(this.tail);
+ }
+};
+
+List.prototype.unshift = function(data) {
+ this.prepend(createItem(data));
+};
+
+List.prototype.shift = function() {
+ if (this.head !== null) {
+ return this.remove(this.head);
+ }
+};
+
+List.prototype.prependList = function(list) {
+ return this.insertList(list, this.head);
+};
+
+List.prototype.appendList = function(list) {
+ return this.insertList(list);
+};
+
+List.prototype.insertList = function(list, before) {
+ // ignore empty lists
+ if (list.head === null) {
+ return this;
+ }
+
+ if (before !== undefined && before !== null) {
+ this.updateCursors(before.prev, list.tail, before, list.head);
+
+ // insert in the middle of dist list
+ if (before.prev !== null) {
+ // before.prev <-> list.head
+ before.prev.next = list.head;
+ list.head.prev = before.prev;
+ } else {
+ this.head = list.head;
+ }
+
+ before.prev = list.tail;
+ list.tail.next = before;
+ } else {
+ this.updateCursors(this.tail, list.tail, null, list.head);
+
+ // insert to end of the list
+ if (this.tail !== null) {
+ // if destination list has a tail, then it also has a head,
+ // but head doesn't change
+
+ // dest tail -> source head
+ this.tail.next = list.head;
+
+ // dest tail <- source head
+ list.head.prev = this.tail;
+ } else {
+ // if list has no a tail, then it also has no a head
+ // in this case points head to new item
+ this.head = list.head;
+ }
+
+ // tail always start point to new item
+ this.tail = list.tail;
+ }
+
+ list.head = null;
+ list.tail = null;
+
+ return this;
+};
+
+List.prototype.replace = function(oldItem, newItemOrList) {
+ if ('head' in newItemOrList) {
+ this.insertList(newItemOrList, oldItem);
+ } else {
+ this.insert(newItemOrList, oldItem);
+ }
+
+ this.remove(oldItem);
+};
+
+module.exports = List;
diff --git a/node_modules/css-tree/lib/common/OffsetToLocation.js b/node_modules/css-tree/lib/common/OffsetToLocation.js
new file mode 100644
index 0000000..eee8228
--- /dev/null
+++ b/node_modules/css-tree/lib/common/OffsetToLocation.js
@@ -0,0 +1,91 @@
+var adoptBuffer = require('./adopt-buffer');
+var isBOM = require('../tokenizer').isBOM;
+
+var N = 10;
+var F = 12;
+var R = 13;
+
+function computeLinesAndColumns(host, source) {
+ var sourceLength = source.length;
+ var lines = adoptBuffer(host.lines, sourceLength); // +1
+ var line = host.startLine;
+ var columns = adoptBuffer(host.columns, sourceLength);
+ var column = host.startColumn;
+ var startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0;
+
+ for (var i = startOffset; i < sourceLength; i++) { // -1
+ var code = source.charCodeAt(i);
+
+ lines[i] = line;
+ columns[i] = column++;
+
+ if (code === N || code === R || code === F) {
+ if (code === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) {
+ i++;
+ lines[i] = line;
+ columns[i] = column;
+ }
+
+ line++;
+ column = 1;
+ }
+ }
+
+ lines[i] = line;
+ columns[i] = column;
+
+ host.lines = lines;
+ host.columns = columns;
+}
+
+var OffsetToLocation = function() {
+ this.lines = null;
+ this.columns = null;
+ this.linesAndColumnsComputed = false;
+};
+
+OffsetToLocation.prototype = {
+ setSource: function(source, startOffset, startLine, startColumn) {
+ this.source = source;
+ this.startOffset = typeof startOffset === 'undefined' ? 0 : startOffset;
+ this.startLine = typeof startLine === 'undefined' ? 1 : startLine;
+ this.startColumn = typeof startColumn === 'undefined' ? 1 : startColumn;
+ this.linesAndColumnsComputed = false;
+ },
+
+ ensureLinesAndColumnsComputed: function() {
+ if (!this.linesAndColumnsComputed) {
+ computeLinesAndColumns(this, this.source);
+ this.linesAndColumnsComputed = true;
+ }
+ },
+ getLocation: function(offset, filename) {
+ this.ensureLinesAndColumnsComputed();
+
+ return {
+ source: filename,
+ offset: this.startOffset + offset,
+ line: this.lines[offset],
+ column: this.columns[offset]
+ };
+ },
+ getLocationRange: function(start, end, filename) {
+ this.ensureLinesAndColumnsComputed();
+
+ return {
+ source: filename,
+ start: {
+ offset: this.startOffset + start,
+ line: this.lines[start],
+ column: this.columns[start]
+ },
+ end: {
+ offset: this.startOffset + end,
+ line: this.lines[end],
+ column: this.columns[end]
+ }
+ };
+ }
+};
+
+module.exports = OffsetToLocation;
diff --git a/node_modules/css-tree/lib/common/SyntaxError.js b/node_modules/css-tree/lib/common/SyntaxError.js
new file mode 100644
index 0000000..0cbf16a
--- /dev/null
+++ b/node_modules/css-tree/lib/common/SyntaxError.js
@@ -0,0 +1,82 @@
+var createCustomError = require('../utils/createCustomError');
+var MAX_LINE_LENGTH = 100;
+var OFFSET_CORRECTION = 60;
+var TAB_REPLACEMENT = ' ';
+
+function sourceFragment(error, extraLines) {
+ function processLines(start, end) {
+ return lines.slice(start, end).map(function(line, idx) {
+ var num = String(start + idx + 1);
+
+ while (num.length < maxNumLength) {
+ num = ' ' + num;
+ }
+
+ return num + ' |' + line;
+ }).join('\n');
+ }
+
+ var lines = error.source.split(/\r\n?|\n|\f/);
+ var line = error.line;
+ var column = error.column;
+ var startLine = Math.max(1, line - extraLines) - 1;
+ var endLine = Math.min(line + extraLines, lines.length + 1);
+ var maxNumLength = Math.max(4, String(endLine).length) + 1;
+ var cutLeft = 0;
+
+ // column correction according to replaced tab before column
+ column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
+
+ if (column > MAX_LINE_LENGTH) {
+ cutLeft = column - OFFSET_CORRECTION + 3;
+ column = OFFSET_CORRECTION - 2;
+ }
+
+ for (var i = startLine; i <= endLine; i++) {
+ if (i >= 0 && i < lines.length) {
+ lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
+ lines[i] =
+ (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
+ lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
+ (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
+ }
+ }
+
+ return [
+ processLines(startLine, line),
+ new Array(column + maxNumLength + 2).join('-') + '^',
+ processLines(line, endLine)
+ ].filter(Boolean).join('\n');
+}
+
+var SyntaxError = function(message, source, offset, line, column) {
+ var error = createCustomError('SyntaxError', message);
+
+ error.source = source;
+ error.offset = offset;
+ error.line = line;
+ error.column = column;
+
+ error.sourceFragment = function(extraLines) {
+ return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
+ };
+ Object.defineProperty(error, 'formattedMessage', {
+ get: function() {
+ return (
+ 'Parse error: ' + error.message + '\n' +
+ sourceFragment(error, 2)
+ );
+ }
+ });
+
+ // for backward capability
+ error.parseError = {
+ offset: offset,
+ line: line,
+ column: column
+ };
+
+ return error;
+};
+
+module.exports = SyntaxError;
diff --git a/node_modules/css-tree/lib/common/TokenStream.js b/node_modules/css-tree/lib/common/TokenStream.js
new file mode 100644
index 0000000..c41ed1b
--- /dev/null
+++ b/node_modules/css-tree/lib/common/TokenStream.js
@@ -0,0 +1,219 @@
+var constants = require('../tokenizer/const');
+var TYPE = constants.TYPE;
+var NAME = constants.NAME;
+
+var utils = require('../tokenizer/utils');
+var cmpStr = utils.cmpStr;
+
+var EOF = TYPE.EOF;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+
+var OFFSET_MASK = 0x00FFFFFF;
+var TYPE_SHIFT = 24;
+
+var TokenStream = function() {
+ this.offsetAndType = null;
+ this.balance = null;
+
+ this.reset();
+};
+
+TokenStream.prototype = {
+ reset: function() {
+ this.eof = false;
+ this.tokenIndex = -1;
+ this.tokenType = 0;
+ this.tokenStart = this.firstCharOffset;
+ this.tokenEnd = this.firstCharOffset;
+ },
+
+ lookupType: function(offset) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return this.offsetAndType[offset] >> TYPE_SHIFT;
+ }
+
+ return EOF;
+ },
+ lookupOffset: function(offset) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return this.offsetAndType[offset - 1] & OFFSET_MASK;
+ }
+
+ return this.source.length;
+ },
+ lookupValue: function(offset, referenceStr) {
+ offset += this.tokenIndex;
+
+ if (offset < this.tokenCount) {
+ return cmpStr(
+ this.source,
+ this.offsetAndType[offset - 1] & OFFSET_MASK,
+ this.offsetAndType[offset] & OFFSET_MASK,
+ referenceStr
+ );
+ }
+
+ return false;
+ },
+ getTokenStart: function(tokenIndex) {
+ if (tokenIndex === this.tokenIndex) {
+ return this.tokenStart;
+ }
+
+ if (tokenIndex > 0) {
+ return tokenIndex < this.tokenCount
+ ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK
+ : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
+ }
+
+ return this.firstCharOffset;
+ },
+
+ // TODO: -> skipUntilBalanced
+ getRawLength: function(startToken, mode) {
+ var cursor = startToken;
+ var balanceEnd;
+ var offset = this.offsetAndType[Math.max(cursor - 1, 0)] & OFFSET_MASK;
+ var type;
+
+ loop:
+ for (; cursor < this.tokenCount; cursor++) {
+ balanceEnd = this.balance[cursor];
+
+ // stop scanning on balance edge that points to offset before start token
+ if (balanceEnd < startToken) {
+ break loop;
+ }
+
+ type = this.offsetAndType[cursor] >> TYPE_SHIFT;
+
+ // check token is stop type
+ switch (mode(type, this.source, offset)) {
+ case 1:
+ break loop;
+
+ case 2:
+ cursor++;
+ break loop;
+
+ default:
+ // fast forward to the end of balanced block
+ if (this.balance[balanceEnd] === cursor) {
+ cursor = balanceEnd;
+ }
+
+ offset = this.offsetAndType[cursor] & OFFSET_MASK;
+ }
+ }
+
+ return cursor - this.tokenIndex;
+ },
+ isBalanceEdge: function(pos) {
+ return this.balance[this.tokenIndex] < pos;
+ },
+ isDelim: function(code, offset) {
+ if (offset) {
+ return (
+ this.lookupType(offset) === TYPE.Delim &&
+ this.source.charCodeAt(this.lookupOffset(offset)) === code
+ );
+ }
+
+ return (
+ this.tokenType === TYPE.Delim &&
+ this.source.charCodeAt(this.tokenStart) === code
+ );
+ },
+
+ getTokenValue: function() {
+ return this.source.substring(this.tokenStart, this.tokenEnd);
+ },
+ getTokenLength: function() {
+ return this.tokenEnd - this.tokenStart;
+ },
+ substrToCursor: function(start) {
+ return this.source.substring(start, this.tokenStart);
+ },
+
+ skipWS: function() {
+ for (var i = this.tokenIndex, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
+ if ((this.offsetAndType[i] >> TYPE_SHIFT) !== WHITESPACE) {
+ break;
+ }
+ }
+
+ if (skipTokenCount > 0) {
+ this.skip(skipTokenCount);
+ }
+ },
+ skipSC: function() {
+ while (this.tokenType === WHITESPACE || this.tokenType === COMMENT) {
+ this.next();
+ }
+ },
+ skip: function(tokenCount) {
+ var next = this.tokenIndex + tokenCount;
+
+ if (next < this.tokenCount) {
+ this.tokenIndex = next;
+ this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
+ next = this.offsetAndType[next];
+ this.tokenType = next >> TYPE_SHIFT;
+ this.tokenEnd = next & OFFSET_MASK;
+ } else {
+ this.tokenIndex = this.tokenCount;
+ this.next();
+ }
+ },
+ next: function() {
+ var next = this.tokenIndex + 1;
+
+ if (next < this.tokenCount) {
+ this.tokenIndex = next;
+ this.tokenStart = this.tokenEnd;
+ next = this.offsetAndType[next];
+ this.tokenType = next >> TYPE_SHIFT;
+ this.tokenEnd = next & OFFSET_MASK;
+ } else {
+ this.tokenIndex = this.tokenCount;
+ this.eof = true;
+ this.tokenType = EOF;
+ this.tokenStart = this.tokenEnd = this.source.length;
+ }
+ },
+
+ forEachToken(fn) {
+ for (var i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {
+ var start = offset;
+ var item = this.offsetAndType[i];
+ var end = item & OFFSET_MASK;
+ var type = item >> TYPE_SHIFT;
+
+ offset = end;
+
+ fn(type, start, end, i);
+ }
+ },
+
+ dump() {
+ var tokens = new Array(this.tokenCount);
+
+ this.forEachToken((type, start, end, index) => {
+ tokens[index] = {
+ idx: index,
+ type: NAME[type],
+ chunk: this.source.substring(start, end),
+ balance: this.balance[index]
+ };
+ });
+
+ return tokens;
+ }
+};
+
+module.exports = TokenStream;
diff --git a/node_modules/css-tree/lib/common/adopt-buffer.js b/node_modules/css-tree/lib/common/adopt-buffer.js
new file mode 100644
index 0000000..ef35b9b
--- /dev/null
+++ b/node_modules/css-tree/lib/common/adopt-buffer.js
@@ -0,0 +1,10 @@
+var MIN_SIZE = 16 * 1024;
+var SafeUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
+
+module.exports = function adoptBuffer(buffer, size) {
+ if (buffer === null || buffer.length < size) {
+ return new SafeUint32Array(Math.max(size + 1024, MIN_SIZE));
+ }
+
+ return buffer;
+};
diff --git a/node_modules/css-tree/lib/convertor/create.js b/node_modules/css-tree/lib/convertor/create.js
new file mode 100644
index 0000000..f2d1983
--- /dev/null
+++ b/node_modules/css-tree/lib/convertor/create.js
@@ -0,0 +1,28 @@
+var List = require('../common/List');
+
+module.exports = function createConvertors(walk) {
+ return {
+ fromPlainObject: function(ast) {
+ walk(ast, {
+ enter: function(node) {
+ if (node.children && node.children instanceof List === false) {
+ node.children = new List().fromArray(node.children);
+ }
+ }
+ });
+
+ return ast;
+ },
+ toPlainObject: function(ast) {
+ walk(ast, {
+ leave: function(node) {
+ if (node.children && node.children instanceof List) {
+ node.children = node.children.toArray();
+ }
+ }
+ });
+
+ return ast;
+ }
+ };
+};
diff --git a/node_modules/css-tree/lib/convertor/index.js b/node_modules/css-tree/lib/convertor/index.js
new file mode 100644
index 0000000..3248a57
--- /dev/null
+++ b/node_modules/css-tree/lib/convertor/index.js
@@ -0,0 +1,3 @@
+var createConvertor = require('./create');
+
+module.exports = createConvertor(require('../walker'));
diff --git a/node_modules/css-tree/lib/definition-syntax/SyntaxError.js b/node_modules/css-tree/lib/definition-syntax/SyntaxError.js
new file mode 100644
index 0000000..1f2f051
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/SyntaxError.js
@@ -0,0 +1,14 @@
+var createCustomError = require('../utils/createCustomError');
+
+module.exports = function SyntaxError(message, input, offset) {
+ var error = createCustomError('SyntaxError', message);
+
+ error.input = input;
+ error.offset = offset;
+ error.rawMessage = message;
+ error.message = error.rawMessage + '\n' +
+ ' ' + error.input + '\n' +
+ '--' + new Array((error.offset || error.input.length) + 1).join('-') + '^';
+
+ return error;
+};
diff --git a/node_modules/css-tree/lib/definition-syntax/generate.js b/node_modules/css-tree/lib/definition-syntax/generate.js
new file mode 100644
index 0000000..786ad2a
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/generate.js
@@ -0,0 +1,129 @@
+function noop(value) {
+ return value;
+}
+
+function generateMultiplier(multiplier) {
+ if (multiplier.min === 0 && multiplier.max === 0) {
+ return '*';
+ }
+
+ if (multiplier.min === 0 && multiplier.max === 1) {
+ return '?';
+ }
+
+ if (multiplier.min === 1 && multiplier.max === 0) {
+ return multiplier.comma ? '#' : '+';
+ }
+
+ if (multiplier.min === 1 && multiplier.max === 1) {
+ return '';
+ }
+
+ return (
+ (multiplier.comma ? '#' : '') +
+ (multiplier.min === multiplier.max
+ ? '{' + multiplier.min + '}'
+ : '{' + multiplier.min + ',' + (multiplier.max !== 0 ? multiplier.max : '') + '}'
+ )
+ );
+}
+
+function generateTypeOpts(node) {
+ switch (node.type) {
+ case 'Range':
+ return (
+ ' [' +
+ (node.min === null ? '-∞' : node.min) +
+ ',' +
+ (node.max === null ? '∞' : node.max) +
+ ']'
+ );
+
+ default:
+ throw new Error('Unknown node type `' + node.type + '`');
+ }
+}
+
+function generateSequence(node, decorate, forceBraces, compact) {
+ var combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';
+ var result = node.terms.map(function(term) {
+ return generate(term, decorate, forceBraces, compact);
+ }).join(combinator);
+
+ if (node.explicit || forceBraces) {
+ result = (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');
+ }
+
+ return result;
+}
+
+function generate(node, decorate, forceBraces, compact) {
+ var result;
+
+ switch (node.type) {
+ case 'Group':
+ result =
+ generateSequence(node, decorate, forceBraces, compact) +
+ (node.disallowEmpty ? '!' : '');
+ break;
+
+ case 'Multiplier':
+ // return since node is a composition
+ return (
+ generate(node.term, decorate, forceBraces, compact) +
+ decorate(generateMultiplier(node), node)
+ );
+
+ case 'Type':
+ result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';
+ break;
+
+ case 'Property':
+ result = '<\'' + node.name + '\'>';
+ break;
+
+ case 'Keyword':
+ result = node.name;
+ break;
+
+ case 'AtKeyword':
+ result = '@' + node.name;
+ break;
+
+ case 'Function':
+ result = node.name + '(';
+ break;
+
+ case 'String':
+ case 'Token':
+ result = node.value;
+ break;
+
+ case 'Comma':
+ result = ',';
+ break;
+
+ default:
+ throw new Error('Unknown node type `' + node.type + '`');
+ }
+
+ return decorate(result, node);
+}
+
+module.exports = function(node, options) {
+ var decorate = noop;
+ var forceBraces = false;
+ var compact = false;
+
+ if (typeof options === 'function') {
+ decorate = options;
+ } else if (options) {
+ forceBraces = Boolean(options.forceBraces);
+ compact = Boolean(options.compact);
+ if (typeof options.decorate === 'function') {
+ decorate = options.decorate;
+ }
+ }
+
+ return generate(node, decorate, forceBraces, compact);
+};
diff --git a/node_modules/css-tree/lib/definition-syntax/index.js b/node_modules/css-tree/lib/definition-syntax/index.js
new file mode 100644
index 0000000..282234a
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/index.js
@@ -0,0 +1,6 @@
+module.exports = {
+ SyntaxError: require('./SyntaxError'),
+ parse: require('./parse'),
+ generate: require('./generate'),
+ walk: require('./walk')
+};
diff --git a/node_modules/css-tree/lib/definition-syntax/parse.js b/node_modules/css-tree/lib/definition-syntax/parse.js
new file mode 100644
index 0000000..004ac57
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/parse.js
@@ -0,0 +1,568 @@
+var Tokenizer = require('./tokenizer');
+var TAB = 9;
+var N = 10;
+var F = 12;
+var R = 13;
+var SPACE = 32;
+var EXCLAMATIONMARK = 33; // !
+var NUMBERSIGN = 35; // #
+var AMPERSAND = 38; // &
+var APOSTROPHE = 39; // '
+var LEFTPARENTHESIS = 40; // (
+var RIGHTPARENTHESIS = 41; // )
+var ASTERISK = 42; // *
+var PLUSSIGN = 43; // +
+var COMMA = 44; // ,
+var HYPERMINUS = 45; // -
+var LESSTHANSIGN = 60; // <
+var GREATERTHANSIGN = 62; // >
+var QUESTIONMARK = 63; // ?
+var COMMERCIALAT = 64; // @
+var LEFTSQUAREBRACKET = 91; // [
+var RIGHTSQUAREBRACKET = 93; // ]
+var LEFTCURLYBRACKET = 123; // {
+var VERTICALLINE = 124; // |
+var RIGHTCURLYBRACKET = 125; // }
+var INFINITY = 8734; // ∞
+var NAME_CHAR = createCharMap(function(ch) {
+ return /[a-zA-Z0-9\-]/.test(ch);
+});
+var COMBINATOR_PRECEDENCE = {
+ ' ': 1,
+ '&&': 2,
+ '||': 3,
+ '|': 4
+};
+
+function createCharMap(fn) {
+ var array = typeof Uint32Array === 'function' ? new Uint32Array(128) : new Array(128);
+ for (var i = 0; i < 128; i++) {
+ array[i] = fn(String.fromCharCode(i)) ? 1 : 0;
+ }
+ return array;
+}
+
+function scanSpaces(tokenizer) {
+ return tokenizer.substringToPos(
+ tokenizer.findWsEnd(tokenizer.pos)
+ );
+}
+
+function scanWord(tokenizer) {
+ var end = tokenizer.pos;
+
+ for (; end < tokenizer.str.length; end++) {
+ var code = tokenizer.str.charCodeAt(end);
+ if (code >= 128 || NAME_CHAR[code] === 0) {
+ break;
+ }
+ }
+
+ if (tokenizer.pos === end) {
+ tokenizer.error('Expect a keyword');
+ }
+
+ return tokenizer.substringToPos(end);
+}
+
+function scanNumber(tokenizer) {
+ var end = tokenizer.pos;
+
+ for (; end < tokenizer.str.length; end++) {
+ var code = tokenizer.str.charCodeAt(end);
+ if (code < 48 || code > 57) {
+ break;
+ }
+ }
+
+ if (tokenizer.pos === end) {
+ tokenizer.error('Expect a number');
+ }
+
+ return tokenizer.substringToPos(end);
+}
+
+function scanString(tokenizer) {
+ var end = tokenizer.str.indexOf('\'', tokenizer.pos + 1);
+
+ if (end === -1) {
+ tokenizer.pos = tokenizer.str.length;
+ tokenizer.error('Expect an apostrophe');
+ }
+
+ return tokenizer.substringToPos(end + 1);
+}
+
+function readMultiplierRange(tokenizer) {
+ var min = null;
+ var max = null;
+
+ tokenizer.eat(LEFTCURLYBRACKET);
+
+ min = scanNumber(tokenizer);
+
+ if (tokenizer.charCode() === COMMA) {
+ tokenizer.pos++;
+ if (tokenizer.charCode() !== RIGHTCURLYBRACKET) {
+ max = scanNumber(tokenizer);
+ }
+ } else {
+ max = min;
+ }
+
+ tokenizer.eat(RIGHTCURLYBRACKET);
+
+ return {
+ min: Number(min),
+ max: max ? Number(max) : 0
+ };
+}
+
+function readMultiplier(tokenizer) {
+ var range = null;
+ var comma = false;
+
+ switch (tokenizer.charCode()) {
+ case ASTERISK:
+ tokenizer.pos++;
+
+ range = {
+ min: 0,
+ max: 0
+ };
+
+ break;
+
+ case PLUSSIGN:
+ tokenizer.pos++;
+
+ range = {
+ min: 1,
+ max: 0
+ };
+
+ break;
+
+ case QUESTIONMARK:
+ tokenizer.pos++;
+
+ range = {
+ min: 0,
+ max: 1
+ };
+
+ break;
+
+ case NUMBERSIGN:
+ tokenizer.pos++;
+
+ comma = true;
+
+ if (tokenizer.charCode() === LEFTCURLYBRACKET) {
+ range = readMultiplierRange(tokenizer);
+ } else {
+ range = {
+ min: 1,
+ max: 0
+ };
+ }
+
+ break;
+
+ case LEFTCURLYBRACKET:
+ range = readMultiplierRange(tokenizer);
+ break;
+
+ default:
+ return null;
+ }
+
+ return {
+ type: 'Multiplier',
+ comma: comma,
+ min: range.min,
+ max: range.max,
+ term: null
+ };
+}
+
+function maybeMultiplied(tokenizer, node) {
+ var multiplier = readMultiplier(tokenizer);
+
+ if (multiplier !== null) {
+ multiplier.term = node;
+ return multiplier;
+ }
+
+ return node;
+}
+
+function maybeToken(tokenizer) {
+ var ch = tokenizer.peek();
+
+ if (ch === '') {
+ return null;
+ }
+
+ return {
+ type: 'Token',
+ value: ch
+ };
+}
+
+function readProperty(tokenizer) {
+ var name;
+
+ tokenizer.eat(LESSTHANSIGN);
+ tokenizer.eat(APOSTROPHE);
+
+ name = scanWord(tokenizer);
+
+ tokenizer.eat(APOSTROPHE);
+ tokenizer.eat(GREATERTHANSIGN);
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Property',
+ name: name
+ });
+}
+
+// https://drafts.csswg.org/css-values-3/#numeric-ranges
+// 4.1. Range Restrictions and Range Definition Notation
+//
+// Range restrictions can be annotated in the numeric type notation using CSS bracketed
+// range notation—[min,max]—within the angle brackets, after the identifying keyword,
+// indicating a closed range between (and including) min and max.
+// For example, <integer [0, 10]> indicates an integer between 0 and 10, inclusive.
+function readTypeRange(tokenizer) {
+ // use null for Infinity to make AST format JSON serializable/deserializable
+ var min = null; // -Infinity
+ var max = null; // Infinity
+ var sign = 1;
+
+ tokenizer.eat(LEFTSQUAREBRACKET);
+
+ if (tokenizer.charCode() === HYPERMINUS) {
+ tokenizer.peek();
+ sign = -1;
+ }
+
+ if (sign == -1 && tokenizer.charCode() === INFINITY) {
+ tokenizer.peek();
+ } else {
+ min = sign * Number(scanNumber(tokenizer));
+ }
+
+ scanSpaces(tokenizer);
+ tokenizer.eat(COMMA);
+ scanSpaces(tokenizer);
+
+ if (tokenizer.charCode() === INFINITY) {
+ tokenizer.peek();
+ } else {
+ sign = 1;
+
+ if (tokenizer.charCode() === HYPERMINUS) {
+ tokenizer.peek();
+ sign = -1;
+ }
+
+ max = sign * Number(scanNumber(tokenizer));
+ }
+
+ tokenizer.eat(RIGHTSQUAREBRACKET);
+
+ // If no range is indicated, either by using the bracketed range notation
+ // or in the property description, then [−∞,∞] is assumed.
+ if (min === null && max === null) {
+ return null;
+ }
+
+ return {
+ type: 'Range',
+ min: min,
+ max: max
+ };
+}
+
+function readType(tokenizer) {
+ var name;
+ var opts = null;
+
+ tokenizer.eat(LESSTHANSIGN);
+ name = scanWord(tokenizer);
+
+ if (tokenizer.charCode() === LEFTPARENTHESIS &&
+ tokenizer.nextCharCode() === RIGHTPARENTHESIS) {
+ tokenizer.pos += 2;
+ name += '()';
+ }
+
+ if (tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos)) === LEFTSQUAREBRACKET) {
+ scanSpaces(tokenizer);
+ opts = readTypeRange(tokenizer);
+ }
+
+ tokenizer.eat(GREATERTHANSIGN);
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Type',
+ name: name,
+ opts: opts
+ });
+}
+
+function readKeywordOrFunction(tokenizer) {
+ var name;
+
+ name = scanWord(tokenizer);
+
+ if (tokenizer.charCode() === LEFTPARENTHESIS) {
+ tokenizer.pos++;
+
+ return {
+ type: 'Function',
+ name: name
+ };
+ }
+
+ return maybeMultiplied(tokenizer, {
+ type: 'Keyword',
+ name: name
+ });
+}
+
+function regroupTerms(terms, combinators) {
+ function createGroup(terms, combinator) {
+ return {
+ type: 'Group',
+ terms: terms,
+ combinator: combinator,
+ disallowEmpty: false,
+ explicit: false
+ };
+ }
+
+ combinators = Object.keys(combinators).sort(function(a, b) {
+ return COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b];
+ });
+
+ while (combinators.length > 0) {
+ var combinator = combinators.shift();
+ for (var i = 0, subgroupStart = 0; i < terms.length; i++) {
+ var term = terms[i];
+ if (term.type === 'Combinator') {
+ if (term.value === combinator) {
+ if (subgroupStart === -1) {
+ subgroupStart = i - 1;
+ }
+ terms.splice(i, 1);
+ i--;
+ } else {
+ if (subgroupStart !== -1 && i - subgroupStart > 1) {
+ terms.splice(
+ subgroupStart,
+ i - subgroupStart,
+ createGroup(terms.slice(subgroupStart, i), combinator)
+ );
+ i = subgroupStart + 1;
+ }
+ subgroupStart = -1;
+ }
+ }
+ }
+
+ if (subgroupStart !== -1 && combinators.length) {
+ terms.splice(
+ subgroupStart,
+ i - subgroupStart,
+ createGroup(terms.slice(subgroupStart, i), combinator)
+ );
+ }
+ }
+
+ return combinator;
+}
+
+function readImplicitGroup(tokenizer) {
+ var terms = [];
+ var combinators = {};
+ var token;
+ var prevToken = null;
+ var prevTokenPos = tokenizer.pos;
+
+ while (token = peek(tokenizer)) {
+ if (token.type !== 'Spaces') {
+ if (token.type === 'Combinator') {
+ // check for combinator in group beginning and double combinator sequence
+ if (prevToken === null || prevToken.type === 'Combinator') {
+ tokenizer.pos = prevTokenPos;
+ tokenizer.error('Unexpected combinator');
+ }
+
+ combinators[token.value] = true;
+ } else if (prevToken !== null && prevToken.type !== 'Combinator') {
+ combinators[' '] = true; // a b
+ terms.push({
+ type: 'Combinator',
+ value: ' '
+ });
+ }
+
+ terms.push(token);
+ prevToken = token;
+ prevTokenPos = tokenizer.pos;
+ }
+ }
+
+ // check for combinator in group ending
+ if (prevToken !== null && prevToken.type === 'Combinator') {
+ tokenizer.pos -= prevTokenPos;
+ tokenizer.error('Unexpected combinator');
+ }
+
+ return {
+ type: 'Group',
+ terms: terms,
+ combinator: regroupTerms(terms, combinators) || ' ',
+ disallowEmpty: false,
+ explicit: false
+ };
+}
+
+function readGroup(tokenizer) {
+ var result;
+
+ tokenizer.eat(LEFTSQUAREBRACKET);
+ result = readImplicitGroup(tokenizer);
+ tokenizer.eat(RIGHTSQUAREBRACKET);
+
+ result.explicit = true;
+
+ if (tokenizer.charCode() === EXCLAMATIONMARK) {
+ tokenizer.pos++;
+ result.disallowEmpty = true;
+ }
+
+ return result;
+}
+
+function peek(tokenizer) {
+ var code = tokenizer.charCode();
+
+ if (code < 128 && NAME_CHAR[code] === 1) {
+ return readKeywordOrFunction(tokenizer);
+ }
+
+ switch (code) {
+ case RIGHTSQUAREBRACKET:
+ // don't eat, stop scan a group
+ break;
+
+ case LEFTSQUAREBRACKET:
+ return maybeMultiplied(tokenizer, readGroup(tokenizer));
+
+ case LESSTHANSIGN:
+ return tokenizer.nextCharCode() === APOSTROPHE
+ ? readProperty(tokenizer)
+ : readType(tokenizer);
+
+ case VERTICALLINE:
+ return {
+ type: 'Combinator',
+ value: tokenizer.substringToPos(
+ tokenizer.nextCharCode() === VERTICALLINE
+ ? tokenizer.pos + 2
+ : tokenizer.pos + 1
+ )
+ };
+
+ case AMPERSAND:
+ tokenizer.pos++;
+ tokenizer.eat(AMPERSAND);
+
+ return {
+ type: 'Combinator',
+ value: '&&'
+ };
+
+ case COMMA:
+ tokenizer.pos++;
+ return {
+ type: 'Comma'
+ };
+
+ case APOSTROPHE:
+ return maybeMultiplied(tokenizer, {
+ type: 'String',
+ value: scanString(tokenizer)
+ });
+
+ case SPACE:
+ case TAB:
+ case N:
+ case R:
+ case F:
+ return {
+ type: 'Spaces',
+ value: scanSpaces(tokenizer)
+ };
+
+ case COMMERCIALAT:
+ code = tokenizer.nextCharCode();
+
+ if (code < 128 && NAME_CHAR[code] === 1) {
+ tokenizer.pos++;
+ return {
+ type: 'AtKeyword',
+ name: scanWord(tokenizer)
+ };
+ }
+
+ return maybeToken(tokenizer);
+
+ case ASTERISK:
+ case PLUSSIGN:
+ case QUESTIONMARK:
+ case NUMBERSIGN:
+ case EXCLAMATIONMARK:
+ // prohibited tokens (used as a multiplier start)
+ break;
+
+ case LEFTCURLYBRACKET:
+ // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting
+ // check next char isn't a number, because it's likely a disjoined multiplier
+ code = tokenizer.nextCharCode();
+
+ if (code < 48 || code > 57) {
+ return maybeToken(tokenizer);
+ }
+
+ break;
+
+ default:
+ return maybeToken(tokenizer);
+ }
+}
+
+function parse(source) {
+ var tokenizer = new Tokenizer(source);
+ var result = readImplicitGroup(tokenizer);
+
+ if (tokenizer.pos !== source.length) {
+ tokenizer.error('Unexpected input');
+ }
+
+ // reduce redundant groups with single group term
+ if (result.terms.length === 1 && result.terms[0].type === 'Group') {
+ result = result.terms[0];
+ }
+
+ return result;
+}
+
+// warm up parse to elimitate code branches that never execute
+// fix soft deoptimizations (insufficient type feedback)
+parse('[a&&<b>#|<\'c\'>*||e() f{2} /,(% g#{1,2} h{2,})]!');
+
+module.exports = parse;
diff --git a/node_modules/css-tree/lib/definition-syntax/tokenizer.js b/node_modules/css-tree/lib/definition-syntax/tokenizer.js
new file mode 100644
index 0000000..81ee681
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/tokenizer.js
@@ -0,0 +1,55 @@
+var SyntaxError = require('./SyntaxError');
+
+var TAB = 9;
+var N = 10;
+var F = 12;
+var R = 13;
+var SPACE = 32;
+
+var Tokenizer = function(str) {
+ this.str = str;
+ this.pos = 0;
+};
+
+Tokenizer.prototype = {
+ charCodeAt: function(pos) {
+ return pos < this.str.length ? this.str.charCodeAt(pos) : 0;
+ },
+ charCode: function() {
+ return this.charCodeAt(this.pos);
+ },
+ nextCharCode: function() {
+ return this.charCodeAt(this.pos + 1);
+ },
+ nextNonWsCode: function(pos) {
+ return this.charCodeAt(this.findWsEnd(pos));
+ },
+ findWsEnd: function(pos) {
+ for (; pos < this.str.length; pos++) {
+ var code = this.str.charCodeAt(pos);
+ if (code !== R && code !== N && code !== F && code !== SPACE && code !== TAB) {
+ break;
+ }
+ }
+
+ return pos;
+ },
+ substringToPos: function(end) {
+ return this.str.substring(this.pos, this.pos = end);
+ },
+ eat: function(code) {
+ if (this.charCode() !== code) {
+ this.error('Expect `' + String.fromCharCode(code) + '`');
+ }
+
+ this.pos++;
+ },
+ peek: function() {
+ return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';
+ },
+ error: function(message) {
+ throw new SyntaxError(message, this.str, this.pos);
+ }
+};
+
+module.exports = Tokenizer;
diff --git a/node_modules/css-tree/lib/definition-syntax/walk.js b/node_modules/css-tree/lib/definition-syntax/walk.js
new file mode 100644
index 0000000..7ba80e9
--- /dev/null
+++ b/node_modules/css-tree/lib/definition-syntax/walk.js
@@ -0,0 +1,52 @@
+var noop = function() {};
+
+function ensureFunction(value) {
+ return typeof value === 'function' ? value : noop;
+}
+
+module.exports = function(node, options, context) {
+ function walk(node) {
+ enter.call(context, node);
+
+ switch (node.type) {
+ case 'Group':
+ node.terms.forEach(walk);
+ break;
+
+ case 'Multiplier':
+ walk(node.term);
+ break;
+
+ case 'Type':
+ case 'Property':
+ case 'Keyword':
+ case 'AtKeyword':
+ case 'Function':
+ case 'String':
+ case 'Token':
+ case 'Comma':
+ break;
+
+ default:
+ throw new Error('Unknown type: ' + node.type);
+ }
+
+ leave.call(context, node);
+ }
+
+ var enter = noop;
+ var leave = noop;
+
+ if (typeof options === 'function') {
+ enter = options;
+ } else if (options) {
+ enter = ensureFunction(options.enter);
+ leave = ensureFunction(options.leave);
+ }
+
+ if (enter === noop && leave === noop) {
+ throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+ }
+
+ walk(node, context);
+};
diff --git a/node_modules/css-tree/lib/generator/create.js b/node_modules/css-tree/lib/generator/create.js
new file mode 100644
index 0000000..90fb973
--- /dev/null
+++ b/node_modules/css-tree/lib/generator/create.js
@@ -0,0 +1,66 @@
+var sourceMap = require('./sourceMap');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function processChildren(node, delimeter) {
+ var list = node.children;
+ var prev = null;
+
+ if (typeof delimeter !== 'function') {
+ list.forEach(this.node, this);
+ } else {
+ list.forEach(function(node) {
+ if (prev !== null) {
+ delimeter.call(this, prev);
+ }
+
+ this.node(node);
+ prev = node;
+ }, this);
+ }
+}
+
+module.exports = function createGenerator(config) {
+ function processNode(node) {
+ if (hasOwnProperty.call(types, node.type)) {
+ types[node.type].call(this, node);
+ } else {
+ throw new Error('Unknown node type: ' + node.type);
+ }
+ }
+
+ var types = {};
+
+ if (config.node) {
+ for (var name in config.node) {
+ types[name] = config.node[name].generate;
+ }
+ }
+
+ return function(node, options) {
+ var buffer = '';
+ var handlers = {
+ children: processChildren,
+ node: processNode,
+ chunk: function(chunk) {
+ buffer += chunk;
+ },
+ result: function() {
+ return buffer;
+ }
+ };
+
+ if (options) {
+ if (typeof options.decorator === 'function') {
+ handlers = options.decorator(handlers);
+ }
+
+ if (options.sourceMap) {
+ handlers = sourceMap(handlers);
+ }
+ }
+
+ handlers.node(node);
+
+ return handlers.result();
+ };
+};
diff --git a/node_modules/css-tree/lib/generator/index.js b/node_modules/css-tree/lib/generator/index.js
new file mode 100644
index 0000000..5bd86a8
--- /dev/null
+++ b/node_modules/css-tree/lib/generator/index.js
@@ -0,0 +1,4 @@
+var createGenerator = require('./create');
+var config = require('../syntax/config/parser');
+
+module.exports = createGenerator(config);
diff --git a/node_modules/css-tree/lib/generator/sourceMap.js b/node_modules/css-tree/lib/generator/sourceMap.js
new file mode 100644
index 0000000..720c190
--- /dev/null
+++ b/node_modules/css-tree/lib/generator/sourceMap.js
@@ -0,0 +1,95 @@
+var SourceMapGenerator = require('source-map/lib/source-map-generator').SourceMapGenerator;
+var trackNodes = {
+ Atrule: true,
+ Selector: true,
+ Declaration: true
+};
+
+module.exports = function generateSourceMap(handlers) {
+ var map = new SourceMapGenerator();
+ var line = 1;
+ var column = 0;
+ var generated = {
+ line: 1,
+ column: 0
+ };
+ var original = {
+ line: 0, // should be zero to add first mapping
+ column: 0
+ };
+ var sourceMappingActive = false;
+ var activatedGenerated = {
+ line: 1,
+ column: 0
+ };
+ var activatedMapping = {
+ generated: activatedGenerated
+ };
+
+ var handlersNode = handlers.node;
+ handlers.node = function(node) {
+ if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
+ var nodeLine = node.loc.start.line;
+ var nodeColumn = node.loc.start.column - 1;
+
+ if (original.line !== nodeLine ||
+ original.column !== nodeColumn) {
+ original.line = nodeLine;
+ original.column = nodeColumn;
+
+ generated.line = line;
+ generated.column = column;
+
+ if (sourceMappingActive) {
+ sourceMappingActive = false;
+ if (generated.line !== activatedGenerated.line ||
+ generated.column !== activatedGenerated.column) {
+ map.addMapping(activatedMapping);
+ }
+ }
+
+ sourceMappingActive = true;
+ map.addMapping({
+ source: node.loc.source,
+ original: original,
+ generated: generated
+ });
+ }
+ }
+
+ handlersNode.call(this, node);
+
+ if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
+ activatedGenerated.line = line;
+ activatedGenerated.column = column;
+ }
+ };
+
+ var handlersChunk = handlers.chunk;
+ handlers.chunk = function(chunk) {
+ for (var i = 0; i < chunk.length; i++) {
+ if (chunk.charCodeAt(i) === 10) { // \n
+ line++;
+ column = 0;
+ } else {
+ column++;
+ }
+ }
+
+ handlersChunk(chunk);
+ };
+
+ var handlersResult = handlers.result;
+ handlers.result = function() {
+ if (sourceMappingActive) {
+ map.addMapping(activatedMapping);
+ }
+
+ return {
+ css: handlersResult(),
+ map: map
+ };
+ };
+
+ return handlers;
+};
diff --git a/node_modules/css-tree/lib/index.js b/node_modules/css-tree/lib/index.js
new file mode 100644
index 0000000..7688ab9
--- /dev/null
+++ b/node_modules/css-tree/lib/index.js
@@ -0,0 +1 @@
+module.exports = require('./syntax');
diff --git a/node_modules/css-tree/lib/lexer/Lexer.js b/node_modules/css-tree/lib/lexer/Lexer.js
new file mode 100644
index 0000000..9484881
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/Lexer.js
@@ -0,0 +1,466 @@
+var SyntaxReferenceError = require('./error').SyntaxReferenceError;
+var SyntaxMatchError = require('./error').SyntaxMatchError;
+var names = require('../utils/names');
+var generic = require('./generic');
+var parse = require('../definition-syntax/parse');
+var generate = require('../definition-syntax/generate');
+var walk = require('../definition-syntax/walk');
+var prepareTokens = require('./prepare-tokens');
+var buildMatchGraph = require('./match-graph').buildMatchGraph;
+var matchAsTree = require('./match').matchAsTree;
+var trace = require('./trace');
+var search = require('./search');
+var getStructureFromConfig = require('./structure').getStructureFromConfig;
+var cssWideKeywords = buildMatchGraph('inherit | initial | unset');
+var cssWideKeywordsWithExpression = buildMatchGraph('inherit | initial | unset | <-ms-legacy-expression>');
+
+function dumpMapSyntax(map, compact, syntaxAsAst) {
+ var result = {};
+
+ for (var name in map) {
+ if (map[name].syntax) {
+ result[name] = syntaxAsAst
+ ? map[name].syntax
+ : generate(map[name].syntax, { compact: compact });
+ }
+ }
+
+ return result;
+}
+
+function dumpAtruleMapSyntax(map, compact, syntaxAsAst) {
+ const result = {};
+
+ for (const [name, atrule] of Object.entries(map)) {
+ result[name] = {
+ prelude: atrule.prelude && (
+ syntaxAsAst
+ ? atrule.prelude.syntax
+ : generate(atrule.prelude.syntax, { compact })
+ ),
+ descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)
+ };
+ }
+
+ return result;
+}
+
+function valueHasVar(tokens) {
+ for (var i = 0; i < tokens.length; i++) {
+ if (tokens[i].value.toLowerCase() === 'var(') {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function buildMatchResult(match, error, iterations) {
+ return {
+ matched: match,
+ iterations: iterations,
+ error: error,
+ getTrace: trace.getTrace,
+ isType: trace.isType,
+ isProperty: trace.isProperty,
+ isKeyword: trace.isKeyword
+ };
+}
+
+function matchSyntax(lexer, syntax, value, useCommon) {
+ var tokens = prepareTokens(value, lexer.syntax);
+ var result;
+
+ if (valueHasVar(tokens)) {
+ return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
+ }
+
+ if (useCommon) {
+ result = matchAsTree(tokens, lexer.valueCommonSyntax, lexer);
+ }
+
+ if (!useCommon || !result.match) {
+ result = matchAsTree(tokens, syntax.match, lexer);
+ if (!result.match) {
+ return buildMatchResult(
+ null,
+ new SyntaxMatchError(result.reason, syntax.syntax, value, result),
+ result.iterations
+ );
+ }
+ }
+
+ return buildMatchResult(result.match, null, result.iterations);
+}
+
+var Lexer = function(config, syntax, structure) {
+ this.valueCommonSyntax = cssWideKeywords;
+ this.syntax = syntax;
+ this.generic = false;
+ this.atrules = {};
+ this.properties = {};
+ this.types = {};
+ this.structure = structure || getStructureFromConfig(config);
+
+ if (config) {
+ if (config.types) {
+ for (var name in config.types) {
+ this.addType_(name, config.types[name]);
+ }
+ }
+
+ if (config.generic) {
+ this.generic = true;
+ for (var name in generic) {
+ this.addType_(name, generic[name]);
+ }
+ }
+
+ if (config.atrules) {
+ for (var name in config.atrules) {
+ this.addAtrule_(name, config.atrules[name]);
+ }
+ }
+
+ if (config.properties) {
+ for (var name in config.properties) {
+ this.addProperty_(name, config.properties[name]);
+ }
+ }
+ }
+};
+
+Lexer.prototype = {
+ structure: {},
+ checkStructure: function(ast) {
+ function collectWarning(node, message) {
+ warns.push({
+ node: node,
+ message: message
+ });
+ }
+
+ var structure = this.structure;
+ var warns = [];
+
+ this.syntax.walk(ast, function(node) {
+ if (structure.hasOwnProperty(node.type)) {
+ structure[node.type].check(node, collectWarning);
+ } else {
+ collectWarning(node, 'Unknown node type `' + node.type + '`');
+ }
+ });
+
+ return warns.length ? warns : false;
+ },
+
+ createDescriptor: function(syntax, type, name, parent = null) {
+ var ref = {
+ type: type,
+ name: name
+ };
+ var descriptor = {
+ type: type,
+ name: name,
+ parent: parent,
+ syntax: null,
+ match: null
+ };
+
+ if (typeof syntax === 'function') {
+ descriptor.match = buildMatchGraph(syntax, ref);
+ } else {
+ if (typeof syntax === 'string') {
+ // lazy parsing on first access
+ Object.defineProperty(descriptor, 'syntax', {
+ get: function() {
+ Object.defineProperty(descriptor, 'syntax', {
+ value: parse(syntax)
+ });
+
+ return descriptor.syntax;
+ }
+ });
+ } else {
+ descriptor.syntax = syntax;
+ }
+
+ // lazy graph build on first access
+ Object.defineProperty(descriptor, 'match', {
+ get: function() {
+ Object.defineProperty(descriptor, 'match', {
+ value: buildMatchGraph(descriptor.syntax, ref)
+ });
+
+ return descriptor.match;
+ }
+ });
+ }
+
+ return descriptor;
+ },
+ addAtrule_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.atrules[name] = {
+ type: 'Atrule',
+ name: name,
+ prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,
+ descriptors: syntax.descriptors
+ ? Object.keys(syntax.descriptors).reduce((res, descName) => {
+ res[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);
+ return res;
+ }, {})
+ : null
+ };
+ },
+ addProperty_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.properties[name] = this.createDescriptor(syntax, 'Property', name);
+ },
+ addType_: function(name, syntax) {
+ if (!syntax) {
+ return;
+ }
+
+ this.types[name] = this.createDescriptor(syntax, 'Type', name);
+
+ if (syntax === generic['-ms-legacy-expression']) {
+ this.valueCommonSyntax = cssWideKeywordsWithExpression;
+ }
+ },
+
+ checkAtruleName: function(atruleName) {
+ if (!this.getAtrule(atruleName)) {
+ return new SyntaxReferenceError('Unknown at-rule', '@' + atruleName);
+ }
+ },
+ checkAtrulePrelude: function(atruleName, prelude) {
+ let error = this.checkAtruleName(atruleName);
+
+ if (error) {
+ return error;
+ }
+
+ var atrule = this.getAtrule(atruleName);
+
+ if (!atrule.prelude && prelude) {
+ return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');
+ }
+
+ if (atrule.prelude && !prelude) {
+ return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');
+ }
+ },
+ checkAtruleDescriptorName: function(atruleName, descriptorName) {
+ let error = this.checkAtruleName(atruleName);
+
+ if (error) {
+ return error;
+ }
+
+ var atrule = this.getAtrule(atruleName);
+ var descriptor = names.keyword(descriptorName);
+
+ if (!atrule.descriptors) {
+ return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');
+ }
+
+ if (!atrule.descriptors[descriptor.name] &&
+ !atrule.descriptors[descriptor.basename]) {
+ return new SyntaxReferenceError('Unknown at-rule descriptor', descriptorName);
+ }
+ },
+ checkPropertyName: function(propertyName) {
+ var property = names.property(propertyName);
+
+ // don't match syntax for a custom property
+ if (property.custom) {
+ return new Error('Lexer matching doesn\'t applicable for custom properties');
+ }
+
+ if (!this.getProperty(propertyName)) {
+ return new SyntaxReferenceError('Unknown property', propertyName);
+ }
+ },
+
+ matchAtrulePrelude: function(atruleName, prelude) {
+ var error = this.checkAtrulePrelude(atruleName, prelude);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ if (!prelude) {
+ return buildMatchResult(null, null);
+ }
+
+ return matchSyntax(this, this.getAtrule(atruleName).prelude, prelude, false);
+ },
+ matchAtruleDescriptor: function(atruleName, descriptorName, value) {
+ var error = this.checkAtruleDescriptorName(atruleName, descriptorName);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ var atrule = this.getAtrule(atruleName);
+ var descriptor = names.keyword(descriptorName);
+
+ return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);
+ },
+ matchDeclaration: function(node) {
+ if (node.type !== 'Declaration') {
+ return buildMatchResult(null, new Error('Not a Declaration node'));
+ }
+
+ return this.matchProperty(node.property, node.value);
+ },
+ matchProperty: function(propertyName, value) {
+ var error = this.checkPropertyName(propertyName);
+
+ if (error) {
+ return buildMatchResult(null, error);
+ }
+
+ return matchSyntax(this, this.getProperty(propertyName), value, true);
+ },
+ matchType: function(typeName, value) {
+ var typeSyntax = this.getType(typeName);
+
+ if (!typeSyntax) {
+ return buildMatchResult(null, new SyntaxReferenceError('Unknown type', typeName));
+ }
+
+ return matchSyntax(this, typeSyntax, value, false);
+ },
+ match: function(syntax, value) {
+ if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {
+ return buildMatchResult(null, new SyntaxReferenceError('Bad syntax'));
+ }
+
+ if (typeof syntax === 'string' || !syntax.match) {
+ syntax = this.createDescriptor(syntax, 'Type', 'anonymous');
+ }
+
+ return matchSyntax(this, syntax, value, false);
+ },
+
+ findValueFragments: function(propertyName, value, type, name) {
+ return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
+ },
+ findDeclarationValueFragments: function(declaration, type, name) {
+ return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
+ },
+ findAllFragments: function(ast, type, name) {
+ var result = [];
+
+ this.syntax.walk(ast, {
+ visit: 'Declaration',
+ enter: function(declaration) {
+ result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
+ }.bind(this)
+ });
+
+ return result;
+ },
+
+ getAtrule: function(atruleName, fallbackBasename = true) {
+ var atrule = names.keyword(atruleName);
+ var atruleEntry = atrule.vendor && fallbackBasename
+ ? this.atrules[atrule.name] || this.atrules[atrule.basename]
+ : this.atrules[atrule.name];
+
+ return atruleEntry || null;
+ },
+ getAtrulePrelude: function(atruleName, fallbackBasename = true) {
+ const atrule = this.getAtrule(atruleName, fallbackBasename);
+
+ return atrule && atrule.prelude || null;
+ },
+ getAtruleDescriptor: function(atruleName, name) {
+ return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators
+ ? this.atrules[atruleName].declarators[name] || null
+ : null;
+ },
+ getProperty: function(propertyName, fallbackBasename = true) {
+ var property = names.property(propertyName);
+ var propertyEntry = property.vendor && fallbackBasename
+ ? this.properties[property.name] || this.properties[property.basename]
+ : this.properties[property.name];
+
+ return propertyEntry || null;
+ },
+ getType: function(name) {
+ return this.types.hasOwnProperty(name) ? this.types[name] : null;
+ },
+
+ validate: function() {
+ function validate(syntax, name, broken, descriptor) {
+ if (broken.hasOwnProperty(name)) {
+ return broken[name];
+ }
+
+ broken[name] = false;
+ if (descriptor.syntax !== null) {
+ walk(descriptor.syntax, function(node) {
+ if (node.type !== 'Type' && node.type !== 'Property') {
+ return;
+ }
+
+ var map = node.type === 'Type' ? syntax.types : syntax.properties;
+ var brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
+
+ if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
+ broken[name] = true;
+ }
+ }, this);
+ }
+ }
+
+ var brokenTypes = {};
+ var brokenProperties = {};
+
+ for (var key in this.types) {
+ validate(this, key, brokenTypes, this.types[key]);
+ }
+
+ for (var key in this.properties) {
+ validate(this, key, brokenProperties, this.properties[key]);
+ }
+
+ brokenTypes = Object.keys(brokenTypes).filter(function(name) {
+ return brokenTypes[name];
+ });
+ brokenProperties = Object.keys(brokenProperties).filter(function(name) {
+ return brokenProperties[name];
+ });
+
+ if (brokenTypes.length || brokenProperties.length) {
+ return {
+ types: brokenTypes,
+ properties: brokenProperties
+ };
+ }
+
+ return null;
+ },
+ dump: function(syntaxAsAst, pretty) {
+ return {
+ generic: this.generic,
+ types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),
+ properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),
+ atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)
+ };
+ },
+ toString: function() {
+ return JSON.stringify(this.dump());
+ }
+};
+
+module.exports = Lexer;
diff --git a/node_modules/css-tree/lib/lexer/error.js b/node_modules/css-tree/lib/lexer/error.js
new file mode 100644
index 0000000..2a6af15
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/error.js
@@ -0,0 +1,127 @@
+const createCustomError = require('../utils/createCustomError');
+const generate = require('../definition-syntax/generate');
+const defaultLoc = { offset: 0, line: 1, column: 1 };
+
+function locateMismatch(matchResult, node) {
+ const tokens = matchResult.tokens;
+ const longestMatch = matchResult.longestMatch;
+ const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null;
+ const badNode = mismatchNode !== node ? mismatchNode : null;
+ let mismatchOffset = 0;
+ let mismatchLength = 0;
+ let entries = 0;
+ let css = '';
+ let start;
+ let end;
+
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i].value;
+
+ if (i === longestMatch) {
+ mismatchLength = token.length;
+ mismatchOffset = css.length;
+ }
+
+ if (badNode !== null && tokens[i].node === badNode) {
+ if (i <= longestMatch) {
+ entries++;
+ } else {
+ entries = 0;
+ }
+ }
+
+ css += token;
+ }
+
+ if (longestMatch === tokens.length || entries > 1) { // last
+ start = fromLoc(badNode || node, 'end') || buildLoc(defaultLoc, css);
+ end = buildLoc(start);
+ } else {
+ start = fromLoc(badNode, 'start') ||
+ buildLoc(fromLoc(node, 'start') || defaultLoc, css.slice(0, mismatchOffset));
+ end = fromLoc(badNode, 'end') ||
+ buildLoc(start, css.substr(mismatchOffset, mismatchLength));
+ }
+
+ return {
+ css,
+ mismatchOffset,
+ mismatchLength,
+ start,
+ end
+ };
+}
+
+function fromLoc(node, point) {
+ const value = node && node.loc && node.loc[point];
+
+ if (value) {
+ return 'line' in value ? buildLoc(value) : value;
+ }
+
+ return null;
+}
+
+function buildLoc({ offset, line, column }, extra) {
+ const loc = {
+ offset,
+ line,
+ column
+ };
+
+ if (extra) {
+ const lines = extra.split(/\n|\r\n?|\f/);
+
+ loc.offset += extra.length;
+ loc.line += lines.length - 1;
+ loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1;
+ }
+
+ return loc;
+}
+
+const SyntaxReferenceError = function(type, referenceName) {
+ const error = createCustomError(
+ 'SyntaxReferenceError',
+ type + (referenceName ? ' `' + referenceName + '`' : '')
+ );
+
+ error.reference = referenceName;
+
+ return error;
+};
+
+const SyntaxMatchError = function(message, syntax, node, matchResult) {
+ const error = createCustomError('SyntaxMatchError', message);
+ const {
+ css,
+ mismatchOffset,
+ mismatchLength,
+ start,
+ end
+ } = locateMismatch(matchResult, node);
+
+ error.rawMessage = message;
+ error.syntax = syntax ? generate(syntax) : '<generic>';
+ error.css = css;
+ error.mismatchOffset = mismatchOffset;
+ error.mismatchLength = mismatchLength;
+ error.message = message + '\n' +
+ ' syntax: ' + error.syntax + '\n' +
+ ' value: ' + (css || '<empty string>') + '\n' +
+ ' --------' + new Array(error.mismatchOffset + 1).join('-') + '^';
+
+ Object.assign(error, start);
+ error.loc = {
+ source: (node && node.loc && node.loc.source) || '<unknown>',
+ start,
+ end
+ };
+
+ return error;
+};
+
+module.exports = {
+ SyntaxReferenceError,
+ SyntaxMatchError
+};
diff --git a/node_modules/css-tree/lib/lexer/generic-an-plus-b.js b/node_modules/css-tree/lib/lexer/generic-an-plus-b.js
new file mode 100644
index 0000000..7b8a818
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/generic-an-plus-b.js
@@ -0,0 +1,236 @@
+var isDigit = require('../tokenizer').isDigit;
+var cmpChar = require('../tokenizer').cmpChar;
+var TYPE = require('../tokenizer').TYPE;
+
+var DELIM = TYPE.Delim;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var N = 0x006E; // U+006E LATIN SMALL LETTER N (n)
+var DISALLOW_SIGN = true;
+var ALLOW_SIGN = false;
+
+function isDelim(token, code) {
+ return token !== null && token.type === DELIM && token.value.charCodeAt(0) === code;
+}
+
+function skipSC(token, offset, getNextToken) {
+ while (token !== null && (token.type === WHITESPACE || token.type === COMMENT)) {
+ token = getNextToken(++offset);
+ }
+
+ return offset;
+}
+
+function checkInteger(token, valueOffset, disallowSign, offset) {
+ if (!token) {
+ return 0;
+ }
+
+ var code = token.value.charCodeAt(valueOffset);
+
+ if (code === PLUSSIGN || code === HYPHENMINUS) {
+ if (disallowSign) {
+ // Number sign is not allowed
+ return 0;
+ }
+ valueOffset++;
+ }
+
+ for (; valueOffset < token.value.length; valueOffset++) {
+ if (!isDigit(token.value.charCodeAt(valueOffset))) {
+ // Integer is expected
+ return 0;
+ }
+ }
+
+ return offset + 1;
+}
+
+// ... <signed-integer>
+// ... ['+' | '-'] <signless-integer>
+function consumeB(token, offset_, getNextToken) {
+ var sign = false;
+ var offset = skipSC(token, offset_, getNextToken);
+
+ token = getNextToken(offset);
+
+ if (token === null) {
+ return offset_;
+ }
+
+ if (token.type !== NUMBER) {
+ if (isDelim(token, PLUSSIGN) || isDelim(token, HYPHENMINUS)) {
+ sign = true;
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ if (token === null && token.type !== NUMBER) {
+ return 0;
+ }
+ } else {
+ return offset_;
+ }
+ }
+
+ if (!sign) {
+ var code = token.value.charCodeAt(0);
+ if (code !== PLUSSIGN && code !== HYPHENMINUS) {
+ // Number sign is expected
+ return 0;
+ }
+ }
+
+ return checkInteger(token, sign ? 0 : 1, sign, offset);
+}
+
+// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+module.exports = function anPlusB(token, getNextToken) {
+ /* eslint-disable brace-style*/
+ var offset = 0;
+
+ if (!token) {
+ return 0;
+ }
+
+ // <integer>
+ if (token.type === NUMBER) {
+ return checkInteger(token, 0, ALLOW_SIGN, offset); // b
+ }
+
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ // -n- <signless-integer>
+ // <dashndashdigit-ident>
+ else if (token.type === IDENT && token.value.charCodeAt(0) === HYPHENMINUS) {
+ // expect 1st char is N
+ if (!cmpChar(token.value, 1, N)) {
+ return 0;
+ }
+
+ switch (token.value.length) {
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ case 2:
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+
+ // -n- <signless-integer>
+ case 3:
+ if (token.value.charCodeAt(2) !== HYPHENMINUS) {
+ return 0;
+ }
+
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+
+ // <dashndashdigit-ident>
+ default:
+ if (token.value.charCodeAt(2) !== HYPHENMINUS) {
+ return 0;
+ }
+
+ return checkInteger(token, 3, DISALLOW_SIGN, offset);
+ }
+ }
+
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ // '+'? n- <signless-integer>
+ // '+'? <ndashdigit-ident>
+ else if (token.type === IDENT || (isDelim(token, PLUSSIGN) && getNextToken(offset + 1).type === IDENT)) {
+ // just ignore a plus
+ if (token.type !== IDENT) {
+ token = getNextToken(++offset);
+ }
+
+ if (token === null || !cmpChar(token.value, 0, N)) {
+ return 0;
+ }
+
+ switch (token.value.length) {
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ case 1:
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+
+ // '+'? n- <signless-integer>
+ case 2:
+ if (token.value.charCodeAt(1) !== HYPHENMINUS) {
+ return 0;
+ }
+
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+
+ // '+'? <ndashdigit-ident>
+ default:
+ if (token.value.charCodeAt(1) !== HYPHENMINUS) {
+ return 0;
+ }
+
+ return checkInteger(token, 2, DISALLOW_SIGN, offset);
+ }
+ }
+
+ // <ndashdigit-dimension>
+ // <ndash-dimension> <signless-integer>
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ else if (token.type === DIMENSION) {
+ var code = token.value.charCodeAt(0);
+ var sign = code === PLUSSIGN || code === HYPHENMINUS ? 1 : 0;
+
+ for (var i = sign; i < token.value.length; i++) {
+ if (!isDigit(token.value.charCodeAt(i))) {
+ break;
+ }
+ }
+
+ if (i === sign) {
+ // Integer is expected
+ return 0;
+ }
+
+ if (!cmpChar(token.value, i, N)) {
+ return 0;
+ }
+
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ if (i + 1 === token.value.length) {
+ return consumeB(getNextToken(++offset), offset, getNextToken);
+ } else {
+ if (token.value.charCodeAt(i + 1) !== HYPHENMINUS) {
+ return 0;
+ }
+
+ // <ndash-dimension> <signless-integer>
+ if (i + 2 === token.value.length) {
+ offset = skipSC(getNextToken(++offset), offset, getNextToken);
+ token = getNextToken(offset);
+
+ return checkInteger(token, 0, DISALLOW_SIGN, offset);
+ }
+ // <ndashdigit-dimension>
+ else {
+ return checkInteger(token, i + 2, DISALLOW_SIGN, offset);
+ }
+ }
+ }
+
+ return 0;
+};
diff --git a/node_modules/css-tree/lib/lexer/generic-urange.js b/node_modules/css-tree/lib/lexer/generic-urange.js
new file mode 100644
index 0000000..2556d70
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/generic-urange.js
@@ -0,0 +1,159 @@
+var isHexDigit = require('../tokenizer').isHexDigit;
+var cmpChar = require('../tokenizer').cmpChar;
+var TYPE = require('../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var DELIM = TYPE.Delim;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)
+var U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+function isDelim(token, code) {
+ return token !== null && token.type === DELIM && token.value.charCodeAt(0) === code;
+}
+
+function startsWith(token, code) {
+ return token.value.charCodeAt(0) === code;
+}
+
+function hexSequence(token, offset, allowDash) {
+ for (var pos = offset, hexlen = 0; pos < token.value.length; pos++) {
+ var code = token.value.charCodeAt(pos);
+
+ if (code === HYPHENMINUS && allowDash && hexlen !== 0) {
+ if (hexSequence(token, offset + hexlen + 1, false) > 0) {
+ return 6; // dissallow following question marks
+ }
+
+ return 0; // dash at the ending of a hex sequence is not allowed
+ }
+
+ if (!isHexDigit(code)) {
+ return 0; // not a hex digit
+ }
+
+ if (++hexlen > 6) {
+ return 0; // too many hex digits
+ };
+ }
+
+ return hexlen;
+}
+
+function withQuestionMarkSequence(consumed, length, getNextToken) {
+ if (!consumed) {
+ return 0; // nothing consumed
+ }
+
+ while (isDelim(getNextToken(length), QUESTIONMARK)) {
+ if (++consumed > 6) {
+ return 0; // too many question marks
+ }
+
+ length++;
+ }
+
+ return length;
+}
+
+// https://drafts.csswg.org/css-syntax/#urange
+// Informally, the <urange> production has three forms:
+// U+0001
+// Defines a range consisting of a single code point, in this case the code point "1".
+// U+0001-00ff
+// Defines a range of codepoints between the first and the second value, in this case
+// the range between "1" and "ff" (255 in decimal) inclusive.
+// U+00??
+// Defines a range of codepoints where the "?" characters range over all hex digits,
+// in this case defining the same as the value U+0000-00ff.
+// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+//
+// <urange> =
+// u '+' <ident-token> '?'* |
+// u <dimension-token> '?'* |
+// u <number-token> '?'* |
+// u <number-token> <dimension-token> |
+// u <number-token> <number-token> |
+// u '+' '?'+
+module.exports = function urange(token, getNextToken) {
+ var length = 0;
+
+ // should start with `u` or `U`
+ if (token === null || token.type !== IDENT || !cmpChar(token.value, 0, U)) {
+ return 0;
+ }
+
+ token = getNextToken(++length);
+ if (token === null) {
+ return 0;
+ }
+
+ // u '+' <ident-token> '?'*
+ // u '+' '?'+
+ if (isDelim(token, PLUSSIGN)) {
+ token = getNextToken(++length);
+ if (token === null) {
+ return 0;
+ }
+
+ if (token.type === IDENT) {
+ // u '+' <ident-token> '?'*
+ return withQuestionMarkSequence(hexSequence(token, 0, true), ++length, getNextToken);
+ }
+
+ if (isDelim(token, QUESTIONMARK)) {
+ // u '+' '?'+
+ return withQuestionMarkSequence(1, ++length, getNextToken);
+ }
+
+ // Hex digit or question mark is expected
+ return 0;
+ }
+
+ // u <number-token> '?'*
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (token.type === NUMBER) {
+ if (!startsWith(token, PLUSSIGN)) {
+ return 0;
+ }
+
+ var consumedHexLength = hexSequence(token, 1, true);
+ if (consumedHexLength === 0) {
+ return 0;
+ }
+
+ token = getNextToken(++length);
+ if (token === null) {
+ // u <number-token> <eof>
+ return length;
+ }
+
+ if (token.type === DIMENSION || token.type === NUMBER) {
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (!startsWith(token, HYPHENMINUS) || !hexSequence(token, 1, false)) {
+ return 0;
+ }
+
+ return length + 1;
+ }
+
+ // u <number-token> '?'*
+ return withQuestionMarkSequence(consumedHexLength, length, getNextToken);
+ }
+
+ // u <dimension-token> '?'*
+ if (token.type === DIMENSION) {
+ if (!startsWith(token, PLUSSIGN)) {
+ return 0;
+ }
+
+ return withQuestionMarkSequence(hexSequence(token, 1, true), ++length, getNextToken);
+ }
+
+ return 0;
+};
diff --git a/node_modules/css-tree/lib/lexer/generic.js b/node_modules/css-tree/lib/lexer/generic.js
new file mode 100644
index 0000000..c5b733a
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/generic.js
@@ -0,0 +1,585 @@
+var tokenizer = require('../tokenizer');
+var isIdentifierStart = tokenizer.isIdentifierStart;
+var isHexDigit = tokenizer.isHexDigit;
+var isDigit = tokenizer.isDigit;
+var cmpStr = tokenizer.cmpStr;
+var consumeNumber = tokenizer.consumeNumber;
+var TYPE = tokenizer.TYPE;
+var anPlusB = require('./generic-an-plus-b');
+var urange = require('./generic-urange');
+
+var cssWideKeywords = ['unset', 'initial', 'inherit'];
+var calcFunctionNames = ['calc(', '-moz-calc(', '-webkit-calc('];
+
+// https://www.w3.org/TR/css-values-3/#lengths
+var LENGTH = {
+ // absolute length units
+ 'px': true,
+ 'mm': true,
+ 'cm': true,
+ 'in': true,
+ 'pt': true,
+ 'pc': true,
+ 'q': true,
+
+ // relative length units
+ 'em': true,
+ 'ex': true,
+ 'ch': true,
+ 'rem': true,
+
+ // viewport-percentage lengths
+ 'vh': true,
+ 'vw': true,
+ 'vmin': true,
+ 'vmax': true,
+ 'vm': true
+};
+
+var ANGLE = {
+ 'deg': true,
+ 'grad': true,
+ 'rad': true,
+ 'turn': true
+};
+
+var TIME = {
+ 's': true,
+ 'ms': true
+};
+
+var FREQUENCY = {
+ 'hz': true,
+ 'khz': true
+};
+
+// https://www.w3.org/TR/css-values-3/#resolution (https://drafts.csswg.org/css-values/#resolution)
+var RESOLUTION = {
+ 'dpi': true,
+ 'dpcm': true,
+ 'dppx': true,
+ 'x': true // https://github.com/w3c/csswg-drafts/issues/461
+};
+
+// https://drafts.csswg.org/css-grid/#fr-unit
+var FLEX = {
+ 'fr': true
+};
+
+// https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume
+var DECIBEL = {
+ 'db': true
+};
+
+// https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch
+var SEMITONES = {
+ 'st': true
+};
+
+// safe char code getter
+function charCode(str, index) {
+ return index < str.length ? str.charCodeAt(index) : 0;
+}
+
+function eqStr(actual, expected) {
+ return cmpStr(actual, 0, actual.length, expected);
+}
+
+function eqStrAny(actual, expected) {
+ for (var i = 0; i < expected.length; i++) {
+ if (eqStr(actual, expected[i])) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// IE postfix hack, i.e. 123\0 or 123px\9
+function isPostfixIeHack(str, offset) {
+ if (offset !== str.length - 2) {
+ return false;
+ }
+
+ return (
+ str.charCodeAt(offset) === 0x005C && // U+005C REVERSE SOLIDUS (\)
+ isDigit(str.charCodeAt(offset + 1))
+ );
+}
+
+function outOfRange(opts, value, numEnd) {
+ if (opts && opts.type === 'Range') {
+ var num = Number(
+ numEnd !== undefined && numEnd !== value.length
+ ? value.substr(0, numEnd)
+ : value
+ );
+
+ if (isNaN(num)) {
+ return true;
+ }
+
+ if (opts.min !== null && num < opts.min) {
+ return true;
+ }
+
+ if (opts.max !== null && num > opts.max) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function consumeFunction(token, getNextToken) {
+ var startIdx = token.index;
+ var length = 0;
+
+ // balanced token consuming
+ do {
+ length++;
+
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+}
+
+// TODO: implement
+// can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed
+// https://drafts.csswg.org/css-values/#calc-notation
+function calc(next) {
+ return function(token, getNextToken, opts) {
+ if (token === null) {
+ return 0;
+ }
+
+ if (token.type === TYPE.Function && eqStrAny(token.value, calcFunctionNames)) {
+ return consumeFunction(token, getNextToken);
+ }
+
+ return next(token, getNextToken, opts);
+ };
+}
+
+function tokenType(expectedTokenType) {
+ return function(token) {
+ if (token === null || token.type !== expectedTokenType) {
+ return 0;
+ }
+
+ return 1;
+ };
+}
+
+function func(name) {
+ name = name + '(';
+
+ return function(token, getNextToken) {
+ if (token !== null && eqStr(token.value, name)) {
+ return consumeFunction(token, getNextToken);
+ }
+
+ return 0;
+ };
+}
+
+// =========================
+// Complex types
+//
+
+// https://drafts.csswg.org/css-values-4/#custom-idents
+// 4.2. Author-defined Identifiers: the <custom-ident> type
+// Some properties accept arbitrary author-defined identifiers as a component value.
+// This generic data type is denoted by <custom-ident>, and represents any valid CSS identifier
+// that would not be misinterpreted as a pre-defined keyword in that property’s value definition.
+//
+// See also: https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident
+function customIdent(token) {
+ if (token === null || token.type !== TYPE.Ident) {
+ return 0;
+ }
+
+ var name = token.value.toLowerCase();
+
+ // The CSS-wide keywords are not valid <custom-ident>s
+ if (eqStrAny(name, cssWideKeywords)) {
+ return 0;
+ }
+
+ // The default keyword is reserved and is also not a valid <custom-ident>
+ if (eqStr(name, 'default')) {
+ return 0;
+ }
+
+ // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)
+ // Specifications using <custom-ident> must specify clearly what other keywords
+ // are excluded from <custom-ident>, if any—for example by saying that any pre-defined keywords
+ // in that property’s value definition are excluded. Excluded keywords are excluded
+ // in all ASCII case permutations.
+
+ return 1;
+}
+
+// https://drafts.csswg.org/css-variables/#typedef-custom-property-name
+// A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo.
+// The <custom-property-name> production corresponds to this: it’s defined as any valid identifier
+// that starts with two dashes, except -- itself, which is reserved for future use by CSS.
+// NOTE: Current implementation treat `--` as a valid name since most (all?) major browsers treat it as valid.
+function customPropertyName(token) {
+ // ... defined as any valid identifier
+ if (token === null || token.type !== TYPE.Ident) {
+ return 0;
+ }
+
+ // ... that starts with two dashes (U+002D HYPHEN-MINUS)
+ if (charCode(token.value, 0) !== 0x002D || charCode(token.value, 1) !== 0x002D) {
+ return 0;
+ }
+
+ return 1;
+}
+
+// https://drafts.csswg.org/css-color-4/#hex-notation
+// The syntax of a <hex-color> is a <hash-token> token whose value consists of 3, 4, 6, or 8 hexadecimal digits.
+// In other words, a hex color is written as a hash character, "#", followed by some number of digits 0-9 or
+// letters a-f (the case of the letters doesn’t matter - #00ff00 is identical to #00FF00).
+function hexColor(token) {
+ if (token === null || token.type !== TYPE.Hash) {
+ return 0;
+ }
+
+ var length = token.value.length;
+
+ // valid values (length): #rgb (4), #rgba (5), #rrggbb (7), #rrggbbaa (9)
+ if (length !== 4 && length !== 5 && length !== 7 && length !== 9) {
+ return 0;
+ }
+
+ for (var i = 1; i < length; i++) {
+ if (!isHexDigit(token.value.charCodeAt(i))) {
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+function idSelector(token) {
+ if (token === null || token.type !== TYPE.Hash) {
+ return 0;
+ }
+
+ if (!isIdentifierStart(charCode(token.value, 1), charCode(token.value, 2), charCode(token.value, 3))) {
+ return 0;
+ }
+
+ return 1;
+}
+
+// https://drafts.csswg.org/css-syntax/#any-value
+// It represents the entirety of what a valid declaration can have as its value.
+function declarationValue(token, getNextToken) {
+ if (!token) {
+ return 0;
+ }
+
+ var length = 0;
+ var level = 0;
+ var startIdx = token.index;
+
+ // The <declaration-value> production matches any sequence of one or more tokens,
+ // so long as the sequence ...
+ scan:
+ do {
+ switch (token.type) {
+ // ... does not contain <bad-string-token>, <bad-url-token>,
+ case TYPE.BadString:
+ case TYPE.BadUrl:
+ break scan;
+
+ // ... unmatched <)-token>, <]-token>, or <}-token>,
+ case TYPE.RightCurlyBracket:
+ case TYPE.RightParenthesis:
+ case TYPE.RightSquareBracket:
+ if (token.balance > token.index || token.balance < startIdx) {
+ break scan;
+ }
+
+ level--;
+ break;
+
+ // ... or top-level <semicolon-token> tokens
+ case TYPE.Semicolon:
+ if (level === 0) {
+ break scan;
+ }
+
+ break;
+
+ // ... or <delim-token> tokens with a value of "!"
+ case TYPE.Delim:
+ if (token.value === '!' && level === 0) {
+ break scan;
+ }
+
+ break;
+
+ case TYPE.Function:
+ case TYPE.LeftParenthesis:
+ case TYPE.LeftSquareBracket:
+ case TYPE.LeftCurlyBracket:
+ level++;
+ break;
+ }
+
+ length++;
+
+ // until balance closing
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+}
+
+// https://drafts.csswg.org/css-syntax/#any-value
+// The <any-value> production is identical to <declaration-value>, but also
+// allows top-level <semicolon-token> tokens and <delim-token> tokens
+// with a value of "!". It represents the entirety of what valid CSS can be in any context.
+function anyValue(token, getNextToken) {
+ if (!token) {
+ return 0;
+ }
+
+ var startIdx = token.index;
+ var length = 0;
+
+ // The <any-value> production matches any sequence of one or more tokens,
+ // so long as the sequence ...
+ scan:
+ do {
+ switch (token.type) {
+ // ... does not contain <bad-string-token>, <bad-url-token>,
+ case TYPE.BadString:
+ case TYPE.BadUrl:
+ break scan;
+
+ // ... unmatched <)-token>, <]-token>, or <}-token>,
+ case TYPE.RightCurlyBracket:
+ case TYPE.RightParenthesis:
+ case TYPE.RightSquareBracket:
+ if (token.balance > token.index || token.balance < startIdx) {
+ break scan;
+ }
+
+ break;
+ }
+
+ length++;
+
+ // until balance closing
+ if (token.balance <= startIdx) {
+ break;
+ }
+ } while (token = getNextToken(length));
+
+ return length;
+}
+
+// =========================
+// Dimensions
+//
+
+function dimension(type) {
+ return function(token, getNextToken, opts) {
+ if (token === null || token.type !== TYPE.Dimension) {
+ return 0;
+ }
+
+ var numberEnd = consumeNumber(token.value, 0);
+
+ // check unit
+ if (type !== null) {
+ // check for IE postfix hack, i.e. 123px\0 or 123px\9
+ var reverseSolidusOffset = token.value.indexOf('\\', numberEnd);
+ var unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset)
+ ? token.value.substr(numberEnd)
+ : token.value.substring(numberEnd, reverseSolidusOffset);
+
+ if (type.hasOwnProperty(unit.toLowerCase()) === false) {
+ return 0;
+ }
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, numberEnd)) {
+ return 0;
+ }
+
+ return 1;
+ };
+}
+
+// =========================
+// Percentage
+//
+
+// §5.5. Percentages: the <percentage> type
+// https://drafts.csswg.org/css-values-4/#percentages
+function percentage(token, getNextToken, opts) {
+ // ... corresponds to the <percentage-token> production
+ if (token === null || token.type !== TYPE.Percentage) {
+ return 0;
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, token.value.length - 1)) {
+ return 0;
+ }
+
+ return 1;
+}
+
+// =========================
+// Numeric
+//
+
+// https://drafts.csswg.org/css-values-4/#numbers
+// The value <zero> represents a literal number with the value 0. Expressions that merely
+// evaluate to a <number> with the value 0 (for example, calc(0)) do not match <zero>;
+// only literal <number-token>s do.
+function zero(next) {
+ if (typeof next !== 'function') {
+ next = function() {
+ return 0;
+ };
+ }
+
+ return function(token, getNextToken, opts) {
+ if (token !== null && token.type === TYPE.Number) {
+ if (Number(token.value) === 0) {
+ return 1;
+ }
+ }
+
+ return next(token, getNextToken, opts);
+ };
+}
+
+// § 5.3. Real Numbers: the <number> type
+// https://drafts.csswg.org/css-values-4/#numbers
+// Number values are denoted by <number>, and represent real numbers, possibly with a fractional component.
+// ... It corresponds to the <number-token> production
+function number(token, getNextToken, opts) {
+ if (token === null) {
+ return 0;
+ }
+
+ var numberEnd = consumeNumber(token.value, 0);
+ var isNumber = numberEnd === token.value.length;
+ if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) {
+ return 0;
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, numberEnd)) {
+ return 0;
+ }
+
+ return 1;
+}
+
+// §5.2. Integers: the <integer> type
+// https://drafts.csswg.org/css-values-4/#integers
+function integer(token, getNextToken, opts) {
+ // ... corresponds to a subset of the <number-token> production
+ if (token === null || token.type !== TYPE.Number) {
+ return 0;
+ }
+
+ // The first digit of an integer may be immediately preceded by `-` or `+` to indicate the integer’s sign.
+ var i = token.value.charCodeAt(0) === 0x002B || // U+002B PLUS SIGN (+)
+ token.value.charCodeAt(0) === 0x002D ? 1 : 0; // U+002D HYPHEN-MINUS (-)
+
+ // When written literally, an integer is one or more decimal digits 0 through 9 ...
+ for (; i < token.value.length; i++) {
+ if (!isDigit(token.value.charCodeAt(i))) {
+ return 0;
+ }
+ }
+
+ // check range if specified
+ if (outOfRange(opts, token.value, i)) {
+ return 0;
+ }
+
+ return 1;
+}
+
+module.exports = {
+ // token types
+ 'ident-token': tokenType(TYPE.Ident),
+ 'function-token': tokenType(TYPE.Function),
+ 'at-keyword-token': tokenType(TYPE.AtKeyword),
+ 'hash-token': tokenType(TYPE.Hash),
+ 'string-token': tokenType(TYPE.String),
+ 'bad-string-token': tokenType(TYPE.BadString),
+ 'url-token': tokenType(TYPE.Url),
+ 'bad-url-token': tokenType(TYPE.BadUrl),
+ 'delim-token': tokenType(TYPE.Delim),
+ 'number-token': tokenType(TYPE.Number),
+ 'percentage-token': tokenType(TYPE.Percentage),
+ 'dimension-token': tokenType(TYPE.Dimension),
+ 'whitespace-token': tokenType(TYPE.WhiteSpace),
+ 'CDO-token': tokenType(TYPE.CDO),
+ 'CDC-token': tokenType(TYPE.CDC),
+ 'colon-token': tokenType(TYPE.Colon),
+ 'semicolon-token': tokenType(TYPE.Semicolon),
+ 'comma-token': tokenType(TYPE.Comma),
+ '[-token': tokenType(TYPE.LeftSquareBracket),
+ ']-token': tokenType(TYPE.RightSquareBracket),
+ '(-token': tokenType(TYPE.LeftParenthesis),
+ ')-token': tokenType(TYPE.RightParenthesis),
+ '{-token': tokenType(TYPE.LeftCurlyBracket),
+ '}-token': tokenType(TYPE.RightCurlyBracket),
+
+ // token type aliases
+ 'string': tokenType(TYPE.String),
+ 'ident': tokenType(TYPE.Ident),
+
+ // complex types
+ 'custom-ident': customIdent,
+ 'custom-property-name': customPropertyName,
+ 'hex-color': hexColor,
+ 'id-selector': idSelector, // element( <id-selector> )
+ 'an-plus-b': anPlusB,
+ 'urange': urange,
+ 'declaration-value': declarationValue,
+ 'any-value': anyValue,
+
+ // dimensions
+ 'dimension': calc(dimension(null)),
+ 'angle': calc(dimension(ANGLE)),
+ 'decibel': calc(dimension(DECIBEL)),
+ 'frequency': calc(dimension(FREQUENCY)),
+ 'flex': calc(dimension(FLEX)),
+ 'length': calc(zero(dimension(LENGTH))),
+ 'resolution': calc(dimension(RESOLUTION)),
+ 'semitones': calc(dimension(SEMITONES)),
+ 'time': calc(dimension(TIME)),
+
+ // percentage
+ 'percentage': calc(percentage),
+
+ // numeric
+ 'zero': zero(),
+ 'number': calc(number),
+ 'integer': calc(integer),
+
+ // old IE stuff
+ '-ms-legacy-expression': func('expression')
+};
diff --git a/node_modules/css-tree/lib/lexer/index.js b/node_modules/css-tree/lib/lexer/index.js
new file mode 100644
index 0000000..e29f392
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/index.js
@@ -0,0 +1,3 @@
+module.exports = {
+ Lexer: require('./Lexer')
+};
diff --git a/node_modules/css-tree/lib/lexer/match-graph.js b/node_modules/css-tree/lib/lexer/match-graph.js
new file mode 100644
index 0000000..3d27704
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/match-graph.js
@@ -0,0 +1,455 @@
+var parse = require('../definition-syntax/parse');
+
+var MATCH = { type: 'Match' };
+var MISMATCH = { type: 'Mismatch' };
+var DISALLOW_EMPTY = { type: 'DisallowEmpty' };
+var LEFTPARENTHESIS = 40; // (
+var RIGHTPARENTHESIS = 41; // )
+
+function createCondition(match, thenBranch, elseBranch) {
+ // reduce node count
+ if (thenBranch === MATCH && elseBranch === MISMATCH) {
+ return match;
+ }
+
+ if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {
+ return match;
+ }
+
+ if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {
+ thenBranch = match.then;
+ match = match.match;
+ }
+
+ return {
+ type: 'If',
+ match: match,
+ then: thenBranch,
+ else: elseBranch
+ };
+}
+
+function isFunctionType(name) {
+ return (
+ name.length > 2 &&
+ name.charCodeAt(name.length - 2) === LEFTPARENTHESIS &&
+ name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS
+ );
+}
+
+function isEnumCapatible(term) {
+ return (
+ term.type === 'Keyword' ||
+ term.type === 'AtKeyword' ||
+ term.type === 'Function' ||
+ term.type === 'Type' && isFunctionType(term.name)
+ );
+}
+
+function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {
+ switch (combinator) {
+ case ' ':
+ // Juxtaposing components means that all of them must occur, in the given order.
+ //
+ // a b c
+ // =
+ // match a
+ // then match b
+ // then match c
+ // then MATCH
+ // else MISMATCH
+ // else MISMATCH
+ // else MISMATCH
+ var result = MATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+
+ result = createCondition(
+ term,
+ result,
+ MISMATCH
+ );
+ };
+
+ return result;
+
+ case '|':
+ // A bar (|) separates two or more alternatives: exactly one of them must occur.
+ //
+ // a | b | c
+ // =
+ // match a
+ // then MATCH
+ // else match b
+ // then MATCH
+ // else match c
+ // then MATCH
+ // else MISMATCH
+
+ var result = MISMATCH;
+ var map = null;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+
+ // reduce sequence of keywords into a Enum
+ if (isEnumCapatible(term)) {
+ if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {
+ map = Object.create(null);
+ result = createCondition(
+ {
+ type: 'Enum',
+ map: map
+ },
+ MATCH,
+ result
+ );
+ }
+
+ if (map !== null) {
+ var key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();
+ if (key in map === false) {
+ map[key] = term;
+ continue;
+ }
+ }
+ }
+
+ map = null;
+
+ // create a new conditonal node
+ result = createCondition(
+ term,
+ MATCH,
+ result
+ );
+ };
+
+ return result;
+
+ case '&&':
+ // A double ampersand (&&) separates two or more components,
+ // all of which must occur, in any order.
+
+ // Use MatchOnce for groups with a large number of terms,
+ // since &&-groups produces at least N!-node trees
+ if (terms.length > 5) {
+ return {
+ type: 'MatchOnce',
+ terms: terms,
+ all: true
+ };
+ }
+
+ // Use a combination tree for groups with small number of terms
+ //
+ // a && b && c
+ // =
+ // match a
+ // then [b && c]
+ // else match b
+ // then [a && c]
+ // else match c
+ // then [a && b]
+ // else MISMATCH
+ //
+ // a && b
+ // =
+ // match a
+ // then match b
+ // then MATCH
+ // else MISMATCH
+ // else match b
+ // then match a
+ // then MATCH
+ // else MISMATCH
+ // else MISMATCH
+ var result = MISMATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+ var thenClause;
+
+ if (terms.length > 1) {
+ thenClause = buildGroupMatchGraph(
+ combinator,
+ terms.filter(function(newGroupTerm) {
+ return newGroupTerm !== term;
+ }),
+ false
+ );
+ } else {
+ thenClause = MATCH;
+ }
+
+ result = createCondition(
+ term,
+ thenClause,
+ result
+ );
+ };
+
+ return result;
+
+ case '||':
+ // A double bar (||) separates two or more options:
+ // one or more of them must occur, in any order.
+
+ // Use MatchOnce for groups with a large number of terms,
+ // since ||-groups produces at least N!-node trees
+ if (terms.length > 5) {
+ return {
+ type: 'MatchOnce',
+ terms: terms,
+ all: false
+ };
+ }
+
+ // Use a combination tree for groups with small number of terms
+ //
+ // a || b || c
+ // =
+ // match a
+ // then [b || c]
+ // else match b
+ // then [a || c]
+ // else match c
+ // then [a || b]
+ // else MISMATCH
+ //
+ // a || b
+ // =
+ // match a
+ // then match b
+ // then MATCH
+ // else MATCH
+ // else match b
+ // then match a
+ // then MATCH
+ // else MATCH
+ // else MISMATCH
+ var result = atLeastOneTermMatched ? MATCH : MISMATCH;
+
+ for (var i = terms.length - 1; i >= 0; i--) {
+ var term = terms[i];
+ var thenClause;
+
+ if (terms.length > 1) {
+ thenClause = buildGroupMatchGraph(
+ combinator,
+ terms.filter(function(newGroupTerm) {
+ return newGroupTerm !== term;
+ }),
+ true
+ );
+ } else {
+ thenClause = MATCH;
+ }
+
+ result = createCondition(
+ term,
+ thenClause,
+ result
+ );
+ };
+
+ return result;
+ }
+}
+
+function buildMultiplierMatchGraph(node) {
+ var result = MATCH;
+ var matchTerm = buildMatchGraph(node.term);
+
+ if (node.max === 0) {
+ // disable repeating of empty match to prevent infinite loop
+ matchTerm = createCondition(
+ matchTerm,
+ DISALLOW_EMPTY,
+ MISMATCH
+ );
+
+ // an occurrence count is not limited, make a cycle;
+ // to collect more terms on each following matching mismatch
+ result = createCondition(
+ matchTerm,
+ null, // will be a loop
+ MISMATCH
+ );
+
+ result.then = createCondition(
+ MATCH,
+ MATCH,
+ result // make a loop
+ );
+
+ if (node.comma) {
+ result.then.else = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+ } else {
+ // create a match node chain for [min .. max] interval with optional matches
+ for (var i = node.min || 1; i <= node.max; i++) {
+ if (node.comma && result !== MATCH) {
+ result = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+
+ result = createCondition(
+ matchTerm,
+ createCondition(
+ MATCH,
+ MATCH,
+ result
+ ),
+ MISMATCH
+ );
+ }
+ }
+
+ if (node.min === 0) {
+ // allow zero match
+ result = createCondition(
+ MATCH,
+ MATCH,
+ result
+ );
+ } else {
+ // create a match node chain to collect [0 ... min - 1] required matches
+ for (var i = 0; i < node.min - 1; i++) {
+ if (node.comma && result !== MATCH) {
+ result = createCondition(
+ { type: 'Comma', syntax: node },
+ result,
+ MISMATCH
+ );
+ }
+
+ result = createCondition(
+ matchTerm,
+ result,
+ MISMATCH
+ );
+ }
+ }
+
+ return result;
+}
+
+function buildMatchGraph(node) {
+ if (typeof node === 'function') {
+ return {
+ type: 'Generic',
+ fn: node
+ };
+ }
+
+ switch (node.type) {
+ case 'Group':
+ var result = buildGroupMatchGraph(
+ node.combinator,
+ node.terms.map(buildMatchGraph),
+ false
+ );
+
+ if (node.disallowEmpty) {
+ result = createCondition(
+ result,
+ DISALLOW_EMPTY,
+ MISMATCH
+ );
+ }
+
+ return result;
+
+ case 'Multiplier':
+ return buildMultiplierMatchGraph(node);
+
+ case 'Type':
+ case 'Property':
+ return {
+ type: node.type,
+ name: node.name,
+ syntax: node
+ };
+
+ case 'Keyword':
+ return {
+ type: node.type,
+ name: node.name.toLowerCase(),
+ syntax: node
+ };
+
+ case 'AtKeyword':
+ return {
+ type: node.type,
+ name: '@' + node.name.toLowerCase(),
+ syntax: node
+ };
+
+ case 'Function':
+ return {
+ type: node.type,
+ name: node.name.toLowerCase() + '(',
+ syntax: node
+ };
+
+ case 'String':
+ // convert a one char length String to a Token
+ if (node.value.length === 3) {
+ return {
+ type: 'Token',
+ value: node.value.charAt(1),
+ syntax: node
+ };
+ }
+
+ // otherwise use it as is
+ return {
+ type: node.type,
+ value: node.value.substr(1, node.value.length - 2).replace(/\\'/g, '\''),
+ syntax: node
+ };
+
+ case 'Token':
+ return {
+ type: node.type,
+ value: node.value,
+ syntax: node
+ };
+
+ case 'Comma':
+ return {
+ type: node.type,
+ syntax: node
+ };
+
+ default:
+ throw new Error('Unknown node type:', node.type);
+ }
+}
+
+module.exports = {
+ MATCH: MATCH,
+ MISMATCH: MISMATCH,
+ DISALLOW_EMPTY: DISALLOW_EMPTY,
+ buildMatchGraph: function(syntaxTree, ref) {
+ if (typeof syntaxTree === 'string') {
+ syntaxTree = parse(syntaxTree);
+ }
+
+ return {
+ type: 'MatchGraph',
+ match: buildMatchGraph(syntaxTree),
+ syntax: ref || null,
+ source: syntaxTree
+ };
+ }
+};
diff --git a/node_modules/css-tree/lib/lexer/match.js b/node_modules/css-tree/lib/lexer/match.js
new file mode 100644
index 0000000..333ed7f
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/match.js
@@ -0,0 +1,639 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var matchGraph = require('./match-graph');
+var MATCH = matchGraph.MATCH;
+var MISMATCH = matchGraph.MISMATCH;
+var DISALLOW_EMPTY = matchGraph.DISALLOW_EMPTY;
+var TYPE = require('../tokenizer/const').TYPE;
+
+var STUB = 0;
+var TOKEN = 1;
+var OPEN_SYNTAX = 2;
+var CLOSE_SYNTAX = 3;
+
+var EXIT_REASON_MATCH = 'Match';
+var EXIT_REASON_MISMATCH = 'Mismatch';
+var EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';
+
+var ITERATION_LIMIT = 15000;
+var totalIterationCount = 0;
+
+function reverseList(list) {
+ var prev = null;
+ var next = null;
+ var item = list;
+
+ while (item !== null) {
+ next = item.prev;
+ item.prev = prev;
+ prev = item;
+ item = next;
+ }
+
+ return prev;
+}
+
+function areStringsEqualCaseInsensitive(testStr, referenceStr) {
+ if (testStr.length !== referenceStr.length) {
+ return false;
+ }
+
+ for (var i = 0; i < testStr.length; i++) {
+ var testCode = testStr.charCodeAt(i);
+ var referenceCode = referenceStr.charCodeAt(i);
+
+ // testCode.toLowerCase() for U+0041 LATIN CAPITAL LETTER A (A) .. U+005A LATIN CAPITAL LETTER Z (Z).
+ if (testCode >= 0x0041 && testCode <= 0x005A) {
+ testCode = testCode | 32;
+ }
+
+ if (testCode !== referenceCode) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function isContextEdgeDelim(token) {
+ if (token.type !== TYPE.Delim) {
+ return false;
+ }
+
+ // Fix matching for unicode-range: U+30??, U+FF00-FF9F
+ // Probably we need to check out previous match instead
+ return token.value !== '?';
+}
+
+function isCommaContextStart(token) {
+ if (token === null) {
+ return true;
+ }
+
+ return (
+ token.type === TYPE.Comma ||
+ token.type === TYPE.Function ||
+ token.type === TYPE.LeftParenthesis ||
+ token.type === TYPE.LeftSquareBracket ||
+ token.type === TYPE.LeftCurlyBracket ||
+ isContextEdgeDelim(token)
+ );
+}
+
+function isCommaContextEnd(token) {
+ if (token === null) {
+ return true;
+ }
+
+ return (
+ token.type === TYPE.RightParenthesis ||
+ token.type === TYPE.RightSquareBracket ||
+ token.type === TYPE.RightCurlyBracket ||
+ token.type === TYPE.Delim
+ );
+}
+
+function internalMatch(tokens, state, syntaxes) {
+ function moveToNextToken() {
+ do {
+ tokenIndex++;
+ token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
+ } while (token !== null && (token.type === TYPE.WhiteSpace || token.type === TYPE.Comment));
+ }
+
+ function getNextToken(offset) {
+ var nextIndex = tokenIndex + offset;
+
+ return nextIndex < tokens.length ? tokens[nextIndex] : null;
+ }
+
+ function stateSnapshotFromSyntax(nextState, prev) {
+ return {
+ nextState: nextState,
+ matchStack: matchStack,
+ syntaxStack: syntaxStack,
+ thenStack: thenStack,
+ tokenIndex: tokenIndex,
+ prev: prev
+ };
+ }
+
+ function pushThenStack(nextState) {
+ thenStack = {
+ nextState: nextState,
+ matchStack: matchStack,
+ syntaxStack: syntaxStack,
+ prev: thenStack
+ };
+ }
+
+ function pushElseStack(nextState) {
+ elseStack = stateSnapshotFromSyntax(nextState, elseStack);
+ }
+
+ function addTokenToMatch() {
+ matchStack = {
+ type: TOKEN,
+ syntax: state.syntax,
+ token: token,
+ prev: matchStack
+ };
+
+ moveToNextToken();
+ syntaxStash = null;
+
+ if (tokenIndex > longestMatch) {
+ longestMatch = tokenIndex;
+ }
+ }
+
+ function openSyntax() {
+ syntaxStack = {
+ syntax: state.syntax,
+ opts: state.syntax.opts || (syntaxStack !== null && syntaxStack.opts) || null,
+ prev: syntaxStack
+ };
+
+ matchStack = {
+ type: OPEN_SYNTAX,
+ syntax: state.syntax,
+ token: matchStack.token,
+ prev: matchStack
+ };
+ }
+
+ function closeSyntax() {
+ if (matchStack.type === OPEN_SYNTAX) {
+ matchStack = matchStack.prev;
+ } else {
+ matchStack = {
+ type: CLOSE_SYNTAX,
+ syntax: syntaxStack.syntax,
+ token: matchStack.token,
+ prev: matchStack
+ };
+ }
+
+ syntaxStack = syntaxStack.prev;
+ }
+
+ var syntaxStack = null;
+ var thenStack = null;
+ var elseStack = null;
+
+ // null – stashing allowed, nothing stashed
+ // false – stashing disabled, nothing stashed
+ // anithing else – fail stashable syntaxes, some syntax stashed
+ var syntaxStash = null;
+
+ var iterationCount = 0; // count iterations and prevent infinite loop
+ var exitReason = null;
+
+ var token = null;
+ var tokenIndex = -1;
+ var longestMatch = 0;
+ var matchStack = {
+ type: STUB,
+ syntax: null,
+ token: null,
+ prev: null
+ };
+
+ moveToNextToken();
+
+ while (exitReason === null && ++iterationCount < ITERATION_LIMIT) {
+ // function mapList(list, fn) {
+ // var result = [];
+ // while (list) {
+ // result.unshift(fn(list));
+ // list = list.prev;
+ // }
+ // return result;
+ // }
+ // console.log('--\n',
+ // '#' + iterationCount,
+ // require('util').inspect({
+ // match: mapList(matchStack, x => x.type === TOKEN ? x.token && x.token.value : x.syntax ? ({ [OPEN_SYNTAX]: '<', [CLOSE_SYNTAX]: '</' }[x.type] || x.type) + '!' + x.syntax.name : null),
+ // token: token && token.value,
+ // tokenIndex,
+ // syntax: syntax.type + (syntax.id ? ' #' + syntax.id : '')
+ // }, { depth: null })
+ // );
+ switch (state.type) {
+ case 'Match':
+ if (thenStack === null) {
+ // turn to MISMATCH when some tokens left unmatched
+ if (token !== null) {
+ // doesn't mismatch if just one token left and it's an IE hack
+ if (tokenIndex !== tokens.length - 1 || (token.value !== '\\0' && token.value !== '\\9')) {
+ state = MISMATCH;
+ break;
+ }
+ }
+
+ // break the main loop, return a result - MATCH
+ exitReason = EXIT_REASON_MATCH;
+ break;
+ }
+
+ // go to next syntax (`then` branch)
+ state = thenStack.nextState;
+
+ // check match is not empty
+ if (state === DISALLOW_EMPTY) {
+ if (thenStack.matchStack === matchStack) {
+ state = MISMATCH;
+ break;
+ } else {
+ state = MATCH;
+ }
+ }
+
+ // close syntax if needed
+ while (thenStack.syntaxStack !== syntaxStack) {
+ closeSyntax();
+ }
+
+ // pop stack
+ thenStack = thenStack.prev;
+ break;
+
+ case 'Mismatch':
+ // when some syntax is stashed
+ if (syntaxStash !== null && syntaxStash !== false) {
+ // there is no else branches or a branch reduce match stack
+ if (elseStack === null || tokenIndex > elseStack.tokenIndex) {
+ // restore state from the stash
+ elseStack = syntaxStash;
+ syntaxStash = false; // disable stashing
+ }
+ } else if (elseStack === null) {
+ // no else branches -> break the main loop
+ // return a result - MISMATCH
+ exitReason = EXIT_REASON_MISMATCH;
+ break;
+ }
+
+ // go to next syntax (`else` branch)
+ state = elseStack.nextState;
+
+ // restore all the rest stack states
+ thenStack = elseStack.thenStack;
+ syntaxStack = elseStack.syntaxStack;
+ matchStack = elseStack.matchStack;
+ tokenIndex = elseStack.tokenIndex;
+ token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;
+
+ // pop stack
+ elseStack = elseStack.prev;
+ break;
+
+ case 'MatchGraph':
+ state = state.match;
+ break;
+
+ case 'If':
+ // IMPORTANT: else stack push must go first,
+ // since it stores the state of thenStack before changes
+ if (state.else !== MISMATCH) {
+ pushElseStack(state.else);
+ }
+
+ if (state.then !== MATCH) {
+ pushThenStack(state.then);
+ }
+
+ state = state.match;
+ break;
+
+ case 'MatchOnce':
+ state = {
+ type: 'MatchOnceBuffer',
+ syntax: state,
+ index: 0,
+ mask: 0
+ };
+ break;
+
+ case 'MatchOnceBuffer':
+ var terms = state.syntax.terms;
+
+ if (state.index === terms.length) {
+ // no matches at all or it's required all terms to be matched
+ if (state.mask === 0 || state.syntax.all) {
+ state = MISMATCH;
+ break;
+ }
+
+ // a partial match is ok
+ state = MATCH;
+ break;
+ }
+
+ // all terms are matched
+ if (state.mask === (1 << terms.length) - 1) {
+ state = MATCH;
+ break;
+ }
+
+ for (; state.index < terms.length; state.index++) {
+ var matchFlag = 1 << state.index;
+
+ if ((state.mask & matchFlag) === 0) {
+ // IMPORTANT: else stack push must go first,
+ // since it stores the state of thenStack before changes
+ pushElseStack(state);
+ pushThenStack({
+ type: 'AddMatchOnce',
+ syntax: state.syntax,
+ mask: state.mask | matchFlag
+ });
+
+ // match
+ state = terms[state.index++];
+ break;
+ }
+ }
+ break;
+
+ case 'AddMatchOnce':
+ state = {
+ type: 'MatchOnceBuffer',
+ syntax: state.syntax,
+ index: 0,
+ mask: state.mask
+ };
+ break;
+
+ case 'Enum':
+ if (token !== null) {
+ var name = token.value.toLowerCase();
+
+ // drop \0 and \9 hack from keyword name
+ if (name.indexOf('\\') !== -1) {
+ name = name.replace(/\\[09].*$/, '');
+ }
+
+ if (hasOwnProperty.call(state.map, name)) {
+ state = state.map[name];
+ break;
+ }
+ }
+
+ state = MISMATCH;
+ break;
+
+ case 'Generic':
+ var opts = syntaxStack !== null ? syntaxStack.opts : null;
+ var lastTokenIndex = tokenIndex + Math.floor(state.fn(token, getNextToken, opts));
+
+ if (!isNaN(lastTokenIndex) && lastTokenIndex > tokenIndex) {
+ while (tokenIndex < lastTokenIndex) {
+ addTokenToMatch();
+ }
+
+ state = MATCH;
+ } else {
+ state = MISMATCH;
+ }
+
+ break;
+
+ case 'Type':
+ case 'Property':
+ var syntaxDict = state.type === 'Type' ? 'types' : 'properties';
+ var dictSyntax = hasOwnProperty.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null;
+
+ if (!dictSyntax || !dictSyntax.match) {
+ throw new Error(
+ 'Bad syntax reference: ' +
+ (state.type === 'Type'
+ ? '<' + state.name + '>'
+ : '<\'' + state.name + '\'>')
+ );
+ }
+
+ // stash a syntax for types with low priority
+ if (syntaxStash !== false && token !== null && state.type === 'Type') {
+ var lowPriorityMatching =
+ // https://drafts.csswg.org/css-values-4/#custom-idents
+ // When parsing positionally-ambiguous keywords in a property value, a <custom-ident> production
+ // can only claim the keyword if no other unfulfilled production can claim it.
+ (state.name === 'custom-ident' && token.type === TYPE.Ident) ||
+
+ // https://drafts.csswg.org/css-values-4/#lengths
+ // ... if a `0` could be parsed as either a <number> or a <length> in a property (such as line-height),
+ // it must parse as a <number>
+ (state.name === 'length' && token.value === '0');
+
+ if (lowPriorityMatching) {
+ if (syntaxStash === null) {
+ syntaxStash = stateSnapshotFromSyntax(state, elseStack);
+ }
+
+ state = MISMATCH;
+ break;
+ }
+ }
+
+ openSyntax();
+ state = dictSyntax.match;
+ break;
+
+ case 'Keyword':
+ var name = state.name;
+
+ if (token !== null) {
+ var keywordName = token.value;
+
+ // drop \0 and \9 hack from keyword name
+ if (keywordName.indexOf('\\') !== -1) {
+ keywordName = keywordName.replace(/\\[09].*$/, '');
+ }
+
+ if (areStringsEqualCaseInsensitive(keywordName, name)) {
+ addTokenToMatch();
+ state = MATCH;
+ break;
+ }
+ }
+
+ state = MISMATCH;
+ break;
+
+ case 'AtKeyword':
+ case 'Function':
+ if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) {
+ addTokenToMatch();
+ state = MATCH;
+ break;
+ }
+
+ state = MISMATCH;
+ break;
+
+ case 'Token':
+ if (token !== null && token.value === state.value) {
+ addTokenToMatch();
+ state = MATCH;
+ break;
+ }
+
+ state = MISMATCH;
+ break;
+
+ case 'Comma':
+ if (token !== null && token.type === TYPE.Comma) {
+ if (isCommaContextStart(matchStack.token)) {
+ state = MISMATCH;
+ } else {
+ addTokenToMatch();
+ state = isCommaContextEnd(token) ? MISMATCH : MATCH;
+ }
+ } else {
+ state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH : MISMATCH;
+ }
+
+ break;
+
+ case 'String':
+ var string = '';
+
+ for (var lastTokenIndex = tokenIndex; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) {
+ string += tokens[lastTokenIndex].value;
+ }
+
+ if (areStringsEqualCaseInsensitive(string, state.value)) {
+ while (tokenIndex < lastTokenIndex) {
+ addTokenToMatch();
+ }
+
+ state = MATCH;
+ } else {
+ state = MISMATCH;
+ }
+
+ break;
+
+ default:
+ throw new Error('Unknown node type: ' + state.type);
+ }
+ }
+
+ totalIterationCount += iterationCount;
+
+ switch (exitReason) {
+ case null:
+ console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');
+ exitReason = EXIT_REASON_ITERATION_LIMIT;
+ matchStack = null;
+ break;
+
+ case EXIT_REASON_MATCH:
+ while (syntaxStack !== null) {
+ closeSyntax();
+ }
+ break;
+
+ default:
+ matchStack = null;
+ }
+
+ return {
+ tokens: tokens,
+ reason: exitReason,
+ iterations: iterationCount,
+ match: matchStack,
+ longestMatch: longestMatch
+ };
+}
+
+function matchAsList(tokens, matchGraph, syntaxes) {
+ var matchResult = internalMatch(tokens, matchGraph, syntaxes || {});
+
+ if (matchResult.match !== null) {
+ var item = reverseList(matchResult.match).prev;
+
+ matchResult.match = [];
+
+ while (item !== null) {
+ switch (item.type) {
+ case STUB:
+ break;
+
+ case OPEN_SYNTAX:
+ case CLOSE_SYNTAX:
+ matchResult.match.push({
+ type: item.type,
+ syntax: item.syntax
+ });
+ break;
+
+ default:
+ matchResult.match.push({
+ token: item.token.value,
+ node: item.token.node
+ });
+ break;
+ }
+
+ item = item.prev;
+ }
+ }
+
+ return matchResult;
+}
+
+function matchAsTree(tokens, matchGraph, syntaxes) {
+ var matchResult = internalMatch(tokens, matchGraph, syntaxes || {});
+
+ if (matchResult.match === null) {
+ return matchResult;
+ }
+
+ var item = matchResult.match;
+ var host = matchResult.match = {
+ syntax: matchGraph.syntax || null,
+ match: []
+ };
+ var hostStack = [host];
+
+ // revert a list and start with 2nd item since 1st is a stub item
+ item = reverseList(item).prev;
+
+ // build a tree
+ while (item !== null) {
+ switch (item.type) {
+ case OPEN_SYNTAX:
+ host.match.push(host = {
+ syntax: item.syntax,
+ match: []
+ });
+ hostStack.push(host);
+ break;
+
+ case CLOSE_SYNTAX:
+ hostStack.pop();
+ host = hostStack[hostStack.length - 1];
+ break;
+
+ default:
+ host.match.push({
+ syntax: item.syntax || null,
+ token: item.token.value,
+ node: item.token.node
+ });
+ }
+
+ item = item.prev;
+ }
+
+ return matchResult;
+}
+
+module.exports = {
+ matchAsList: matchAsList,
+ matchAsTree: matchAsTree,
+ getTotalIterationCount: function() {
+ return totalIterationCount;
+ }
+};
diff --git a/node_modules/css-tree/lib/lexer/prepare-tokens.js b/node_modules/css-tree/lib/lexer/prepare-tokens.js
new file mode 100644
index 0000000..0a9d65e
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/prepare-tokens.js
@@ -0,0 +1,73 @@
+var tokenize = require('../tokenizer');
+var TokenStream = require('../common/TokenStream');
+var tokenStream = new TokenStream();
+var astToTokens = {
+ decorator: function(handlers) {
+ var curNode = null;
+ var prev = { len: 0, node: null };
+ var nodes = [prev];
+ var buffer = '';
+
+ return {
+ children: handlers.children,
+ node: function(node) {
+ var tmp = curNode;
+ curNode = node;
+ handlers.node.call(this, node);
+ curNode = tmp;
+ },
+ chunk: function(chunk) {
+ buffer += chunk;
+ if (prev.node !== curNode) {
+ nodes.push({
+ len: chunk.length,
+ node: curNode
+ });
+ } else {
+ prev.len += chunk.length;
+ }
+ },
+ result: function() {
+ return prepareTokens(buffer, nodes);
+ }
+ };
+ }
+};
+
+function prepareTokens(str, nodes) {
+ var tokens = [];
+ var nodesOffset = 0;
+ var nodesIndex = 0;
+ var currentNode = nodes ? nodes[nodesIndex].node : null;
+
+ tokenize(str, tokenStream);
+
+ while (!tokenStream.eof) {
+ if (nodes) {
+ while (nodesIndex < nodes.length && nodesOffset + nodes[nodesIndex].len <= tokenStream.tokenStart) {
+ nodesOffset += nodes[nodesIndex++].len;
+ currentNode = nodes[nodesIndex].node;
+ }
+ }
+
+ tokens.push({
+ type: tokenStream.tokenType,
+ value: tokenStream.getTokenValue(),
+ index: tokenStream.tokenIndex, // TODO: remove it, temporary solution
+ balance: tokenStream.balance[tokenStream.tokenIndex], // TODO: remove it, temporary solution
+ node: currentNode
+ });
+ tokenStream.next();
+ // console.log({ ...tokens[tokens.length - 1], node: undefined });
+ }
+
+ return tokens;
+}
+
+module.exports = function(value, syntax) {
+ if (typeof value === 'string') {
+ return prepareTokens(value, null);
+ }
+
+ return syntax.generate(value, astToTokens);
+};
diff --git a/node_modules/css-tree/lib/lexer/search.js b/node_modules/css-tree/lib/lexer/search.js
new file mode 100644
index 0000000..7e270ab
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/search.js
@@ -0,0 +1,65 @@
+var List = require('../common/List');
+
+function getFirstMatchNode(matchNode) {
+ if ('node' in matchNode) {
+ return matchNode.node;
+ }
+
+ return getFirstMatchNode(matchNode.match[0]);
+}
+
+function getLastMatchNode(matchNode) {
+ if ('node' in matchNode) {
+ return matchNode.node;
+ }
+
+ return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
+}
+
+function matchFragments(lexer, ast, match, type, name) {
+ function findFragments(matchNode) {
+ if (matchNode.syntax !== null &&
+ matchNode.syntax.type === type &&
+ matchNode.syntax.name === name) {
+ var start = getFirstMatchNode(matchNode);
+ var end = getLastMatchNode(matchNode);
+
+ lexer.syntax.walk(ast, function(node, item, list) {
+ if (node === start) {
+ var nodes = new List();
+
+ do {
+ nodes.appendData(item.data);
+
+ if (item.data === end) {
+ break;
+ }
+
+ item = item.next;
+ } while (item !== null);
+
+ fragments.push({
+ parent: list,
+ nodes: nodes
+ });
+ }
+ });
+ }
+
+ if (Array.isArray(matchNode.match)) {
+ matchNode.match.forEach(findFragments);
+ }
+ }
+
+ var fragments = [];
+
+ if (match.matched !== null) {
+ findFragments(match.matched);
+ }
+
+ return fragments;
+}
+
+module.exports = {
+ matchFragments: matchFragments
+};
diff --git a/node_modules/css-tree/lib/lexer/structure.js b/node_modules/css-tree/lib/lexer/structure.js
new file mode 100644
index 0000000..e1239dd
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/structure.js
@@ -0,0 +1,163 @@
+var List = require('../common/List');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isValidNumber(value) {
+ // Number.isInteger(value) && value >= 0
+ return (
+ typeof value === 'number' &&
+ isFinite(value) &&
+ Math.floor(value) === value &&
+ value >= 0
+ );
+}
+
+function isValidLocation(loc) {
+ return (
+ Boolean(loc) &&
+ isValidNumber(loc.offset) &&
+ isValidNumber(loc.line) &&
+ isValidNumber(loc.column)
+ );
+}
+
+function createNodeStructureChecker(type, fields) {
+ return function checkNode(node, warn) {
+ if (!node || node.constructor !== Object) {
+ return warn(node, 'Type of node should be an Object');
+ }
+
+ for (var key in node) {
+ var valid = true;
+
+ if (hasOwnProperty.call(node, key) === false) {
+ continue;
+ }
+
+ if (key === 'type') {
+ if (node.type !== type) {
+ warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
+ }
+ } else if (key === 'loc') {
+ if (node.loc === null) {
+ continue;
+ } else if (node.loc && node.loc.constructor === Object) {
+ if (typeof node.loc.source !== 'string') {
+ key += '.source';
+ } else if (!isValidLocation(node.loc.start)) {
+ key += '.start';
+ } else if (!isValidLocation(node.loc.end)) {
+ key += '.end';
+ } else {
+ continue;
+ }
+ }
+
+ valid = false;
+ } else if (fields.hasOwnProperty(key)) {
+ for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
+ var fieldType = fields[key][i];
+
+ switch (fieldType) {
+ case String:
+ valid = typeof node[key] === 'string';
+ break;
+
+ case Boolean:
+ valid = typeof node[key] === 'boolean';
+ break;
+
+ case null:
+ valid = node[key] === null;
+ break;
+
+ default:
+ if (typeof fieldType === 'string') {
+ valid = node[key] && node[key].type === fieldType;
+ } else if (Array.isArray(fieldType)) {
+ valid = node[key] instanceof List;
+ }
+ }
+ }
+ } else {
+ warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
+ }
+
+ if (!valid) {
+ warn(node, 'Bad value for `' + type + '.' + key + '`');
+ }
+ }
+
+ for (var key in fields) {
+ if (hasOwnProperty.call(fields, key) &&
+ hasOwnProperty.call(node, key) === false) {
+ warn(node, 'Field `' + type + '.' + key + '` is missed');
+ }
+ }
+ };
+}
+
+function processStructure(name, nodeType) {
+ var structure = nodeType.structure;
+ var fields = {
+ type: String,
+ loc: true
+ };
+ var docs = {
+ type: '"' + name + '"'
+ };
+
+ for (var key in structure) {
+ if (hasOwnProperty.call(structure, key) === false) {
+ continue;
+ }
+
+ var docsTypes = [];
+ var fieldTypes = fields[key] = Array.isArray(structure[key])
+ ? structure[key].slice()
+ : [structure[key]];
+
+ for (var i = 0; i < fieldTypes.length; i++) {
+ var fieldType = fieldTypes[i];
+ if (fieldType === String || fieldType === Boolean) {
+ docsTypes.push(fieldType.name);
+ } else if (fieldType === null) {
+ docsTypes.push('null');
+ } else if (typeof fieldType === 'string') {
+ docsTypes.push('<' + fieldType + '>');
+ } else if (Array.isArray(fieldType)) {
+ docsTypes.push('List'); // TODO: use type enum
+ } else {
+ throw new Error('Wrong value `' + fieldType + '` in `' + name + '.' + key + '` structure definition');
+ }
+ }
+
+ docs[key] = docsTypes.join(' | ');
+ }
+
+ return {
+ docs: docs,
+ check: createNodeStructureChecker(name, fields)
+ };
+}
+
+module.exports = {
+ getStructureFromConfig: function(config) {
+ var structure = {};
+
+ if (config.node) {
+ for (var name in config.node) {
+ if (hasOwnProperty.call(config.node, name)) {
+ var nodeType = config.node[name];
+
+ if (nodeType.structure) {
+ structure[name] = processStructure(name, nodeType);
+ } else {
+ throw new Error('Missed `structure` field in `' + name + '` node type definition');
+ }
+ }
+ }
+ }
+
+ return structure;
+ }
+};
diff --git a/node_modules/css-tree/lib/lexer/trace.js b/node_modules/css-tree/lib/lexer/trace.js
new file mode 100644
index 0000000..3a45e53
--- /dev/null
+++ b/node_modules/css-tree/lib/lexer/trace.js
@@ -0,0 +1,79 @@
+function getTrace(node) {
+ function shouldPutToTrace(syntax) {
+ if (syntax === null) {
+ return false;
+ }
+
+ return (
+ syntax.type === 'Type' ||
+ syntax.type === 'Property' ||
+ syntax.type === 'Keyword'
+ );
+ }
+
+ function hasMatch(matchNode) {
+ if (Array.isArray(matchNode.match)) {
+ // use for-loop for better perfomance
+ for (var i = 0; i < matchNode.match.length; i++) {
+ if (hasMatch(matchNode.match[i])) {
+ if (shouldPutToTrace(matchNode.syntax)) {
+ result.unshift(matchNode.syntax);
+ }
+
+ return true;
+ }
+ }
+ } else if (matchNode.node === node) {
+ result = shouldPutToTrace(matchNode.syntax)
+ ? [matchNode.syntax]
+ : [];
+
+ return true;
+ }
+
+ return false;
+ }
+
+ var result = null;
+
+ if (this.matched !== null) {
+ hasMatch(this.matched);
+ }
+
+ return result;
+}
+
+function testNode(match, node, fn) {
+ var trace = getTrace.call(match, node);
+
+ if (trace === null) {
+ return false;
+ }
+
+ return trace.some(fn);
+}
+
+function isType(node, type) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Type' && matchNode.name === type;
+ });
+}
+
+function isProperty(node, property) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Property' && matchNode.name === property;
+ });
+}
+
+function isKeyword(node) {
+ return testNode(this, node, function(matchNode) {
+ return matchNode.type === 'Keyword';
+ });
+}
+
+module.exports = {
+ getTrace: getTrace,
+ isType: isType,
+ isProperty: isProperty,
+ isKeyword: isKeyword
+};
diff --git a/node_modules/css-tree/lib/parser/create.js b/node_modules/css-tree/lib/parser/create.js
new file mode 100644
index 0000000..a01f625
--- /dev/null
+++ b/node_modules/css-tree/lib/parser/create.js
@@ -0,0 +1,304 @@
+var OffsetToLocation = require('../common/OffsetToLocation');
+var SyntaxError = require('../common/SyntaxError');
+var TokenStream = require('../common/TokenStream');
+var List = require('../common/List');
+var tokenize = require('../tokenizer');
+var constants = require('../tokenizer/const');
+var { findWhiteSpaceStart, cmpStr } = require('../tokenizer/utils');
+var sequence = require('./sequence');
+var noop = function() {};
+
+var TYPE = constants.TYPE;
+var NAME = constants.NAME;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var HASH = TYPE.Hash;
+var PERCENTAGE = TYPE.Percentage;
+var NUMBER = TYPE.Number;
+var NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)
+var NULL = 0;
+
+function createParseContext(name) {
+ return function() {
+ return this[name]();
+ };
+}
+
+function processConfig(config) {
+ var parserConfig = {
+ context: {},
+ scope: {},
+ atrule: {},
+ pseudo: {}
+ };
+
+ if (config.parseContext) {
+ for (var name in config.parseContext) {
+ switch (typeof config.parseContext[name]) {
+ case 'function':
+ parserConfig.context[name] = config.parseContext[name];
+ break;
+
+ case 'string':
+ parserConfig.context[name] = createParseContext(config.parseContext[name]);
+ break;
+ }
+ }
+ }
+
+ if (config.scope) {
+ for (var name in config.scope) {
+ parserConfig.scope[name] = config.scope[name];
+ }
+ }
+
+ if (config.atrule) {
+ for (var name in config.atrule) {
+ var atrule = config.atrule[name];
+
+ if (atrule.parse) {
+ parserConfig.atrule[name] = atrule.parse;
+ }
+ }
+ }
+
+ if (config.pseudo) {
+ for (var name in config.pseudo) {
+ var pseudo = config.pseudo[name];
+
+ if (pseudo.parse) {
+ parserConfig.pseudo[name] = pseudo.parse;
+ }
+ }
+ }
+
+ if (config.node) {
+ for (var name in config.node) {
+ parserConfig[name] = config.node[name].parse;
+ }
+ }
+
+ return parserConfig;
+}
+
+module.exports = function createParser(config) {
+ var parser = {
+ scanner: new TokenStream(),
+ locationMap: new OffsetToLocation(),
+
+ filename: '<unknown>',
+ needPositions: false,
+ onParseError: noop,
+ onParseErrorThrow: false,
+ parseAtrulePrelude: true,
+ parseRulePrelude: true,
+ parseValue: true,
+ parseCustomProperty: false,
+
+ readSequence: sequence,
+
+ createList: function() {
+ return new List();
+ },
+ createSingleNodeList: function(node) {
+ return new List().appendData(node);
+ },
+ getFirstListNode: function(list) {
+ return list && list.first();
+ },
+ getLastListNode: function(list) {
+ return list.last();
+ },
+
+ parseWithFallback: function(consumer, fallback) {
+ var startToken = this.scanner.tokenIndex;
+
+ try {
+ return consumer.call(this);
+ } catch (e) {
+ if (this.onParseErrorThrow) {
+ throw e;
+ }
+
+ var fallbackNode = fallback.call(this, startToken);
+
+ this.onParseErrorThrow = true;
+ this.onParseError(e, fallbackNode);
+ this.onParseErrorThrow = false;
+
+ return fallbackNode;
+ }
+ },
+
+ lookupNonWSType: function(offset) {
+ do {
+ var type = this.scanner.lookupType(offset++);
+ if (type !== WHITESPACE) {
+ return type;
+ }
+ } while (type !== NULL);
+
+ return NULL;
+ },
+
+ eat: function(tokenType) {
+ if (this.scanner.tokenType !== tokenType) {
+ var offset = this.scanner.tokenStart;
+ var message = NAME[tokenType] + ' is expected';
+
+ // tweak message and offset
+ switch (tokenType) {
+ case IDENT:
+ // when identifier is expected but there is a function or url
+ if (this.scanner.tokenType === FUNCTION || this.scanner.tokenType === URL) {
+ offset = this.scanner.tokenEnd - 1;
+ message = 'Identifier is expected but function found';
+ } else {
+ message = 'Identifier is expected';
+ }
+ break;
+
+ case HASH:
+ if (this.scanner.isDelim(NUMBERSIGN)) {
+ this.scanner.next();
+ offset++;
+ message = 'Name is expected';
+ }
+ break;
+
+ case PERCENTAGE:
+ if (this.scanner.tokenType === NUMBER) {
+ offset = this.scanner.tokenEnd;
+ message = 'Percent sign is expected';
+ }
+ break;
+
+ default:
+ // when test type is part of another token show error for current position + 1
+ // e.g. eat(HYPHENMINUS) will fail on "-foo", but pointing on "-" is odd
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === tokenType) {
+ offset = offset + 1;
+ }
+ }
+
+ this.error(message, offset);
+ }
+
+ this.scanner.next();
+ },
+
+ consume: function(tokenType) {
+ var value = this.scanner.getTokenValue();
+
+ this.eat(tokenType);
+
+ return value;
+ },
+ consumeFunctionName: function() {
+ var name = this.scanner.source.substring(this.scanner.tokenStart, this.scanner.tokenEnd - 1);
+
+ this.eat(FUNCTION);
+
+ return name;
+ },
+
+ getLocation: function(start, end) {
+ if (this.needPositions) {
+ return this.locationMap.getLocationRange(
+ start,
+ end,
+ this.filename
+ );
+ }
+
+ return null;
+ },
+ getLocationFromList: function(list) {
+ if (this.needPositions) {
+ var head = this.getFirstListNode(list);
+ var tail = this.getLastListNode(list);
+ return this.locationMap.getLocationRange(
+ head !== null ? head.loc.start.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+ tail !== null ? tail.loc.end.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+ this.filename
+ );
+ }
+
+ return null;
+ },
+
+ error: function(message, offset) {
+ var location = typeof offset !== 'undefined' && offset < this.scanner.source.length
+ ? this.locationMap.getLocation(offset)
+ : this.scanner.eof
+ ? this.locationMap.getLocation(findWhiteSpaceStart(this.scanner.source, this.scanner.source.length - 1))
+ : this.locationMap.getLocation(this.scanner.tokenStart);
+
+ throw new SyntaxError(
+ message || 'Unexpected input',
+ this.scanner.source,
+ location.offset,
+ location.line,
+ location.column
+ );
+ }
+ };
+
+ config = processConfig(config || {});
+ for (var key in config) {
+ parser[key] = config[key];
+ }
+
+ return function(source, options) {
+ options = options || {};
+
+ var context = options.context || 'default';
+ var onComment = options.onComment;
+ var ast;
+
+ tokenize(source, parser.scanner);
+ parser.locationMap.setSource(
+ source,
+ options.offset,
+ options.line,
+ options.column
+ );
+
+ parser.filename = options.filename || '<unknown>';
+ parser.needPositions = Boolean(options.positions);
+ parser.onParseError = typeof options.onParseError === 'function' ? options.onParseError : noop;
+ parser.onParseErrorThrow = false;
+ parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;
+ parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;
+ parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
+ parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
+
+ if (!parser.context.hasOwnProperty(context)) {
+ throw new Error('Unknown context `' + context + '`');
+ }
+
+ if (typeof onComment === 'function') {
+ parser.scanner.forEachToken((type, start, end) => {
+ if (type === COMMENT) {
+ const loc = parser.getLocation(start, end);
+ const value = cmpStr(source, end - 2, end, '*/')
+ ? source.slice(start + 2, end - 2)
+ : source.slice(start + 2, end);
+
+ onComment(value, loc);
+ }
+ });
+ }
+
+ ast = parser.context[context].call(parser, options);
+
+ if (!parser.scanner.eof) {
+ parser.error();
+ }
+
+ return ast;
+ };
+};
diff --git a/node_modules/css-tree/lib/parser/index.js b/node_modules/css-tree/lib/parser/index.js
new file mode 100644
index 0000000..1cba9c3
--- /dev/null
+++ b/node_modules/css-tree/lib/parser/index.js
@@ -0,0 +1,4 @@
+var createParser = require('./create');
+var config = require('../syntax/config/parser');
+
+module.exports = createParser(config);
diff --git a/node_modules/css-tree/lib/parser/sequence.js b/node_modules/css-tree/lib/parser/sequence.js
new file mode 100644
index 0000000..44647e5
--- /dev/null
+++ b/node_modules/css-tree/lib/parser/sequence.js
@@ -0,0 +1,54 @@
+var TYPE = require('../tokenizer').TYPE;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+
+module.exports = function readSequence(recognizer) {
+ var children = this.createList();
+ var child = null;
+ var context = {
+ recognizer: recognizer,
+ space: null,
+ ignoreWS: false,
+ ignoreWSAfter: false
+ };
+
+ this.scanner.skipSC();
+
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case COMMENT:
+ this.scanner.next();
+ continue;
+
+ case WHITESPACE:
+ if (context.ignoreWS) {
+ this.scanner.next();
+ } else {
+ context.space = this.WhiteSpace();
+ }
+ continue;
+ }
+
+ child = recognizer.getNode.call(this, context);
+
+ if (child === undefined) {
+ break;
+ }
+
+ if (context.space !== null) {
+ children.push(context.space);
+ context.space = null;
+ }
+
+ children.push(child);
+
+ if (context.ignoreWSAfter) {
+ context.ignoreWSAfter = false;
+ context.ignoreWS = true;
+ } else {
+ context.ignoreWS = false;
+ }
+ }
+
+ return children;
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/font-face.js b/node_modules/css-tree/lib/syntax/atrule/font-face.js
new file mode 100644
index 0000000..ea33ad9
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/font-face.js
@@ -0,0 +1,8 @@
+module.exports = {
+ parse: {
+ prelude: null,
+ block: function() {
+ return this.Block(true);
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/import.js b/node_modules/css-tree/lib/syntax/atrule/import.js
new file mode 100644
index 0000000..58bda97
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/import.js
@@ -0,0 +1,40 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var STRING = TYPE.String;
+var IDENT = TYPE.Ident;
+var URL = TYPE.Url;
+var FUNCTION = TYPE.Function;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+
+module.exports = {
+ parse: {
+ prelude: function() {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ switch (this.scanner.tokenType) {
+ case STRING:
+ children.push(this.String());
+ break;
+
+ case URL:
+ case FUNCTION:
+ children.push(this.Url());
+ break;
+
+ default:
+ this.error('String or url() is expected');
+ }
+
+ if (this.lookupNonWSType(0) === IDENT ||
+ this.lookupNonWSType(0) === LEFTPARENTHESIS) {
+ children.push(this.WhiteSpace());
+ children.push(this.MediaQueryList());
+ }
+
+ return children;
+ },
+ block: null
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/index.js b/node_modules/css-tree/lib/syntax/atrule/index.js
new file mode 100644
index 0000000..5098cfb
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/index.js
@@ -0,0 +1,7 @@
+module.exports = {
+ 'font-face': require('./font-face'),
+ 'import': require('./import'),
+ 'media': require('./media'),
+ 'page': require('./page'),
+ 'supports': require('./supports')
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/media.js b/node_modules/css-tree/lib/syntax/atrule/media.js
new file mode 100644
index 0000000..f148346
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/media.js
@@ -0,0 +1,12 @@
+module.exports = {
+ parse: {
+ prelude: function() {
+ return this.createSingleNodeList(
+ this.MediaQueryList()
+ );
+ },
+ block: function() {
+ return this.Block(false);
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/page.js b/node_modules/css-tree/lib/syntax/atrule/page.js
new file mode 100644
index 0000000..aa2229f
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/page.js
@@ -0,0 +1,12 @@
+module.exports = {
+ parse: {
+ prelude: function() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ },
+ block: function() {
+ return this.Block(true);
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/atrule/supports.js b/node_modules/css-tree/lib/syntax/atrule/supports.js
new file mode 100644
index 0000000..75fa1d8
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/atrule/supports.js
@@ -0,0 +1,89 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var FUNCTION = TYPE.Function;
+var COLON = TYPE.Colon;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+
+function consumeRaw() {
+ return this.createSingleNodeList(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+}
+
+function parentheses() {
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType === IDENT &&
+ this.lookupNonWSType(1) === COLON) {
+ return this.createSingleNodeList(
+ this.Declaration()
+ );
+ }
+
+ return readSequence.call(this);
+}
+
+function readSequence() {
+ var children = this.createList();
+ var space = null;
+ var child;
+
+ this.scanner.skipSC();
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE:
+ space = this.WhiteSpace();
+ continue;
+
+ case COMMENT:
+ this.scanner.next();
+ continue;
+
+ case FUNCTION:
+ child = this.Function(consumeRaw, this.scope.AtrulePrelude);
+ break;
+
+ case IDENT:
+ child = this.Identifier();
+ break;
+
+ case LEFTPARENTHESIS:
+ child = this.Parentheses(parentheses, this.scope.AtrulePrelude);
+ break;
+
+ default:
+ break scan;
+ }
+
+ if (space !== null) {
+ children.push(space);
+ space = null;
+ }
+
+ children.push(child);
+ }
+
+ return children;
+}
+
+module.exports = {
+ parse: {
+ prelude: function() {
+ var children = readSequence.call(this);
+
+ if (this.getFirstListNode(children) === null) {
+ this.error('Condition is expected');
+ }
+
+ return children;
+ },
+ block: function() {
+ return this.Block(false);
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/config/lexer.js b/node_modules/css-tree/lib/syntax/config/lexer.js
new file mode 100644
index 0000000..2c58b0f
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/config/lexer.js
@@ -0,0 +1,9 @@
+var data = require('../../../data');
+
+module.exports = {
+ generic: true,
+ types: data.types,
+ atrules: data.atrules,
+ properties: data.properties,
+ node: require('../node')
+};
diff --git a/node_modules/css-tree/lib/syntax/config/mix.js b/node_modules/css-tree/lib/syntax/config/mix.js
new file mode 100644
index 0000000..8eb57ec
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/config/mix.js
@@ -0,0 +1,140 @@
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const shape = {
+ generic: true,
+ types: appendOrAssign,
+ atrules: {
+ prelude: appendOrAssignOrNull,
+ descriptors: appendOrAssignOrNull
+ },
+ properties: appendOrAssign,
+ parseContext: assign,
+ scope: deepAssign,
+ atrule: ['parse'],
+ pseudo: ['parse'],
+ node: ['name', 'structure', 'parse', 'generate', 'walkContext']
+};
+
+function isObject(value) {
+ return value && value.constructor === Object;
+}
+
+function copy(value) {
+ return isObject(value)
+ ? Object.assign({}, value)
+ : value;
+}
+
+function assign(dest, src) {
+ return Object.assign(dest, src);
+}
+
+function deepAssign(dest, src) {
+ for (const key in src) {
+ if (hasOwnProperty.call(src, key)) {
+ if (isObject(dest[key])) {
+ deepAssign(dest[key], copy(src[key]));
+ } else {
+ dest[key] = copy(src[key]);
+ }
+ }
+ }
+
+ return dest;
+}
+
+function append(a, b) {
+ if (typeof b === 'string' && /^\s*\|/.test(b)) {
+ return typeof a === 'string'
+ ? a + b
+ : b.replace(/^\s*\|\s*/, '');
+ }
+
+ return b || null;
+}
+
+function appendOrAssign(a, b) {
+ if (typeof b === 'string') {
+ return append(a, b);
+ }
+
+ const result = Object.assign({}, a);
+ for (let key in b) {
+ if (hasOwnProperty.call(b, key)) {
+ result[key] = append(hasOwnProperty.call(a, key) ? a[key] : undefined, b[key]);
+ }
+ }
+
+ return result;
+}
+
+function appendOrAssignOrNull(a, b) {
+ const result = appendOrAssign(a, b);
+
+ return !isObject(result) || Object.keys(result).length
+ ? result
+ : null;
+}
+
+function mix(dest, src, shape) {
+ for (const key in shape) {
+ if (hasOwnProperty.call(shape, key) === false) {
+ continue;
+ }
+
+ if (shape[key] === true) {
+ if (key in src) {
+ if (hasOwnProperty.call(src, key)) {
+ dest[key] = copy(src[key]);
+ }
+ }
+ } else if (shape[key]) {
+ if (typeof shape[key] === 'function') {
+ const fn = shape[key];
+ dest[key] = fn({}, dest[key]);
+ dest[key] = fn(dest[key] || {}, src[key]);
+ } else if (isObject(shape[key])) {
+ const result = {};
+
+ for (let name in dest[key]) {
+ result[name] = mix({}, dest[key][name], shape[key]);
+ }
+
+ for (let name in src[key]) {
+ result[name] = mix(result[name] || {}, src[key][name], shape[key]);
+ }
+
+ dest[key] = result;
+ } else if (Array.isArray(shape[key])) {
+ const res = {};
+ const innerShape = shape[key].reduce(function(s, k) {
+ s[k] = true;
+ return s;
+ }, {});
+
+ for (const [name, value] of Object.entries(dest[key] || {})) {
+ res[name] = {};
+ if (value) {
+ mix(res[name], value, innerShape);
+ }
+ }
+
+ for (const name in src[key]) {
+ if (hasOwnProperty.call(src[key], name)) {
+ if (!res[name]) {
+ res[name] = {};
+ }
+
+ if (src[key] && src[key][name]) {
+ mix(res[name], src[key][name], innerShape);
+ }
+ }
+ }
+
+ dest[key] = res;
+ }
+ }
+ }
+ return dest;
+}
+
+module.exports = (dest, src) => mix(dest, src, shape);
diff --git a/node_modules/css-tree/lib/syntax/config/parser.js b/node_modules/css-tree/lib/syntax/config/parser.js
new file mode 100644
index 0000000..88d2921
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/config/parser.js
@@ -0,0 +1,25 @@
+module.exports = {
+ parseContext: {
+ default: 'StyleSheet',
+ stylesheet: 'StyleSheet',
+ atrule: 'Atrule',
+ atrulePrelude: function(options) {
+ return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);
+ },
+ mediaQueryList: 'MediaQueryList',
+ mediaQuery: 'MediaQuery',
+ rule: 'Rule',
+ selectorList: 'SelectorList',
+ selector: 'Selector',
+ block: function() {
+ return this.Block(true);
+ },
+ declarationList: 'DeclarationList',
+ declaration: 'Declaration',
+ value: 'Value'
+ },
+ scope: require('../scope'),
+ atrule: require('../atrule'),
+ pseudo: require('../pseudo'),
+ node: require('../node')
+};
diff --git a/node_modules/css-tree/lib/syntax/config/walker.js b/node_modules/css-tree/lib/syntax/config/walker.js
new file mode 100644
index 0000000..3a030de
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/config/walker.js
@@ -0,0 +1,3 @@
+module.exports = {
+ node: require('../node')
+};
diff --git a/node_modules/css-tree/lib/syntax/create.js b/node_modules/css-tree/lib/syntax/create.js
new file mode 100644
index 0000000..68b6d16
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/create.js
@@ -0,0 +1,77 @@
+var List = require('../common/List');
+var SyntaxError = require('../common/SyntaxError');
+var TokenStream = require('../common/TokenStream');
+var Lexer = require('../lexer/Lexer');
+var definitionSyntax = require('../definition-syntax');
+var tokenize = require('../tokenizer');
+var createParser = require('../parser/create');
+var createGenerator = require('../generator/create');
+var createConvertor = require('../convertor/create');
+var createWalker = require('../walker/create');
+var clone = require('../utils/clone');
+var names = require('../utils/names');
+var mix = require('./config/mix');
+
+function createSyntax(config) {
+ var parse = createParser(config);
+ var walk = createWalker(config);
+ var generate = createGenerator(config);
+ var convert = createConvertor(walk);
+
+ var syntax = {
+ List: List,
+ SyntaxError: SyntaxError,
+ TokenStream: TokenStream,
+ Lexer: Lexer,
+
+ vendorPrefix: names.vendorPrefix,
+ keyword: names.keyword,
+ property: names.property,
+ isCustomProperty: names.isCustomProperty,
+
+ definitionSyntax: definitionSyntax,
+ lexer: null,
+ createLexer: function(config) {
+ return new Lexer(config, syntax, syntax.lexer.structure);
+ },
+
+ tokenize: tokenize,
+ parse: parse,
+ walk: walk,
+ generate: generate,
+
+ find: walk.find,
+ findLast: walk.findLast,
+ findAll: walk.findAll,
+
+ clone: clone,
+ fromPlainObject: convert.fromPlainObject,
+ toPlainObject: convert.toPlainObject,
+
+ createSyntax: function(config) {
+ return createSyntax(mix({}, config));
+ },
+ fork: function(extension) {
+ var base = mix({}, config); // copy of config
+ return createSyntax(
+ typeof extension === 'function'
+ ? extension(base, Object.assign)
+ : mix(base, extension)
+ );
+ }
+ };
+
+ syntax.lexer = new Lexer({
+ generic: true,
+ types: config.types,
+ atrules: config.atrules,
+ properties: config.properties,
+ node: config.node
+ }, syntax);
+
+ return syntax;
+};
+
+exports.create = function(config) {
+ return createSyntax(mix({}, config));
+};
diff --git a/node_modules/css-tree/lib/syntax/function/expression.js b/node_modules/css-tree/lib/syntax/function/expression.js
new file mode 100644
index 0000000..e76f631
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/function/expression.js
@@ -0,0 +1,7 @@
+// legacy IE function
+// expression( <any-value> )
+module.exports = function() {
+ return this.createSingleNodeList(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+};
diff --git a/node_modules/css-tree/lib/syntax/function/var.js b/node_modules/css-tree/lib/syntax/function/var.js
new file mode 100644
index 0000000..ba55b48
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/function/var.js
@@ -0,0 +1,43 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('../node/Raw').mode;
+
+var COMMA = TYPE.Comma;
+var WHITESPACE = TYPE.WhiteSpace;
+
+// var( <ident> , <value>? )
+module.exports = function() {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ // NOTE: Don't check more than a first argument is an ident, rest checks are for lexer
+ children.push(this.Identifier());
+
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType === COMMA) {
+ children.push(this.Operator());
+
+ const startIndex = this.scanner.tokenIndex;
+ const value = this.parseCustomProperty
+ ? this.Value(null)
+ : this.Raw(this.scanner.tokenIndex, rawMode.exclamationMarkOrSemicolon, false);
+
+ if (value.type === 'Value' && value.children.isEmpty()) {
+ for (let offset = startIndex - this.scanner.tokenIndex; offset <= 0; offset++) {
+ if (this.scanner.lookupType(offset) === WHITESPACE) {
+ value.children.appendData({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+ });
+ break;
+ }
+ }
+ }
+
+ children.push(value);
+ }
+
+ return children;
+};
diff --git a/node_modules/css-tree/lib/syntax/index.js b/node_modules/css-tree/lib/syntax/index.js
new file mode 100644
index 0000000..065ea04
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/index.js
@@ -0,0 +1,21 @@
+function merge() {
+ var dest = {};
+
+ for (var i = 0; i < arguments.length; i++) {
+ var src = arguments[i];
+ for (var key in src) {
+ dest[key] = src[key];
+ }
+ }
+
+ return dest;
+}
+
+module.exports = require('./create').create(
+ merge(
+ require('./config/lexer'),
+ require('./config/parser'),
+ require('./config/walker')
+ )
+);
+module.exports.version = require('../../package.json').version;
diff --git a/node_modules/css-tree/lib/syntax/node/AnPlusB.js b/node_modules/css-tree/lib/syntax/node/AnPlusB.js
new file mode 100644
index 0000000..d33d21a
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/AnPlusB.js
@@ -0,0 +1,297 @@
+var cmpChar = require('../../tokenizer').cmpChar;
+var isDigit = require('../../tokenizer').isDigit;
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var N = 0x006E; // U+006E LATIN SMALL LETTER N (n)
+var DISALLOW_SIGN = true;
+var ALLOW_SIGN = false;
+
+function checkInteger(offset, disallowSign) {
+ var pos = this.scanner.tokenStart + offset;
+ var code = this.scanner.source.charCodeAt(pos);
+
+ if (code === PLUSSIGN || code === HYPHENMINUS) {
+ if (disallowSign) {
+ this.error('Number sign is not allowed');
+ }
+ pos++;
+ }
+
+ for (; pos < this.scanner.tokenEnd; pos++) {
+ if (!isDigit(this.scanner.source.charCodeAt(pos))) {
+ this.error('Integer is expected', pos);
+ }
+ }
+}
+
+function checkTokenIsInteger(disallowSign) {
+ return checkInteger.call(this, 0, disallowSign);
+}
+
+function expectCharCode(offset, code) {
+ if (!cmpChar(this.scanner.source, this.scanner.tokenStart + offset, code)) {
+ var msg = '';
+
+ switch (code) {
+ case N:
+ msg = 'N is expected';
+ break;
+ case HYPHENMINUS:
+ msg = 'HyphenMinus is expected';
+ break;
+ }
+
+ this.error(msg, this.scanner.tokenStart + offset);
+ }
+}
+
+// ... <signed-integer>
+// ... ['+' | '-'] <signless-integer>
+function consumeB() {
+ var offset = 0;
+ var sign = 0;
+ var type = this.scanner.tokenType;
+
+ while (type === WHITESPACE || type === COMMENT) {
+ type = this.scanner.lookupType(++offset);
+ }
+
+ if (type !== NUMBER) {
+ if (this.scanner.isDelim(PLUSSIGN, offset) ||
+ this.scanner.isDelim(HYPHENMINUS, offset)) {
+ sign = this.scanner.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;
+
+ do {
+ type = this.scanner.lookupType(++offset);
+ } while (type === WHITESPACE || type === COMMENT);
+
+ if (type !== NUMBER) {
+ this.scanner.skip(offset);
+ checkTokenIsInteger.call(this, DISALLOW_SIGN);
+ }
+ } else {
+ return null;
+ }
+ }
+
+ if (offset > 0) {
+ this.scanner.skip(offset);
+ }
+
+ if (sign === 0) {
+ type = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+ if (type !== PLUSSIGN && type !== HYPHENMINUS) {
+ this.error('Number sign is expected');
+ }
+ }
+
+ checkTokenIsInteger.call(this, sign !== 0);
+ return sign === HYPHENMINUS ? '-' + this.consume(NUMBER) : this.consume(NUMBER);
+}
+
+// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+module.exports = {
+ name: 'AnPlusB',
+ structure: {
+ a: [String, null],
+ b: [String, null]
+ },
+ parse: function() {
+ /* eslint-disable brace-style*/
+ var start = this.scanner.tokenStart;
+ var a = null;
+ var b = null;
+
+ // <integer>
+ if (this.scanner.tokenType === NUMBER) {
+ checkTokenIsInteger.call(this, ALLOW_SIGN);
+ b = this.consume(NUMBER);
+ }
+
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ // -n- <signless-integer>
+ // <dashndashdigit-ident>
+ else if (this.scanner.tokenType === IDENT && cmpChar(this.scanner.source, this.scanner.tokenStart, HYPHENMINUS)) {
+ a = '-1';
+
+ expectCharCode.call(this, 1, N);
+
+ switch (this.scanner.getTokenLength()) {
+ // -n
+ // -n <signed-integer>
+ // -n ['+' | '-'] <signless-integer>
+ case 2:
+ this.scanner.next();
+ b = consumeB.call(this);
+ break;
+
+ // -n- <signless-integer>
+ case 3:
+ expectCharCode.call(this, 2, HYPHENMINUS);
+
+ this.scanner.next();
+ this.scanner.skipSC();
+
+ checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+ b = '-' + this.consume(NUMBER);
+ break;
+
+ // <dashndashdigit-ident>
+ default:
+ expectCharCode.call(this, 2, HYPHENMINUS);
+ checkInteger.call(this, 3, DISALLOW_SIGN);
+ this.scanner.next();
+
+ b = this.scanner.substrToCursor(start + 2);
+ }
+ }
+
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ // '+'? n- <signless-integer>
+ // '+'? <ndashdigit-ident>
+ else if (this.scanner.tokenType === IDENT || (this.scanner.isDelim(PLUSSIGN) && this.scanner.lookupType(1) === IDENT)) {
+ var sign = 0;
+ a = '1';
+
+ // just ignore a plus
+ if (this.scanner.isDelim(PLUSSIGN)) {
+ sign = 1;
+ this.scanner.next();
+ }
+
+ expectCharCode.call(this, 0, N);
+
+ switch (this.scanner.getTokenLength()) {
+ // '+'? n
+ // '+'? n <signed-integer>
+ // '+'? n ['+' | '-'] <signless-integer>
+ case 1:
+ this.scanner.next();
+ b = consumeB.call(this);
+ break;
+
+ // '+'? n- <signless-integer>
+ case 2:
+ expectCharCode.call(this, 1, HYPHENMINUS);
+
+ this.scanner.next();
+ this.scanner.skipSC();
+
+ checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+ b = '-' + this.consume(NUMBER);
+ break;
+
+ // '+'? <ndashdigit-ident>
+ default:
+ expectCharCode.call(this, 1, HYPHENMINUS);
+ checkInteger.call(this, 2, DISALLOW_SIGN);
+ this.scanner.next();
+
+ b = this.scanner.substrToCursor(start + sign + 1);
+ }
+ }
+
+ // <ndashdigit-dimension>
+ // <ndash-dimension> <signless-integer>
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ else if (this.scanner.tokenType === DIMENSION) {
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+ var sign = code === PLUSSIGN || code === HYPHENMINUS;
+
+ for (var i = this.scanner.tokenStart + sign; i < this.scanner.tokenEnd; i++) {
+ if (!isDigit(this.scanner.source.charCodeAt(i))) {
+ break;
+ }
+ }
+
+ if (i === this.scanner.tokenStart + sign) {
+ this.error('Integer is expected', this.scanner.tokenStart + sign);
+ }
+
+ expectCharCode.call(this, i - this.scanner.tokenStart, N);
+ a = this.scanner.source.substring(start, i);
+
+ // <n-dimension>
+ // <n-dimension> <signed-integer>
+ // <n-dimension> ['+' | '-'] <signless-integer>
+ if (i + 1 === this.scanner.tokenEnd) {
+ this.scanner.next();
+ b = consumeB.call(this);
+ } else {
+ expectCharCode.call(this, i - this.scanner.tokenStart + 1, HYPHENMINUS);
+
+ // <ndash-dimension> <signless-integer>
+ if (i + 2 === this.scanner.tokenEnd) {
+ this.scanner.next();
+ this.scanner.skipSC();
+ checkTokenIsInteger.call(this, DISALLOW_SIGN);
+ b = '-' + this.consume(NUMBER);
+ }
+ // <ndashdigit-dimension>
+ else {
+ checkInteger.call(this, i - this.scanner.tokenStart + 2, DISALLOW_SIGN);
+ this.scanner.next();
+ b = this.scanner.substrToCursor(i + 1);
+ }
+ }
+ } else {
+ this.error();
+ }
+
+ if (a !== null && a.charCodeAt(0) === PLUSSIGN) {
+ a = a.substr(1);
+ }
+
+ if (b !== null && b.charCodeAt(0) === PLUSSIGN) {
+ b = b.substr(1);
+ }
+
+ return {
+ type: 'AnPlusB',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ a: a,
+ b: b
+ };
+ },
+ generate: function(node) {
+ var a = node.a !== null && node.a !== undefined;
+ var b = node.b !== null && node.b !== undefined;
+
+ if (a) {
+ this.chunk(
+ node.a === '+1' ? '+n' : // eslint-disable-line operator-linebreak, indent
+ node.a === '1' ? 'n' : // eslint-disable-line operator-linebreak, indent
+ node.a === '-1' ? '-n' : // eslint-disable-line operator-linebreak, indent
+ node.a + 'n' // eslint-disable-line operator-linebreak, indent
+ );
+
+ if (b) {
+ b = String(node.b);
+ if (b.charAt(0) === '-' || b.charAt(0) === '+') {
+ this.chunk(b.charAt(0));
+ this.chunk(b.substr(1));
+ } else {
+ this.chunk('+');
+ this.chunk(b);
+ }
+ }
+ } else {
+ this.chunk(String(node.b));
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Atrule.js b/node_modules/css-tree/lib/syntax/node/Atrule.js
new file mode 100644
index 0000000..284499f
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Atrule.js
@@ -0,0 +1,107 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var ATKEYWORD = TYPE.AtKeyword;
+var SEMICOLON = TYPE.Semicolon;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
+
+function consumeRaw(startToken) {
+ return this.Raw(startToken, rawMode.leftCurlyBracketOrSemicolon, true);
+}
+
+function isDeclarationBlockAtrule() {
+ for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
+ if (type === RIGHTCURLYBRACKET) {
+ return true;
+ }
+
+ if (type === LEFTCURLYBRACKET ||
+ type === ATKEYWORD) {
+ return false;
+ }
+ }
+
+ return false;
+}
+
+module.exports = {
+ name: 'Atrule',
+ structure: {
+ name: String,
+ prelude: ['AtrulePrelude', 'Raw', null],
+ block: ['Block', null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var nameLowerCase;
+ var prelude = null;
+ var block = null;
+
+ this.eat(ATKEYWORD);
+
+ name = this.scanner.substrToCursor(start + 1);
+ nameLowerCase = name.toLowerCase();
+ this.scanner.skipSC();
+
+ // parse prelude
+ if (this.scanner.eof === false &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET &&
+ this.scanner.tokenType !== SEMICOLON) {
+ if (this.parseAtrulePrelude) {
+ prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
+
+ // turn empty AtrulePrelude into null
+ if (prelude.type === 'AtrulePrelude' && prelude.children.head === null) {
+ prelude = null;
+ }
+ } else {
+ prelude = consumeRaw.call(this, this.scanner.tokenIndex);
+ }
+
+ this.scanner.skipSC();
+ }
+
+ switch (this.scanner.tokenType) {
+ case SEMICOLON:
+ this.scanner.next();
+ break;
+
+ case LEFTCURLYBRACKET:
+ if (this.atrule.hasOwnProperty(nameLowerCase) &&
+ typeof this.atrule[nameLowerCase].block === 'function') {
+ block = this.atrule[nameLowerCase].block.call(this);
+ } else {
+ // TODO: should consume block content as Raw?
+ block = this.Block(isDeclarationBlockAtrule.call(this));
+ }
+
+ break;
+ }
+
+ return {
+ type: 'Atrule',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ prelude: prelude,
+ block: block
+ };
+ },
+ generate: function(node) {
+ this.chunk('@');
+ this.chunk(node.name);
+
+ if (node.prelude !== null) {
+ this.chunk(' ');
+ this.node(node.prelude);
+ }
+
+ if (node.block) {
+ this.node(node.block);
+ } else {
+ this.chunk(';');
+ }
+ },
+ walkContext: 'atrule'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/AtrulePrelude.js b/node_modules/css-tree/lib/syntax/node/AtrulePrelude.js
new file mode 100644
index 0000000..f9f21ff
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/AtrulePrelude.js
@@ -0,0 +1,51 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var SEMICOLON = TYPE.Semicolon;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+
+module.exports = {
+ name: 'AtrulePrelude',
+ structure: {
+ children: [[]]
+ },
+ parse: function(name) {
+ var children = null;
+
+ if (name !== null) {
+ name = name.toLowerCase();
+ }
+
+ this.scanner.skipSC();
+
+ if (this.atrule.hasOwnProperty(name) &&
+ typeof this.atrule[name].prelude === 'function') {
+ // custom consumer
+ children = this.atrule[name].prelude.call(this);
+ } else {
+ // default consumer
+ children = this.readSequence(this.scope.AtrulePrelude);
+ }
+
+ this.scanner.skipSC();
+
+ if (this.scanner.eof !== true &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET &&
+ this.scanner.tokenType !== SEMICOLON) {
+ this.error('Semicolon or block is expected');
+ }
+
+ if (children === null) {
+ children = this.createList();
+ }
+
+ return {
+ type: 'AtrulePrelude',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ },
+ walkContext: 'atrulePrelude'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/AttributeSelector.js b/node_modules/css-tree/lib/syntax/node/AttributeSelector.js
new file mode 100644
index 0000000..656446c
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/AttributeSelector.js
@@ -0,0 +1,165 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var STRING = TYPE.String;
+var COLON = TYPE.Colon;
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var RIGHTSQUAREBRACKET = TYPE.RightSquareBracket;
+var DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)
+var CIRCUMFLEXACCENT = 0x005E; // U+005E (^)
+var VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)
+var TILDE = 0x007E; // U+007E TILDE (~)
+
+function getAttributeName() {
+ if (this.scanner.eof) {
+ this.error('Unexpected end of input');
+ }
+
+ var start = this.scanner.tokenStart;
+ var expectIdent = false;
+ var checkColon = true;
+
+ if (this.scanner.isDelim(ASTERISK)) {
+ expectIdent = true;
+ checkColon = false;
+ this.scanner.next();
+ } else if (!this.scanner.isDelim(VERTICALLINE)) {
+ this.eat(IDENT);
+ }
+
+ if (this.scanner.isDelim(VERTICALLINE)) {
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 1) !== EQUALSSIGN) {
+ this.scanner.next();
+ this.eat(IDENT);
+ } else if (expectIdent) {
+ this.error('Identifier is expected', this.scanner.tokenEnd);
+ }
+ } else if (expectIdent) {
+ this.error('Vertical line is expected');
+ }
+
+ if (checkColon && this.scanner.tokenType === COLON) {
+ this.scanner.next();
+ this.eat(IDENT);
+ }
+
+ return {
+ type: 'Identifier',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+}
+
+function getOperator() {
+ var start = this.scanner.tokenStart;
+ var code = this.scanner.source.charCodeAt(start);
+
+ if (code !== EQUALSSIGN && // =
+ code !== TILDE && // ~=
+ code !== CIRCUMFLEXACCENT && // ^=
+ code !== DOLLARSIGN && // $=
+ code !== ASTERISK && // *=
+ code !== VERTICALLINE // |=
+ ) {
+ this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
+ }
+
+ this.scanner.next();
+
+ if (code !== EQUALSSIGN) {
+ if (!this.scanner.isDelim(EQUALSSIGN)) {
+ this.error('Equal sign is expected');
+ }
+
+ this.scanner.next();
+ }
+
+ return this.scanner.substrToCursor(start);
+}
+
+// '[' <wq-name> ']'
+// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
+module.exports = {
+ name: 'AttributeSelector',
+ structure: {
+ name: 'Identifier',
+ matcher: [String, null],
+ value: ['String', 'Identifier', null],
+ flags: [String, null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var matcher = null;
+ var value = null;
+ var flags = null;
+
+ this.eat(LEFTSQUAREBRACKET);
+ this.scanner.skipSC();
+
+ name = getAttributeName.call(this);
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType !== RIGHTSQUAREBRACKET) {
+ // avoid case `[name i]`
+ if (this.scanner.tokenType !== IDENT) {
+ matcher = getOperator.call(this);
+
+ this.scanner.skipSC();
+
+ value = this.scanner.tokenType === STRING
+ ? this.String()
+ : this.Identifier();
+
+ this.scanner.skipSC();
+ }
+
+ // attribute flags
+ if (this.scanner.tokenType === IDENT) {
+ flags = this.scanner.getTokenValue();
+ this.scanner.next();
+
+ this.scanner.skipSC();
+ }
+ }
+
+ this.eat(RIGHTSQUAREBRACKET);
+
+ return {
+ type: 'AttributeSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ matcher: matcher,
+ value: value,
+ flags: flags
+ };
+ },
+ generate: function(node) {
+ var flagsPrefix = ' ';
+
+ this.chunk('[');
+ this.node(node.name);
+
+ if (node.matcher !== null) {
+ this.chunk(node.matcher);
+
+ if (node.value !== null) {
+ this.node(node.value);
+
+ // space between string and flags is not required
+ if (node.value.type === 'String') {
+ flagsPrefix = '';
+ }
+ }
+ }
+
+ if (node.flags !== null) {
+ this.chunk(flagsPrefix);
+ this.chunk(node.flags);
+ }
+
+ this.chunk(']');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Block.js b/node_modules/css-tree/lib/syntax/node/Block.js
new file mode 100644
index 0000000..b4fc6ba
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Block.js
@@ -0,0 +1,91 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var SEMICOLON = TYPE.Semicolon;
+var ATKEYWORD = TYPE.AtKeyword;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
+
+function consumeRaw(startToken) {
+ return this.Raw(startToken, null, true);
+}
+function consumeRule() {
+ return this.parseWithFallback(this.Rule, consumeRaw);
+}
+function consumeRawDeclaration(startToken) {
+ return this.Raw(startToken, rawMode.semicolonIncluded, true);
+}
+function consumeDeclaration() {
+ if (this.scanner.tokenType === SEMICOLON) {
+ return consumeRawDeclaration.call(this, this.scanner.tokenIndex);
+ }
+
+ var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
+
+ if (this.scanner.tokenType === SEMICOLON) {
+ this.scanner.next();
+ }
+
+ return node;
+}
+
+module.exports = {
+ name: 'Block',
+ structure: {
+ children: [[
+ 'Atrule',
+ 'Rule',
+ 'Declaration'
+ ]]
+ },
+ parse: function(isDeclaration) {
+ var consumer = isDeclaration ? consumeDeclaration : consumeRule;
+
+ var start = this.scanner.tokenStart;
+ var children = this.createList();
+
+ this.eat(LEFTCURLYBRACKET);
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case RIGHTCURLYBRACKET:
+ break scan;
+
+ case WHITESPACE:
+ case COMMENT:
+ this.scanner.next();
+ break;
+
+ case ATKEYWORD:
+ children.push(this.parseWithFallback(this.Atrule, consumeRaw));
+ break;
+
+ default:
+ children.push(consumer.call(this));
+ }
+ }
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTCURLYBRACKET);
+ }
+
+ return {
+ type: 'Block',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('{');
+ this.children(node, function(prev) {
+ if (prev.type === 'Declaration') {
+ this.chunk(';');
+ }
+ });
+ this.chunk('}');
+ },
+ walkContext: 'block'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Brackets.js b/node_modules/css-tree/lib/syntax/node/Brackets.js
new file mode 100644
index 0000000..a81c474
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Brackets.js
@@ -0,0 +1,34 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var RIGHTSQUAREBRACKET = TYPE.RightSquareBracket;
+
+module.exports = {
+ name: 'Brackets',
+ structure: {
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var children = null;
+
+ this.eat(LEFTSQUAREBRACKET);
+
+ children = readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTSQUAREBRACKET);
+ }
+
+ return {
+ type: 'Brackets',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('[');
+ this.children(node);
+ this.chunk(']');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/CDC.js b/node_modules/css-tree/lib/syntax/node/CDC.js
new file mode 100644
index 0000000..885b258
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/CDC.js
@@ -0,0 +1,19 @@
+var CDC = require('../../tokenizer').TYPE.CDC;
+
+module.exports = {
+ name: 'CDC',
+ structure: [],
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(CDC); // -->
+
+ return {
+ type: 'CDC',
+ loc: this.getLocation(start, this.scanner.tokenStart)
+ };
+ },
+ generate: function() {
+ this.chunk('-->');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/CDO.js b/node_modules/css-tree/lib/syntax/node/CDO.js
new file mode 100644
index 0000000..f701be7
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/CDO.js
@@ -0,0 +1,19 @@
+var CDO = require('../../tokenizer').TYPE.CDO;
+
+module.exports = {
+ name: 'CDO',
+ structure: [],
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(CDO); // <!--
+
+ return {
+ type: 'CDO',
+ loc: this.getLocation(start, this.scanner.tokenStart)
+ };
+ },
+ generate: function() {
+ this.chunk('<!--');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/ClassSelector.js b/node_modules/css-tree/lib/syntax/node/ClassSelector.js
new file mode 100644
index 0000000..c84d69b
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/ClassSelector.js
@@ -0,0 +1,29 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+
+// '.' ident
+module.exports = {
+ name: 'ClassSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ if (!this.scanner.isDelim(FULLSTOP)) {
+ this.error('Full stop is expected');
+ }
+
+ this.scanner.next();
+
+ return {
+ type: 'ClassSelector',
+ loc: this.getLocation(this.scanner.tokenStart - 1, this.scanner.tokenEnd),
+ name: this.consume(IDENT)
+ };
+ },
+ generate: function(node) {
+ this.chunk('.');
+ this.chunk(node.name);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Combinator.js b/node_modules/css-tree/lib/syntax/node/Combinator.js
new file mode 100644
index 0000000..308ca81
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Combinator.js
@@ -0,0 +1,55 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+var GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+var TILDE = 0x007E; // U+007E TILDE (~)
+
+// + | > | ~ | /deep/
+module.exports = {
+ name: 'Combinator',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ switch (code) {
+ case GREATERTHANSIGN:
+ case PLUSSIGN:
+ case TILDE:
+ this.scanner.next();
+ break;
+
+ case SOLIDUS:
+ this.scanner.next();
+
+ if (this.scanner.tokenType !== IDENT || this.scanner.lookupValue(0, 'deep') === false) {
+ this.error('Identifier `deep` is expected');
+ }
+
+ this.scanner.next();
+
+ if (!this.scanner.isDelim(SOLIDUS)) {
+ this.error('Solidus is expected');
+ }
+
+ this.scanner.next();
+ break;
+
+ default:
+ this.error('Combinator is expected');
+ }
+
+ return {
+ type: 'Combinator',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Comment.js b/node_modules/css-tree/lib/syntax/node/Comment.js
new file mode 100644
index 0000000..9f0e2f4
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Comment.js
@@ -0,0 +1,36 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var COMMENT = TYPE.Comment;
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+
+// '/*' .* '*/'
+module.exports = {
+ name: 'Comment',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var end = this.scanner.tokenEnd;
+
+ this.eat(COMMENT);
+
+ if ((end - start + 2) >= 2 &&
+ this.scanner.source.charCodeAt(end - 2) === ASTERISK &&
+ this.scanner.source.charCodeAt(end - 1) === SOLIDUS) {
+ end -= 2;
+ }
+
+ return {
+ type: 'Comment',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start + 2, end)
+ };
+ },
+ generate: function(node) {
+ this.chunk('/*');
+ this.chunk(node.value);
+ this.chunk('*/');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Declaration.js b/node_modules/css-tree/lib/syntax/node/Declaration.js
new file mode 100644
index 0000000..0792836
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Declaration.js
@@ -0,0 +1,169 @@
+var isCustomProperty = require('../../utils/names').isCustomProperty;
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var IDENT = TYPE.Ident;
+var HASH = TYPE.Hash;
+var COLON = TYPE.Colon;
+var SEMICOLON = TYPE.Semicolon;
+var DELIM = TYPE.Delim;
+var WHITESPACE = TYPE.WhiteSpace;
+var EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+var NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)
+var DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)
+var AMPERSAND = 0x0026; // U+0026 ANPERSAND (&)
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+
+function consumeValueRaw(startToken) {
+ return this.Raw(startToken, rawMode.exclamationMarkOrSemicolon, true);
+}
+
+function consumeCustomPropertyRaw(startToken) {
+ return this.Raw(startToken, rawMode.exclamationMarkOrSemicolon, false);
+}
+
+function consumeValue() {
+ var startValueToken = this.scanner.tokenIndex;
+ var value = this.Value();
+
+ if (value.type !== 'Raw' &&
+ this.scanner.eof === false &&
+ this.scanner.tokenType !== SEMICOLON &&
+ this.scanner.isDelim(EXCLAMATIONMARK) === false &&
+ this.scanner.isBalanceEdge(startValueToken) === false) {
+ this.error();
+ }
+
+ return value;
+}
+
+module.exports = {
+ name: 'Declaration',
+ structure: {
+ important: [Boolean, String],
+ property: String,
+ value: ['Value', 'Raw']
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var startToken = this.scanner.tokenIndex;
+ var property = readProperty.call(this);
+ var customProperty = isCustomProperty(property);
+ var parseValue = customProperty ? this.parseCustomProperty : this.parseValue;
+ var consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;
+ var important = false;
+ var value;
+
+ this.scanner.skipSC();
+ this.eat(COLON);
+
+ const valueStart = this.scanner.tokenIndex;
+
+ if (!customProperty) {
+ this.scanner.skipSC();
+ }
+
+ if (parseValue) {
+ value = this.parseWithFallback(consumeValue, consumeRaw);
+ } else {
+ value = consumeRaw.call(this, this.scanner.tokenIndex);
+ }
+
+ if (customProperty && value.type === 'Value' && value.children.isEmpty()) {
+ for (let offset = valueStart - this.scanner.tokenIndex; offset <= 0; offset++) {
+ if (this.scanner.lookupType(offset) === WHITESPACE) {
+ value.children.appendData({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+ });
+ break;
+ }
+ }
+ }
+
+ if (this.scanner.isDelim(EXCLAMATIONMARK)) {
+ important = getImportant.call(this);
+ this.scanner.skipSC();
+ }
+
+ // Do not include semicolon to range per spec
+ // https://drafts.csswg.org/css-syntax/#declaration-diagram
+
+ if (this.scanner.eof === false &&
+ this.scanner.tokenType !== SEMICOLON &&
+ this.scanner.isBalanceEdge(startToken) === false) {
+ this.error();
+ }
+
+ return {
+ type: 'Declaration',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ important: important,
+ property: property,
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.property);
+ this.chunk(':');
+ this.node(node.value);
+
+ if (node.important) {
+ this.chunk(node.important === true ? '!important' : '!' + node.important);
+ }
+ },
+ walkContext: 'declaration'
+};
+
+function readProperty() {
+ var start = this.scanner.tokenStart;
+ var prefix = 0;
+
+ // hacks
+ if (this.scanner.tokenType === DELIM) {
+ switch (this.scanner.source.charCodeAt(this.scanner.tokenStart)) {
+ case ASTERISK:
+ case DOLLARSIGN:
+ case PLUSSIGN:
+ case NUMBERSIGN:
+ case AMPERSAND:
+ this.scanner.next();
+ break;
+
+ // TODO: not sure we should support this hack
+ case SOLIDUS:
+ this.scanner.next();
+ if (this.scanner.isDelim(SOLIDUS)) {
+ this.scanner.next();
+ }
+ break;
+ }
+ }
+
+ if (prefix) {
+ this.scanner.skip(prefix);
+ }
+
+ if (this.scanner.tokenType === HASH) {
+ this.eat(HASH);
+ } else {
+ this.eat(IDENT);
+ }
+
+ return this.scanner.substrToCursor(start);
+}
+
+// ! ws* important
+function getImportant() {
+ this.eat(DELIM);
+ this.scanner.skipSC();
+
+ var important = this.consume(IDENT);
+
+ // store original value in case it differ from `important`
+ // for better original source restoring and hacks like `!ie` support
+ return important === 'important' ? true : important;
+}
diff --git a/node_modules/css-tree/lib/syntax/node/DeclarationList.js b/node_modules/css-tree/lib/syntax/node/DeclarationList.js
new file mode 100644
index 0000000..084b5c6
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/DeclarationList.js
@@ -0,0 +1,49 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var SEMICOLON = TYPE.Semicolon;
+
+function consumeRaw(startToken) {
+ return this.Raw(startToken, rawMode.semicolonIncluded, true);
+}
+
+module.exports = {
+ name: 'DeclarationList',
+ structure: {
+ children: [[
+ 'Declaration'
+ ]]
+ },
+ parse: function() {
+ var children = this.createList();
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE:
+ case COMMENT:
+ case SEMICOLON:
+ this.scanner.next();
+ break;
+
+ default:
+ children.push(this.parseWithFallback(this.Declaration, consumeRaw));
+ }
+ }
+
+ return {
+ type: 'DeclarationList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function(prev) {
+ if (prev.type === 'Declaration') {
+ this.chunk(';');
+ }
+ });
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Dimension.js b/node_modules/css-tree/lib/syntax/node/Dimension.js
new file mode 100644
index 0000000..186f6ee
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Dimension.js
@@ -0,0 +1,29 @@
+var consumeNumber = require('../../tokenizer/utils').consumeNumber;
+var TYPE = require('../../tokenizer').TYPE;
+
+var DIMENSION = TYPE.Dimension;
+
+module.exports = {
+ name: 'Dimension',
+ structure: {
+ value: String,
+ unit: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var numberEnd = consumeNumber(this.scanner.source, start);
+
+ this.eat(DIMENSION);
+
+ return {
+ type: 'Dimension',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start, numberEnd),
+ unit: this.scanner.source.substring(numberEnd, this.scanner.tokenStart)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ this.chunk(node.unit);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Function.js b/node_modules/css-tree/lib/syntax/node/Function.js
new file mode 100644
index 0000000..9e6b420
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Function.js
@@ -0,0 +1,40 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+// <function-token> <sequence> )
+module.exports = {
+ name: 'Function',
+ structure: {
+ name: String,
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var name = this.consumeFunctionName();
+ var nameLowerCase = name.toLowerCase();
+ var children;
+
+ children = recognizer.hasOwnProperty(nameLowerCase)
+ ? recognizer[nameLowerCase].call(this, recognizer)
+ : readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTPARENTHESIS);
+ }
+
+ return {
+ type: 'Function',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ },
+ walkContext: 'function'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Hash.js b/node_modules/css-tree/lib/syntax/node/Hash.js
new file mode 100644
index 0000000..5632636
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Hash.js
@@ -0,0 +1,26 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var HASH = TYPE.Hash;
+
+// '#' ident
+module.exports = {
+ name: 'Hash',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.eat(HASH);
+
+ return {
+ type: 'Hash',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start + 1)
+ };
+ },
+ generate: function(node) {
+ this.chunk('#');
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/IdSelector.js b/node_modules/css-tree/lib/syntax/node/IdSelector.js
new file mode 100644
index 0000000..b35fd96
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/IdSelector.js
@@ -0,0 +1,27 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var HASH = TYPE.Hash;
+
+// <hash-token>
+module.exports = {
+ name: 'IdSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ // TODO: check value is an ident
+ this.eat(HASH);
+
+ return {
+ type: 'IdSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start + 1)
+ };
+ },
+ generate: function(node) {
+ this.chunk('#');
+ this.chunk(node.name);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Identifier.js b/node_modules/css-tree/lib/syntax/node/Identifier.js
new file mode 100644
index 0000000..3fce2b4
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Identifier.js
@@ -0,0 +1,20 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+
+module.exports = {
+ name: 'Identifier',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ return {
+ type: 'Identifier',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ name: this.consume(IDENT)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/MediaFeature.js b/node_modules/css-tree/lib/syntax/node/MediaFeature.js
new file mode 100644
index 0000000..bdc7bc2
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/MediaFeature.js
@@ -0,0 +1,76 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+var COLON = TYPE.Colon;
+var DELIM = TYPE.Delim;
+
+module.exports = {
+ name: 'MediaFeature',
+ structure: {
+ name: String,
+ value: ['Identifier', 'Number', 'Dimension', 'Ratio', null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var name;
+ var value = null;
+
+ this.eat(LEFTPARENTHESIS);
+ this.scanner.skipSC();
+
+ name = this.consume(IDENT);
+ this.scanner.skipSC();
+
+ if (this.scanner.tokenType !== RIGHTPARENTHESIS) {
+ this.eat(COLON);
+ this.scanner.skipSC();
+
+ switch (this.scanner.tokenType) {
+ case NUMBER:
+ if (this.lookupNonWSType(1) === DELIM) {
+ value = this.Ratio();
+ } else {
+ value = this.Number();
+ }
+
+ break;
+
+ case DIMENSION:
+ value = this.Dimension();
+ break;
+
+ case IDENT:
+ value = this.Identifier();
+
+ break;
+
+ default:
+ this.error('Number, dimension, ratio or identifier is expected');
+ }
+
+ this.scanner.skipSC();
+ }
+
+ this.eat(RIGHTPARENTHESIS);
+
+ return {
+ type: 'MediaFeature',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk('(');
+ this.chunk(node.name);
+ if (node.value !== null) {
+ this.chunk(':');
+ this.node(node.value);
+ }
+ this.chunk(')');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/MediaQuery.js b/node_modules/css-tree/lib/syntax/node/MediaQuery.js
new file mode 100644
index 0000000..e0c74ce
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/MediaQuery.js
@@ -0,0 +1,68 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+
+module.exports = {
+ name: 'MediaQuery',
+ structure: {
+ children: [[
+ 'Identifier',
+ 'MediaFeature',
+ 'WhiteSpace'
+ ]]
+ },
+ parse: function() {
+ this.scanner.skipSC();
+
+ var children = this.createList();
+ var child = null;
+ var space = null;
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case COMMENT:
+ this.scanner.next();
+ continue;
+
+ case WHITESPACE:
+ space = this.WhiteSpace();
+ continue;
+
+ case IDENT:
+ child = this.Identifier();
+ break;
+
+ case LEFTPARENTHESIS:
+ child = this.MediaFeature();
+ break;
+
+ default:
+ break scan;
+ }
+
+ if (space !== null) {
+ children.push(space);
+ space = null;
+ }
+
+ children.push(child);
+ }
+
+ if (child === null) {
+ this.error('Identifier or parenthesis is expected');
+ }
+
+ return {
+ type: 'MediaQuery',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/MediaQueryList.js b/node_modules/css-tree/lib/syntax/node/MediaQueryList.js
new file mode 100644
index 0000000..a25a965
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/MediaQueryList.js
@@ -0,0 +1,36 @@
+var COMMA = require('../../tokenizer').TYPE.Comma;
+
+module.exports = {
+ name: 'MediaQueryList',
+ structure: {
+ children: [[
+ 'MediaQuery'
+ ]]
+ },
+ parse: function(relative) {
+ var children = this.createList();
+
+ this.scanner.skipSC();
+
+ while (!this.scanner.eof) {
+ children.push(this.MediaQuery(relative));
+
+ if (this.scanner.tokenType !== COMMA) {
+ break;
+ }
+
+ this.scanner.next();
+ }
+
+ return {
+ type: 'MediaQueryList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function() {
+ this.chunk(',');
+ });
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Nth.js b/node_modules/css-tree/lib/syntax/node/Nth.js
new file mode 100644
index 0000000..43835cc
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Nth.js
@@ -0,0 +1,51 @@
+module.exports = {
+ name: 'Nth',
+ structure: {
+ nth: ['AnPlusB', 'Identifier'],
+ selector: ['SelectorList', null]
+ },
+ parse: function(allowOfClause) {
+ this.scanner.skipSC();
+
+ var start = this.scanner.tokenStart;
+ var end = start;
+ var selector = null;
+ var query;
+
+ if (this.scanner.lookupValue(0, 'odd') || this.scanner.lookupValue(0, 'even')) {
+ query = this.Identifier();
+ } else {
+ query = this.AnPlusB();
+ }
+
+ this.scanner.skipSC();
+
+ if (allowOfClause && this.scanner.lookupValue(0, 'of')) {
+ this.scanner.next();
+
+ selector = this.SelectorList();
+
+ if (this.needPositions) {
+ end = this.getLastListNode(selector.children).loc.end.offset;
+ }
+ } else {
+ if (this.needPositions) {
+ end = query.loc.end.offset;
+ }
+ }
+
+ return {
+ type: 'Nth',
+ loc: this.getLocation(start, end),
+ nth: query,
+ selector: selector
+ };
+ },
+ generate: function(node) {
+ this.node(node.nth);
+ if (node.selector !== null) {
+ this.chunk(' of ');
+ this.node(node.selector);
+ }
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Number.js b/node_modules/css-tree/lib/syntax/node/Number.js
new file mode 100644
index 0000000..1c01936
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Number.js
@@ -0,0 +1,18 @@
+var NUMBER = require('../../tokenizer').TYPE.Number;
+
+module.exports = {
+ name: 'Number',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ return {
+ type: 'Number',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ value: this.consume(NUMBER)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Operator.js b/node_modules/css-tree/lib/syntax/node/Operator.js
new file mode 100644
index 0000000..d94259a
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Operator.js
@@ -0,0 +1,21 @@
+// '/' | '*' | ',' | ':' | '+' | '-'
+module.exports = {
+ name: 'Operator',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ this.scanner.next();
+
+ return {
+ type: 'Operator',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Parentheses.js b/node_modules/css-tree/lib/syntax/node/Parentheses.js
new file mode 100644
index 0000000..19efe6f
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Parentheses.js
@@ -0,0 +1,34 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+module.exports = {
+ name: 'Parentheses',
+ structure: {
+ children: [[]]
+ },
+ parse: function(readSequence, recognizer) {
+ var start = this.scanner.tokenStart;
+ var children = null;
+
+ this.eat(LEFTPARENTHESIS);
+
+ children = readSequence.call(this, recognizer);
+
+ if (!this.scanner.eof) {
+ this.eat(RIGHTPARENTHESIS);
+ }
+
+ return {
+ type: 'Parentheses',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Percentage.js b/node_modules/css-tree/lib/syntax/node/Percentage.js
new file mode 100644
index 0000000..99b7641
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Percentage.js
@@ -0,0 +1,27 @@
+var consumeNumber = require('../../tokenizer/utils').consumeNumber;
+var TYPE = require('../../tokenizer').TYPE;
+
+var PERCENTAGE = TYPE.Percentage;
+
+module.exports = {
+ name: 'Percentage',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var numberEnd = consumeNumber(this.scanner.source, start);
+
+ this.eat(PERCENTAGE);
+
+ return {
+ type: 'Percentage',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.source.substring(start, numberEnd)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ this.chunk('%');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js b/node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js
new file mode 100644
index 0000000..282e236
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js
@@ -0,0 +1,61 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var FUNCTION = TYPE.Function;
+var COLON = TYPE.Colon;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+// : [ <ident> | <function-token> <any-value>? ) ]
+module.exports = {
+ name: 'PseudoClassSelector',
+ structure: {
+ name: String,
+ children: [['Raw'], null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = null;
+ var name;
+ var nameLowerCase;
+
+ this.eat(COLON);
+
+ if (this.scanner.tokenType === FUNCTION) {
+ name = this.consumeFunctionName();
+ nameLowerCase = name.toLowerCase();
+
+ if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+ this.scanner.skipSC();
+ children = this.pseudo[nameLowerCase].call(this);
+ this.scanner.skipSC();
+ } else {
+ children = this.createList();
+ children.push(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ }
+
+ this.eat(RIGHTPARENTHESIS);
+ } else {
+ name = this.consume(IDENT);
+ }
+
+ return {
+ type: 'PseudoClassSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk(':');
+ this.chunk(node.name);
+
+ if (node.children !== null) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+ },
+ walkContext: 'function'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js b/node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js
new file mode 100644
index 0000000..b736cea
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js
@@ -0,0 +1,62 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var FUNCTION = TYPE.Function;
+var COLON = TYPE.Colon;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+// :: [ <ident> | <function-token> <any-value>? ) ]
+module.exports = {
+ name: 'PseudoElementSelector',
+ structure: {
+ name: String,
+ children: [['Raw'], null]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = null;
+ var name;
+ var nameLowerCase;
+
+ this.eat(COLON);
+ this.eat(COLON);
+
+ if (this.scanner.tokenType === FUNCTION) {
+ name = this.consumeFunctionName();
+ nameLowerCase = name.toLowerCase();
+
+ if (this.pseudo.hasOwnProperty(nameLowerCase)) {
+ this.scanner.skipSC();
+ children = this.pseudo[nameLowerCase].call(this);
+ this.scanner.skipSC();
+ } else {
+ children = this.createList();
+ children.push(
+ this.Raw(this.scanner.tokenIndex, null, false)
+ );
+ }
+
+ this.eat(RIGHTPARENTHESIS);
+ } else {
+ name = this.consume(IDENT);
+ }
+
+ return {
+ type: 'PseudoElementSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: name,
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.chunk('::');
+ this.chunk(node.name);
+
+ if (node.children !== null) {
+ this.chunk('(');
+ this.children(node);
+ this.chunk(')');
+ }
+ },
+ walkContext: 'function'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Ratio.js b/node_modules/css-tree/lib/syntax/node/Ratio.js
new file mode 100644
index 0000000..940fee5
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Ratio.js
@@ -0,0 +1,66 @@
+var isDigit = require('../../tokenizer').isDigit;
+var TYPE = require('../../tokenizer').TYPE;
+
+var NUMBER = TYPE.Number;
+var DELIM = TYPE.Delim;
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+var FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+
+// Terms of <ratio> should be a positive numbers (not zero or negative)
+// (see https://drafts.csswg.org/mediaqueries-3/#values)
+// However, -o-min-device-pixel-ratio takes fractional values as a ratio's term
+// and this is using by various sites. Therefore we relax checking on parse
+// to test a term is unsigned number without an exponent part.
+// Additional checking may be applied on lexer validation.
+function consumeNumber() {
+ this.scanner.skipWS();
+
+ var value = this.consume(NUMBER);
+
+ for (var i = 0; i < value.length; i++) {
+ var code = value.charCodeAt(i);
+ if (!isDigit(code) && code !== FULLSTOP) {
+ this.error('Unsigned number is expected', this.scanner.tokenStart - value.length + i);
+ }
+ }
+
+ if (Number(value) === 0) {
+ this.error('Zero number is not allowed', this.scanner.tokenStart - value.length);
+ }
+
+ return value;
+}
+
+// <positive-integer> S* '/' S* <positive-integer>
+module.exports = {
+ name: 'Ratio',
+ structure: {
+ left: String,
+ right: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var left = consumeNumber.call(this);
+ var right;
+
+ this.scanner.skipWS();
+
+ if (!this.scanner.isDelim(SOLIDUS)) {
+ this.error('Solidus is expected');
+ }
+ this.eat(DELIM);
+ right = consumeNumber.call(this);
+
+ return {
+ type: 'Ratio',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ left: left,
+ right: right
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.left);
+ this.chunk('/');
+ this.chunk(node.right);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Raw.js b/node_modules/css-tree/lib/syntax/node/Raw.js
new file mode 100644
index 0000000..a47deb4
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Raw.js
@@ -0,0 +1,87 @@
+var tokenizer = require('../../tokenizer');
+var TYPE = tokenizer.TYPE;
+
+var WhiteSpace = TYPE.WhiteSpace;
+var Semicolon = TYPE.Semicolon;
+var LeftCurlyBracket = TYPE.LeftCurlyBracket;
+var Delim = TYPE.Delim;
+var EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+function getOffsetExcludeWS() {
+ if (this.scanner.tokenIndex > 0) {
+ if (this.scanner.lookupType(-1) === WhiteSpace) {
+ return this.scanner.tokenIndex > 1
+ ? this.scanner.getTokenStart(this.scanner.tokenIndex - 1)
+ : this.scanner.firstCharOffset;
+ }
+ }
+
+ return this.scanner.tokenStart;
+}
+
+// 0, 0, false
+function balanceEnd() {
+ return 0;
+}
+
+// LEFTCURLYBRACKET, 0, false
+function leftCurlyBracket(tokenType) {
+ return tokenType === LeftCurlyBracket ? 1 : 0;
+}
+
+// LEFTCURLYBRACKET, SEMICOLON, false
+function leftCurlyBracketOrSemicolon(tokenType) {
+ return tokenType === LeftCurlyBracket || tokenType === Semicolon ? 1 : 0;
+}
+
+// EXCLAMATIONMARK, SEMICOLON, false
+function exclamationMarkOrSemicolon(tokenType, source, offset) {
+ if (tokenType === Delim && source.charCodeAt(offset) === EXCLAMATIONMARK) {
+ return 1;
+ }
+
+ return tokenType === Semicolon ? 1 : 0;
+}
+
+// 0, SEMICOLON, true
+function semicolonIncluded(tokenType) {
+ return tokenType === Semicolon ? 2 : 0;
+}
+
+module.exports = {
+ name: 'Raw',
+ structure: {
+ value: String
+ },
+ parse: function(startToken, mode, excludeWhiteSpace) {
+ var startOffset = this.scanner.getTokenStart(startToken);
+ var endOffset;
+
+ this.scanner.skip(
+ this.scanner.getRawLength(startToken, mode || balanceEnd)
+ );
+
+ if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
+ endOffset = getOffsetExcludeWS.call(this);
+ } else {
+ endOffset = this.scanner.tokenStart;
+ }
+
+ return {
+ type: 'Raw',
+ loc: this.getLocation(startOffset, endOffset),
+ value: this.scanner.source.substring(startOffset, endOffset)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ },
+
+ mode: {
+ default: balanceEnd,
+ leftCurlyBracket: leftCurlyBracket,
+ leftCurlyBracketOrSemicolon: leftCurlyBracketOrSemicolon,
+ exclamationMarkOrSemicolon: exclamationMarkOrSemicolon,
+ semicolonIncluded: semicolonIncluded
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Rule.js b/node_modules/css-tree/lib/syntax/node/Rule.js
new file mode 100644
index 0000000..2f1aaa2
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Rule.js
@@ -0,0 +1,54 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+
+function consumeRaw(startToken) {
+ return this.Raw(startToken, rawMode.leftCurlyBracket, true);
+}
+
+function consumePrelude() {
+ var prelude = this.SelectorList();
+
+ if (prelude.type !== 'Raw' &&
+ this.scanner.eof === false &&
+ this.scanner.tokenType !== LEFTCURLYBRACKET) {
+ this.error();
+ }
+
+ return prelude;
+}
+
+module.exports = {
+ name: 'Rule',
+ structure: {
+ prelude: ['SelectorList', 'Raw'],
+ block: ['Block']
+ },
+ parse: function() {
+ var startToken = this.scanner.tokenIndex;
+ var startOffset = this.scanner.tokenStart;
+ var prelude;
+ var block;
+
+ if (this.parseRulePrelude) {
+ prelude = this.parseWithFallback(consumePrelude, consumeRaw);
+ } else {
+ prelude = consumeRaw.call(this, startToken);
+ }
+
+ block = this.Block(true);
+
+ return {
+ type: 'Rule',
+ loc: this.getLocation(startOffset, this.scanner.tokenStart),
+ prelude: prelude,
+ block: block
+ };
+ },
+ generate: function(node) {
+ this.node(node.prelude);
+ this.node(node.block);
+ },
+ walkContext: 'rule'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Selector.js b/node_modules/css-tree/lib/syntax/node/Selector.js
new file mode 100644
index 0000000..a1b17f3
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Selector.js
@@ -0,0 +1,32 @@
+module.exports = {
+ name: 'Selector',
+ structure: {
+ children: [[
+ 'TypeSelector',
+ 'IdSelector',
+ 'ClassSelector',
+ 'AttributeSelector',
+ 'PseudoClassSelector',
+ 'PseudoElementSelector',
+ 'Combinator',
+ 'WhiteSpace'
+ ]]
+ },
+ parse: function() {
+ var children = this.readSequence(this.scope.Selector);
+
+ // nothing were consumed
+ if (this.getFirstListNode(children) === null) {
+ this.error('Selector is expected');
+ }
+
+ return {
+ type: 'Selector',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/SelectorList.js b/node_modules/css-tree/lib/syntax/node/SelectorList.js
new file mode 100644
index 0000000..70dd7c5
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/SelectorList.js
@@ -0,0 +1,39 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var COMMA = TYPE.Comma;
+
+module.exports = {
+ name: 'SelectorList',
+ structure: {
+ children: [[
+ 'Selector',
+ 'Raw'
+ ]]
+ },
+ parse: function() {
+ var children = this.createList();
+
+ while (!this.scanner.eof) {
+ children.push(this.Selector());
+
+ if (this.scanner.tokenType === COMMA) {
+ this.scanner.next();
+ continue;
+ }
+
+ break;
+ }
+
+ return {
+ type: 'SelectorList',
+ loc: this.getLocationFromList(children),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node, function() {
+ this.chunk(',');
+ });
+ },
+ walkContext: 'selector'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/String.js b/node_modules/css-tree/lib/syntax/node/String.js
new file mode 100644
index 0000000..d3b8cc1
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/String.js
@@ -0,0 +1,18 @@
+var STRING = require('../../tokenizer').TYPE.String;
+
+module.exports = {
+ name: 'String',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ return {
+ type: 'String',
+ loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ value: this.consume(STRING)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/StyleSheet.js b/node_modules/css-tree/lib/syntax/node/StyleSheet.js
new file mode 100644
index 0000000..db332cf
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/StyleSheet.js
@@ -0,0 +1,81 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var ATKEYWORD = TYPE.AtKeyword;
+var CDO = TYPE.CDO;
+var CDC = TYPE.CDC;
+var EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+function consumeRaw(startToken) {
+ return this.Raw(startToken, null, false);
+}
+
+module.exports = {
+ name: 'StyleSheet',
+ structure: {
+ children: [[
+ 'Comment',
+ 'CDO',
+ 'CDC',
+ 'Atrule',
+ 'Rule',
+ 'Raw'
+ ]]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = this.createList();
+ var child;
+
+ scan:
+ while (!this.scanner.eof) {
+ switch (this.scanner.tokenType) {
+ case WHITESPACE:
+ this.scanner.next();
+ continue;
+
+ case COMMENT:
+ // ignore comments except exclamation comments (i.e. /*! .. */) on top level
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK) {
+ this.scanner.next();
+ continue;
+ }
+
+ child = this.Comment();
+ break;
+
+ case CDO: // <!--
+ child = this.CDO();
+ break;
+
+ case CDC: // -->
+ child = this.CDC();
+ break;
+
+ // CSS Syntax Module Level 3
+ // §2.2 Error handling
+ // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
+ case ATKEYWORD:
+ child = this.parseWithFallback(this.Atrule, consumeRaw);
+ break;
+
+ // Anything else starts a qualified rule ...
+ default:
+ child = this.parseWithFallback(this.Rule, consumeRaw);
+ }
+
+ children.push(child);
+ }
+
+ return {
+ type: 'StyleSheet',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ },
+ walkContext: 'stylesheet'
+};
diff --git a/node_modules/css-tree/lib/syntax/node/TypeSelector.js b/node_modules/css-tree/lib/syntax/node/TypeSelector.js
new file mode 100644
index 0000000..c8a692c
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/TypeSelector.js
@@ -0,0 +1,53 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)
+
+function eatIdentifierOrAsterisk() {
+ if (this.scanner.tokenType !== IDENT &&
+ this.scanner.isDelim(ASTERISK) === false) {
+ this.error('Identifier or asterisk is expected');
+ }
+
+ this.scanner.next();
+}
+
+// ident
+// ident|ident
+// ident|*
+// *
+// *|ident
+// *|*
+// |ident
+// |*
+module.exports = {
+ name: 'TypeSelector',
+ structure: {
+ name: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ if (this.scanner.isDelim(VERTICALLINE)) {
+ this.scanner.next();
+ eatIdentifierOrAsterisk.call(this);
+ } else {
+ eatIdentifierOrAsterisk.call(this);
+
+ if (this.scanner.isDelim(VERTICALLINE)) {
+ this.scanner.next();
+ eatIdentifierOrAsterisk.call(this);
+ }
+ }
+
+ return {
+ type: 'TypeSelector',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ name: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.name);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/UnicodeRange.js b/node_modules/css-tree/lib/syntax/node/UnicodeRange.js
new file mode 100644
index 0000000..f3ca607
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/UnicodeRange.js
@@ -0,0 +1,173 @@
+var isHexDigit = require('../../tokenizer').isHexDigit;
+var cmpChar = require('../../tokenizer').cmpChar;
+var TYPE = require('../../tokenizer').TYPE;
+var NAME = require('../../tokenizer').NAME;
+
+var IDENT = TYPE.Ident;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)
+var U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+function eatHexSequence(offset, allowDash) {
+ for (var pos = this.scanner.tokenStart + offset, len = 0; pos < this.scanner.tokenEnd; pos++) {
+ var code = this.scanner.source.charCodeAt(pos);
+
+ if (code === HYPHENMINUS && allowDash && len !== 0) {
+ if (eatHexSequence.call(this, offset + len + 1, false) === 0) {
+ this.error();
+ }
+
+ return -1;
+ }
+
+ if (!isHexDigit(code)) {
+ this.error(
+ allowDash && len !== 0
+ ? 'HyphenMinus' + (len < 6 ? ' or hex digit' : '') + ' is expected'
+ : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),
+ pos
+ );
+ }
+
+ if (++len > 6) {
+ this.error('Too many hex digits', pos);
+ };
+ }
+
+ this.scanner.next();
+ return len;
+}
+
+function eatQuestionMarkSequence(max) {
+ var count = 0;
+
+ while (this.scanner.isDelim(QUESTIONMARK)) {
+ if (++count > max) {
+ this.error('Too many question marks');
+ }
+
+ this.scanner.next();
+ }
+}
+
+function startsWith(code) {
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== code) {
+ this.error(NAME[code] + ' is expected');
+ }
+}
+
+// https://drafts.csswg.org/css-syntax/#urange
+// Informally, the <urange> production has three forms:
+// U+0001
+// Defines a range consisting of a single code point, in this case the code point "1".
+// U+0001-00ff
+// Defines a range of codepoints between the first and the second value, in this case
+// the range between "1" and "ff" (255 in decimal) inclusive.
+// U+00??
+// Defines a range of codepoints where the "?" characters range over all hex digits,
+// in this case defining the same as the value U+0000-00ff.
+// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+//
+// <urange> =
+// u '+' <ident-token> '?'* |
+// u <dimension-token> '?'* |
+// u <number-token> '?'* |
+// u <number-token> <dimension-token> |
+// u <number-token> <number-token> |
+// u '+' '?'+
+function scanUnicodeRange() {
+ var hexLength = 0;
+
+ // u '+' <ident-token> '?'*
+ // u '+' '?'+
+ if (this.scanner.isDelim(PLUSSIGN)) {
+ this.scanner.next();
+
+ if (this.scanner.tokenType === IDENT) {
+ hexLength = eatHexSequence.call(this, 0, true);
+ if (hexLength > 0) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ }
+ return;
+ }
+
+ if (this.scanner.isDelim(QUESTIONMARK)) {
+ this.scanner.next();
+ eatQuestionMarkSequence.call(this, 5);
+ return;
+ }
+
+ this.error('Hex digit or question mark is expected');
+ return;
+ }
+
+ // u <number-token> '?'*
+ // u <number-token> <dimension-token>
+ // u <number-token> <number-token>
+ if (this.scanner.tokenType === NUMBER) {
+ startsWith.call(this, PLUSSIGN);
+ hexLength = eatHexSequence.call(this, 1, true);
+
+ if (this.scanner.isDelim(QUESTIONMARK)) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ return;
+ }
+
+ if (this.scanner.tokenType === DIMENSION ||
+ this.scanner.tokenType === NUMBER) {
+ startsWith.call(this, HYPHENMINUS);
+ eatHexSequence.call(this, 1, false);
+ return;
+ }
+
+ return;
+ }
+
+ // u <dimension-token> '?'*
+ if (this.scanner.tokenType === DIMENSION) {
+ startsWith.call(this, PLUSSIGN);
+ hexLength = eatHexSequence.call(this, 1, true);
+
+ if (hexLength > 0) {
+ eatQuestionMarkSequence.call(this, 6 - hexLength);
+ }
+
+ return;
+ }
+
+ this.error();
+}
+
+module.exports = {
+ name: 'UnicodeRange',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+
+ // U or u
+ if (!cmpChar(this.scanner.source, start, U)) {
+ this.error('U is expected');
+ }
+
+ if (!cmpChar(this.scanner.source, start + 1, PLUSSIGN)) {
+ this.error('Plus sign is expected');
+ }
+
+ this.scanner.next();
+ scanUnicodeRange.call(this);
+
+ return {
+ type: 'UnicodeRange',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: this.scanner.substrToCursor(start)
+ };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Url.js b/node_modules/css-tree/lib/syntax/node/Url.js
new file mode 100644
index 0000000..91c6f59
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Url.js
@@ -0,0 +1,69 @@
+var isWhiteSpace = require('../../tokenizer').isWhiteSpace;
+var cmpStr = require('../../tokenizer').cmpStr;
+var TYPE = require('../../tokenizer').TYPE;
+
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+// <url-token> | <function-token> <string> )
+module.exports = {
+ name: 'Url',
+ structure: {
+ value: ['String', 'Raw']
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var value;
+
+ switch (this.scanner.tokenType) {
+ case URL:
+ var rawStart = start + 4;
+ var rawEnd = this.scanner.tokenEnd - 1;
+
+ while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawStart))) {
+ rawStart++;
+ }
+
+ while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawEnd - 1))) {
+ rawEnd--;
+ }
+
+ value = {
+ type: 'Raw',
+ loc: this.getLocation(rawStart, rawEnd),
+ value: this.scanner.source.substring(rawStart, rawEnd)
+ };
+
+ this.eat(URL);
+ break;
+
+ case FUNCTION:
+ if (!cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')) {
+ this.error('Function name must be `url`');
+ }
+
+ this.eat(FUNCTION);
+ this.scanner.skipSC();
+ value = this.String();
+ this.scanner.skipSC();
+ this.eat(RIGHTPARENTHESIS);
+ break;
+
+ default:
+ this.error('Url or Function is expected');
+ }
+
+ return {
+ type: 'Url',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ value: value
+ };
+ },
+ generate: function(node) {
+ this.chunk('url');
+ this.chunk('(');
+ this.node(node.value);
+ this.chunk(')');
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/Value.js b/node_modules/css-tree/lib/syntax/node/Value.js
new file mode 100644
index 0000000..6dcb265
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/Value.js
@@ -0,0 +1,19 @@
+module.exports = {
+ name: 'Value',
+ structure: {
+ children: [[]]
+ },
+ parse: function() {
+ var start = this.scanner.tokenStart;
+ var children = this.readSequence(this.scope.Value);
+
+ return {
+ type: 'Value',
+ loc: this.getLocation(start, this.scanner.tokenStart),
+ children: children
+ };
+ },
+ generate: function(node) {
+ this.children(node);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/WhiteSpace.js b/node_modules/css-tree/lib/syntax/node/WhiteSpace.js
new file mode 100644
index 0000000..0c6a363
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/WhiteSpace.js
@@ -0,0 +1,26 @@
+var WHITESPACE = require('../../tokenizer').TYPE.WhiteSpace;
+var SPACE = Object.freeze({
+ type: 'WhiteSpace',
+ loc: null,
+ value: ' '
+});
+
+module.exports = {
+ name: 'WhiteSpace',
+ structure: {
+ value: String
+ },
+ parse: function() {
+ this.eat(WHITESPACE);
+ return SPACE;
+
+ // return {
+ // type: 'WhiteSpace',
+ // loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+ // value: this.consume(WHITESPACE)
+ // };
+ },
+ generate: function(node) {
+ this.chunk(node.value);
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/node/index.js b/node_modules/css-tree/lib/syntax/node/index.js
new file mode 100644
index 0000000..182b2cf
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/node/index.js
@@ -0,0 +1,42 @@
+module.exports = {
+ AnPlusB: require('./AnPlusB'),
+ Atrule: require('./Atrule'),
+ AtrulePrelude: require('./AtrulePrelude'),
+ AttributeSelector: require('./AttributeSelector'),
+ Block: require('./Block'),
+ Brackets: require('./Brackets'),
+ CDC: require('./CDC'),
+ CDO: require('./CDO'),
+ ClassSelector: require('./ClassSelector'),
+ Combinator: require('./Combinator'),
+ Comment: require('./Comment'),
+ Declaration: require('./Declaration'),
+ DeclarationList: require('./DeclarationList'),
+ Dimension: require('./Dimension'),
+ Function: require('./Function'),
+ Hash: require('./Hash'),
+ Identifier: require('./Identifier'),
+ IdSelector: require('./IdSelector'),
+ MediaFeature: require('./MediaFeature'),
+ MediaQuery: require('./MediaQuery'),
+ MediaQueryList: require('./MediaQueryList'),
+ Nth: require('./Nth'),
+ Number: require('./Number'),
+ Operator: require('./Operator'),
+ Parentheses: require('./Parentheses'),
+ Percentage: require('./Percentage'),
+ PseudoClassSelector: require('./PseudoClassSelector'),
+ PseudoElementSelector: require('./PseudoElementSelector'),
+ Ratio: require('./Ratio'),
+ Raw: require('./Raw'),
+ Rule: require('./Rule'),
+ Selector: require('./Selector'),
+ SelectorList: require('./SelectorList'),
+ String: require('./String'),
+ StyleSheet: require('./StyleSheet'),
+ TypeSelector: require('./TypeSelector'),
+ UnicodeRange: require('./UnicodeRange'),
+ Url: require('./Url'),
+ Value: require('./Value'),
+ WhiteSpace: require('./WhiteSpace')
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/common/nth.js b/node_modules/css-tree/lib/syntax/pseudo/common/nth.js
new file mode 100644
index 0000000..c201e7e
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/common/nth.js
@@ -0,0 +1,9 @@
+var DISALLOW_OF_CLAUSE = false;
+
+module.exports = {
+ parse: function nth() {
+ return this.createSingleNodeList(
+ this.Nth(DISALLOW_OF_CLAUSE)
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js b/node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js
new file mode 100644
index 0000000..527bd1a
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js
@@ -0,0 +1,9 @@
+var ALLOW_OF_CLAUSE = true;
+
+module.exports = {
+ parse: function nthWithOfClause() {
+ return this.createSingleNodeList(
+ this.Nth(ALLOW_OF_CLAUSE)
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js b/node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js
new file mode 100644
index 0000000..7f87d08
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js
@@ -0,0 +1,7 @@
+module.exports = {
+ parse: function selectorList() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/dir.js b/node_modules/css-tree/lib/syntax/pseudo/dir.js
new file mode 100644
index 0000000..10f7232
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/dir.js
@@ -0,0 +1,7 @@
+module.exports = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.Identifier()
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/has.js b/node_modules/css-tree/lib/syntax/pseudo/has.js
new file mode 100644
index 0000000..0e6b583
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/has.js
@@ -0,0 +1,7 @@
+module.exports = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.SelectorList()
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/index.js b/node_modules/css-tree/lib/syntax/pseudo/index.js
new file mode 100644
index 0000000..eb68aef
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/index.js
@@ -0,0 +1,12 @@
+module.exports = {
+ 'dir': require('./dir'),
+ 'has': require('./has'),
+ 'lang': require('./lang'),
+ 'matches': require('./matches'),
+ 'not': require('./not'),
+ 'nth-child': require('./nth-child'),
+ 'nth-last-child': require('./nth-last-child'),
+ 'nth-last-of-type': require('./nth-last-of-type'),
+ 'nth-of-type': require('./nth-of-type'),
+ 'slotted': require('./slotted')
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/lang.js b/node_modules/css-tree/lib/syntax/pseudo/lang.js
new file mode 100644
index 0000000..10f7232
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/lang.js
@@ -0,0 +1,7 @@
+module.exports = {
+ parse: function() {
+ return this.createSingleNodeList(
+ this.Identifier()
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/pseudo/matches.js b/node_modules/css-tree/lib/syntax/pseudo/matches.js
new file mode 100644
index 0000000..43aa085
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/matches.js
@@ -0,0 +1 @@
+module.exports = require('./common/selectorList');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/not.js b/node_modules/css-tree/lib/syntax/pseudo/not.js
new file mode 100644
index 0000000..43aa085
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/not.js
@@ -0,0 +1 @@
+module.exports = require('./common/selectorList');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/nth-child.js b/node_modules/css-tree/lib/syntax/pseudo/nth-child.js
new file mode 100644
index 0000000..ed62028
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/nth-child.js
@@ -0,0 +1 @@
+module.exports = require('./common/nthWithOfClause');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js b/node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js
new file mode 100644
index 0000000..ed62028
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js
@@ -0,0 +1 @@
+module.exports = require('./common/nthWithOfClause');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js b/node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js
new file mode 100644
index 0000000..9417189
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js
@@ -0,0 +1 @@
+module.exports = require('./common/nth');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js b/node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js
new file mode 100644
index 0000000..9417189
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js
@@ -0,0 +1 @@
+module.exports = require('./common/nth');
diff --git a/node_modules/css-tree/lib/syntax/pseudo/slotted.js b/node_modules/css-tree/lib/syntax/pseudo/slotted.js
new file mode 100644
index 0000000..9719f44
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/pseudo/slotted.js
@@ -0,0 +1,7 @@
+module.exports = {
+ parse: function compoundSelector() {
+ return this.createSingleNodeList(
+ this.Selector()
+ );
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/scope/atrulePrelude.js b/node_modules/css-tree/lib/syntax/scope/atrulePrelude.js
new file mode 100644
index 0000000..a4bcab6
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/scope/atrulePrelude.js
@@ -0,0 +1,3 @@
+module.exports = {
+ getNode: require('./default')
+};
diff --git a/node_modules/css-tree/lib/syntax/scope/default.js b/node_modules/css-tree/lib/syntax/scope/default.js
new file mode 100644
index 0000000..a1c6a31
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/scope/default.js
@@ -0,0 +1,87 @@
+var cmpChar = require('../../tokenizer').cmpChar;
+var cmpStr = require('../../tokenizer').cmpStr;
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var STRING = TYPE.String;
+var NUMBER = TYPE.Number;
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var HASH = TYPE.Hash;
+var DIMENSION = TYPE.Dimension;
+var PERCENTAGE = TYPE.Percentage;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var COMMA = TYPE.Comma;
+var DELIM = TYPE.Delim;
+var NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+var U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)
+
+module.exports = function defaultRecognizer(context) {
+ switch (this.scanner.tokenType) {
+ case HASH:
+ return this.Hash();
+
+ case COMMA:
+ context.space = null;
+ context.ignoreWSAfter = true;
+ return this.Operator();
+
+ case LEFTPARENTHESIS:
+ return this.Parentheses(this.readSequence, context.recognizer);
+
+ case LEFTSQUAREBRACKET:
+ return this.Brackets(this.readSequence, context.recognizer);
+
+ case STRING:
+ return this.String();
+
+ case DIMENSION:
+ return this.Dimension();
+
+ case PERCENTAGE:
+ return this.Percentage();
+
+ case NUMBER:
+ return this.Number();
+
+ case FUNCTION:
+ return cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')
+ ? this.Url()
+ : this.Function(this.readSequence, context.recognizer);
+
+ case URL:
+ return this.Url();
+
+ case IDENT:
+ // check for unicode range, it should start with u+ or U+
+ if (cmpChar(this.scanner.source, this.scanner.tokenStart, U) &&
+ cmpChar(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN)) {
+ return this.UnicodeRange();
+ } else {
+ return this.Identifier();
+ }
+
+ case DELIM:
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ if (code === SOLIDUS ||
+ code === ASTERISK ||
+ code === PLUSSIGN ||
+ code === HYPHENMINUS) {
+ return this.Operator(); // TODO: replace with Delim
+ }
+
+ // TODO: produce a node with Delim node type
+
+ if (code === NUMBERSIGN) {
+ this.error('Hex or identifier is expected', this.scanner.tokenStart + 1);
+ }
+
+ break;
+ }
+};
diff --git a/node_modules/css-tree/lib/syntax/scope/index.js b/node_modules/css-tree/lib/syntax/scope/index.js
new file mode 100644
index 0000000..d217ff8
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/scope/index.js
@@ -0,0 +1,5 @@
+module.exports = {
+ AtrulePrelude: require('./atrulePrelude'),
+ Selector: require('./selector'),
+ Value: require('./value')
+};
diff --git a/node_modules/css-tree/lib/syntax/scope/selector.js b/node_modules/css-tree/lib/syntax/scope/selector.js
new file mode 100644
index 0000000..7cb990b
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/scope/selector.js
@@ -0,0 +1,80 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var DELIM = TYPE.Delim;
+var IDENT = TYPE.Ident;
+var DIMENSION = TYPE.Dimension;
+var PERCENTAGE = TYPE.Percentage;
+var NUMBER = TYPE.Number;
+var HASH = TYPE.Hash;
+var COLON = TYPE.Colon;
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)
+var ASTERISK = 0x002A; // U+002A ASTERISK (*)
+var PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)
+var SOLIDUS = 0x002F; // U+002F SOLIDUS (/)
+var FULLSTOP = 0x002E; // U+002E FULL STOP (.)
+var GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)
+var VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)
+var TILDE = 0x007E; // U+007E TILDE (~)
+
+function getNode(context) {
+ switch (this.scanner.tokenType) {
+ case LEFTSQUAREBRACKET:
+ return this.AttributeSelector();
+
+ case HASH:
+ return this.IdSelector();
+
+ case COLON:
+ if (this.scanner.lookupType(1) === COLON) {
+ return this.PseudoElementSelector();
+ } else {
+ return this.PseudoClassSelector();
+ }
+
+ case IDENT:
+ return this.TypeSelector();
+
+ case NUMBER:
+ case PERCENTAGE:
+ return this.Percentage();
+
+ case DIMENSION:
+ // throws when .123ident
+ if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === FULLSTOP) {
+ this.error('Identifier is expected', this.scanner.tokenStart + 1);
+ }
+ break;
+
+ case DELIM:
+ var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+ switch (code) {
+ case PLUSSIGN:
+ case GREATERTHANSIGN:
+ case TILDE:
+ context.space = null;
+ context.ignoreWSAfter = true;
+ return this.Combinator();
+
+ case SOLIDUS: // /deep/
+ return this.Combinator();
+
+ case FULLSTOP:
+ return this.ClassSelector();
+
+ case ASTERISK:
+ case VERTICALLINE:
+ return this.TypeSelector();
+
+ case NUMBERSIGN:
+ return this.IdSelector();
+ }
+
+ break;
+ }
+};
+
+module.exports = {
+ getNode: getNode
+};
diff --git a/node_modules/css-tree/lib/syntax/scope/value.js b/node_modules/css-tree/lib/syntax/scope/value.js
new file mode 100644
index 0000000..0403eb8
--- /dev/null
+++ b/node_modules/css-tree/lib/syntax/scope/value.js
@@ -0,0 +1,5 @@
+module.exports = {
+ getNode: require('./default'),
+ 'expression': require('../function/expression'),
+ 'var': require('../function/var')
+};
diff --git a/node_modules/css-tree/lib/tokenizer/char-code-definitions.js b/node_modules/css-tree/lib/tokenizer/char-code-definitions.js
new file mode 100644
index 0000000..fb9ec3f
--- /dev/null
+++ b/node_modules/css-tree/lib/tokenizer/char-code-definitions.js
@@ -0,0 +1,249 @@
+var EOF = 0;
+
+// https://drafts.csswg.org/css-syntax-3/
+// § 4.2. Definitions
+
+// digit
+// A code point between U+0030 DIGIT ZERO (0) and U+0039 DIGIT NINE (9).
+function isDigit(code) {
+ return code >= 0x0030 && code <= 0x0039;
+}
+
+// hex digit
+// A digit, or a code point between U+0041 LATIN CAPITAL LETTER A (A) and U+0046 LATIN CAPITAL LETTER F (F),
+// or a code point between U+0061 LATIN SMALL LETTER A (a) and U+0066 LATIN SMALL LETTER F (f).
+function isHexDigit(code) {
+ return (
+ isDigit(code) || // 0 .. 9
+ (code >= 0x0041 && code <= 0x0046) || // A .. F
+ (code >= 0x0061 && code <= 0x0066) // a .. f
+ );
+}
+
+// uppercase letter
+// A code point between U+0041 LATIN CAPITAL LETTER A (A) and U+005A LATIN CAPITAL LETTER Z (Z).
+function isUppercaseLetter(code) {
+ return code >= 0x0041 && code <= 0x005A;
+}
+
+// lowercase letter
+// A code point between U+0061 LATIN SMALL LETTER A (a) and U+007A LATIN SMALL LETTER Z (z).
+function isLowercaseLetter(code) {
+ return code >= 0x0061 && code <= 0x007A;
+}
+
+// letter
+// An uppercase letter or a lowercase letter.
+function isLetter(code) {
+ return isUppercaseLetter(code) || isLowercaseLetter(code);
+}
+
+// non-ASCII code point
+// A code point with a value equal to or greater than U+0080 <control>.
+function isNonAscii(code) {
+ return code >= 0x0080;
+}
+
+// name-start code point
+// A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+function isNameStart(code) {
+ return isLetter(code) || isNonAscii(code) || code === 0x005F;
+}
+
+// name code point
+// A name-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+function isName(code) {
+ return isNameStart(code) || isDigit(code) || code === 0x002D;
+}
+
+// non-printable code point
+// A code point between U+0000 NULL and U+0008 BACKSPACE, or U+000B LINE TABULATION,
+// or a code point between U+000E SHIFT OUT and U+001F INFORMATION SEPARATOR ONE, or U+007F DELETE.
+function isNonPrintable(code) {
+ return (
+ (code >= 0x0000 && code <= 0x0008) ||
+ (code === 0x000B) ||
+ (code >= 0x000E && code <= 0x001F) ||
+ (code === 0x007F)
+ );
+}
+
+// newline
+// U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,
+// as they are converted to U+000A LINE FEED during preprocessing.
+// TODO: we doesn't do a preprocessing, so check a code point for U+000D CARRIAGE RETURN and U+000C FORM FEED
+function isNewline(code) {
+ return code === 0x000A || code === 0x000D || code === 0x000C;
+}
+
+// whitespace
+// A newline, U+0009 CHARACTER TABULATION, or U+0020 SPACE.
+function isWhiteSpace(code) {
+ return isNewline(code) || code === 0x0020 || code === 0x0009;
+}
+
+// § 4.3.8. Check if two code points are a valid escape
+function isValidEscape(first, second) {
+ // If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
+ if (first !== 0x005C) {
+ return false;
+ }
+
+ // Otherwise, if the second code point is a newline or EOF, return false.
+ if (isNewline(second) || second === EOF) {
+ return false;
+ }
+
+ // Otherwise, return true.
+ return true;
+}
+
+// § 4.3.9. Check if three code points would start an identifier
+function isIdentifierStart(first, second, third) {
+ // Look at the first code point:
+
+ // U+002D HYPHEN-MINUS
+ if (first === 0x002D) {
+ // If the second code point is a name-start code point or a U+002D HYPHEN-MINUS,
+ // or the second and third code points are a valid escape, return true. Otherwise, return false.
+ return (
+ isNameStart(second) ||
+ second === 0x002D ||
+ isValidEscape(second, third)
+ );
+ }
+
+ // name-start code point
+ if (isNameStart(first)) {
+ // Return true.
+ return true;
+ }
+
+ // U+005C REVERSE SOLIDUS (\)
+ if (first === 0x005C) {
+ // If the first and second code points are a valid escape, return true. Otherwise, return false.
+ return isValidEscape(first, second);
+ }
+
+ // anything else
+ // Return false.
+ return false;
+}
+
+// § 4.3.10. Check if three code points would start a number
+function isNumberStart(first, second, third) {
+ // Look at the first code point:
+
+ // U+002B PLUS SIGN (+)
+ // U+002D HYPHEN-MINUS (-)
+ if (first === 0x002B || first === 0x002D) {
+ // If the second code point is a digit, return true.
+ if (isDigit(second)) {
+ return 2;
+ }
+
+ // Otherwise, if the second code point is a U+002E FULL STOP (.)
+ // and the third code point is a digit, return true.
+ // Otherwise, return false.
+ return second === 0x002E && isDigit(third) ? 3 : 0;
+ }
+
+ // U+002E FULL STOP (.)
+ if (first === 0x002E) {
+ // If the second code point is a digit, return true. Otherwise, return false.
+ return isDigit(second) ? 2 : 0;
+ }
+
+ // digit
+ if (isDigit(first)) {
+ // Return true.
+ return 1;
+ }
+
+ // anything else
+ // Return false.
+ return 0;
+}
+
+//
+// Misc
+//
+
+// detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)
+function isBOM(code) {
+ // UTF-16BE
+ if (code === 0xFEFF) {
+ return 1;
+ }
+
+ // UTF-16LE
+ if (code === 0xFFFE) {
+ return 1;
+ }
+
+ return 0;
+}
+
+// Fast code category
+//
+// https://drafts.csswg.org/css-syntax/#tokenizer-definitions
+// > non-ASCII code point
+// > A code point with a value equal to or greater than U+0080 <control>
+// > name-start code point
+// > A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+// > name code point
+// > A name-start code point, a digit, or U+002D HYPHEN-MINUS (-)
+// That means only ASCII code points has a special meaning and we define a maps for 0..127 codes only
+var CATEGORY = new Array(0x80);
+charCodeCategory.Eof = 0x80;
+charCodeCategory.WhiteSpace = 0x82;
+charCodeCategory.Digit = 0x83;
+charCodeCategory.NameStart = 0x84;
+charCodeCategory.NonPrintable = 0x85;
+
+for (var i = 0; i < CATEGORY.length; i++) {
+ switch (true) {
+ case isWhiteSpace(i):
+ CATEGORY[i] = charCodeCategory.WhiteSpace;
+ break;
+
+ case isDigit(i):
+ CATEGORY[i] = charCodeCategory.Digit;
+ break;
+
+ case isNameStart(i):
+ CATEGORY[i] = charCodeCategory.NameStart;
+ break;
+
+ case isNonPrintable(i):
+ CATEGORY[i] = charCodeCategory.NonPrintable;
+ break;
+
+ default:
+ CATEGORY[i] = i || charCodeCategory.Eof;
+ }
+}
+
+function charCodeCategory(code) {
+ return code < 0x80 ? CATEGORY[code] : charCodeCategory.NameStart;
+};
+
+module.exports = {
+ isDigit: isDigit,
+ isHexDigit: isHexDigit,
+ isUppercaseLetter: isUppercaseLetter,
+ isLowercaseLetter: isLowercaseLetter,
+ isLetter: isLetter,
+ isNonAscii: isNonAscii,
+ isNameStart: isNameStart,
+ isName: isName,
+ isNonPrintable: isNonPrintable,
+ isNewline: isNewline,
+ isWhiteSpace: isWhiteSpace,
+ isValidEscape: isValidEscape,
+ isIdentifierStart: isIdentifierStart,
+ isNumberStart: isNumberStart,
+
+ isBOM: isBOM,
+ charCodeCategory: charCodeCategory
+};
diff --git a/node_modules/css-tree/lib/tokenizer/const.js b/node_modules/css-tree/lib/tokenizer/const.js
new file mode 100644
index 0000000..e0f8869
--- /dev/null
+++ b/node_modules/css-tree/lib/tokenizer/const.js
@@ -0,0 +1,40 @@
+// CSS Syntax Module Level 3
+// https://www.w3.org/TR/css-syntax-3/
+var TYPE = {
+ EOF: 0, // <EOF-token>
+ Ident: 1, // <ident-token>
+ Function: 2, // <function-token>
+ AtKeyword: 3, // <at-keyword-token>
+ Hash: 4, // <hash-token>
+ String: 5, // <string-token>
+ BadString: 6, // <bad-string-token>
+ Url: 7, // <url-token>
+ BadUrl: 8, // <bad-url-token>
+ Delim: 9, // <delim-token>
+ Number: 10, // <number-token>
+ Percentage: 11, // <percentage-token>
+ Dimension: 12, // <dimension-token>
+ WhiteSpace: 13, // <whitespace-token>
+ CDO: 14, // <CDO-token>
+ CDC: 15, // <CDC-token>
+ Colon: 16, // <colon-token> :
+ Semicolon: 17, // <semicolon-token> ;
+ Comma: 18, // <comma-token> ,
+ LeftSquareBracket: 19, // <[-token>
+ RightSquareBracket: 20, // <]-token>
+ LeftParenthesis: 21, // <(-token>
+ RightParenthesis: 22, // <)-token>
+ LeftCurlyBracket: 23, // <{-token>
+ RightCurlyBracket: 24, // <}-token>
+ Comment: 25
+};
+
+var NAME = Object.keys(TYPE).reduce(function(result, key) {
+ result[TYPE[key]] = key;
+ return result;
+}, {});
+
+module.exports = {
+ TYPE: TYPE,
+ NAME: NAME
+};
diff --git a/node_modules/css-tree/lib/tokenizer/index.js b/node_modules/css-tree/lib/tokenizer/index.js
new file mode 100644
index 0000000..dd7ada2
--- /dev/null
+++ b/node_modules/css-tree/lib/tokenizer/index.js
@@ -0,0 +1,591 @@
+var TokenStream = require('../common/TokenStream');
+var adoptBuffer = require('../common/adopt-buffer');
+
+var constants = require('./const');
+var TYPE = constants.TYPE;
+
+var charCodeDefinitions = require('./char-code-definitions');
+var isNewline = charCodeDefinitions.isNewline;
+var isName = charCodeDefinitions.isName;
+var isValidEscape = charCodeDefinitions.isValidEscape;
+var isNumberStart = charCodeDefinitions.isNumberStart;
+var isIdentifierStart = charCodeDefinitions.isIdentifierStart;
+var charCodeCategory = charCodeDefinitions.charCodeCategory;
+var isBOM = charCodeDefinitions.isBOM;
+
+var utils = require('./utils');
+var cmpStr = utils.cmpStr;
+var getNewlineLength = utils.getNewlineLength;
+var findWhiteSpaceEnd = utils.findWhiteSpaceEnd;
+var consumeEscaped = utils.consumeEscaped;
+var consumeName = utils.consumeName;
+var consumeNumber = utils.consumeNumber;
+var consumeBadUrlRemnants = utils.consumeBadUrlRemnants;
+
+var OFFSET_MASK = 0x00FFFFFF;
+var TYPE_SHIFT = 24;
+
+function tokenize(source, stream) {
+ function getCharCode(offset) {
+ return offset < sourceLength ? source.charCodeAt(offset) : 0;
+ }
+
+ // § 4.3.3. Consume a numeric token
+ function consumeNumericToken() {
+ // Consume a number and let number be the result.
+ offset = consumeNumber(source, offset);
+
+ // If the next 3 input code points would start an identifier, then:
+ if (isIdentifierStart(getCharCode(offset), getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // Create a <dimension-token> with the same value and type flag as number, and a unit set initially to the empty string.
+ // Consume a name. Set the <dimension-token>’s unit to the returned value.
+ // Return the <dimension-token>.
+ type = TYPE.Dimension;
+ offset = consumeName(source, offset);
+ return;
+ }
+
+ // Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.
+ if (getCharCode(offset) === 0x0025) {
+ // Create a <percentage-token> with the same value as number, and return it.
+ type = TYPE.Percentage;
+ offset++;
+ return;
+ }
+
+ // Otherwise, create a <number-token> with the same value and type flag as number, and return it.
+ type = TYPE.Number;
+ }
+
+ // § 4.3.4. Consume an ident-like token
+ function consumeIdentLikeToken() {
+ const nameStartOffset = offset;
+
+ // Consume a name, and let string be the result.
+ offset = consumeName(source, offset);
+
+ // If string’s value is an ASCII case-insensitive match for "url",
+ // and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
+ if (cmpStr(source, nameStartOffset, offset, 'url') && getCharCode(offset) === 0x0028) {
+ // While the next two input code points are whitespace, consume the next input code point.
+ offset = findWhiteSpaceEnd(source, offset + 1);
+
+ // If the next one or two input code points are U+0022 QUOTATION MARK ("), U+0027 APOSTROPHE ('),
+ // or whitespace followed by U+0022 QUOTATION MARK (") or U+0027 APOSTROPHE ('),
+ // then create a <function-token> with its value set to string and return it.
+ if (getCharCode(offset) === 0x0022 ||
+ getCharCode(offset) === 0x0027) {
+ type = TYPE.Function;
+ offset = nameStartOffset + 4;
+ return;
+ }
+
+ // Otherwise, consume a url token, and return it.
+ consumeUrlToken();
+ return;
+ }
+
+ // Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.
+ // Create a <function-token> with its value set to string and return it.
+ if (getCharCode(offset) === 0x0028) {
+ type = TYPE.Function;
+ offset++;
+ return;
+ }
+
+ // Otherwise, create an <ident-token> with its value set to string and return it.
+ type = TYPE.Ident;
+ }
+
+ // § 4.3.5. Consume a string token
+ function consumeStringToken(endingCodePoint) {
+ // This algorithm may be called with an ending code point, which denotes the code point
+ // that ends the string. If an ending code point is not specified,
+ // the current input code point is used.
+ if (!endingCodePoint) {
+ endingCodePoint = getCharCode(offset++);
+ }
+
+ // Initially create a <string-token> with its value set to the empty string.
+ type = TYPE.String;
+
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ switch (charCodeCategory(code)) {
+ // ending code point
+ case endingCodePoint:
+ // Return the <string-token>.
+ offset++;
+ return;
+
+ // EOF
+ case charCodeCategory.Eof:
+ // This is a parse error. Return the <string-token>.
+ return;
+
+ // newline
+ case charCodeCategory.WhiteSpace:
+ if (isNewline(code)) {
+ // This is a parse error. Reconsume the current input code point,
+ // create a <bad-string-token>, and return it.
+ offset += getNewlineLength(source, offset, code);
+ type = TYPE.BadString;
+ return;
+ }
+ break;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the next input code point is EOF, do nothing.
+ if (offset === source.length - 1) {
+ break;
+ }
+
+ var nextCode = getCharCode(offset + 1);
+
+ // Otherwise, if the next input code point is a newline, consume it.
+ if (isNewline(nextCode)) {
+ offset += getNewlineLength(source, offset + 1, nextCode);
+ } else if (isValidEscape(code, nextCode)) {
+ // Otherwise, (the stream starts with a valid escape) consume
+ // an escaped code point and append the returned code point to
+ // the <string-token>’s value.
+ offset = consumeEscaped(source, offset) - 1;
+ }
+ break;
+
+ // anything else
+ // Append the current input code point to the <string-token>’s value.
+ }
+ }
+ }
+
+ // § 4.3.6. Consume a url token
+ // Note: This algorithm assumes that the initial "url(" has already been consumed.
+ // This algorithm also assumes that it’s being called to consume an "unquoted" value, like url(foo).
+ // A quoted value, like url("foo"), is parsed as a <function-token>. Consume an ident-like token
+ // automatically handles this distinction; this algorithm shouldn’t be called directly otherwise.
+ function consumeUrlToken() {
+ // Initially create a <url-token> with its value set to the empty string.
+ type = TYPE.Url;
+
+ // Consume as much whitespace as possible.
+ offset = findWhiteSpaceEnd(source, offset);
+
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ switch (charCodeCategory(code)) {
+ // U+0029 RIGHT PARENTHESIS ())
+ case 0x0029:
+ // Return the <url-token>.
+ offset++;
+ return;
+
+ // EOF
+ case charCodeCategory.Eof:
+ // This is a parse error. Return the <url-token>.
+ return;
+
+ // whitespace
+ case charCodeCategory.WhiteSpace:
+ // Consume as much whitespace as possible.
+ offset = findWhiteSpaceEnd(source, offset);
+
+ // If the next input code point is U+0029 RIGHT PARENTHESIS ()) or EOF,
+ // consume it and return the <url-token>
+ // (if EOF was encountered, this is a parse error);
+ if (getCharCode(offset) === 0x0029 || offset >= source.length) {
+ if (offset < source.length) {
+ offset++;
+ }
+ return;
+ }
+
+ // otherwise, consume the remnants of a bad url, create a <bad-url-token>,
+ // and return it.
+ offset = consumeBadUrlRemnants(source, offset);
+ type = TYPE.BadUrl;
+ return;
+
+ // U+0022 QUOTATION MARK (")
+ // U+0027 APOSTROPHE (')
+ // U+0028 LEFT PARENTHESIS (()
+ // non-printable code point
+ case 0x0022:
+ case 0x0027:
+ case 0x0028:
+ case charCodeCategory.NonPrintable:
+ // This is a parse error. Consume the remnants of a bad url,
+ // create a <bad-url-token>, and return it.
+ offset = consumeBadUrlRemnants(source, offset);
+ type = TYPE.BadUrl;
+ return;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the stream starts with a valid escape, consume an escaped code point and
+ // append the returned code point to the <url-token>’s value.
+ if (isValidEscape(code, getCharCode(offset + 1))) {
+ offset = consumeEscaped(source, offset) - 1;
+ break;
+ }
+
+ // Otherwise, this is a parse error. Consume the remnants of a bad url,
+ // create a <bad-url-token>, and return it.
+ offset = consumeBadUrlRemnants(source, offset);
+ type = TYPE.BadUrl;
+ return;
+
+ // anything else
+ // Append the current input code point to the <url-token>’s value.
+ }
+ }
+ }
+
+ if (!stream) {
+ stream = new TokenStream();
+ }
+
+ // ensure source is a string
+ source = String(source || '');
+
+ var sourceLength = source.length;
+ var offsetAndType = adoptBuffer(stream.offsetAndType, sourceLength + 1); // +1 because of eof-token
+ var balance = adoptBuffer(stream.balance, sourceLength + 1);
+ var tokenCount = 0;
+ var start = isBOM(getCharCode(0));
+ var offset = start;
+ var balanceCloseType = 0;
+ var balanceStart = 0;
+ var balancePrev = 0;
+
+ // https://drafts.csswg.org/css-syntax-3/#consume-token
+ // § 4.3.1. Consume a token
+ while (offset < sourceLength) {
+ var code = source.charCodeAt(offset);
+ var type = 0;
+
+ balance[tokenCount] = sourceLength;
+
+ switch (charCodeCategory(code)) {
+ // whitespace
+ case charCodeCategory.WhiteSpace:
+ // Consume as much whitespace as possible. Return a <whitespace-token>.
+ type = TYPE.WhiteSpace;
+ offset = findWhiteSpaceEnd(source, offset + 1);
+ break;
+
+ // U+0022 QUOTATION MARK (")
+ case 0x0022:
+ // Consume a string token and return it.
+ consumeStringToken();
+ break;
+
+ // U+0023 NUMBER SIGN (#)
+ case 0x0023:
+ // If the next input code point is a name code point or the next two input code points are a valid escape, then:
+ if (isName(getCharCode(offset + 1)) || isValidEscape(getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // Create a <hash-token>.
+ type = TYPE.Hash;
+
+ // If the next 3 input code points would start an identifier, set the <hash-token>’s type flag to "id".
+ // if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {
+ // // TODO: set id flag
+ // }
+
+ // Consume a name, and set the <hash-token>’s value to the returned string.
+ offset = consumeName(source, offset + 1);
+
+ // Return the <hash-token>.
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+0027 APOSTROPHE (')
+ case 0x0027:
+ // Consume a string token and return it.
+ consumeStringToken();
+ break;
+
+ // U+0028 LEFT PARENTHESIS (()
+ case 0x0028:
+ // Return a <(-token>.
+ type = TYPE.LeftParenthesis;
+ offset++;
+ break;
+
+ // U+0029 RIGHT PARENTHESIS ())
+ case 0x0029:
+ // Return a <)-token>.
+ type = TYPE.RightParenthesis;
+ offset++;
+ break;
+
+ // U+002B PLUS SIGN (+)
+ case 0x002B:
+ // If the input stream starts with a number, ...
+ if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+ break;
+
+ // U+002C COMMA (,)
+ case 0x002C:
+ // Return a <comma-token>.
+ type = TYPE.Comma;
+ offset++;
+ break;
+
+ // U+002D HYPHEN-MINUS (-)
+ case 0x002D:
+ // If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.
+ if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ consumeNumericToken();
+ } else {
+ // Otherwise, if the next 2 input code points are U+002D HYPHEN-MINUS U+003E GREATER-THAN SIGN (->), consume them and return a <CDC-token>.
+ if (getCharCode(offset + 1) === 0x002D &&
+ getCharCode(offset + 2) === 0x003E) {
+ type = TYPE.CDC;
+ offset = offset + 3;
+ } else {
+ // Otherwise, if the input stream starts with an identifier, ...
+ if (isIdentifierStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+ }
+ }
+ break;
+
+ // U+002E FULL STOP (.)
+ case 0x002E:
+ // If the input stream starts with a number, ...
+ if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {
+ // ... reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+002F SOLIDUS (/)
+ case 0x002F:
+ // If the next two input code point are U+002F SOLIDUS (/) followed by a U+002A ASTERISK (*),
+ if (getCharCode(offset + 1) === 0x002A) {
+ // ... consume them and all following code points up to and including the first U+002A ASTERISK (*)
+ // followed by a U+002F SOLIDUS (/), or up to an EOF code point.
+ type = TYPE.Comment;
+ offset = source.indexOf('*/', offset + 2) + 2;
+ if (offset === 1) {
+ offset = source.length;
+ }
+ } else {
+ type = TYPE.Delim;
+ offset++;
+ }
+ break;
+
+ // U+003A COLON (:)
+ case 0x003A:
+ // Return a <colon-token>.
+ type = TYPE.Colon;
+ offset++;
+ break;
+
+ // U+003B SEMICOLON (;)
+ case 0x003B:
+ // Return a <semicolon-token>.
+ type = TYPE.Semicolon;
+ offset++;
+ break;
+
+ // U+003C LESS-THAN SIGN (<)
+ case 0x003C:
+ // If the next 3 input code points are U+0021 EXCLAMATION MARK U+002D HYPHEN-MINUS U+002D HYPHEN-MINUS (!--), ...
+ if (getCharCode(offset + 1) === 0x0021 &&
+ getCharCode(offset + 2) === 0x002D &&
+ getCharCode(offset + 3) === 0x002D) {
+ // ... consume them and return a <CDO-token>.
+ type = TYPE.CDO;
+ offset = offset + 4;
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+0040 COMMERCIAL AT (@)
+ case 0x0040:
+ // If the next 3 input code points would start an identifier, ...
+ if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {
+ // ... consume a name, create an <at-keyword-token> with its value set to the returned value, and return it.
+ type = TYPE.AtKeyword;
+ offset = consumeName(source, offset + 1);
+ } else {
+ // Otherwise, return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+
+ break;
+
+ // U+005B LEFT SQUARE BRACKET ([)
+ case 0x005B:
+ // Return a <[-token>.
+ type = TYPE.LeftSquareBracket;
+ offset++;
+ break;
+
+ // U+005C REVERSE SOLIDUS (\)
+ case 0x005C:
+ // If the input stream starts with a valid escape, ...
+ if (isValidEscape(code, getCharCode(offset + 1))) {
+ // ... reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ } else {
+ // Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+ break;
+
+ // U+005D RIGHT SQUARE BRACKET (])
+ case 0x005D:
+ // Return a <]-token>.
+ type = TYPE.RightSquareBracket;
+ offset++;
+ break;
+
+ // U+007B LEFT CURLY BRACKET ({)
+ case 0x007B:
+ // Return a <{-token>.
+ type = TYPE.LeftCurlyBracket;
+ offset++;
+ break;
+
+ // U+007D RIGHT CURLY BRACKET (})
+ case 0x007D:
+ // Return a <}-token>.
+ type = TYPE.RightCurlyBracket;
+ offset++;
+ break;
+
+ // digit
+ case charCodeCategory.Digit:
+ // Reconsume the current input code point, consume a numeric token, and return it.
+ consumeNumericToken();
+ break;
+
+ // name-start code point
+ case charCodeCategory.NameStart:
+ // Reconsume the current input code point, consume an ident-like token, and return it.
+ consumeIdentLikeToken();
+ break;
+
+ // EOF
+ case charCodeCategory.Eof:
+ // Return an <EOF-token>.
+ break;
+
+ // anything else
+ default:
+ // Return a <delim-token> with its value set to the current input code point.
+ type = TYPE.Delim;
+ offset++;
+ }
+
+ switch (type) {
+ case balanceCloseType:
+ balancePrev = balanceStart & OFFSET_MASK;
+ balanceStart = balance[balancePrev];
+ balanceCloseType = balanceStart >> TYPE_SHIFT;
+ balance[tokenCount] = balancePrev;
+ balance[balancePrev++] = tokenCount;
+ for (; balancePrev < tokenCount; balancePrev++) {
+ if (balance[balancePrev] === sourceLength) {
+ balance[balancePrev] = tokenCount;
+ }
+ }
+ break;
+
+ case TYPE.LeftParenthesis:
+ case TYPE.Function:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE.RightParenthesis;
+ balanceStart = (balanceCloseType << TYPE_SHIFT) | tokenCount;
+ break;
+
+ case TYPE.LeftSquareBracket:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE.RightSquareBracket;
+ balanceStart = (balanceCloseType << TYPE_SHIFT) | tokenCount;
+ break;
+
+ case TYPE.LeftCurlyBracket:
+ balance[tokenCount] = balanceStart;
+ balanceCloseType = TYPE.RightCurlyBracket;
+ balanceStart = (balanceCloseType << TYPE_SHIFT) | tokenCount;
+ break;
+ }
+
+ offsetAndType[tokenCount++] = (type << TYPE_SHIFT) | offset;
+ }
+
+ // finalize buffers
+ offsetAndType[tokenCount] = (TYPE.EOF << TYPE_SHIFT) | offset; // <EOF-token>
+ balance[tokenCount] = sourceLength;
+ balance[sourceLength] = sourceLength; // prevents false positive balance match with any token
+ while (balanceStart !== 0) {
+ balancePrev = balanceStart & OFFSET_MASK;
+ balanceStart = balance[balancePrev];
+ balance[balancePrev] = sourceLength;
+ }
+
+ // update stream
+ stream.source = source;
+ stream.firstCharOffset = start;
+ stream.offsetAndType = offsetAndType;
+ stream.tokenCount = tokenCount;
+ stream.balance = balance;
+ stream.reset();
+ stream.next();
+
+ return stream;
+}
+
+// extend tokenizer with constants
+Object.keys(constants).forEach(function(key) {
+ tokenize[key] = constants[key];
+});
+
+// extend tokenizer with static methods from utils
+Object.keys(charCodeDefinitions).forEach(function(key) {
+ tokenize[key] = charCodeDefinitions[key];
+});
+Object.keys(utils).forEach(function(key) {
+ tokenize[key] = utils[key];
+});
+
+module.exports = tokenize;
diff --git a/node_modules/css-tree/lib/tokenizer/utils.js b/node_modules/css-tree/lib/tokenizer/utils.js
new file mode 100644
index 0000000..f5a38ec
--- /dev/null
+++ b/node_modules/css-tree/lib/tokenizer/utils.js
@@ -0,0 +1,243 @@
+var charCodeDef = require('./char-code-definitions');
+var isDigit = charCodeDef.isDigit;
+var isHexDigit = charCodeDef.isHexDigit;
+var isUppercaseLetter = charCodeDef.isUppercaseLetter;
+var isName = charCodeDef.isName;
+var isWhiteSpace = charCodeDef.isWhiteSpace;
+var isValidEscape = charCodeDef.isValidEscape;
+
+function getCharCode(source, offset) {
+ return offset < source.length ? source.charCodeAt(offset) : 0;
+}
+
+function getNewlineLength(source, offset, code) {
+ if (code === 13 /* \r */ && getCharCode(source, offset + 1) === 10 /* \n */) {
+ return 2;
+ }
+
+ return 1;
+}
+
+function cmpChar(testStr, offset, referenceCode) {
+ var code = testStr.charCodeAt(offset);
+
+ // code.toLowerCase() for A..Z
+ if (isUppercaseLetter(code)) {
+ code = code | 32;
+ }
+
+ return code === referenceCode;
+}
+
+function cmpStr(testStr, start, end, referenceStr) {
+ if (end - start !== referenceStr.length) {
+ return false;
+ }
+
+ if (start < 0 || end > testStr.length) {
+ return false;
+ }
+
+ for (var i = start; i < end; i++) {
+ var testCode = testStr.charCodeAt(i);
+ var referenceCode = referenceStr.charCodeAt(i - start);
+
+ // testCode.toLowerCase() for A..Z
+ if (isUppercaseLetter(testCode)) {
+ testCode = testCode | 32;
+ }
+
+ if (testCode !== referenceCode) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function findWhiteSpaceStart(source, offset) {
+ for (; offset >= 0; offset--) {
+ if (!isWhiteSpace(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset + 1;
+}
+
+function findWhiteSpaceEnd(source, offset) {
+ for (; offset < source.length; offset++) {
+ if (!isWhiteSpace(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset;
+}
+
+function findDecimalNumberEnd(source, offset) {
+ for (; offset < source.length; offset++) {
+ if (!isDigit(source.charCodeAt(offset))) {
+ break;
+ }
+ }
+
+ return offset;
+}
+
+// § 4.3.7. Consume an escaped code point
+function consumeEscaped(source, offset) {
+ // It assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed and
+ // that the next input code point has already been verified to be part of a valid escape.
+ offset += 2;
+
+ // hex digit
+ if (isHexDigit(getCharCode(source, offset - 1))) {
+ // Consume as many hex digits as possible, but no more than 5.
+ // Note that this means 1-6 hex digits have been consumed in total.
+ for (var maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) {
+ if (!isHexDigit(getCharCode(source, offset))) {
+ break;
+ }
+ }
+
+ // If the next input code point is whitespace, consume it as well.
+ var code = getCharCode(source, offset);
+ if (isWhiteSpace(code)) {
+ offset += getNewlineLength(source, offset, code);
+ }
+ }
+
+ return offset;
+}
+
+// §4.3.11. Consume a name
+// Note: This algorithm does not do the verification of the first few code points that are necessary
+// to ensure the returned code points would constitute an <ident-token>. If that is the intended use,
+// ensure that the stream starts with an identifier before calling this algorithm.
+function consumeName(source, offset) {
+ // Let result initially be an empty string.
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ // name code point
+ if (isName(code)) {
+ // Append the code point to result.
+ continue;
+ }
+
+ // the stream starts with a valid escape
+ if (isValidEscape(code, getCharCode(source, offset + 1))) {
+ // Consume an escaped code point. Append the returned code point to result.
+ offset = consumeEscaped(source, offset) - 1;
+ continue;
+ }
+
+ // anything else
+ // Reconsume the current input code point. Return result.
+ break;
+ }
+
+ return offset;
+}
+
+// §4.3.12. Consume a number
+function consumeNumber(source, offset) {
+ var code = source.charCodeAt(offset);
+
+ // 2. If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-),
+ // consume it and append it to repr.
+ if (code === 0x002B || code === 0x002D) {
+ code = source.charCodeAt(offset += 1);
+ }
+
+ // 3. While the next input code point is a digit, consume it and append it to repr.
+ if (isDigit(code)) {
+ offset = findDecimalNumberEnd(source, offset + 1);
+ code = source.charCodeAt(offset);
+ }
+
+ // 4. If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then:
+ if (code === 0x002E && isDigit(source.charCodeAt(offset + 1))) {
+ // 4.1 Consume them.
+ // 4.2 Append them to repr.
+ code = source.charCodeAt(offset += 2);
+
+ // 4.3 Set type to "number".
+ // TODO
+
+ // 4.4 While the next input code point is a digit, consume it and append it to repr.
+
+ offset = findDecimalNumberEnd(source, offset);
+ }
+
+ // 5. If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E)
+ // or U+0065 LATIN SMALL LETTER E (e), ... , followed by a digit, then:
+ if (cmpChar(source, offset, 101 /* e */)) {
+ var sign = 0;
+ code = source.charCodeAt(offset + 1);
+
+ // ... optionally followed by U+002D HYPHEN-MINUS (-) or U+002B PLUS SIGN (+) ...
+ if (code === 0x002D || code === 0x002B) {
+ sign = 1;
+ code = source.charCodeAt(offset + 2);
+ }
+
+ // ... followed by a digit
+ if (isDigit(code)) {
+ // 5.1 Consume them.
+ // 5.2 Append them to repr.
+
+ // 5.3 Set type to "number".
+ // TODO
+
+ // 5.4 While the next input code point is a digit, consume it and append it to repr.
+ offset = findDecimalNumberEnd(source, offset + 1 + sign + 1);
+ }
+ }
+
+ return offset;
+}
+
+// § 4.3.14. Consume the remnants of a bad url
+// ... its sole use is to consume enough of the input stream to reach a recovery point
+// where normal tokenizing can resume.
+function consumeBadUrlRemnants(source, offset) {
+ // Repeatedly consume the next input code point from the stream:
+ for (; offset < source.length; offset++) {
+ var code = source.charCodeAt(offset);
+
+ // U+0029 RIGHT PARENTHESIS ())
+ // EOF
+ if (code === 0x0029) {
+ // Return.
+ offset++;
+ break;
+ }
+
+ if (isValidEscape(code, getCharCode(source, offset + 1))) {
+ // Consume an escaped code point.
+ // Note: This allows an escaped right parenthesis ("\)") to be encountered
+ // without ending the <bad-url-token>. This is otherwise identical to
+ // the "anything else" clause.
+ offset = consumeEscaped(source, offset);
+ }
+ }
+
+ return offset;
+}
+
+module.exports = {
+ consumeEscaped: consumeEscaped,
+ consumeName: consumeName,
+ consumeNumber: consumeNumber,
+ consumeBadUrlRemnants: consumeBadUrlRemnants,
+
+ cmpChar: cmpChar,
+ cmpStr: cmpStr,
+
+ getNewlineLength: getNewlineLength,
+ findWhiteSpaceStart: findWhiteSpaceStart,
+ findWhiteSpaceEnd: findWhiteSpaceEnd
+};
diff --git a/node_modules/css-tree/lib/utils/clone.js b/node_modules/css-tree/lib/utils/clone.js
new file mode 100644
index 0000000..927294b
--- /dev/null
+++ b/node_modules/css-tree/lib/utils/clone.js
@@ -0,0 +1,21 @@
+var List = require('../common/List');
+
+module.exports = function clone(node) {
+ var result = {};
+
+ for (var key in node) {
+ var value = node[key];
+
+ if (value) {
+ if (Array.isArray(value) || value instanceof List) {
+ value = value.map(clone);
+ } else if (value.constructor === Object) {
+ value = clone(value);
+ }
+ }
+
+ result[key] = value;
+ }
+
+ return result;
+};
diff --git a/node_modules/css-tree/lib/utils/createCustomError.js b/node_modules/css-tree/lib/utils/createCustomError.js
new file mode 100644
index 0000000..59285d8
--- /dev/null
+++ b/node_modules/css-tree/lib/utils/createCustomError.js
@@ -0,0 +1,17 @@
+module.exports = function createCustomError(name, message) {
+ // use Object.create(), because some VMs prevent setting line/column otherwise
+ // (iOS Safari 10 even throws an exception)
+ var error = Object.create(SyntaxError.prototype);
+ var errorStack = new Error();
+
+ error.name = name;
+ error.message = message;
+
+ Object.defineProperty(error, 'stack', {
+ get: function() {
+ return (errorStack.stack || '').replace(/^(.+\n){1,3}/, name + ': ' + message + '\n');
+ }
+ });
+
+ return error;
+};
diff --git a/node_modules/css-tree/lib/utils/names.js b/node_modules/css-tree/lib/utils/names.js
new file mode 100644
index 0000000..fdc3f1f
--- /dev/null
+++ b/node_modules/css-tree/lib/utils/names.js
@@ -0,0 +1,104 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var keywords = Object.create(null);
+var properties = Object.create(null);
+var HYPHENMINUS = 45; // '-'.charCodeAt()
+
+function isCustomProperty(str, offset) {
+ offset = offset || 0;
+
+ return str.length - offset >= 2 &&
+ str.charCodeAt(offset) === HYPHENMINUS &&
+ str.charCodeAt(offset + 1) === HYPHENMINUS;
+}
+
+function getVendorPrefix(str, offset) {
+ offset = offset || 0;
+
+ // verdor prefix should be at least 3 chars length
+ if (str.length - offset >= 3) {
+ // vendor prefix starts with hyper minus following non-hyper minus
+ if (str.charCodeAt(offset) === HYPHENMINUS &&
+ str.charCodeAt(offset + 1) !== HYPHENMINUS) {
+ // vendor prefix should contain a hyper minus at the ending
+ var secondDashIndex = str.indexOf('-', offset + 2);
+
+ if (secondDashIndex !== -1) {
+ return str.substring(offset, secondDashIndex + 1);
+ }
+ }
+ }
+
+ return '';
+}
+
+function getKeywordDescriptor(keyword) {
+ if (hasOwnProperty.call(keywords, keyword)) {
+ return keywords[keyword];
+ }
+
+ var name = keyword.toLowerCase();
+
+ if (hasOwnProperty.call(keywords, name)) {
+ return keywords[keyword] = keywords[name];
+ }
+
+ var custom = isCustomProperty(name, 0);
+ var vendor = !custom ? getVendorPrefix(name, 0) : '';
+
+ return keywords[keyword] = Object.freeze({
+ basename: name.substr(vendor.length),
+ name: name,
+ vendor: vendor,
+ prefix: vendor,
+ custom: custom
+ });
+}
+
+function getPropertyDescriptor(property) {
+ if (hasOwnProperty.call(properties, property)) {
+ return properties[property];
+ }
+
+ var name = property;
+ var hack = property[0];
+
+ if (hack === '/') {
+ hack = property[1] === '/' ? '//' : '/';
+ } else if (hack !== '_' &&
+ hack !== '*' &&
+ hack !== '$' &&
+ hack !== '#' &&
+ hack !== '+' &&
+ hack !== '&') {
+ hack = '';
+ }
+
+ var custom = isCustomProperty(name, hack.length);
+
+ // re-use result when possible (the same as for lower case)
+ if (!custom) {
+ name = name.toLowerCase();
+ if (hasOwnProperty.call(properties, name)) {
+ return properties[property] = properties[name];
+ }
+ }
+
+ var vendor = !custom ? getVendorPrefix(name, hack.length) : '';
+ var prefix = name.substr(0, hack.length + vendor.length);
+
+ return properties[property] = Object.freeze({
+ basename: name.substr(prefix.length),
+ name: name.substr(hack.length),
+ hack: hack,
+ vendor: vendor,
+ prefix: prefix,
+ custom: custom
+ });
+}
+
+module.exports = {
+ keyword: getKeywordDescriptor,
+ property: getPropertyDescriptor,
+ isCustomProperty: isCustomProperty,
+ vendorPrefix: getVendorPrefix
+};
diff --git a/node_modules/css-tree/lib/walker/create.js b/node_modules/css-tree/lib/walker/create.js
new file mode 100644
index 0000000..1731465
--- /dev/null
+++ b/node_modules/css-tree/lib/walker/create.js
@@ -0,0 +1,284 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var noop = function() {};
+
+function ensureFunction(value) {
+ return typeof value === 'function' ? value : noop;
+}
+
+function invokeForType(fn, type) {
+ return function(node, item, list) {
+ if (node.type === type) {
+ fn.call(this, node, item, list);
+ }
+ };
+}
+
+function getWalkersFromStructure(name, nodeType) {
+ var structure = nodeType.structure;
+ var walkers = [];
+
+ for (var key in structure) {
+ if (hasOwnProperty.call(structure, key) === false) {
+ continue;
+ }
+
+ var fieldTypes = structure[key];
+ var walker = {
+ name: key,
+ type: false,
+ nullable: false
+ };
+
+ if (!Array.isArray(structure[key])) {
+ fieldTypes = [structure[key]];
+ }
+
+ for (var i = 0; i < fieldTypes.length; i++) {
+ var fieldType = fieldTypes[i];
+ if (fieldType === null) {
+ walker.nullable = true;
+ } else if (typeof fieldType === 'string') {
+ walker.type = 'node';
+ } else if (Array.isArray(fieldType)) {
+ walker.type = 'list';
+ }
+ }
+
+ if (walker.type) {
+ walkers.push(walker);
+ }
+ }
+
+ if (walkers.length) {
+ return {
+ context: nodeType.walkContext,
+ fields: walkers
+ };
+ }
+
+ return null;
+}
+
+function getTypesFromConfig(config) {
+ var types = {};
+
+ for (var name in config.node) {
+ if (hasOwnProperty.call(config.node, name)) {
+ var nodeType = config.node[name];
+
+ if (!nodeType.structure) {
+ throw new Error('Missed `structure` field in `' + name + '` node type definition');
+ }
+
+ types[name] = getWalkersFromStructure(name, nodeType);
+ }
+ }
+
+ return types;
+}
+
+function createTypeIterator(config, reverse) {
+ var fields = config.fields.slice();
+ var contextName = config.context;
+ var useContext = typeof contextName === 'string';
+
+ if (reverse) {
+ fields.reverse();
+ }
+
+ return function(node, context, walk, walkReducer) {
+ var prevContextValue;
+
+ if (useContext) {
+ prevContextValue = context[contextName];
+ context[contextName] = node;
+ }
+
+ for (var i = 0; i < fields.length; i++) {
+ var field = fields[i];
+ var ref = node[field.name];
+
+ if (!field.nullable || ref) {
+ if (field.type === 'list') {
+ var breakWalk = reverse
+ ? ref.reduceRight(walkReducer, false)
+ : ref.reduce(walkReducer, false);
+
+ if (breakWalk) {
+ return true;
+ }
+ } else if (walk(ref)) {
+ return true;
+ }
+ }
+ }
+
+ if (useContext) {
+ context[contextName] = prevContextValue;
+ }
+ };
+}
+
+function createFastTraveralMap(iterators) {
+ return {
+ Atrule: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block
+ },
+ Rule: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block
+ },
+ Declaration: {
+ StyleSheet: iterators.StyleSheet,
+ Atrule: iterators.Atrule,
+ Rule: iterators.Rule,
+ Block: iterators.Block,
+ DeclarationList: iterators.DeclarationList
+ }
+ };
+}
+
+module.exports = function createWalker(config) {
+ var types = getTypesFromConfig(config);
+ var iteratorsNatural = {};
+ var iteratorsReverse = {};
+ var breakWalk = Symbol('break-walk');
+ var skipNode = Symbol('skip-node');
+
+ for (var name in types) {
+ if (hasOwnProperty.call(types, name) && types[name] !== null) {
+ iteratorsNatural[name] = createTypeIterator(types[name], false);
+ iteratorsReverse[name] = createTypeIterator(types[name], true);
+ }
+ }
+
+ var fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
+ var fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
+
+ var walk = function(root, options) {
+ function walkNode(node, item, list) {
+ var enterRet = enter.call(context, node, item, list);
+
+ if (enterRet === breakWalk) {
+ debugger;
+ return true;
+ }
+
+ if (enterRet === skipNode) {
+ return false;
+ }
+
+ if (iterators.hasOwnProperty(node.type)) {
+ if (iterators[node.type](node, context, walkNode, walkReducer)) {
+ return true;
+ }
+ }
+
+ if (leave.call(context, node, item, list) === breakWalk) {
+ return true;
+ }
+
+ return false;
+ }
+
+ var walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);
+ var enter = noop;
+ var leave = noop;
+ var iterators = iteratorsNatural;
+ var context = {
+ break: breakWalk,
+ skip: skipNode,
+
+ root: root,
+ stylesheet: null,
+ atrule: null,
+ atrulePrelude: null,
+ rule: null,
+ selector: null,
+ block: null,
+ declaration: null,
+ function: null
+ };
+
+ if (typeof options === 'function') {
+ enter = options;
+ } else if (options) {
+ enter = ensureFunction(options.enter);
+ leave = ensureFunction(options.leave);
+
+ if (options.reverse) {
+ iterators = iteratorsReverse;
+ }
+
+ if (options.visit) {
+ if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
+ iterators = options.reverse
+ ? fastTraversalIteratorsReverse[options.visit]
+ : fastTraversalIteratorsNatural[options.visit];
+ } else if (!types.hasOwnProperty(options.visit)) {
+ throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).join(', ') + ')');
+ }
+
+ enter = invokeForType(enter, options.visit);
+ leave = invokeForType(leave, options.visit);
+ }
+ }
+
+ if (enter === noop && leave === noop) {
+ throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+ }
+
+ walkNode(root);
+ };
+
+ walk.break = breakWalk;
+ walk.skip = skipNode;
+
+ walk.find = function(ast, fn) {
+ var found = null;
+
+ walk(ast, function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found = node;
+ return breakWalk;
+ }
+ });
+
+ return found;
+ };
+
+ walk.findLast = function(ast, fn) {
+ var found = null;
+
+ walk(ast, {
+ reverse: true,
+ enter: function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found = node;
+ return breakWalk;
+ }
+ }
+ });
+
+ return found;
+ };
+
+ walk.findAll = function(ast, fn) {
+ var found = [];
+
+ walk(ast, function(node, item, list) {
+ if (fn.call(this, node, item, list)) {
+ found.push(node);
+ }
+ });
+
+ return found;
+ };
+
+ return walk;
+};
diff --git a/node_modules/css-tree/lib/walker/index.js b/node_modules/css-tree/lib/walker/index.js
new file mode 100644
index 0000000..f3f0d6d
--- /dev/null
+++ b/node_modules/css-tree/lib/walker/index.js
@@ -0,0 +1,4 @@
+var createWalker = require('./create');
+var config = require('../syntax/config/walker');
+
+module.exports = createWalker(config);
diff --git a/node_modules/css-tree/package.json b/node_modules/css-tree/package.json
new file mode 100644
index 0000000..0bb7770
--- /dev/null
+++ b/node_modules/css-tree/package.json
@@ -0,0 +1,60 @@
+{
+ "name": "css-tree",
+ "version": "1.1.3",
+ "description": "A tool set for CSS: fast detailed parser (CSS \u2192 AST), walker (AST traversal), generator (AST \u2192 CSS) and lexer (validation and matching) based on specs and browser implementations",
+ "author": "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
+ "license": "MIT",
+ "repository": "csstree/csstree",
+ "keywords": [
+ "css",
+ "ast",
+ "tokenizer",
+ "parser",
+ "walker",
+ "lexer",
+ "generator",
+ "utils",
+ "syntax",
+ "validation"
+ ],
+ "main": "lib/index.js",
+ "unpkg": "dist/csstree.min.js",
+ "jsdelivr": "dist/csstree.min.js",
+ "scripts": {
+ "build": "rollup --config",
+ "lint": "eslint data lib scripts test && node scripts/review-syntax-patch --lint && node scripts/update-docs --lint",
+ "lint-and-test": "npm run lint && npm test",
+ "update:docs": "node scripts/update-docs",
+ "review:syntax-patch": "node scripts/review-syntax-patch",
+ "test": "mocha --reporter progress",
+ "coverage": "nyc npm test",
+ "travis": "nyc npm run lint-and-test && npm run coveralls",
+ "coveralls": "nyc report --reporter=text-lcov | coveralls",
+ "prepublishOnly": "npm run build",
+ "hydrogen": "node --trace-hydrogen --trace-phase=Z --trace-deopt --code-comments --hydrogen-track-positions --redirect-code-traces --redirect-code-traces-to=code.asm --trace_hydrogen_file=code.cfg --print-opt-code bin/parse --stat -o /dev/null"
+ },
+ "dependencies": {
+ "mdn-data": "2.0.14",
+ "source-map": "^0.6.1"
+ },
+ "devDependencies": {
+ "@rollup/plugin-commonjs": "^11.0.2",
+ "@rollup/plugin-json": "^4.0.2",
+ "@rollup/plugin-node-resolve": "^7.1.1",
+ "coveralls": "^3.0.9",
+ "eslint": "^6.8.0",
+ "json-to-ast": "^2.1.0",
+ "mocha": "^6.2.3",
+ "nyc": "^14.1.1",
+ "rollup": "^1.32.1",
+ "rollup-plugin-terser": "^5.3.0"
+ },
+ "engines": {
+ "node": ">=8.0.0"
+ },
+ "files": [
+ "data",
+ "dist",
+ "lib"
+ ]
+}