4525.js.map (646383B)
1 {"version":3,"file":"bundles/9cacd6575f4c8ee1aedb/4525.js","mappings":"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vb,KAAKkf,MAAMzR,GAAY8N,EAAKxY,MAChC,CCtBA,UACIkwB,SAAS,EACThM,gBAAe,GCLf,SAAW,EACX,gBAAmB,CACf,UACA,UACA,QACA,SACA,gBAEJ,MAAS,CACL,MAAS,CACL,MACA,OACA,MACA,QAEJ,QAAW,CACP,MAEJ,KAAQ,CACJ,MAEJ,UAAa,CACT,KACA,OAEJ,OAAU,CACN,KACA,KACA,IACA,KACA,KACA,KACA,KACA,KACA,MACA,KACA,MACA,MACA,OACA,KACA,MACA,KACA,MACA,KACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,OACA,QACA,QACA,QACA,OACA,QACA,QACA,QACA,MACA,MACA,MACA,MACA,QACA,SAEJ,WAAc,CACV,MACA,OACA,OACA,KAEJ,UAAa,CACT,MAEJ,KAAQ,CACJ,IACA,OAGR,MAAS,CACL,QAAS,oBACT,gBAAiB,iEACjB,SAAU,qBACV,cAAe,wBACf,mBAAoB,uBACpB,qBAAsB,qBACtB,qBAAsB,+BACtB,0BAA2B,2EAC3B,sBAAuB,0CACvB,SAAU,qBACV,SAAU,qBACV,UAAW,mCACX,WAAc,qBACd,SAAU,2DACV,eAAgB,6BAChB,gBAAiB,MACjB,qBAAsB,qGACtB,cAAe,+EACf,kBAAmB,0IACnB,KAAQ,mBACR,oBAAqB,yBACrB,cAAe,0EACf,WAAY,eACZ,WAAY,uFACZ,cAAe,8NACf,UAAW,gDACX,SAAU,mBACV,aAAc,kJACd,IAAO,qCACP,eAAgB,oCAChB,SAAU,qBACV,WAAY,6CACZ,eAAgB,gDAChB,aAAc,mEACd,gBAAiB,8BACjB,iBAAkB,kBAClB,kBAAmB,yBACnB,WAAY,+CACZ,UAAW,0BACX,iBAAkB,oBAClB,cAAe,QACf,MAAS,gGACT,aAAc,yCACd,mBAAoB,0BACpB,oBAAqB,2BACrB,kBAAmB,wEACnB,6BAA8B,sGAC9B,WAAc,wBACd,oBAAqB,yCACrB,cAAe,6HACf,kBAAmB,+HACnB,uBAAwB,iCACxB,oBAAqB,2CACrB,yBAA0B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","sources":["webpack://element-web/./node_modules/source-map-js/lib/array-set.js","webpack://element-web/./node_modules/source-map-js/lib/base64-vlq.js","webpack://element-web/./node_modules/source-map-js/lib/base64.js","webpack://element-web/./node_modules/source-map-js/lib/mapping-list.js","webpack://element-web/./node_modules/source-map-js/lib/source-map-generator.js","webpack://element-web/./node_modules/source-map-js/lib/util.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/types.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/char-code-definitions.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/utils.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/names.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/adopt-buffer.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/OffsetToLocation.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/TokenStream.js","webpack://element-web/./node_modules/css-tree/lib/tokenizer/index.js","webpack://element-web/./node_modules/css-tree/lib/utils/List.js","webpack://element-web/./node_modules/css-tree/lib/utils/create-custom-error.js","webpack://element-web/./node_modules/css-tree/lib/parser/SyntaxError.js","webpack://element-web/./node_modules/css-tree/lib/parser/sequence.js","webpack://element-web/./node_modules/css-tree/lib/parser/create.js","webpack://element-web/./node_modules/css-tree/lib/generator/sourceMap.js","webpack://element-web/./node_modules/css-tree/lib/generator/token-before.js","webpack://element-web/./node_modules/css-tree/lib/generator/create.js","webpack://element-web/./node_modules/css-tree/lib/walker/create.js","webpack://element-web/./node_modules/css-tree/lib/definition-syntax/generate.js","webpack://element-web/./node_modules/css-tree/lib/lexer/error.js","webpack://element-web/./node_modules/css-tree/lib/utils/names.js","webpack://element-web/./node_modules/css-tree/lib/lexer/generic-const.js","webpack://element-web/./node_modules/css-tree/lib/lexer/generic-an-plus-b.js","webpack://element-web/./node_modules/css-tree/lib/lexer/generic-urange.js","webpack://element-web/./node_modules/css-tree/lib/lexer/generic.js","webpack://element-web/./node_modules/css-tree/lib/lexer/units.js","webpack://element-web/./node_modules/css-tree/lib/definition-syntax/SyntaxError.js","webpack://element-web/./node_modules/css-tree/lib/definition-syntax/scanner.js","webpack://element-web/./node_modules/css-tree/lib/definition-syntax/parse.js","webpack://element-web/./node_modules/css-tree/lib/definition-syntax/walk.js","webpack://element-web/./node_modules/css-tree/lib/lexer/prepare-tokens.js","webpack://element-web/./node_modules/css-tree/lib/lexer/match-graph.js","webpack://element-web/./node_modules/css-tree/lib/lexer/match.js","webpack://element-web/./node_modules/css-tree/lib/lexer/trace.js","webpack://element-web/./node_modules/css-tree/lib/lexer/search.js","webpack://element-web/./node_modules/css-tree/lib/lexer/structure.js","webpack://element-web/./node_modules/css-tree/lib/lexer/Lexer.js","webpack://element-web/./node_modules/css-tree/lib/syntax/config/mix.js","webpack://element-web/./node_modules/css-tree/lib/syntax/create.js","webpack://element-web/./node_modules/css-tree/lib/convertor/create.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/AnPlusB.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Atrule.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/AtrulePrelude.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/AttributeSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Block.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Brackets.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/CDC.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/CDO.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/ClassSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Combinator.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Comment.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Condition.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Declaration.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/DeclarationList.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Dimension.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Feature.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/FeatureFunction.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/FeatureRange.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Function.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/GeneralEnclosed.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Hash.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Identifier.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/IdSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Layer.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/LayerList.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/MediaQuery.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/MediaQueryList.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/NestingSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Nth.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Number.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Operator.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Parentheses.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Percentage.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Ratio.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Raw.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Rule.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Scope.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Selector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/SelectorList.js","webpack://element-web/./node_modules/css-tree/lib/utils/string.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/String.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/StyleSheet.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/SupportsDeclaration.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/TypeSelector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/UnicodeRange.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Url.js","webpack://element-web/./node_modules/css-tree/lib/utils/url.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/Value.js","webpack://element-web/./node_modules/css-tree/lib/syntax/node/WhiteSpace.js","webpack://element-web/./node_modules/css-tree/lib/syntax/config/lexer.js","webpack://element-web/./node_modules/css-tree/dist/data.js","webpack://element-web/./node_modules/css-tree/lib/syntax/scope/default.js","webpack://element-web/./node_modules/css-tree/lib/syntax/scope/atrulePrelude.js","webpack://element-web/./node_modules/css-tree/lib/syntax/scope/selector.js","webpack://element-web/./node_modules/css-tree/lib/syntax/scope/value.js","webpack://element-web/./node_modules/css-tree/lib/syntax/function/expression.js","webpack://element-web/./node_modules/css-tree/lib/syntax/function/var.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/container.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/font-face.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/import.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/index.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/layer.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/media.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/nest.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/page.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/scope.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/starting-style.js","webpack://element-web/./node_modules/css-tree/lib/syntax/atrule/supports.js","webpack://element-web/./node_modules/css-tree/lib/syntax/pseudo/index.js","webpack://element-web/./node_modules/css-tree/lib/syntax/pseudo/lang.js","webpack://element-web/./node_modules/css-tree/lib/syntax/index.js","webpack://element-web/./node_modules/css-tree/lib/syntax/config/parser.js","webpack://element-web/./node_modules/css-tree/lib/syntax/config/walker.js","webpack://element-web/./node_modules/css-tree/lib/index.js"],"sourcesContent":["/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n this._array = [];\n this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n var set = new ArraySet();\n for (var i = 0, len = aArray.length; i < len; i++) {\n set.add(aArray[i], aAllowDuplicates);\n }\n return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n var idx = this._array.length;\n if (!isDuplicate || aAllowDuplicates) {\n this._array.push(aStr);\n }\n if (!isDuplicate) {\n if (hasNativeMap) {\n this._set.set(aStr, idx);\n } else {\n this._set[sStr] = idx;\n }\n }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n if (hasNativeMap) {\n return this._set.has(aStr);\n } else {\n var sStr = util.toSetString(aStr);\n return has.call(this._set, sStr);\n }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n if (hasNativeMap) {\n var idx = this._set.get(aStr);\n if (idx >= 0) {\n return idx;\n }\n } else {\n var sStr = util.toSetString(aStr);\n if (has.call(this._set, sStr)) {\n return this._set[sStr];\n }\n }\n\n throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n if (aIdx >= 0 && aIdx < this._array.length) {\n return this._array[aIdx];\n }\n throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of Google Inc. nor the names of its\n * contributors may be used to endorse or promote products derived\n * from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n// Continuation\n// | Sign\n// | |\n// V V\n// 101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit. For example, as decimals:\n * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n return aValue < 0\n ? ((-aValue) << 1) + 1\n : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit. For example, as decimals:\n * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n var isNegative = (aValue & 1) === 1;\n var shifted = aValue >> 1;\n return isNegative\n ? -shifted\n : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n var encoded = \"\";\n var digit;\n\n var vlq = toVLQSigned(aValue);\n\n do {\n digit = vlq & VLQ_BASE_MASK;\n vlq >>>= VLQ_BASE_SHIFT;\n if (vlq > 0) {\n // There are still more digits in this value, so we must make sure the\n // continuation bit is marked.\n digit |= VLQ_CONTINUATION_BIT;\n }\n encoded += base64.encode(digit);\n } while (vlq > 0);\n\n return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n var strLen = aStr.length;\n var result = 0;\n var shift = 0;\n var continuation, digit;\n\n do {\n if (aIndex >= strLen) {\n throw new Error(\"Expected more digits in base 64 VLQ value.\");\n }\n\n digit = base64.decode(aStr.charCodeAt(aIndex++));\n if (digit === -1) {\n throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n }\n\n continuation = !!(digit & VLQ_CONTINUATION_BIT);\n digit &= VLQ_BASE_MASK;\n result = result + (digit << shift);\n shift += VLQ_BASE_SHIFT;\n } while (continuation);\n\n aOutParam.value = fromVLQSigned(result);\n aOutParam.rest = aIndex;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n if (0 <= number && number < intToCharMap.length) {\n return intToCharMap[number];\n }\n throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n var bigA = 65; // 'A'\n var bigZ = 90; // 'Z'\n\n var littleA = 97; // 'a'\n var littleZ = 122; // 'z'\n\n var zero = 48; // '0'\n var nine = 57; // '9'\n\n var plus = 43; // '+'\n var slash = 47; // '/'\n\n var littleOffset = 26;\n var numberOffset = 52;\n\n // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n if (bigA <= charCode && charCode <= bigZ) {\n return (charCode - bigA);\n }\n\n // 26 - 51: abcdefghijklmnopqrstuvwxyz\n if (littleA <= charCode && charCode <= littleZ) {\n return (charCode - littleA + littleOffset);\n }\n\n // 52 - 61: 0123456789\n if (zero <= charCode && charCode <= nine) {\n return (charCode - zero + numberOffset);\n }\n\n // 62: +\n if (charCode == plus) {\n return 62;\n }\n\n // 63: /\n if (charCode == slash) {\n return 63;\n }\n\n // Invalid base64 digit.\n return -1;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n // Optimized for most common case\n var lineA = mappingA.generatedLine;\n var lineB = mappingB.generatedLine;\n var columnA = mappingA.generatedColumn;\n var columnB = mappingB.generatedColumn;\n return lineB > lineA || lineB == lineA && columnB >= columnA ||\n util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n this._array = [];\n this._sorted = true;\n // Serves as infimum\n this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n function MappingList_forEach(aCallback, aThisArg) {\n this._array.forEach(aCallback, aThisArg);\n };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n if (generatedPositionAfter(this._last, aMapping)) {\n this._last = aMapping;\n this._array.push(aMapping);\n } else {\n this._sorted = false;\n this._array.push(aMapping);\n }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n if (!this._sorted) {\n this._array.sort(util.compareByGeneratedPositionsInflated);\n this._sorted = true;\n }\n return this._array;\n};\n\nexports.MappingList = MappingList;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n * - file: The filename of the generated source.\n * - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n if (!aArgs) {\n aArgs = {};\n }\n this._file = util.getArg(aArgs, 'file', null);\n this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n this._ignoreInvalidMapping = util.getArg(aArgs, 'ignoreInvalidMapping', false);\n this._sources = new ArraySet();\n this._names = new ArraySet();\n this._mappings = new MappingList();\n this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {\n var sourceRoot = aSourceMapConsumer.sourceRoot;\n var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {\n file: aSourceMapConsumer.file,\n sourceRoot: sourceRoot\n }));\n aSourceMapConsumer.eachMapping(function (mapping) {\n var newMapping = {\n generated: {\n line: mapping.generatedLine,\n column: mapping.generatedColumn\n }\n };\n\n if (mapping.source != null) {\n newMapping.source = mapping.source;\n if (sourceRoot != null) {\n newMapping.source = util.relative(sourceRoot, newMapping.source);\n }\n\n newMapping.original = {\n line: mapping.originalLine,\n column: mapping.originalColumn\n };\n\n if (mapping.name != null) {\n newMapping.name = mapping.name;\n }\n }\n\n generator.addMapping(newMapping);\n });\n aSourceMapConsumer.sources.forEach(function (sourceFile) {\n var sourceRelative = sourceFile;\n if (sourceRoot !== null) {\n sourceRelative = util.relative(sourceRoot, sourceFile);\n }\n\n if (!generator._sources.has(sourceRelative)) {\n generator._sources.add(sourceRelative);\n }\n\n var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n if (content != null) {\n generator.setSourceContent(sourceFile, content);\n }\n });\n return generator;\n };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n * - generated: An object with the generated line and column positions.\n * - original: An object with the original line and column positions.\n * - source: The original source file (relative to the sourceRoot).\n * - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n function SourceMapGenerator_addMapping(aArgs) {\n var generated = util.getArg(aArgs, 'generated');\n var original = util.getArg(aArgs, 'original', null);\n var source = util.getArg(aArgs, 'source', null);\n var name = util.getArg(aArgs, 'name', null);\n\n if (!this._skipValidation) {\n if (this._validateMapping(generated, original, source, name) === false) {\n return;\n }\n }\n\n if (source != null) {\n source = String(source);\n if (!this._sources.has(source)) {\n this._sources.add(source);\n }\n }\n\n if (name != null) {\n name = String(name);\n if (!this._names.has(name)) {\n this._names.add(name);\n }\n }\n\n this._mappings.add({\n generatedLine: generated.line,\n generatedColumn: generated.column,\n originalLine: original != null && original.line,\n originalColumn: original != null && original.column,\n source: source,\n name: name\n });\n };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n var source = aSourceFile;\n if (this._sourceRoot != null) {\n source = util.relative(this._sourceRoot, source);\n }\n\n if (aSourceContent != null) {\n // Add the source content to the _sourcesContents map.\n // Create a new _sourcesContents map if the property is null.\n if (!this._sourcesContents) {\n this._sourcesContents = Object.create(null);\n }\n this._sourcesContents[util.toSetString(source)] = aSourceContent;\n } else if (this._sourcesContents) {\n // Remove the source file from the _sourcesContents map.\n // If the _sourcesContents map is empty, set the property to null.\n delete this._sourcesContents[util.toSetString(source)];\n if (Object.keys(this._sourcesContents).length === 0) {\n this._sourcesContents = null;\n }\n }\n };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n * If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n * to be applied. If relative, it is relative to the SourceMapConsumer.\n * This parameter is needed when the two source maps aren't in the same\n * directory, and the source map to be applied contains relative source\n * paths. If so, those relative source paths need to be rewritten\n * relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n var sourceFile = aSourceFile;\n // If aSourceFile is omitted, we will use the file property of the SourceMap\n if (aSourceFile == null) {\n if (aSourceMapConsumer.file == null) {\n throw new Error(\n 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n 'or the source map\\'s \"file\" property. Both were omitted.'\n );\n }\n sourceFile = aSourceMapConsumer.file;\n }\n var sourceRoot = this._sourceRoot;\n // Make \"sourceFile\" relative if an absolute Url is passed.\n if (sourceRoot != null) {\n sourceFile = util.relative(sourceRoot, sourceFile);\n }\n // Applying the SourceMap can add and remove items from the sources and\n // the names array.\n var newSources = new ArraySet();\n var newNames = new ArraySet();\n\n // Find mappings for the \"sourceFile\"\n this._mappings.unsortedForEach(function (mapping) {\n if (mapping.source === sourceFile && mapping.originalLine != null) {\n // Check if it can be mapped by the source map, then update the mapping.\n var original = aSourceMapConsumer.originalPositionFor({\n line: mapping.originalLine,\n column: mapping.originalColumn\n });\n if (original.source != null) {\n // Copy mapping\n mapping.source = original.source;\n if (aSourceMapPath != null) {\n mapping.source = util.join(aSourceMapPath, mapping.source)\n }\n if (sourceRoot != null) {\n mapping.source = util.relative(sourceRoot, mapping.source);\n }\n mapping.originalLine = original.line;\n mapping.originalColumn = original.column;\n if (original.name != null) {\n mapping.name = original.name;\n }\n }\n }\n\n var source = mapping.source;\n if (source != null && !newSources.has(source)) {\n newSources.add(source);\n }\n\n var name = mapping.name;\n if (name != null && !newNames.has(name)) {\n newNames.add(name);\n }\n\n }, this);\n this._sources = newSources;\n this._names = newNames;\n\n // Copy sourcesContents of applied map.\n aSourceMapConsumer.sources.forEach(function (sourceFile) {\n var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n if (content != null) {\n if (aSourceMapPath != null) {\n sourceFile = util.join(aSourceMapPath, sourceFile);\n }\n if (sourceRoot != null) {\n sourceFile = util.relative(sourceRoot, sourceFile);\n }\n this.setSourceContent(sourceFile, content);\n }\n }, this);\n };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n * 1. Just the generated position.\n * 2. The Generated position, original position, and original source.\n * 3. Generated and original position, original source, as well as a name\n * token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n aName) {\n // When aOriginal is truthy but has empty values for .line and .column,\n // it is most likely a programmer error. In this case we throw a very\n // specific error message to try to guide them the right way.\n // For example: https://github.com/Polymer/polymer-bundler/pull/519\n if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n var message = 'original.line and original.column are not numbers -- you probably meant to omit ' +\n 'the original mapping entirely and only map the generated position. If so, pass ' +\n 'null for the original mapping instead of an object with empty or null values.'\n\n if (this._ignoreInvalidMapping) {\n if (typeof console !== 'undefined' && console.warn) {\n console.warn(message);\n }\n return false;\n } else {\n throw new Error(message);\n }\n }\n\n if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n && aGenerated.line > 0 && aGenerated.column >= 0\n && !aOriginal && !aSource && !aName) {\n // Case 1.\n return;\n }\n else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n && aGenerated.line > 0 && aGenerated.column >= 0\n && aOriginal.line > 0 && aOriginal.column >= 0\n && aSource) {\n // Cases 2 and 3.\n return;\n }\n else {\n var message = 'Invalid mapping: ' + JSON.stringify({\n generated: aGenerated,\n source: aSource,\n original: aOriginal,\n name: aName\n });\n\n if (this._ignoreInvalidMapping) {\n if (typeof console !== 'undefined' && console.warn) {\n console.warn(message);\n }\n return false;\n } else {\n throw new Error(message)\n }\n }\n };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n function SourceMapGenerator_serializeMappings() {\n var previousGeneratedColumn = 0;\n var previousGeneratedLine = 1;\n var previousOriginalColumn = 0;\n var previousOriginalLine = 0;\n var previousName = 0;\n var previousSource = 0;\n var result = '';\n var next;\n var mapping;\n var nameIdx;\n var sourceIdx;\n\n var mappings = this._mappings.toArray();\n for (var i = 0, len = mappings.length; i < len; i++) {\n mapping = mappings[i];\n next = ''\n\n if (mapping.generatedLine !== previousGeneratedLine) {\n previousGeneratedColumn = 0;\n while (mapping.generatedLine !== previousGeneratedLine) {\n next += ';';\n previousGeneratedLine++;\n }\n }\n else {\n if (i > 0) {\n if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n continue;\n }\n next += ',';\n }\n }\n\n next += base64VLQ.encode(mapping.generatedColumn\n - previousGeneratedColumn);\n previousGeneratedColumn = mapping.generatedColumn;\n\n if (mapping.source != null) {\n sourceIdx = this._sources.indexOf(mapping.source);\n next += base64VLQ.encode(sourceIdx - previousSource);\n previousSource = sourceIdx;\n\n // lines are stored 0-based in SourceMap spec version 3\n next += base64VLQ.encode(mapping.originalLine - 1\n - previousOriginalLine);\n previousOriginalLine = mapping.originalLine - 1;\n\n next += base64VLQ.encode(mapping.originalColumn\n - previousOriginalColumn);\n previousOriginalColumn = mapping.originalColumn;\n\n if (mapping.name != null) {\n nameIdx = this._names.indexOf(mapping.name);\n next += base64VLQ.encode(nameIdx - previousName);\n previousName = nameIdx;\n }\n }\n\n result += next;\n }\n\n return result;\n };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n return aSources.map(function (source) {\n if (!this._sourcesContents) {\n return null;\n }\n if (aSourceRoot != null) {\n source = util.relative(aSourceRoot, source);\n }\n var key = util.toSetString(source);\n return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n ? this._sourcesContents[key]\n : null;\n }, this);\n };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n function SourceMapGenerator_toJSON() {\n var map = {\n version: this._version,\n sources: this._sources.toArray(),\n names: this._names.toArray(),\n mappings: this._serializeMappings()\n };\n if (this._file != null) {\n map.file = this._file;\n }\n if (this._sourceRoot != null) {\n map.sourceRoot = this._sourceRoot;\n }\n if (this._sourcesContents) {\n map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n }\n\n return map;\n };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n function SourceMapGenerator_toString() {\n return JSON.stringify(this.toJSON());\n };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n if (aName in aArgs) {\n return aArgs[aName];\n } else if (arguments.length === 3) {\n return aDefaultValue;\n } else {\n throw new Error('\"' + aName + '\" is a required argument.');\n }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.-]*)(?::(\\d+))?(.*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n var match = aUrl.match(urlRegexp);\n if (!match) {\n return null;\n }\n return {\n scheme: match[1],\n auth: match[2],\n host: match[3],\n port: match[4],\n path: match[5]\n };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n var url = '';\n if (aParsedUrl.scheme) {\n url += aParsedUrl.scheme + ':';\n }\n url += '//';\n if (aParsedUrl.auth) {\n url += aParsedUrl.auth + '@';\n }\n if (aParsedUrl.host) {\n url += aParsedUrl.host;\n }\n if (aParsedUrl.port) {\n url += \":\" + aParsedUrl.port\n }\n if (aParsedUrl.path) {\n url += aParsedUrl.path;\n }\n return url;\n}\nexports.urlGenerate = urlGenerate;\n\nvar MAX_CACHED_INPUTS = 32;\n\n/**\n * Takes some function `f(input) -> result` and returns a memoized version of\n * `f`.\n *\n * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The\n * memoization is a dumb-simple, linear least-recently-used cache.\n */\nfunction lruMemoize(f) {\n var cache = [];\n\n return function(input) {\n for (var i = 0; i < cache.length; i++) {\n if (cache[i].input === input) {\n var temp = cache[0];\n cache[0] = cache[i];\n cache[i] = temp;\n return cache[0].result;\n }\n }\n\n var result = f(input);\n\n cache.unshift({\n input,\n result,\n });\n\n if (cache.length > MAX_CACHED_INPUTS) {\n cache.pop();\n }\n\n return result;\n };\n}\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nvar normalize = lruMemoize(function normalize(aPath) {\n var path = aPath;\n var url = urlParse(aPath);\n if (url) {\n if (!url.path) {\n return aPath;\n }\n path = url.path;\n }\n var isAbsolute = exports.isAbsolute(path);\n // Split the path into parts between `/` characters. This is much faster than\n // using `.split(/\\/+/g)`.\n var parts = [];\n var start = 0;\n var i = 0;\n while (true) {\n start = i;\n i = path.indexOf(\"/\", start);\n if (i === -1) {\n parts.push(path.slice(start));\n break;\n } else {\n parts.push(path.slice(start, i));\n while (i < path.length && path[i] === \"/\") {\n i++;\n }\n }\n }\n\n for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n part = parts[i];\n if (part === '.') {\n parts.splice(i, 1);\n } else if (part === '..') {\n up++;\n } else if (up > 0) {\n if (part === '') {\n // The first part is blank if the path is absolute. Trying to go\n // above the root is a no-op. Therefore we can remove all '..' parts\n // directly after the root.\n parts.splice(i + 1, up);\n up = 0;\n } else {\n parts.splice(i, 2);\n up--;\n }\n }\n }\n path = parts.join('/');\n\n if (path === '') {\n path = isAbsolute ? '/' : '.';\n }\n\n if (url) {\n url.path = path;\n return urlGenerate(url);\n }\n return path;\n});\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n * scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n * first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n * is updated with the result and aRoot is returned. Otherwise the result\n * is returned.\n * - If aPath is absolute, the result is aPath.\n * - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n if (aRoot === \"\") {\n aRoot = \".\";\n }\n if (aPath === \"\") {\n aPath = \".\";\n }\n var aPathUrl = urlParse(aPath);\n var aRootUrl = urlParse(aRoot);\n if (aRootUrl) {\n aRoot = aRootUrl.path || '/';\n }\n\n // `join(foo, '//www.example.org')`\n if (aPathUrl && !aPathUrl.scheme) {\n if (aRootUrl) {\n aPathUrl.scheme = aRootUrl.scheme;\n }\n return urlGenerate(aPathUrl);\n }\n\n if (aPathUrl || aPath.match(dataUrlRegexp)) {\n return aPath;\n }\n\n // `join('http://', 'www.example.com')`\n if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n aRootUrl.host = aPath;\n return urlGenerate(aRootUrl);\n }\n\n var joined = aPath.charAt(0) === '/'\n ? aPath\n : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n if (aRootUrl) {\n aRootUrl.path = joined;\n return urlGenerate(aRootUrl);\n }\n return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n return aPath.charAt(0) === '/' || urlRegexp.test(aPath);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n if (aRoot === \"\") {\n aRoot = \".\";\n }\n\n aRoot = aRoot.replace(/\\/$/, '');\n\n // It is possible for the path to be above the root. In this case, simply\n // checking whether the root is a prefix of the path won't work. Instead, we\n // need to remove components from the root one by one, until either we find\n // a prefix that fits, or we run out of components to remove.\n var level = 0;\n while (aPath.indexOf(aRoot + '/') !== 0) {\n var index = aRoot.lastIndexOf(\"/\");\n if (index < 0) {\n return aPath;\n }\n\n // If the only part of the root that is left is the scheme (i.e. http://,\n // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n // have exhausted all components, so the path is not relative to the root.\n aRoot = aRoot.slice(0, index);\n if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n return aPath;\n }\n\n ++level;\n }\n\n // Make sure we add a \"../\" for each component we removed from the root.\n return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n var obj = Object.create(null);\n return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n if (isProtoString(aStr)) {\n return '$' + aStr;\n }\n\n return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n if (isProtoString(aStr)) {\n return aStr.slice(1);\n }\n\n return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n if (!s) {\n return false;\n }\n\n var length = s.length;\n\n if (length < 9 /* \"__proto__\".length */) {\n return false;\n }\n\n if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||\n s.charCodeAt(length - 2) !== 95 /* '_' */ ||\n s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n s.charCodeAt(length - 8) !== 95 /* '_' */ ||\n s.charCodeAt(length - 9) !== 95 /* '_' */) {\n return false;\n }\n\n for (var i = length - 10; i >= 0; i--) {\n if (s.charCodeAt(i) !== 36 /* '$' */) {\n return false;\n }\n }\n\n return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n var cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0 || onlyCompareOriginal) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\nfunction compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {\n var cmp\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0 || onlyCompareOriginal) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n var cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0 || onlyCompareGenerated) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {\n var cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0 || onlyCompareGenerated) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;\n\nfunction strcmp(aStr1, aStr2) {\n if (aStr1 === aStr2) {\n return 0;\n }\n\n if (aStr1 === null) {\n return 1; // aStr2 !== null\n }\n\n if (aStr2 === null) {\n return -1; // aStr1 !== null\n }\n\n if (aStr1 > aStr2) {\n return 1;\n }\n\n return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n var cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n/**\n * Strip any JSON XSSI avoidance prefix from the string (as documented\n * in the source maps specification), and then parse the string as\n * JSON.\n */\nfunction parseSourceMapInput(str) {\n return JSON.parse(str.replace(/^\\)]}'[^\\n]*\\n/, ''));\n}\nexports.parseSourceMapInput = parseSourceMapInput;\n\n/**\n * Compute the URL of a source given the the source root, the source's\n * URL, and the source map's URL.\n */\nfunction computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {\n sourceURL = sourceURL || '';\n\n if (sourceRoot) {\n // This follows what Chrome does.\n if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {\n sourceRoot += '/';\n }\n // The spec says:\n // Line 4: An optional source root, useful for relocating source\n // files on a server or removing repeated values in the\n // “sources” entry. This value is prepended to the individual\n // entries in the “source” field.\n sourceURL = sourceRoot + sourceURL;\n }\n\n // Historically, SourceMapConsumer did not take the sourceMapURL as\n // a parameter. This mode is still somewhat supported, which is why\n // this code block is conditional. However, it's preferable to pass\n // the source map URL to SourceMapConsumer, so that this function\n // can implement the source URL resolution algorithm as outlined in\n // the spec. This block is basically the equivalent of:\n // new URL(sourceURL, sourceMapURL).toString()\n // ... except it avoids using URL, which wasn't available in the\n // older releases of node still supported by this library.\n //\n // The spec says:\n // If the sources are not absolute URLs after prepending of the\n // “sourceRoot”, the sources are resolved relative to the\n // SourceMap (like resolving script src in a html document).\n if (sourceMapURL) {\n var parsed = urlParse(sourceMapURL);\n if (!parsed) {\n throw new Error(\"sourceMapURL could not be parsed\");\n }\n if (parsed.path) {\n // Strip the last path component, but keep the \"/\".\n var index = parsed.path.lastIndexOf('/');\n if (index >= 0) {\n parsed.path = parsed.path.substring(0, index + 1);\n }\n }\n sourceURL = join(urlGenerate(parsed), sourceURL);\n }\n\n return normalize(sourceURL);\n}\nexports.computeSourceURL = computeSourceURL;\n","// CSS Syntax Module Level 3\n// https://www.w3.org/TR/css-syntax-3/\nexport const EOF = 0; // <EOF-token>\nexport const Ident = 1; // <ident-token>\nexport const Function = 2; // <function-token>\nexport const AtKeyword = 3; // <at-keyword-token>\nexport const Hash = 4; // <hash-token>\nexport const String = 5; // <string-token>\nexport const BadString = 6; // <bad-string-token>\nexport const Url = 7; // <url-token>\nexport const BadUrl = 8; // <bad-url-token>\nexport const Delim = 9; // <delim-token>\nexport const Number = 10; // <number-token>\nexport const Percentage = 11; // <percentage-token>\nexport const Dimension = 12; // <dimension-token>\nexport const WhiteSpace = 13; // <whitespace-token>\nexport const CDO = 14; // <CDO-token>\nexport const CDC = 15; // <CDC-token>\nexport const Colon = 16; // <colon-token> :\nexport const Semicolon = 17; // <semicolon-token> ;\nexport const Comma = 18; // <comma-token> ,\nexport const LeftSquareBracket = 19; // <[-token>\nexport const RightSquareBracket = 20; // <]-token>\nexport const LeftParenthesis = 21; // <(-token>\nexport const RightParenthesis = 22; // <)-token>\nexport const LeftCurlyBracket = 23; // <{-token>\nexport const RightCurlyBracket = 24; // <}-token>\nexport const Comment = 25;\n","const EOF = 0;\n\n// https://drafts.csswg.org/css-syntax-3/\n// § 4.2. Definitions\n\n// digit\n// A code point between U+0030 DIGIT ZERO (0) and U+0039 DIGIT NINE (9).\nexport function isDigit(code) {\n return code >= 0x0030 && code <= 0x0039;\n}\n\n// hex digit\n// A digit, or a code point between U+0041 LATIN CAPITAL LETTER A (A) and U+0046 LATIN CAPITAL LETTER F (F),\n// or a code point between U+0061 LATIN SMALL LETTER A (a) and U+0066 LATIN SMALL LETTER F (f).\nexport function isHexDigit(code) {\n return (\n isDigit(code) || // 0 .. 9\n (code >= 0x0041 && code <= 0x0046) || // A .. F\n (code >= 0x0061 && code <= 0x0066) // a .. f\n );\n}\n\n// uppercase letter\n// A code point between U+0041 LATIN CAPITAL LETTER A (A) and U+005A LATIN CAPITAL LETTER Z (Z).\nexport function isUppercaseLetter(code) {\n return code >= 0x0041 && code <= 0x005A;\n}\n\n// lowercase letter\n// A code point between U+0061 LATIN SMALL LETTER A (a) and U+007A LATIN SMALL LETTER Z (z).\nexport function isLowercaseLetter(code) {\n return code >= 0x0061 && code <= 0x007A;\n}\n\n// letter\n// An uppercase letter or a lowercase letter.\nexport function isLetter(code) {\n return isUppercaseLetter(code) || isLowercaseLetter(code);\n}\n\n// non-ASCII code point\n// A code point with a value equal to or greater than U+0080 <control>.\n//\n// 2024-09-02: The latest spec narrows the range for non-ASCII characters (see https://github.com/csstree/csstree/issues/188).\n// However, all modern browsers support a wider range, and strictly following the latest spec could result\n// in some CSS being parsed incorrectly, even though it works in the browser. Therefore, this function adheres\n// to the previous, broader definition of non-ASCII characters.\nexport function isNonAscii(code) {\n return code >= 0x0080;\n}\n\n// name-start code point\n// A letter, a non-ASCII code point, or U+005F LOW LINE (_).\nexport function isNameStart(code) {\n return isLetter(code) || isNonAscii(code) || code === 0x005F;\n}\n\n// name code point\n// A name-start code point, a digit, or U+002D HYPHEN-MINUS (-).\nexport function isName(code) {\n return isNameStart(code) || isDigit(code) || code === 0x002D;\n}\n\n// non-printable code point\n// A code point between U+0000 NULL and U+0008 BACKSPACE, or U+000B LINE TABULATION,\n// or a code point between U+000E SHIFT OUT and U+001F INFORMATION SEPARATOR ONE, or U+007F DELETE.\nexport function isNonPrintable(code) {\n return (\n (code >= 0x0000 && code <= 0x0008) ||\n (code === 0x000B) ||\n (code >= 0x000E && code <= 0x001F) ||\n (code === 0x007F)\n );\n}\n\n// newline\n// U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,\n// as they are converted to U+000A LINE FEED during preprocessing.\n// TODO: we doesn't do a preprocessing, so check a code point for U+000D CARRIAGE RETURN and U+000C FORM FEED\nexport function isNewline(code) {\n return code === 0x000A || code === 0x000D || code === 0x000C;\n}\n\n// whitespace\n// A newline, U+0009 CHARACTER TABULATION, or U+0020 SPACE.\nexport function isWhiteSpace(code) {\n return isNewline(code) || code === 0x0020 || code === 0x0009;\n}\n\n// § 4.3.8. Check if two code points are a valid escape\nexport function isValidEscape(first, second) {\n // If the first code point is not U+005C REVERSE SOLIDUS (\\), return false.\n if (first !== 0x005C) {\n return false;\n }\n\n // Otherwise, if the second code point is a newline or EOF, return false.\n if (isNewline(second) || second === EOF) {\n return false;\n }\n\n // Otherwise, return true.\n return true;\n}\n\n// § 4.3.9. Check if three code points would start an identifier\nexport function isIdentifierStart(first, second, third) {\n // Look at the first code point:\n\n // U+002D HYPHEN-MINUS\n if (first === 0x002D) {\n // If the second code point is a name-start code point or a U+002D HYPHEN-MINUS,\n // or the second and third code points are a valid escape, return true. Otherwise, return false.\n return (\n isNameStart(second) ||\n second === 0x002D ||\n isValidEscape(second, third)\n );\n }\n\n // name-start code point\n if (isNameStart(first)) {\n // Return true.\n return true;\n }\n\n // U+005C REVERSE SOLIDUS (\\)\n if (first === 0x005C) {\n // If the first and second code points are a valid escape, return true. Otherwise, return false.\n return isValidEscape(first, second);\n }\n\n // anything else\n // Return false.\n return false;\n}\n\n// § 4.3.10. Check if three code points would start a number\nexport function isNumberStart(first, second, third) {\n // Look at the first code point:\n\n // U+002B PLUS SIGN (+)\n // U+002D HYPHEN-MINUS (-)\n if (first === 0x002B || first === 0x002D) {\n // If the second code point is a digit, return true.\n if (isDigit(second)) {\n return 2;\n }\n\n // Otherwise, if the second code point is a U+002E FULL STOP (.)\n // and the third code point is a digit, return true.\n // Otherwise, return false.\n return second === 0x002E && isDigit(third) ? 3 : 0;\n }\n\n // U+002E FULL STOP (.)\n if (first === 0x002E) {\n // If the second code point is a digit, return true. Otherwise, return false.\n return isDigit(second) ? 2 : 0;\n }\n\n // digit\n if (isDigit(first)) {\n // Return true.\n return 1;\n }\n\n // anything else\n // Return false.\n return 0;\n}\n\n//\n// Misc\n//\n\n// detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)\nexport function isBOM(code) {\n // UTF-16BE\n if (code === 0xFEFF) {\n return 1;\n }\n\n // UTF-16LE\n if (code === 0xFFFE) {\n return 1;\n }\n\n return 0;\n}\n\n// Fast code category\n// Only ASCII code points has a special meaning, that's why we define a maps for 0..127 codes only\nconst CATEGORY = new Array(0x80);\nexport const EofCategory = 0x80;\nexport const WhiteSpaceCategory = 0x82;\nexport const DigitCategory = 0x83;\nexport const NameStartCategory = 0x84;\nexport const NonPrintableCategory = 0x85;\n\nfor (let i = 0; i < CATEGORY.length; i++) {\n CATEGORY[i] =\n isWhiteSpace(i) && WhiteSpaceCategory ||\n isDigit(i) && DigitCategory ||\n isNameStart(i) && NameStartCategory ||\n isNonPrintable(i) && NonPrintableCategory ||\n i || EofCategory;\n}\n\nexport function charCodeCategory(code) {\n return code < 0x80 ? CATEGORY[code] : NameStartCategory;\n}\n","import {\n isDigit,\n isHexDigit,\n isUppercaseLetter,\n isName,\n isWhiteSpace,\n isValidEscape\n} from './char-code-definitions.js';\n\nfunction getCharCode(source, offset) {\n return offset < source.length ? source.charCodeAt(offset) : 0;\n}\n\nexport function getNewlineLength(source, offset, code) {\n if (code === 13 /* \\r */ && getCharCode(source, offset + 1) === 10 /* \\n */) {\n return 2;\n }\n\n return 1;\n}\n\nexport function cmpChar(testStr, offset, referenceCode) {\n let code = testStr.charCodeAt(offset);\n\n // code.toLowerCase() for A..Z\n if (isUppercaseLetter(code)) {\n code = code | 32;\n }\n\n return code === referenceCode;\n}\n\nexport function cmpStr(testStr, start, end, referenceStr) {\n if (end - start !== referenceStr.length) {\n return false;\n }\n\n if (start < 0 || end > testStr.length) {\n return false;\n }\n\n for (let i = start; i < end; i++) {\n const referenceCode = referenceStr.charCodeAt(i - start);\n let testCode = testStr.charCodeAt(i);\n\n // testCode.toLowerCase() for A..Z\n if (isUppercaseLetter(testCode)) {\n testCode = testCode | 32;\n }\n\n if (testCode !== referenceCode) {\n return false;\n }\n }\n\n return true;\n}\n\nexport function findWhiteSpaceStart(source, offset) {\n for (; offset >= 0; offset--) {\n if (!isWhiteSpace(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset + 1;\n}\n\nexport function findWhiteSpaceEnd(source, offset) {\n for (; offset < source.length; offset++) {\n if (!isWhiteSpace(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset;\n}\n\nexport function findDecimalNumberEnd(source, offset) {\n for (; offset < source.length; offset++) {\n if (!isDigit(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset;\n}\n\n// § 4.3.7. Consume an escaped code point\nexport function consumeEscaped(source, offset) {\n // It assumes that the U+005C REVERSE SOLIDUS (\\) has already been consumed and\n // that the next input code point has already been verified to be part of a valid escape.\n offset += 2;\n\n // hex digit\n if (isHexDigit(getCharCode(source, offset - 1))) {\n // Consume as many hex digits as possible, but no more than 5.\n // Note that this means 1-6 hex digits have been consumed in total.\n for (const maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) {\n if (!isHexDigit(getCharCode(source, offset))) {\n break;\n }\n }\n\n // If the next input code point is whitespace, consume it as well.\n const code = getCharCode(source, offset);\n if (isWhiteSpace(code)) {\n offset += getNewlineLength(source, offset, code);\n }\n }\n\n return offset;\n}\n\n// §4.3.11. Consume a name\n// Note: This algorithm does not do the verification of the first few code points that are necessary\n// to ensure the returned code points would constitute an <ident-token>. If that is the intended use,\n// ensure that the stream starts with an identifier before calling this algorithm.\nexport function consumeName(source, offset) {\n // Let result initially be an empty string.\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n // name code point\n if (isName(code)) {\n // Append the code point to result.\n continue;\n }\n\n // the stream starts with a valid escape\n if (isValidEscape(code, getCharCode(source, offset + 1))) {\n // Consume an escaped code point. Append the returned code point to result.\n offset = consumeEscaped(source, offset) - 1;\n continue;\n }\n\n // anything else\n // Reconsume the current input code point. Return result.\n break;\n }\n\n return offset;\n}\n\n// §4.3.12. Consume a number\nexport function consumeNumber(source, offset) {\n let code = source.charCodeAt(offset);\n\n // 2. If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-),\n // consume it and append it to repr.\n if (code === 0x002B || code === 0x002D) {\n code = source.charCodeAt(offset += 1);\n }\n\n // 3. While the next input code point is a digit, consume it and append it to repr.\n if (isDigit(code)) {\n offset = findDecimalNumberEnd(source, offset + 1);\n code = source.charCodeAt(offset);\n }\n\n // 4. If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then:\n if (code === 0x002E && isDigit(source.charCodeAt(offset + 1))) {\n // 4.1 Consume them.\n // 4.2 Append them to repr.\n offset += 2;\n\n // 4.3 Set type to \"number\".\n // TODO\n\n // 4.4 While the next input code point is a digit, consume it and append it to repr.\n\n offset = findDecimalNumberEnd(source, offset);\n }\n\n // 5. If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E)\n // or U+0065 LATIN SMALL LETTER E (e), ... , followed by a digit, then:\n if (cmpChar(source, offset, 101 /* e */)) {\n let sign = 0;\n code = source.charCodeAt(offset + 1);\n\n // ... optionally followed by U+002D HYPHEN-MINUS (-) or U+002B PLUS SIGN (+) ...\n if (code === 0x002D || code === 0x002B) {\n sign = 1;\n code = source.charCodeAt(offset + 2);\n }\n\n // ... followed by a digit\n if (isDigit(code)) {\n // 5.1 Consume them.\n // 5.2 Append them to repr.\n\n // 5.3 Set type to \"number\".\n // TODO\n\n // 5.4 While the next input code point is a digit, consume it and append it to repr.\n offset = findDecimalNumberEnd(source, offset + 1 + sign + 1);\n }\n }\n\n return offset;\n}\n\n// § 4.3.14. Consume the remnants of a bad url\n// ... its sole use is to consume enough of the input stream to reach a recovery point\n// where normal tokenizing can resume.\nexport function consumeBadUrlRemnants(source, offset) {\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n // U+0029 RIGHT PARENTHESIS ())\n // EOF\n if (code === 0x0029) {\n // Return.\n offset++;\n break;\n }\n\n if (isValidEscape(code, getCharCode(source, offset + 1))) {\n // Consume an escaped code point.\n // Note: This allows an escaped right parenthesis (\"\\)\") to be encountered\n // without ending the <bad-url-token>. This is otherwise identical to\n // the \"anything else\" clause.\n offset = consumeEscaped(source, offset);\n }\n }\n\n return offset;\n}\n\n// § 4.3.7. Consume an escaped code point\n// Note: This algorithm assumes that escaped is valid without leading U+005C REVERSE SOLIDUS (\\)\nexport function decodeEscaped(escaped) {\n // Single char escaped that's not a hex digit\n if (escaped.length === 1 && !isHexDigit(escaped.charCodeAt(0))) {\n return escaped[0];\n }\n\n // Interpret the hex digits as a hexadecimal number.\n let code = parseInt(escaped, 16);\n\n if (\n (code === 0) || // If this number is zero,\n (code >= 0xD800 && code <= 0xDFFF) || // or is for a surrogate,\n (code > 0x10FFFF) // or is greater than the maximum allowed code point\n ) {\n // ... return U+FFFD REPLACEMENT CHARACTER\n code = 0xFFFD;\n }\n\n // Otherwise, return the code point with that value.\n return String.fromCodePoint(code);\n}\n","export default [\n 'EOF-token',\n 'ident-token',\n 'function-token',\n 'at-keyword-token',\n 'hash-token',\n 'string-token',\n 'bad-string-token',\n 'url-token',\n 'bad-url-token',\n 'delim-token',\n 'number-token',\n 'percentage-token',\n 'dimension-token',\n 'whitespace-token',\n 'CDO-token',\n 'CDC-token',\n 'colon-token',\n 'semicolon-token',\n 'comma-token',\n '[-token',\n ']-token',\n '(-token',\n ')-token',\n '{-token',\n '}-token',\n 'comment-token'\n];\n","const MIN_SIZE = 16 * 1024;\n\nexport function adoptBuffer(buffer = null, size) {\n if (buffer === null || buffer.length < size) {\n return new Uint32Array(Math.max(size + 1024, MIN_SIZE));\n }\n\n return buffer;\n};\n","import { adoptBuffer } from './adopt-buffer.js';\nimport { isBOM } from './char-code-definitions.js';\n\nconst N = 10;\nconst F = 12;\nconst R = 13;\n\nfunction computeLinesAndColumns(host) {\n const source = host.source;\n const sourceLength = source.length;\n const startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0;\n const lines = adoptBuffer(host.lines, sourceLength);\n const columns = adoptBuffer(host.columns, sourceLength);\n let line = host.startLine;\n let column = host.startColumn;\n\n for (let i = startOffset; i < sourceLength; i++) {\n const code = source.charCodeAt(i);\n\n lines[i] = line;\n columns[i] = column++;\n\n if (code === N || code === R || code === F) {\n if (code === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) {\n i++;\n lines[i] = line;\n columns[i] = column;\n }\n\n line++;\n column = 1;\n }\n }\n\n lines[sourceLength] = line;\n columns[sourceLength] = column;\n\n host.lines = lines;\n host.columns = columns;\n host.computed = true;\n}\n\nexport class OffsetToLocation {\n constructor(source, startOffset, startLine, startColumn) {\n this.setSource(source, startOffset, startLine, startColumn);\n this.lines = null;\n this.columns = null;\n }\n setSource(source = '', startOffset = 0, startLine = 1, startColumn = 1) {\n this.source = source;\n this.startOffset = startOffset;\n this.startLine = startLine;\n this.startColumn = startColumn;\n this.computed = false;\n }\n getLocation(offset, filename) {\n if (!this.computed) {\n computeLinesAndColumns(this);\n }\n\n return {\n source: filename,\n offset: this.startOffset + offset,\n line: this.lines[offset],\n column: this.columns[offset]\n };\n }\n getLocationRange(start, end, filename) {\n if (!this.computed) {\n computeLinesAndColumns(this);\n }\n\n return {\n source: filename,\n start: {\n offset: this.startOffset + start,\n line: this.lines[start],\n column: this.columns[start]\n },\n end: {\n offset: this.startOffset + end,\n line: this.lines[end],\n column: this.columns[end]\n }\n };\n }\n};\n","import { adoptBuffer } from './adopt-buffer.js';\nimport { cmpStr } from './utils.js';\nimport tokenNames from './names.js';\nimport {\n WhiteSpace,\n Comment,\n Delim,\n EOF,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis,\n LeftSquareBracket,\n RightSquareBracket,\n LeftCurlyBracket,\n RightCurlyBracket\n} from './types.js';\n\nconst OFFSET_MASK = 0x00FFFFFF;\nconst TYPE_SHIFT = 24;\nconst balancePair = new Uint8Array(32); // 32b of memory ought to be enough for anyone (any number of tokens)\nbalancePair[FunctionToken] = RightParenthesis;\nbalancePair[LeftParenthesis] = RightParenthesis;\nbalancePair[LeftSquareBracket] = RightSquareBracket;\nbalancePair[LeftCurlyBracket] = RightCurlyBracket;\n\nfunction isBlockOpenerToken(tokenType) {\n return balancePair[tokenType] !== 0;\n}\n\nexport class TokenStream {\n constructor(source, tokenize) {\n this.setSource(source, tokenize);\n }\n reset() {\n this.eof = false;\n this.tokenIndex = -1;\n this.tokenType = 0;\n this.tokenStart = this.firstCharOffset;\n this.tokenEnd = this.firstCharOffset;\n }\n setSource(source = '', tokenize = () => {}) {\n source = String(source || '');\n\n const sourceLength = source.length;\n const offsetAndType = adoptBuffer(this.offsetAndType, source.length + 1); // +1 because of eof-token\n const balance = adoptBuffer(this.balance, source.length + 1);\n let tokenCount = 0;\n let firstCharOffset = -1;\n let balanceCloseType = 0;\n let balanceStart = source.length;\n\n // capture buffers\n this.offsetAndType = null;\n this.balance = null;\n balance.fill(0);\n\n tokenize(source, (type, start, end) => {\n const index = tokenCount++;\n\n // type & offset\n offsetAndType[index] = (type << TYPE_SHIFT) | end;\n\n if (firstCharOffset === -1) {\n firstCharOffset = start;\n }\n\n // balance\n balance[index] = balanceStart;\n\n if (type === balanceCloseType) {\n const prevBalanceStart = balance[balanceStart];\n\n // set reference to balance end for a block opener\n balance[balanceStart] = index;\n\n // pop state\n balanceStart = prevBalanceStart;\n balanceCloseType = balancePair[offsetAndType[prevBalanceStart] >> TYPE_SHIFT];\n } else if (isBlockOpenerToken(type)) { // check for FunctionToken, <(-token>, <[-token> and <{-token>\n // push state\n balanceStart = index;\n balanceCloseType = balancePair[type];\n }\n });\n\n // finalize buffers\n offsetAndType[tokenCount] = (EOF << TYPE_SHIFT) | sourceLength; // <EOF-token>\n balance[tokenCount] = tokenCount; // prevents false positive balance match with any token\n\n // reverse references from balance start to end\n // tokens\n // token: a ( [ b c ] d e ) {\n // index: 0 1 2 3 4 5 6 7 8 9\n // before\n // balance: 0 8 5 2 2 2 1 1 1 0\n // - > > < < < < < < -\n // after\n // balance: 9 8 5 5 5 2 8 8 1 9\n // > > > > > < > > < >\n for (let i = 0; i < tokenCount; i++) {\n const balanceStart = balance[i];\n\n if (balanceStart <= i) {\n const balanceEnd = balance[balanceStart];\n\n if (balanceEnd !== i) {\n balance[i] = balanceEnd;\n }\n } else if (balanceStart > tokenCount) {\n balance[i] = tokenCount;\n }\n }\n\n // balance[0] = tokenCount;\n\n this.source = source;\n this.firstCharOffset = firstCharOffset === -1 ? 0 : firstCharOffset;\n this.tokenCount = tokenCount;\n this.offsetAndType = offsetAndType;\n this.balance = balance;\n\n this.reset();\n this.next();\n }\n\n lookupType(offset) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return this.offsetAndType[offset] >> TYPE_SHIFT;\n }\n\n return EOF;\n }\n lookupTypeNonSC(idx) {\n for (let offset = this.tokenIndex; offset < this.tokenCount; offset++) {\n const tokenType = this.offsetAndType[offset] >> TYPE_SHIFT;\n\n if (tokenType !== WhiteSpace && tokenType !== Comment) {\n if (idx-- === 0) {\n return tokenType;\n }\n }\n }\n\n return EOF;\n }\n lookupOffset(offset) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return this.offsetAndType[offset - 1] & OFFSET_MASK;\n }\n\n return this.source.length;\n }\n lookupOffsetNonSC(idx) {\n for (let offset = this.tokenIndex; offset < this.tokenCount; offset++) {\n const tokenType = this.offsetAndType[offset] >> TYPE_SHIFT;\n\n if (tokenType !== WhiteSpace && tokenType !== Comment) {\n if (idx-- === 0) {\n return offset - this.tokenIndex;\n }\n }\n }\n\n return EOF;\n }\n lookupValue(offset, referenceStr) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return cmpStr(\n this.source,\n this.offsetAndType[offset - 1] & OFFSET_MASK,\n this.offsetAndType[offset] & OFFSET_MASK,\n referenceStr\n );\n }\n\n return false;\n }\n getTokenStart(tokenIndex) {\n if (tokenIndex === this.tokenIndex) {\n return this.tokenStart;\n }\n\n if (tokenIndex > 0) {\n return tokenIndex < this.tokenCount\n ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK\n : this.offsetAndType[this.tokenCount] & OFFSET_MASK;\n }\n\n return this.firstCharOffset;\n }\n substrToCursor(start) {\n return this.source.substring(start, this.tokenStart);\n }\n\n isBalanceEdge(pos) {\n return this.balance[this.tokenIndex] < pos;\n // return this.balance[this.balance[pos]] !== this.tokenIndex;\n }\n isDelim(code, offset) {\n if (offset) {\n return (\n this.lookupType(offset) === Delim &&\n this.source.charCodeAt(this.lookupOffset(offset)) === code\n );\n }\n\n return (\n this.tokenType === Delim &&\n this.source.charCodeAt(this.tokenStart) === code\n );\n }\n\n skip(tokenCount) {\n let next = this.tokenIndex + tokenCount;\n\n if (next < this.tokenCount) {\n this.tokenIndex = next;\n this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;\n next = this.offsetAndType[next];\n this.tokenType = next >> TYPE_SHIFT;\n this.tokenEnd = next & OFFSET_MASK;\n } else {\n this.tokenIndex = this.tokenCount;\n this.next();\n }\n }\n next() {\n let next = this.tokenIndex + 1;\n\n if (next < this.tokenCount) {\n this.tokenIndex = next;\n this.tokenStart = this.tokenEnd;\n next = this.offsetAndType[next];\n this.tokenType = next >> TYPE_SHIFT;\n this.tokenEnd = next & OFFSET_MASK;\n } else {\n this.eof = true;\n this.tokenIndex = this.tokenCount;\n this.tokenType = EOF;\n this.tokenStart = this.tokenEnd = this.source.length;\n }\n }\n skipSC() {\n while (this.tokenType === WhiteSpace || this.tokenType === Comment) {\n this.next();\n }\n }\n skipUntilBalanced(startToken, stopConsume) {\n let cursor = startToken;\n let balanceEnd = 0;\n let offset = 0;\n\n loop:\n for (; cursor < this.tokenCount; cursor++) {\n balanceEnd = this.balance[cursor];\n\n // stop scanning on balance edge that points to offset before start token\n if (balanceEnd < startToken) {\n break loop;\n }\n\n offset = cursor > 0 ? this.offsetAndType[cursor - 1] & OFFSET_MASK : this.firstCharOffset;\n\n // check stop condition\n switch (stopConsume(this.source.charCodeAt(offset))) {\n case 1: // just stop\n break loop;\n\n case 2: // stop & included\n cursor++;\n break loop;\n\n default:\n // fast forward to the end of balanced block for an open block tokens\n if (isBlockOpenerToken(this.offsetAndType[cursor] >> TYPE_SHIFT)) {\n cursor = balanceEnd;\n }\n }\n }\n\n this.skip(cursor - this.tokenIndex);\n }\n\n forEachToken(fn) {\n for (let i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {\n const start = offset;\n const item = this.offsetAndType[i];\n const end = item & OFFSET_MASK;\n const type = item >> TYPE_SHIFT;\n\n offset = end;\n\n fn(type, start, end, i);\n }\n }\n dump() {\n const tokens = new Array(this.tokenCount);\n\n this.forEachToken((type, start, end, index) => {\n tokens[index] = {\n idx: index,\n type: tokenNames[type],\n chunk: this.source.substring(start, end),\n balance: this.balance[index]\n };\n });\n\n return tokens;\n }\n};\n","import * as TYPE from './types.js';\nimport {\n isNewline,\n isName,\n isValidEscape,\n isNumberStart,\n isIdentifierStart,\n isBOM,\n charCodeCategory,\n WhiteSpaceCategory,\n DigitCategory,\n NameStartCategory,\n NonPrintableCategory\n} from './char-code-definitions.js';\nimport {\n cmpStr,\n getNewlineLength,\n findWhiteSpaceEnd,\n consumeEscaped,\n consumeName,\n consumeNumber,\n consumeBadUrlRemnants\n} from './utils.js';\n\nexport function tokenize(source, onToken) {\n function getCharCode(offset) {\n return offset < sourceLength ? source.charCodeAt(offset) : 0;\n }\n\n // § 4.3.3. Consume a numeric token\n function consumeNumericToken() {\n // Consume a number and let number be the result.\n offset = consumeNumber(source, offset);\n\n // If the next 3 input code points would start an identifier, then:\n if (isIdentifierStart(getCharCode(offset), getCharCode(offset + 1), getCharCode(offset + 2))) {\n // Create a <dimension-token> with the same value and type flag as number, and a unit set initially to the empty string.\n // Consume a name. Set the <dimension-token>’s unit to the returned value.\n // Return the <dimension-token>.\n type = TYPE.Dimension;\n offset = consumeName(source, offset);\n return;\n }\n\n // Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.\n if (getCharCode(offset) === 0x0025) {\n // Create a <percentage-token> with the same value as number, and return it.\n type = TYPE.Percentage;\n offset++;\n return;\n }\n\n // Otherwise, create a <number-token> with the same value and type flag as number, and return it.\n type = TYPE.Number;\n }\n\n // § 4.3.4. Consume an ident-like token\n function consumeIdentLikeToken() {\n const nameStartOffset = offset;\n\n // Consume a name, and let string be the result.\n offset = consumeName(source, offset);\n\n // If string’s value is an ASCII case-insensitive match for \"url\",\n // and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.\n if (cmpStr(source, nameStartOffset, offset, 'url') && getCharCode(offset) === 0x0028) {\n // While the next two input code points are whitespace, consume the next input code point.\n offset = findWhiteSpaceEnd(source, offset + 1);\n\n // If the next one or two input code points are U+0022 QUOTATION MARK (\"), U+0027 APOSTROPHE ('),\n // or whitespace followed by U+0022 QUOTATION MARK (\") or U+0027 APOSTROPHE ('),\n // then create a <function-token> with its value set to string and return it.\n if (getCharCode(offset) === 0x0022 ||\n getCharCode(offset) === 0x0027) {\n type = TYPE.Function;\n offset = nameStartOffset + 4;\n return;\n }\n\n // Otherwise, consume a url token, and return it.\n consumeUrlToken();\n return;\n }\n\n // Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.\n // Create a <function-token> with its value set to string and return it.\n if (getCharCode(offset) === 0x0028) {\n type = TYPE.Function;\n offset++;\n return;\n }\n\n // Otherwise, create an <ident-token> with its value set to string and return it.\n type = TYPE.Ident;\n }\n\n // § 4.3.5. Consume a string token\n function consumeStringToken(endingCodePoint) {\n // This algorithm may be called with an ending code point, which denotes the code point\n // that ends the string. If an ending code point is not specified,\n // the current input code point is used.\n if (!endingCodePoint) {\n endingCodePoint = getCharCode(offset++);\n }\n\n // Initially create a <string-token> with its value set to the empty string.\n type = TYPE.String;\n\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // ending code point\n case endingCodePoint:\n // Return the <string-token>.\n offset++;\n return;\n\n // EOF\n // case EofCategory:\n // This is a parse error. Return the <string-token>.\n // return;\n\n // newline\n case WhiteSpaceCategory:\n if (isNewline(code)) {\n // This is a parse error. Reconsume the current input code point,\n // create a <bad-string-token>, and return it.\n offset += getNewlineLength(source, offset, code);\n type = TYPE.BadString;\n return;\n }\n break;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the next input code point is EOF, do nothing.\n if (offset === source.length - 1) {\n break;\n }\n\n const nextCode = getCharCode(offset + 1);\n\n // Otherwise, if the next input code point is a newline, consume it.\n if (isNewline(nextCode)) {\n offset += getNewlineLength(source, offset + 1, nextCode);\n } else if (isValidEscape(code, nextCode)) {\n // Otherwise, (the stream starts with a valid escape) consume\n // an escaped code point and append the returned code point to\n // the <string-token>’s value.\n offset = consumeEscaped(source, offset) - 1;\n }\n break;\n\n // anything else\n // Append the current input code point to the <string-token>’s value.\n }\n }\n }\n\n // § 4.3.6. Consume a url token\n // Note: This algorithm assumes that the initial \"url(\" has already been consumed.\n // This algorithm also assumes that it’s being called to consume an \"unquoted\" value, like url(foo).\n // A quoted value, like url(\"foo\"), is parsed as a <function-token>. Consume an ident-like token\n // automatically handles this distinction; this algorithm shouldn’t be called directly otherwise.\n function consumeUrlToken() {\n // Initially create a <url-token> with its value set to the empty string.\n type = TYPE.Url;\n\n // Consume as much whitespace as possible.\n offset = findWhiteSpaceEnd(source, offset);\n\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // U+0029 RIGHT PARENTHESIS ())\n case 0x0029:\n // Return the <url-token>.\n offset++;\n return;\n\n // EOF\n // case EofCategory:\n // This is a parse error. Return the <url-token>.\n // return;\n\n // whitespace\n case WhiteSpaceCategory:\n // Consume as much whitespace as possible.\n offset = findWhiteSpaceEnd(source, offset);\n\n // If the next input code point is U+0029 RIGHT PARENTHESIS ()) or EOF,\n // consume it and return the <url-token>\n // (if EOF was encountered, this is a parse error);\n if (getCharCode(offset) === 0x0029 || offset >= source.length) {\n if (offset < source.length) {\n offset++;\n }\n return;\n }\n\n // otherwise, consume the remnants of a bad url, create a <bad-url-token>,\n // and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // U+0022 QUOTATION MARK (\")\n // U+0027 APOSTROPHE (')\n // U+0028 LEFT PARENTHESIS (()\n // non-printable code point\n case 0x0022:\n case 0x0027:\n case 0x0028:\n case NonPrintableCategory:\n // This is a parse error. Consume the remnants of a bad url,\n // create a <bad-url-token>, and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the stream starts with a valid escape, consume an escaped code point and\n // append the returned code point to the <url-token>’s value.\n if (isValidEscape(code, getCharCode(offset + 1))) {\n offset = consumeEscaped(source, offset) - 1;\n break;\n }\n\n // Otherwise, this is a parse error. Consume the remnants of a bad url,\n // create a <bad-url-token>, and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // anything else\n // Append the current input code point to the <url-token>’s value.\n }\n }\n }\n\n // ensure source is a string\n source = String(source || '');\n\n const sourceLength = source.length;\n let start = isBOM(getCharCode(0));\n let offset = start;\n let type;\n\n // https://drafts.csswg.org/css-syntax-3/#consume-token\n // § 4.3.1. Consume a token\n while (offset < sourceLength) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // whitespace\n case WhiteSpaceCategory:\n // Consume as much whitespace as possible. Return a <whitespace-token>.\n type = TYPE.WhiteSpace;\n offset = findWhiteSpaceEnd(source, offset + 1);\n break;\n\n // U+0022 QUOTATION MARK (\")\n case 0x0022:\n // Consume a string token and return it.\n consumeStringToken();\n break;\n\n // U+0023 NUMBER SIGN (#)\n case 0x0023:\n // If the next input code point is a name code point or the next two input code points are a valid escape, then:\n if (isName(getCharCode(offset + 1)) || isValidEscape(getCharCode(offset + 1), getCharCode(offset + 2))) {\n // Create a <hash-token>.\n type = TYPE.Hash;\n\n // If the next 3 input code points would start an identifier, set the <hash-token>’s type flag to \"id\".\n // if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {\n // // TODO: set id flag\n // }\n\n // Consume a name, and set the <hash-token>’s value to the returned string.\n offset = consumeName(source, offset + 1);\n\n // Return the <hash-token>.\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+0027 APOSTROPHE (')\n case 0x0027:\n // Consume a string token and return it.\n consumeStringToken();\n break;\n\n // U+0028 LEFT PARENTHESIS (()\n case 0x0028:\n // Return a <(-token>.\n type = TYPE.LeftParenthesis;\n offset++;\n break;\n\n // U+0029 RIGHT PARENTHESIS ())\n case 0x0029:\n // Return a <)-token>.\n type = TYPE.RightParenthesis;\n offset++;\n break;\n\n // U+002B PLUS SIGN (+)\n case 0x002B:\n // If the input stream starts with a number, ...\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+002C COMMA (,)\n case 0x002C:\n // Return a <comma-token>.\n type = TYPE.Comma;\n offset++;\n break;\n\n // U+002D HYPHEN-MINUS (-)\n case 0x002D:\n // If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n consumeNumericToken();\n } else {\n // 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>.\n if (getCharCode(offset + 1) === 0x002D &&\n getCharCode(offset + 2) === 0x003E) {\n type = TYPE.CDC;\n offset = offset + 3;\n } else {\n // Otherwise, if the input stream starts with an identifier, ...\n if (isIdentifierStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n }\n }\n break;\n\n // U+002E FULL STOP (.)\n case 0x002E:\n // If the input stream starts with a number, ...\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+002F SOLIDUS (/)\n case 0x002F:\n // If the next two input code point are U+002F SOLIDUS (/) followed by a U+002A ASTERISK (*),\n if (getCharCode(offset + 1) === 0x002A) {\n // ... consume them and all following code points up to and including the first U+002A ASTERISK (*)\n // followed by a U+002F SOLIDUS (/), or up to an EOF code point.\n type = TYPE.Comment;\n offset = source.indexOf('*/', offset + 2);\n offset = offset === -1 ? source.length : offset + 2;\n } else {\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+003A COLON (:)\n case 0x003A:\n // Return a <colon-token>.\n type = TYPE.Colon;\n offset++;\n break;\n\n // U+003B SEMICOLON (;)\n case 0x003B:\n // Return a <semicolon-token>.\n type = TYPE.Semicolon;\n offset++;\n break;\n\n // U+003C LESS-THAN SIGN (<)\n case 0x003C:\n // If the next 3 input code points are U+0021 EXCLAMATION MARK U+002D HYPHEN-MINUS U+002D HYPHEN-MINUS (!--), ...\n if (getCharCode(offset + 1) === 0x0021 &&\n getCharCode(offset + 2) === 0x002D &&\n getCharCode(offset + 3) === 0x002D) {\n // ... consume them and return a <CDO-token>.\n type = TYPE.CDO;\n offset = offset + 4;\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+0040 COMMERCIAL AT (@)\n case 0x0040:\n // If the next 3 input code points would start an identifier, ...\n if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {\n // ... consume a name, create an <at-keyword-token> with its value set to the returned value, and return it.\n type = TYPE.AtKeyword;\n offset = consumeName(source, offset + 1);\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+005B LEFT SQUARE BRACKET ([)\n case 0x005B:\n // Return a <[-token>.\n type = TYPE.LeftSquareBracket;\n offset++;\n break;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the input stream starts with a valid escape, ...\n if (isValidEscape(code, getCharCode(offset + 1))) {\n // ... reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n } else {\n // Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+005D RIGHT SQUARE BRACKET (])\n case 0x005D:\n // Return a <]-token>.\n type = TYPE.RightSquareBracket;\n offset++;\n break;\n\n // U+007B LEFT CURLY BRACKET ({)\n case 0x007B:\n // Return a <{-token>.\n type = TYPE.LeftCurlyBracket;\n offset++;\n break;\n\n // U+007D RIGHT CURLY BRACKET (})\n case 0x007D:\n // Return a <}-token>.\n type = TYPE.RightCurlyBracket;\n offset++;\n break;\n\n // digit\n case DigitCategory:\n // Reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n break;\n\n // name-start code point\n case NameStartCategory:\n // Reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n break;\n\n // EOF\n // case EofCategory:\n // Return an <EOF-token>.\n // break;\n\n // anything else\n default:\n // Return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n // put token to stream\n onToken(type, start, start = offset);\n }\n}\n\nexport * from './types.js';\nexport * as tokenTypes from './types.js';\nexport { default as tokenNames } from './names.js';\nexport * from './char-code-definitions.js';\nexport * from './utils.js';\nexport * from './OffsetToLocation.js';\nexport * from './TokenStream.js';\n","//\n// list\n// ┌──────┐\n// ┌──────────────┼─head │\n// │ │ tail─┼──────────────┐\n// │ └──────┘ │\n// ▼ ▼\n// item item item item\n// ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐\n// null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │\n// │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null\n// ├──────┤ ├──────┤ ├──────┤ ├──────┤\n// │ data │ │ data │ │ data │ │ data │\n// └──────┘ └──────┘ └──────┘ └──────┘\n//\n\nlet releasedCursors = null;\n\nexport class List {\n static createItem(data) {\n return {\n prev: null,\n next: null,\n data\n };\n }\n\n constructor() {\n this.head = null;\n this.tail = null;\n this.cursor = null;\n }\n createItem(data) {\n return List.createItem(data);\n }\n\n // cursor helpers\n allocateCursor(prev, next) {\n let cursor;\n\n if (releasedCursors !== null) {\n cursor = releasedCursors;\n releasedCursors = releasedCursors.cursor;\n cursor.prev = prev;\n cursor.next = next;\n cursor.cursor = this.cursor;\n } else {\n cursor = {\n prev,\n next,\n cursor: this.cursor\n };\n }\n\n this.cursor = cursor;\n\n return cursor;\n }\n releaseCursor() {\n const { cursor } = this;\n\n this.cursor = cursor.cursor;\n cursor.prev = null;\n cursor.next = null;\n cursor.cursor = releasedCursors;\n releasedCursors = cursor;\n }\n updateCursors(prevOld, prevNew, nextOld, nextNew) {\n let { cursor } = this;\n\n while (cursor !== null) {\n if (cursor.prev === prevOld) {\n cursor.prev = prevNew;\n }\n\n if (cursor.next === nextOld) {\n cursor.next = nextNew;\n }\n\n cursor = cursor.cursor;\n }\n }\n *[Symbol.iterator]() {\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n yield cursor.data;\n }\n }\n\n // getters\n get size() {\n let size = 0;\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n size++;\n }\n\n return size;\n }\n get isEmpty() {\n return this.head === null;\n }\n get first() {\n return this.head && this.head.data;\n }\n get last() {\n return this.tail && this.tail.data;\n }\n\n // convertors\n fromArray(array) {\n let cursor = null;\n this.head = null;\n\n for (let data of array) {\n const item = List.createItem(data);\n\n if (cursor !== null) {\n cursor.next = item;\n } else {\n this.head = item;\n }\n\n item.prev = cursor;\n cursor = item;\n }\n\n this.tail = cursor;\n return this;\n }\n toArray() {\n return [...this];\n }\n toJSON() {\n return [...this];\n }\n\n // array-like methods\n forEach(fn, thisArg = this) {\n // push cursor\n const cursor = this.allocateCursor(null, this.head);\n\n while (cursor.next !== null) {\n const item = cursor.next;\n cursor.next = item.next;\n fn.call(thisArg, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n }\n forEachRight(fn, thisArg = this) {\n // push cursor\n const cursor = this.allocateCursor(this.tail, null);\n\n while (cursor.prev !== null) {\n const item = cursor.prev;\n cursor.prev = item.prev;\n fn.call(thisArg, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n }\n reduce(fn, initialValue, thisArg = this) {\n // push cursor\n let cursor = this.allocateCursor(null, this.head);\n let acc = initialValue;\n let item;\n\n while (cursor.next !== null) {\n item = cursor.next;\n cursor.next = item.next;\n\n acc = fn.call(thisArg, acc, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n\n return acc;\n }\n reduceRight(fn, initialValue, thisArg = this) {\n // push cursor\n let cursor = this.allocateCursor(this.tail, null);\n let acc = initialValue;\n let item;\n\n while (cursor.prev !== null) {\n item = cursor.prev;\n cursor.prev = item.prev;\n\n acc = fn.call(thisArg, acc, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n\n return acc;\n }\n some(fn, thisArg = this) {\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n if (fn.call(thisArg, cursor.data, cursor, this)) {\n return true;\n }\n }\n\n return false;\n }\n map(fn, thisArg = this) {\n const result = new List();\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n result.appendData(fn.call(thisArg, cursor.data, cursor, this));\n }\n\n return result;\n }\n filter(fn, thisArg = this) {\n const result = new List();\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n if (fn.call(thisArg, cursor.data, cursor, this)) {\n result.appendData(cursor.data);\n }\n }\n\n return result;\n }\n\n nextUntil(start, fn, thisArg = this) {\n if (start === null) {\n return;\n }\n\n // push cursor\n const cursor = this.allocateCursor(null, start);\n\n while (cursor.next !== null) {\n const item = cursor.next;\n cursor.next = item.next;\n if (fn.call(thisArg, item.data, item, this)) {\n break;\n }\n }\n\n // pop cursor\n this.releaseCursor();\n }\n prevUntil(start, fn, thisArg = this) {\n if (start === null) {\n return;\n }\n\n // push cursor\n const cursor = this.allocateCursor(start, null);\n\n while (cursor.prev !== null) {\n const item = cursor.prev;\n cursor.prev = item.prev;\n if (fn.call(thisArg, item.data, item, this)) {\n break;\n }\n }\n\n // pop cursor\n this.releaseCursor();\n }\n\n // mutation\n clear() {\n this.head = null;\n this.tail = null;\n }\n copy() {\n const result = new List();\n\n for (let data of this) {\n result.appendData(data);\n }\n\n return result;\n }\n prepend(item) {\n // head\n // ^\n // item\n this.updateCursors(null, item, this.head, item);\n\n // insert to the beginning of the list\n if (this.head !== null) {\n // new item <- first item\n this.head.prev = item;\n // new item -> first item\n item.next = this.head;\n } else {\n // if list has no head, then it also has no tail\n // in this case tail points to the new item\n this.tail = item;\n }\n\n // head always points to new item\n this.head = item;\n return this;\n }\n prependData(data) {\n return this.prepend(List.createItem(data));\n }\n append(item) {\n return this.insert(item);\n }\n appendData(data) {\n return this.insert(List.createItem(data));\n }\n insert(item, before = null) {\n if (before !== null) {\n // prev before\n // ^\n // item\n this.updateCursors(before.prev, item, before, item);\n\n if (before.prev === null) {\n // insert to the beginning of list\n if (this.head !== before) {\n throw new Error('before doesn\\'t belong to list');\n }\n // since head points to before therefore list doesn't empty\n // no need to check tail\n this.head = item;\n before.prev = item;\n item.next = before;\n this.updateCursors(null, item);\n } else {\n // insert between two items\n before.prev.next = item;\n item.prev = before.prev;\n before.prev = item;\n item.next = before;\n }\n } else {\n // tail\n // ^\n // item\n this.updateCursors(this.tail, item, null, item);\n\n // insert to the ending of the list\n if (this.tail !== null) {\n // last item -> new item\n this.tail.next = item;\n // last item <- new item\n item.prev = this.tail;\n } else {\n // if list has no tail, then it also has no head\n // in this case head points to new item\n this.head = item;\n }\n\n // tail always points to new item\n this.tail = item;\n }\n\n return this;\n }\n insertData(data, before) {\n return this.insert(List.createItem(data), before);\n }\n remove(item) {\n // item\n // ^\n // prev next\n this.updateCursors(item, item.prev, item, item.next);\n\n if (item.prev !== null) {\n item.prev.next = item.next;\n } else {\n if (this.head !== item) {\n throw new Error('item doesn\\'t belong to list');\n }\n\n this.head = item.next;\n }\n\n if (item.next !== null) {\n item.next.prev = item.prev;\n } else {\n if (this.tail !== item) {\n throw new Error('item doesn\\'t belong to list');\n }\n\n this.tail = item.prev;\n }\n\n item.prev = null;\n item.next = null;\n\n return item;\n }\n push(data) {\n this.insert(List.createItem(data));\n }\n pop() {\n return this.tail !== null ? this.remove(this.tail) : null;\n }\n unshift(data) {\n this.prepend(List.createItem(data));\n }\n shift() {\n return this.head !== null ? this.remove(this.head) : null;\n }\n prependList(list) {\n return this.insertList(list, this.head);\n }\n appendList(list) {\n return this.insertList(list);\n }\n insertList(list, before) {\n // ignore empty lists\n if (list.head === null) {\n return this;\n }\n\n if (before !== undefined && before !== null) {\n this.updateCursors(before.prev, list.tail, before, list.head);\n\n // insert in the middle of dist list\n if (before.prev !== null) {\n // before.prev <-> list.head\n before.prev.next = list.head;\n list.head.prev = before.prev;\n } else {\n this.head = list.head;\n }\n\n before.prev = list.tail;\n list.tail.next = before;\n } else {\n this.updateCursors(this.tail, list.tail, null, list.head);\n\n // insert to end of the list\n if (this.tail !== null) {\n // if destination list has a tail, then it also has a head,\n // but head doesn't change\n // dest tail -> source head\n this.tail.next = list.head;\n // dest tail <- source head\n list.head.prev = this.tail;\n } else {\n // if list has no a tail, then it also has no a head\n // in this case points head to new item\n this.head = list.head;\n }\n\n // tail always start point to new item\n this.tail = list.tail;\n }\n\n list.head = null;\n list.tail = null;\n return this;\n }\n replace(oldItem, newItemOrList) {\n if ('head' in newItemOrList) {\n this.insertList(newItemOrList, oldItem);\n } else {\n this.insert(newItemOrList, oldItem);\n }\n\n this.remove(oldItem);\n }\n}\n","export function createCustomError(name, message) {\n // use Object.create(), because some VMs prevent setting line/column otherwise\n // (iOS Safari 10 even throws an exception)\n const error = Object.create(SyntaxError.prototype);\n const errorStack = new Error();\n\n return Object.assign(error, {\n name,\n message,\n get stack() {\n return (errorStack.stack || '').replace(/^(.+\\n){1,3}/, `${name}: ${message}\\n`);\n }\n });\n};\n","import { createCustomError } from '../utils/create-custom-error.js';\n\nconst MAX_LINE_LENGTH = 100;\nconst OFFSET_CORRECTION = 60;\nconst TAB_REPLACEMENT = ' ';\n\nfunction sourceFragment({ source, line, column, baseLine, baseColumn }, extraLines) {\n function processLines(start, end) {\n return lines\n .slice(start, end)\n .map((line, idx) =>\n String(start + idx + 1).padStart(maxNumLength) + ' |' + line\n ).join('\\n');\n }\n\n const prelines = '\\n'.repeat(Math.max(baseLine - 1, 0));\n const precolumns = ' '.repeat(Math.max(baseColumn - 1, 0));\n const lines = (prelines + precolumns + source).split(/\\r\\n?|\\n|\\f/);\n const startLine = Math.max(1, line - extraLines) - 1;\n const endLine = Math.min(line + extraLines, lines.length + 1);\n const maxNumLength = Math.max(4, String(endLine).length) + 1;\n let cutLeft = 0;\n\n // column correction according to replaced tab before column\n column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\\t/g) || []).length;\n\n if (column > MAX_LINE_LENGTH) {\n cutLeft = column - OFFSET_CORRECTION + 3;\n column = OFFSET_CORRECTION - 2;\n }\n\n for (let i = startLine; i <= endLine; i++) {\n if (i >= 0 && i < lines.length) {\n lines[i] = lines[i].replace(/\\t/g, TAB_REPLACEMENT);\n lines[i] =\n (cutLeft > 0 && lines[i].length > cutLeft ? '\\u2026' : '') +\n lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +\n (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\\u2026' : '');\n }\n }\n\n return [\n processLines(startLine, line),\n new Array(column + maxNumLength + 2).join('-') + '^',\n processLines(line, endLine)\n ].filter(Boolean)\n .join('\\n')\n .replace(/^(\\s+\\d+\\s+\\|\\n)+/, '')\n .replace(/\\n(\\s+\\d+\\s+\\|)+$/, '');\n}\n\nexport function SyntaxError(message, source, offset, line, column, baseLine = 1, baseColumn = 1) {\n const error = Object.assign(createCustomError('SyntaxError', message), {\n source,\n offset,\n line,\n column,\n sourceFragment(extraLines) {\n return sourceFragment({ source, line, column, baseLine, baseColumn }, isNaN(extraLines) ? 0 : extraLines);\n },\n get formattedMessage() {\n return (\n `Parse error: ${message}\\n` +\n sourceFragment({ source, line, column, baseLine, baseColumn }, 2)\n );\n }\n });\n\n return error;\n}\n","import { WhiteSpace, Comment } from '../tokenizer/index.js';\n\nexport function readSequence(recognizer) {\n const children = this.createList();\n let space = false;\n const context = {\n recognizer\n };\n\n while (!this.eof) {\n switch (this.tokenType) {\n case Comment:\n this.next();\n continue;\n\n case WhiteSpace:\n space = true;\n this.next();\n continue;\n }\n\n let child = recognizer.getNode.call(this, context);\n\n if (child === undefined) {\n break;\n }\n\n if (space) {\n if (recognizer.onWhiteSpace) {\n recognizer.onWhiteSpace.call(this, child, children, context);\n }\n space = false;\n }\n\n children.push(child);\n }\n\n if (space && recognizer.onWhiteSpace) {\n recognizer.onWhiteSpace.call(this, null, children, context);\n }\n\n return children;\n};\n","import { List } from '../utils/List.js';\nimport { SyntaxError } from './SyntaxError.js';\nimport {\n tokenize,\n OffsetToLocation,\n TokenStream,\n tokenNames,\n\n consumeNumber,\n findWhiteSpaceStart,\n cmpChar,\n cmpStr,\n\n WhiteSpace,\n Comment,\n Ident,\n Function as FunctionToken,\n Url,\n Hash,\n Percentage,\n Number as NumberToken\n} from '../tokenizer/index.js';\nimport { readSequence } from './sequence.js';\n\nconst NOOP = () => {};\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst SEMICOLON = 0x003B; // U+003B SEMICOLON (;)\nconst LEFTCURLYBRACKET = 0x007B; // U+007B LEFT CURLY BRACKET ({)\nconst NULL = 0;\n\nfunction createParseContext(name) {\n return function() {\n return this[name]();\n };\n}\n\nfunction fetchParseValues(dict) {\n const result = Object.create(null);\n\n for (const name of Object.keys(dict)) {\n const item = dict[name];\n const fn = item.parse || item;\n\n if (fn) {\n result[name] = fn;\n }\n }\n\n return result;\n}\n\nfunction processConfig(config) {\n const parseConfig = {\n context: Object.create(null),\n features: Object.assign(Object.create(null), config.features),\n scope: Object.assign(Object.create(null), config.scope),\n atrule: fetchParseValues(config.atrule),\n pseudo: fetchParseValues(config.pseudo),\n node: fetchParseValues(config.node)\n };\n\n for (const [name, context] of Object.entries(config.parseContext)) {\n switch (typeof context) {\n case 'function':\n parseConfig.context[name] = context;\n break;\n\n case 'string':\n parseConfig.context[name] = createParseContext(context);\n break;\n }\n }\n\n return {\n config: parseConfig,\n ...parseConfig,\n ...parseConfig.node\n };\n}\n\nexport function createParser(config) {\n let source = '';\n let filename = '<unknown>';\n let needPositions = false;\n let onParseError = NOOP;\n let onParseErrorThrow = false;\n\n const locationMap = new OffsetToLocation();\n const parser = Object.assign(new TokenStream(), processConfig(config || {}), {\n parseAtrulePrelude: true,\n parseRulePrelude: true,\n parseValue: true,\n parseCustomProperty: false,\n\n readSequence,\n\n consumeUntilBalanceEnd: () => 0,\n consumeUntilLeftCurlyBracket(code) {\n return code === LEFTCURLYBRACKET ? 1 : 0;\n },\n consumeUntilLeftCurlyBracketOrSemicolon(code) {\n return code === LEFTCURLYBRACKET || code === SEMICOLON ? 1 : 0;\n },\n consumeUntilExclamationMarkOrSemicolon(code) {\n return code === EXCLAMATIONMARK || code === SEMICOLON ? 1 : 0;\n },\n consumeUntilSemicolonIncluded(code) {\n return code === SEMICOLON ? 2 : 0;\n },\n\n createList() {\n return new List();\n },\n createSingleNodeList(node) {\n return new List().appendData(node);\n },\n getFirstListNode(list) {\n return list && list.first;\n },\n getLastListNode(list) {\n return list && list.last;\n },\n\n parseWithFallback(consumer, fallback) {\n const startIndex = this.tokenIndex;\n\n try {\n return consumer.call(this);\n } catch (e) {\n if (onParseErrorThrow) {\n throw e;\n }\n\n this.skip(startIndex - this.tokenIndex);\n const fallbackNode = fallback.call(this);\n\n onParseErrorThrow = true;\n onParseError(e, fallbackNode);\n onParseErrorThrow = false;\n\n return fallbackNode;\n }\n },\n\n lookupNonWSType(offset) {\n let type;\n\n do {\n type = this.lookupType(offset++);\n if (type !== WhiteSpace && type !== Comment) {\n return type;\n }\n } while (type !== NULL);\n\n return NULL;\n },\n\n charCodeAt(offset) {\n return offset >= 0 && offset < source.length ? source.charCodeAt(offset) : 0;\n },\n substring(offsetStart, offsetEnd) {\n return source.substring(offsetStart, offsetEnd);\n },\n substrToCursor(start) {\n return this.source.substring(start, this.tokenStart);\n },\n\n cmpChar(offset, charCode) {\n return cmpChar(source, offset, charCode);\n },\n cmpStr(offsetStart, offsetEnd, str) {\n return cmpStr(source, offsetStart, offsetEnd, str);\n },\n\n consume(tokenType) {\n const start = this.tokenStart;\n\n this.eat(tokenType);\n\n return this.substrToCursor(start);\n },\n consumeFunctionName() {\n const name = source.substring(this.tokenStart, this.tokenEnd - 1);\n\n this.eat(FunctionToken);\n\n return name;\n },\n consumeNumber(type) {\n const number = source.substring(this.tokenStart, consumeNumber(source, this.tokenStart));\n\n this.eat(type);\n\n return number;\n },\n\n eat(tokenType) {\n if (this.tokenType !== tokenType) {\n const tokenName = tokenNames[tokenType].slice(0, -6).replace(/-/g, ' ').replace(/^./, m => m.toUpperCase());\n let message = `${/[[\\](){}]/.test(tokenName) ? `\"${tokenName}\"` : tokenName} is expected`;\n let offset = this.tokenStart;\n\n // tweak message and offset\n switch (tokenType) {\n case Ident:\n // when identifier is expected but there is a function or url\n if (this.tokenType === FunctionToken || this.tokenType === Url) {\n offset = this.tokenEnd - 1;\n message = 'Identifier is expected but function found';\n } else {\n message = 'Identifier is expected';\n }\n break;\n\n case Hash:\n if (this.isDelim(NUMBERSIGN)) {\n this.next();\n offset++;\n message = 'Name is expected';\n }\n break;\n\n case Percentage:\n if (this.tokenType === NumberToken) {\n offset = this.tokenEnd;\n message = 'Percent sign is expected';\n }\n break;\n }\n\n this.error(message, offset);\n }\n\n this.next();\n },\n eatIdent(name) {\n if (this.tokenType !== Ident || this.lookupValue(0, name) === false) {\n this.error(`Identifier \"${name}\" is expected`);\n }\n\n this.next();\n },\n eatDelim(code) {\n if (!this.isDelim(code)) {\n this.error(`Delim \"${String.fromCharCode(code)}\" is expected`);\n }\n\n this.next();\n },\n\n getLocation(start, end) {\n if (needPositions) {\n return locationMap.getLocationRange(\n start,\n end,\n filename\n );\n }\n\n return null;\n },\n getLocationFromList(list) {\n if (needPositions) {\n const head = this.getFirstListNode(list);\n const tail = this.getLastListNode(list);\n return locationMap.getLocationRange(\n head !== null ? head.loc.start.offset - locationMap.startOffset : this.tokenStart,\n tail !== null ? tail.loc.end.offset - locationMap.startOffset : this.tokenStart,\n filename\n );\n }\n\n return null;\n },\n\n error(message, offset) {\n const location = typeof offset !== 'undefined' && offset < source.length\n ? locationMap.getLocation(offset)\n : this.eof\n ? locationMap.getLocation(findWhiteSpaceStart(source, source.length - 1))\n : locationMap.getLocation(this.tokenStart);\n\n throw new SyntaxError(\n message || 'Unexpected input',\n source,\n location.offset,\n location.line,\n location.column,\n locationMap.startLine,\n locationMap.startColumn\n );\n }\n });\n\n const parse = function(source_, options) {\n source = source_;\n options = options || {};\n\n parser.setSource(source, tokenize);\n locationMap.setSource(\n source,\n options.offset,\n options.line,\n options.column\n );\n\n filename = options.filename || '<unknown>';\n needPositions = Boolean(options.positions);\n onParseError = typeof options.onParseError === 'function' ? options.onParseError : NOOP;\n onParseErrorThrow = false;\n\n parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;\n parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;\n parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;\n parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;\n\n const { context = 'default', onComment } = options;\n\n if (context in parser.context === false) {\n throw new Error('Unknown context `' + context + '`');\n }\n\n if (typeof onComment === 'function') {\n parser.forEachToken((type, start, end) => {\n if (type === Comment) {\n const loc = parser.getLocation(start, end);\n const value = cmpStr(source, end - 2, end, '*/')\n ? source.slice(start + 2, end - 2)\n : source.slice(start + 2, end);\n\n onComment(value, loc);\n }\n });\n }\n\n const ast = parser.context[context].call(parser, options);\n\n if (!parser.eof) {\n parser.error();\n }\n\n return ast;\n };\n\n return Object.assign(parse, {\n SyntaxError,\n config: parser.config\n });\n};\n","import { SourceMapGenerator } from 'source-map-js/lib/source-map-generator.js';\n\nconst trackNodes = new Set(['Atrule', 'Selector', 'Declaration']);\n\nexport function generateSourceMap(handlers) {\n const map = new SourceMapGenerator();\n const generated = {\n line: 1,\n column: 0\n };\n const original = {\n line: 0, // should be zero to add first mapping\n column: 0\n };\n const activatedGenerated = {\n line: 1,\n column: 0\n };\n const activatedMapping = {\n generated: activatedGenerated\n };\n let line = 1;\n let column = 0;\n let sourceMappingActive = false;\n\n const origHandlersNode = handlers.node;\n handlers.node = function(node) {\n if (node.loc && node.loc.start && trackNodes.has(node.type)) {\n const nodeLine = node.loc.start.line;\n const nodeColumn = node.loc.start.column - 1;\n\n if (original.line !== nodeLine ||\n original.column !== nodeColumn) {\n original.line = nodeLine;\n original.column = nodeColumn;\n\n generated.line = line;\n generated.column = column;\n\n if (sourceMappingActive) {\n sourceMappingActive = false;\n if (generated.line !== activatedGenerated.line ||\n generated.column !== activatedGenerated.column) {\n map.addMapping(activatedMapping);\n }\n }\n\n sourceMappingActive = true;\n map.addMapping({\n source: node.loc.source,\n original,\n generated\n });\n }\n }\n\n origHandlersNode.call(this, node);\n\n if (sourceMappingActive && trackNodes.has(node.type)) {\n activatedGenerated.line = line;\n activatedGenerated.column = column;\n }\n };\n\n const origHandlersEmit = handlers.emit;\n handlers.emit = function(value, type, auto) {\n for (let i = 0; i < value.length; i++) {\n if (value.charCodeAt(i) === 10) { // \\n\n line++;\n column = 0;\n } else {\n column++;\n }\n }\n\n origHandlersEmit(value, type, auto);\n };\n\n const origHandlersResult = handlers.result;\n handlers.result = function() {\n if (sourceMappingActive) {\n map.addMapping(activatedMapping);\n }\n\n return {\n css: origHandlersResult(),\n map\n };\n };\n\n return handlers;\n};\n","import {\n WhiteSpace,\n Delim,\n Ident,\n Function as FunctionToken,\n Url,\n BadUrl,\n AtKeyword,\n Hash,\n Percentage,\n Dimension,\n Number as NumberToken,\n String as StringToken,\n Colon,\n LeftParenthesis,\n RightParenthesis,\n CDC\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\n\nconst code = (type, value) => {\n if (type === Delim) {\n type = value;\n }\n\n if (typeof type === 'string') {\n const charCode = type.charCodeAt(0);\n return charCode > 0x7F ? 0x8000 : charCode << 8;\n }\n\n return type;\n};\n\n// https://www.w3.org/TR/css-syntax-3/#serialization\n// The only requirement for serialization is that it must \"round-trip\" with parsing,\n// that is, parsing the stylesheet must produce the same data structures as parsing,\n// serializing, and parsing again, except for consecutive <whitespace-token>s,\n// which may be collapsed into a single token.\n\nconst specPairs = [\n [Ident, Ident],\n [Ident, FunctionToken],\n [Ident, Url],\n [Ident, BadUrl],\n [Ident, '-'],\n [Ident, NumberToken],\n [Ident, Percentage],\n [Ident, Dimension],\n [Ident, CDC],\n [Ident, LeftParenthesis],\n\n [AtKeyword, Ident],\n [AtKeyword, FunctionToken],\n [AtKeyword, Url],\n [AtKeyword, BadUrl],\n [AtKeyword, '-'],\n [AtKeyword, NumberToken],\n [AtKeyword, Percentage],\n [AtKeyword, Dimension],\n [AtKeyword, CDC],\n\n [Hash, Ident],\n [Hash, FunctionToken],\n [Hash, Url],\n [Hash, BadUrl],\n [Hash, '-'],\n [Hash, NumberToken],\n [Hash, Percentage],\n [Hash, Dimension],\n [Hash, CDC],\n\n [Dimension, Ident],\n [Dimension, FunctionToken],\n [Dimension, Url],\n [Dimension, BadUrl],\n [Dimension, '-'],\n [Dimension, NumberToken],\n [Dimension, Percentage],\n [Dimension, Dimension],\n [Dimension, CDC],\n\n ['#', Ident],\n ['#', FunctionToken],\n ['#', Url],\n ['#', BadUrl],\n ['#', '-'],\n ['#', NumberToken],\n ['#', Percentage],\n ['#', Dimension],\n ['#', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['-', Ident],\n ['-', FunctionToken],\n ['-', Url],\n ['-', BadUrl],\n ['-', '-'],\n ['-', NumberToken],\n ['-', Percentage],\n ['-', Dimension],\n ['-', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n [NumberToken, Ident],\n [NumberToken, FunctionToken],\n [NumberToken, Url],\n [NumberToken, BadUrl],\n [NumberToken, NumberToken],\n [NumberToken, Percentage],\n [NumberToken, Dimension],\n [NumberToken, '%'],\n [NumberToken, CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['@', Ident],\n ['@', FunctionToken],\n ['@', Url],\n ['@', BadUrl],\n ['@', '-'],\n ['@', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['.', NumberToken],\n ['.', Percentage],\n ['.', Dimension],\n\n ['+', NumberToken],\n ['+', Percentage],\n ['+', Dimension],\n\n ['/', '*']\n];\n// validate with scripts/generate-safe\nconst safePairs = specPairs.concat([\n [Ident, Hash],\n\n [Dimension, Hash],\n\n [Hash, Hash],\n\n [AtKeyword, LeftParenthesis],\n [AtKeyword, StringToken],\n [AtKeyword, Colon],\n\n [Percentage, Percentage],\n [Percentage, Dimension],\n [Percentage, FunctionToken],\n [Percentage, '-'],\n\n [RightParenthesis, Ident],\n [RightParenthesis, FunctionToken],\n [RightParenthesis, Percentage],\n [RightParenthesis, Dimension],\n [RightParenthesis, Hash],\n [RightParenthesis, '-']\n]);\n\nfunction createMap(pairs) {\n const isWhiteSpaceRequired = new Set(\n pairs.map(([prev, next]) => (code(prev) << 16 | code(next)))\n );\n\n return function(prevCode, type, value) {\n const nextCode = code(type, value);\n const nextCharCode = value.charCodeAt(0);\n const emitWs =\n (nextCharCode === HYPHENMINUS &&\n type !== Ident &&\n type !== FunctionToken &&\n type !== CDC) ||\n (nextCharCode === PLUSSIGN)\n ? isWhiteSpaceRequired.has(prevCode << 16 | nextCharCode << 8)\n : isWhiteSpaceRequired.has(prevCode << 16 | nextCode);\n\n if (emitWs) {\n this.emit(' ', WhiteSpace, true);\n }\n\n return nextCode;\n };\n}\n\nexport const spec = createMap(specPairs);\nexport const safe = createMap(safePairs);\n","import { tokenize, Delim, WhiteSpace } from '../tokenizer/index.js';\nimport { generateSourceMap } from './sourceMap.js';\nimport * as tokenBefore from './token-before.js';\n\nconst REVERSESOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\n\nfunction processChildren(node, delimeter) {\n if (typeof delimeter === 'function') {\n let prev = null;\n\n node.children.forEach(node => {\n if (prev !== null) {\n delimeter.call(this, prev);\n }\n\n this.node(node);\n prev = node;\n });\n\n return;\n }\n\n node.children.forEach(this.node, this);\n}\n\nfunction processChunk(chunk) {\n tokenize(chunk, (type, start, end) => {\n this.token(type, chunk.slice(start, end));\n });\n}\n\nexport function createGenerator(config) {\n const types = new Map();\n\n for (let [name, item] of Object.entries(config.node)) {\n const fn = item.generate || item;\n\n if (typeof fn === 'function') {\n types.set(name, item.generate || item);\n }\n }\n\n return function(node, options) {\n let buffer = '';\n let prevCode = 0;\n let handlers = {\n node(node) {\n if (types.has(node.type)) {\n types.get(node.type).call(publicApi, node);\n } else {\n throw new Error('Unknown node type: ' + node.type);\n }\n },\n tokenBefore: tokenBefore.safe,\n token(type, value) {\n prevCode = this.tokenBefore(prevCode, type, value);\n\n this.emit(value, type, false);\n\n if (type === Delim && value.charCodeAt(0) === REVERSESOLIDUS) {\n this.emit('\\n', WhiteSpace, true);\n }\n },\n emit(value) {\n buffer += value;\n },\n result() {\n return buffer;\n }\n };\n\n if (options) {\n if (typeof options.decorator === 'function') {\n handlers = options.decorator(handlers);\n }\n\n if (options.sourceMap) {\n handlers = generateSourceMap(handlers);\n }\n\n if (options.mode in tokenBefore) {\n handlers.tokenBefore = tokenBefore[options.mode];\n }\n }\n\n const publicApi = {\n node: (node) => handlers.node(node),\n children: processChildren,\n token: (type, value) => handlers.token(type, value),\n tokenize: processChunk\n };\n\n handlers.node(node);\n\n return handlers.result();\n };\n};\n","const { hasOwnProperty } = Object.prototype;\nconst noop = function() {};\n\nfunction ensureFunction(value) {\n return typeof value === 'function' ? value : noop;\n}\n\nfunction invokeForType(fn, type) {\n return function(node, item, list) {\n if (node.type === type) {\n fn.call(this, node, item, list);\n }\n };\n}\n\nfunction getWalkersFromStructure(name, nodeType) {\n const structure = nodeType.structure;\n const walkers = [];\n\n for (const key in structure) {\n if (hasOwnProperty.call(structure, key) === false) {\n continue;\n }\n\n let fieldTypes = structure[key];\n const walker = {\n name: key,\n type: false,\n nullable: false\n };\n\n if (!Array.isArray(fieldTypes)) {\n fieldTypes = [fieldTypes];\n }\n\n for (const fieldType of fieldTypes) {\n if (fieldType === null) {\n walker.nullable = true;\n } else if (typeof fieldType === 'string') {\n walker.type = 'node';\n } else if (Array.isArray(fieldType)) {\n walker.type = 'list';\n }\n }\n\n if (walker.type) {\n walkers.push(walker);\n }\n }\n\n if (walkers.length) {\n return {\n context: nodeType.walkContext,\n fields: walkers\n };\n }\n\n return null;\n}\n\nfunction getTypesFromConfig(config) {\n const types = {};\n\n for (const name in config.node) {\n if (hasOwnProperty.call(config.node, name)) {\n const nodeType = config.node[name];\n\n if (!nodeType.structure) {\n throw new Error('Missed `structure` field in `' + name + '` node type definition');\n }\n\n types[name] = getWalkersFromStructure(name, nodeType);\n }\n }\n\n return types;\n}\n\nfunction createTypeIterator(config, reverse) {\n const fields = config.fields.slice();\n const contextName = config.context;\n const useContext = typeof contextName === 'string';\n\n if (reverse) {\n fields.reverse();\n }\n\n return function(node, context, walk, walkReducer) {\n let prevContextValue;\n\n if (useContext) {\n prevContextValue = context[contextName];\n context[contextName] = node;\n }\n\n for (const field of fields) {\n const ref = node[field.name];\n\n if (!field.nullable || ref) {\n if (field.type === 'list') {\n const breakWalk = reverse\n ? ref.reduceRight(walkReducer, false)\n : ref.reduce(walkReducer, false);\n\n if (breakWalk) {\n return true;\n }\n } else if (walk(ref)) {\n return true;\n }\n }\n }\n\n if (useContext) {\n context[contextName] = prevContextValue;\n }\n };\n}\n\nfunction createFastTraveralMap({\n StyleSheet,\n Atrule,\n Rule,\n Block,\n DeclarationList\n}) {\n return {\n Atrule: {\n StyleSheet,\n Atrule,\n Rule,\n Block\n },\n Rule: {\n StyleSheet,\n Atrule,\n Rule,\n Block\n },\n Declaration: {\n StyleSheet,\n Atrule,\n Rule,\n Block,\n DeclarationList\n }\n };\n}\n\nexport function createWalker(config) {\n const types = getTypesFromConfig(config);\n const iteratorsNatural = {};\n const iteratorsReverse = {};\n const breakWalk = Symbol('break-walk');\n const skipNode = Symbol('skip-node');\n\n for (const name in types) {\n if (hasOwnProperty.call(types, name) && types[name] !== null) {\n iteratorsNatural[name] = createTypeIterator(types[name], false);\n iteratorsReverse[name] = createTypeIterator(types[name], true);\n }\n }\n\n const fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);\n const fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);\n\n const walk = function(root, options) {\n function walkNode(node, item, list) {\n const enterRet = enter.call(context, node, item, list);\n\n if (enterRet === breakWalk) {\n return true;\n }\n\n if (enterRet === skipNode) {\n return false;\n }\n\n if (iterators.hasOwnProperty(node.type)) {\n if (iterators[node.type](node, context, walkNode, walkReducer)) {\n return true;\n }\n }\n\n if (leave.call(context, node, item, list) === breakWalk) {\n return true;\n }\n\n return false;\n }\n\n let enter = noop;\n let leave = noop;\n let iterators = iteratorsNatural;\n let walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);\n const context = {\n break: breakWalk,\n skip: skipNode,\n\n root,\n stylesheet: null,\n atrule: null,\n atrulePrelude: null,\n rule: null,\n selector: null,\n block: null,\n declaration: null,\n function: null\n };\n\n if (typeof options === 'function') {\n enter = options;\n } else if (options) {\n enter = ensureFunction(options.enter);\n leave = ensureFunction(options.leave);\n\n if (options.reverse) {\n iterators = iteratorsReverse;\n }\n\n if (options.visit) {\n if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {\n iterators = options.reverse\n ? fastTraversalIteratorsReverse[options.visit]\n : fastTraversalIteratorsNatural[options.visit];\n } else if (!types.hasOwnProperty(options.visit)) {\n throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).sort().join(', ') + ')');\n }\n\n enter = invokeForType(enter, options.visit);\n leave = invokeForType(leave, options.visit);\n }\n }\n\n if (enter === noop && leave === noop) {\n throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\\'t a function');\n }\n\n walkNode(root);\n };\n\n walk.break = breakWalk;\n walk.skip = skipNode;\n\n walk.find = function(ast, fn) {\n let found = null;\n\n walk(ast, function(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found = node;\n return breakWalk;\n }\n });\n\n return found;\n };\n\n walk.findLast = function(ast, fn) {\n let found = null;\n\n walk(ast, {\n reverse: true,\n enter(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found = node;\n return breakWalk;\n }\n }\n });\n\n return found;\n };\n\n walk.findAll = function(ast, fn) {\n const found = [];\n\n walk(ast, function(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found.push(node);\n }\n });\n\n return found;\n };\n\n return walk;\n};\n","function noop(value) {\n return value;\n}\n\nfunction generateMultiplier(multiplier) {\n const { min, max, comma } = multiplier;\n\n if (min === 0 && max === 0) {\n return comma ? '#?' : '*';\n }\n\n if (min === 0 && max === 1) {\n return '?';\n }\n\n if (min === 1 && max === 0) {\n return comma ? '#' : '+';\n }\n\n if (min === 1 && max === 1) {\n return '';\n }\n\n return (\n (comma ? '#' : '') +\n (min === max\n ? '{' + min + '}'\n : '{' + min + ',' + (max !== 0 ? max : '') + '}'\n )\n );\n}\n\nfunction generateTypeOpts(node) {\n switch (node.type) {\n case 'Range':\n return (\n ' [' +\n (node.min === null ? '-∞' : node.min) +\n ',' +\n (node.max === null ? '∞' : node.max) +\n ']'\n );\n\n default:\n throw new Error('Unknown node type `' + node.type + '`');\n }\n}\n\nfunction generateSequence(node, decorate, forceBraces, compact) {\n const combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';\n const result = node.terms\n .map(term => internalGenerate(term, decorate, forceBraces, compact))\n .join(combinator);\n\n if (node.explicit || forceBraces) {\n return (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');\n }\n\n return result;\n}\n\nfunction internalGenerate(node, decorate, forceBraces, compact) {\n let result;\n\n switch (node.type) {\n case 'Group':\n result =\n generateSequence(node, decorate, forceBraces, compact) +\n (node.disallowEmpty ? '!' : '');\n break;\n\n case 'Multiplier':\n // return since node is a composition\n return (\n internalGenerate(node.term, decorate, forceBraces, compact) +\n decorate(generateMultiplier(node), node)\n );\n\n case 'Boolean':\n result = '<boolean-expr[' + internalGenerate(node.term, decorate, forceBraces, compact) + ']>';\n break;\n\n case 'Type':\n result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';\n break;\n\n case 'Property':\n result = '<\\'' + node.name + '\\'>';\n break;\n\n case 'Keyword':\n result = node.name;\n break;\n\n case 'AtKeyword':\n result = '@' + node.name;\n break;\n\n case 'Function':\n result = node.name + '(';\n break;\n\n case 'String':\n case 'Token':\n result = node.value;\n break;\n\n case 'Comma':\n result = ',';\n break;\n\n default:\n throw new Error('Unknown node type `' + node.type + '`');\n }\n\n return decorate(result, node);\n}\n\nexport function generate(node, options) {\n let decorate = noop;\n let forceBraces = false;\n let compact = false;\n\n if (typeof options === 'function') {\n decorate = options;\n } else if (options) {\n forceBraces = Boolean(options.forceBraces);\n compact = Boolean(options.compact);\n if (typeof options.decorate === 'function') {\n decorate = options.decorate;\n }\n }\n\n return internalGenerate(node, decorate, forceBraces, compact);\n};\n","import { createCustomError } from '../utils/create-custom-error.js';\nimport { generate } from '../definition-syntax/generate.js';\n\nconst defaultLoc = { offset: 0, line: 1, column: 1 };\n\nfunction locateMismatch(matchResult, node) {\n const tokens = matchResult.tokens;\n const longestMatch = matchResult.longestMatch;\n const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null;\n const badNode = mismatchNode !== node ? mismatchNode : null;\n let mismatchOffset = 0;\n let mismatchLength = 0;\n let entries = 0;\n let css = '';\n let start;\n let end;\n\n for (let i = 0; i < tokens.length; i++) {\n const token = tokens[i].value;\n\n if (i === longestMatch) {\n mismatchLength = token.length;\n mismatchOffset = css.length;\n }\n\n if (badNode !== null && tokens[i].node === badNode) {\n if (i <= longestMatch) {\n entries++;\n } else {\n entries = 0;\n }\n }\n\n css += token;\n }\n\n if (longestMatch === tokens.length || entries > 1) { // last\n start = fromLoc(badNode || node, 'end') || buildLoc(defaultLoc, css);\n end = buildLoc(start);\n } else {\n start = fromLoc(badNode, 'start') ||\n buildLoc(fromLoc(node, 'start') || defaultLoc, css.slice(0, mismatchOffset));\n end = fromLoc(badNode, 'end') ||\n buildLoc(start, css.substr(mismatchOffset, mismatchLength));\n }\n\n return {\n css,\n mismatchOffset,\n mismatchLength,\n start,\n end\n };\n}\n\nfunction fromLoc(node, point) {\n const value = node && node.loc && node.loc[point];\n\n if (value) {\n return 'line' in value ? buildLoc(value) : value;\n }\n\n return null;\n}\n\nfunction buildLoc({ offset, line, column }, extra) {\n const loc = {\n offset,\n line,\n column\n };\n\n if (extra) {\n const lines = extra.split(/\\n|\\r\\n?|\\f/);\n\n loc.offset += extra.length;\n loc.line += lines.length - 1;\n loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1;\n }\n\n return loc;\n}\n\nexport const SyntaxReferenceError = function(type, referenceName) {\n const error = createCustomError(\n 'SyntaxReferenceError',\n type + (referenceName ? ' `' + referenceName + '`' : '')\n );\n\n error.reference = referenceName;\n\n return error;\n};\n\nexport const SyntaxMatchError = function(message, syntax, node, matchResult) {\n const error = createCustomError('SyntaxMatchError', message);\n const {\n css,\n mismatchOffset,\n mismatchLength,\n start,\n end\n } = locateMismatch(matchResult, node);\n\n error.rawMessage = message;\n error.syntax = syntax ? generate(syntax) : '<generic>';\n error.css = css;\n error.mismatchOffset = mismatchOffset;\n error.mismatchLength = mismatchLength;\n error.message = message + '\\n' +\n ' syntax: ' + error.syntax + '\\n' +\n ' value: ' + (css || '<empty string>') + '\\n' +\n ' --------' + new Array(error.mismatchOffset + 1).join('-') + '^';\n\n Object.assign(error, start);\n error.loc = {\n source: (node && node.loc && node.loc.source) || '<unknown>',\n start,\n end\n };\n\n return error;\n};\n","const keywords = new Map();\nconst properties = new Map();\nconst HYPHENMINUS = 45; // '-'.charCodeAt()\n\nexport const keyword = getKeywordDescriptor;\nexport const property = getPropertyDescriptor;\nexport const vendorPrefix = getVendorPrefix;\nexport function isCustomProperty(str, offset) {\n offset = offset || 0;\n\n return str.length - offset >= 2 &&\n str.charCodeAt(offset) === HYPHENMINUS &&\n str.charCodeAt(offset + 1) === HYPHENMINUS;\n}\n\nfunction getVendorPrefix(str, offset) {\n offset = offset || 0;\n\n // verdor prefix should be at least 3 chars length\n if (str.length - offset >= 3) {\n // vendor prefix starts with hyper minus following non-hyper minus\n if (str.charCodeAt(offset) === HYPHENMINUS &&\n str.charCodeAt(offset + 1) !== HYPHENMINUS) {\n // vendor prefix should contain a hyper minus at the ending\n const secondDashIndex = str.indexOf('-', offset + 2);\n\n if (secondDashIndex !== -1) {\n return str.substring(offset, secondDashIndex + 1);\n }\n }\n }\n\n return '';\n}\n\nfunction getKeywordDescriptor(keyword) {\n if (keywords.has(keyword)) {\n return keywords.get(keyword);\n }\n\n const name = keyword.toLowerCase();\n let descriptor = keywords.get(name);\n\n if (descriptor === undefined) {\n const custom = isCustomProperty(name, 0);\n const vendor = !custom ? getVendorPrefix(name, 0) : '';\n descriptor = Object.freeze({\n basename: name.substr(vendor.length),\n name,\n prefix: vendor,\n vendor,\n custom\n });\n }\n\n keywords.set(keyword, descriptor);\n\n return descriptor;\n}\n\nfunction getPropertyDescriptor(property) {\n if (properties.has(property)) {\n return properties.get(property);\n }\n\n let name = property;\n let hack = property[0];\n\n if (hack === '/') {\n hack = property[1] === '/' ? '//' : '/';\n } else if (hack !== '_' &&\n hack !== '*' &&\n hack !== '$' &&\n hack !== '#' &&\n hack !== '+' &&\n hack !== '&') {\n hack = '';\n }\n\n const custom = isCustomProperty(name, hack.length);\n\n // re-use result when possible (the same as for lower case)\n if (!custom) {\n name = name.toLowerCase();\n if (properties.has(name)) {\n const descriptor = properties.get(name);\n properties.set(property, descriptor);\n return descriptor;\n }\n }\n\n const vendor = !custom ? getVendorPrefix(name, hack.length) : '';\n const prefix = name.substr(0, hack.length + vendor.length);\n const descriptor = Object.freeze({\n basename: name.substr(prefix.length),\n name: name.substr(hack.length),\n hack,\n vendor,\n prefix,\n custom\n });\n\n properties.set(property, descriptor);\n\n return descriptor;\n}\n","// https://drafts.csswg.org/css-cascade-5/\nexport const cssWideKeywords = [\n 'initial',\n 'inherit',\n 'unset',\n 'revert',\n 'revert-layer'\n];\n","import {\n isDigit,\n cmpChar,\n Delim,\n WhiteSpace,\n Comment,\n Ident,\n Number as NumberToken,\n Dimension\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst N = 0x006E; // U+006E LATIN SMALL LETTER N (n)\nconst DISALLOW_SIGN = true;\nconst ALLOW_SIGN = false;\n\nfunction isDelim(token, code) {\n return token !== null && token.type === Delim && token.value.charCodeAt(0) === code;\n}\n\nfunction skipSC(token, offset, getNextToken) {\n while (token !== null && (token.type === WhiteSpace || token.type === Comment)) {\n token = getNextToken(++offset);\n }\n\n return offset;\n}\n\nfunction checkInteger(token, valueOffset, disallowSign, offset) {\n if (!token) {\n return 0;\n }\n\n const code = token.value.charCodeAt(valueOffset);\n\n if (code === PLUSSIGN || code === HYPHENMINUS) {\n if (disallowSign) {\n // Number sign is not allowed\n return 0;\n }\n valueOffset++;\n }\n\n for (; valueOffset < token.value.length; valueOffset++) {\n if (!isDigit(token.value.charCodeAt(valueOffset))) {\n // Integer is expected\n return 0;\n }\n }\n\n return offset + 1;\n}\n\n// ... <signed-integer>\n// ... ['+' | '-'] <signless-integer>\nfunction consumeB(token, offset_, getNextToken) {\n let sign = false;\n let offset = skipSC(token, offset_, getNextToken);\n\n token = getNextToken(offset);\n\n if (token === null) {\n return offset_;\n }\n\n if (token.type !== NumberToken) {\n if (isDelim(token, PLUSSIGN) || isDelim(token, HYPHENMINUS)) {\n sign = true;\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n if (token === null || token.type !== NumberToken) {\n return 0;\n }\n } else {\n return offset_;\n }\n }\n\n if (!sign) {\n const code = token.value.charCodeAt(0);\n if (code !== PLUSSIGN && code !== HYPHENMINUS) {\n // Number sign is expected\n return 0;\n }\n }\n\n return checkInteger(token, sign ? 0 : 1, sign, offset);\n}\n\n// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb\nexport default function anPlusB(token, getNextToken) {\n /* eslint-disable brace-style*/\n let offset = 0;\n\n if (!token) {\n return 0;\n }\n\n // <integer>\n if (token.type === NumberToken) {\n return checkInteger(token, 0, ALLOW_SIGN, offset); // b\n }\n\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n // -n- <signless-integer>\n // <dashndashdigit-ident>\n else if (token.type === Ident && token.value.charCodeAt(0) === HYPHENMINUS) {\n // expect 1st char is N\n if (!cmpChar(token.value, 1, N)) {\n return 0;\n }\n\n switch (token.value.length) {\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n case 2:\n return consumeB(getNextToken(++offset), offset, getNextToken);\n\n // -n- <signless-integer>\n case 3:\n if (token.value.charCodeAt(2) !== HYPHENMINUS) {\n return 0;\n }\n\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n\n // <dashndashdigit-ident>\n default:\n if (token.value.charCodeAt(2) !== HYPHENMINUS) {\n return 0;\n }\n\n return checkInteger(token, 3, DISALLOW_SIGN, offset);\n }\n }\n\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n // '+'? n- <signless-integer>\n // '+'? <ndashdigit-ident>\n else if (token.type === Ident || (isDelim(token, PLUSSIGN) && getNextToken(offset + 1).type === Ident)) {\n // just ignore a plus\n if (token.type !== Ident) {\n token = getNextToken(++offset);\n }\n\n if (token === null || !cmpChar(token.value, 0, N)) {\n return 0;\n }\n\n switch (token.value.length) {\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n case 1:\n return consumeB(getNextToken(++offset), offset, getNextToken);\n\n // '+'? n- <signless-integer>\n case 2:\n if (token.value.charCodeAt(1) !== HYPHENMINUS) {\n return 0;\n }\n\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n\n // '+'? <ndashdigit-ident>\n default:\n if (token.value.charCodeAt(1) !== HYPHENMINUS) {\n return 0;\n }\n\n return checkInteger(token, 2, DISALLOW_SIGN, offset);\n }\n }\n\n // <ndashdigit-dimension>\n // <ndash-dimension> <signless-integer>\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n else if (token.type === Dimension) {\n let code = token.value.charCodeAt(0);\n let sign = code === PLUSSIGN || code === HYPHENMINUS ? 1 : 0;\n let i = sign;\n\n for (; i < token.value.length; i++) {\n if (!isDigit(token.value.charCodeAt(i))) {\n break;\n }\n }\n\n if (i === sign) {\n // Integer is expected\n return 0;\n }\n\n if (!cmpChar(token.value, i, N)) {\n return 0;\n }\n\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n if (i + 1 === token.value.length) {\n return consumeB(getNextToken(++offset), offset, getNextToken);\n } else {\n if (token.value.charCodeAt(i + 1) !== HYPHENMINUS) {\n return 0;\n }\n\n // <ndash-dimension> <signless-integer>\n if (i + 2 === token.value.length) {\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n }\n // <ndashdigit-dimension>\n else {\n return checkInteger(token, i + 2, DISALLOW_SIGN, offset);\n }\n }\n }\n\n return 0;\n};\n","import {\n isHexDigit,\n cmpChar,\n Ident,\n Delim,\n Number as NumberToken,\n Dimension\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)\nconst U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)\n\nfunction isDelim(token, code) {\n return token !== null && token.type === Delim && token.value.charCodeAt(0) === code;\n}\n\nfunction startsWith(token, code) {\n return token.value.charCodeAt(0) === code;\n}\n\nfunction hexSequence(token, offset, allowDash) {\n let hexlen = 0;\n\n for (let pos = offset; pos < token.value.length; pos++) {\n const code = token.value.charCodeAt(pos);\n\n if (code === HYPHENMINUS && allowDash && hexlen !== 0) {\n hexSequence(token, offset + hexlen + 1, false);\n return 6; // dissallow following question marks\n }\n\n if (!isHexDigit(code)) {\n return 0; // not a hex digit\n }\n\n if (++hexlen > 6) {\n return 0; // too many hex digits\n };\n }\n\n return hexlen;\n}\n\nfunction withQuestionMarkSequence(consumed, length, getNextToken) {\n if (!consumed) {\n return 0; // nothing consumed\n }\n\n while (isDelim(getNextToken(length), QUESTIONMARK)) {\n if (++consumed > 6) {\n return 0; // too many question marks\n }\n\n length++;\n }\n\n return length;\n}\n\n// https://drafts.csswg.org/css-syntax/#urange\n// Informally, the <urange> production has three forms:\n// U+0001\n// Defines a range consisting of a single code point, in this case the code point \"1\".\n// U+0001-00ff\n// Defines a range of codepoints between the first and the second value, in this case\n// the range between \"1\" and \"ff\" (255 in decimal) inclusive.\n// U+00??\n// Defines a range of codepoints where the \"?\" characters range over all hex digits,\n// in this case defining the same as the value U+0000-00ff.\n// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat \"?\" as a hexadecimal digit).\n//\n// <urange> =\n// u '+' <ident-token> '?'* |\n// u <dimension-token> '?'* |\n// u <number-token> '?'* |\n// u <number-token> <dimension-token> |\n// u <number-token> <number-token> |\n// u '+' '?'+\nexport default function urange(token, getNextToken) {\n let length = 0;\n\n // should start with `u` or `U`\n if (token === null || token.type !== Ident || !cmpChar(token.value, 0, U)) {\n return 0;\n }\n\n token = getNextToken(++length);\n if (token === null) {\n return 0;\n }\n\n // u '+' <ident-token> '?'*\n // u '+' '?'+\n if (isDelim(token, PLUSSIGN)) {\n token = getNextToken(++length);\n if (token === null) {\n return 0;\n }\n\n if (token.type === Ident) {\n // u '+' <ident-token> '?'*\n return withQuestionMarkSequence(hexSequence(token, 0, true), ++length, getNextToken);\n }\n\n if (isDelim(token, QUESTIONMARK)) {\n // u '+' '?'+\n return withQuestionMarkSequence(1, ++length, getNextToken);\n }\n\n // Hex digit or question mark is expected\n return 0;\n }\n\n // u <number-token> '?'*\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n if (token.type === NumberToken) {\n const consumedHexLength = hexSequence(token, 1, true);\n if (consumedHexLength === 0) {\n return 0;\n }\n\n token = getNextToken(++length);\n if (token === null) {\n // u <number-token> <eof>\n return length;\n }\n\n if (token.type === Dimension || token.type === NumberToken) {\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n if (!startsWith(token, HYPHENMINUS) || !hexSequence(token, 1, false)) {\n return 0;\n }\n\n return length + 1;\n }\n\n // u <number-token> '?'*\n return withQuestionMarkSequence(consumedHexLength, length, getNextToken);\n }\n\n // u <dimension-token> '?'*\n if (token.type === Dimension) {\n return withQuestionMarkSequence(hexSequence(token, 1, true), ++length, getNextToken);\n }\n\n return 0;\n};\n","import { cssWideKeywords } from './generic-const.js';\nimport anPlusB from './generic-an-plus-b.js';\nimport urange from './generic-urange.js';\nimport {\n isIdentifierStart,\n isHexDigit,\n isDigit,\n cmpStr,\n consumeNumber,\n\n Ident,\n Function as FunctionToken,\n AtKeyword,\n Hash,\n String as StringToken,\n BadString,\n Url,\n BadUrl,\n Delim,\n Number as NumberToken,\n Percentage,\n Dimension,\n WhiteSpace,\n CDO,\n CDC,\n Colon,\n Semicolon,\n Comma,\n LeftSquareBracket,\n RightSquareBracket,\n LeftParenthesis,\n RightParenthesis,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../tokenizer/index.js';\n\nconst calcFunctionNames = ['calc(', '-moz-calc(', '-webkit-calc('];\nconst balancePair = new Map([\n [FunctionToken, RightParenthesis],\n [LeftParenthesis, RightParenthesis],\n [LeftSquareBracket, RightSquareBracket],\n [LeftCurlyBracket, RightCurlyBracket]\n]);\n\n// safe char code getter\nfunction charCodeAt(str, index) {\n return index < str.length ? str.charCodeAt(index) : 0;\n}\n\nfunction eqStr(actual, expected) {\n return cmpStr(actual, 0, actual.length, expected);\n}\n\nfunction eqStrAny(actual, expected) {\n for (let i = 0; i < expected.length; i++) {\n if (eqStr(actual, expected[i])) {\n return true;\n }\n }\n\n return false;\n}\n\n// IE postfix hack, i.e. 123\\0 or 123px\\9\nfunction isPostfixIeHack(str, offset) {\n if (offset !== str.length - 2) {\n return false;\n }\n\n return (\n charCodeAt(str, offset) === 0x005C && // U+005C REVERSE SOLIDUS (\\)\n isDigit(charCodeAt(str, offset + 1))\n );\n}\n\nfunction outOfRange(opts, value, numEnd) {\n if (opts && opts.type === 'Range') {\n const num = Number(\n numEnd !== undefined && numEnd !== value.length\n ? value.substr(0, numEnd)\n : value\n );\n\n if (isNaN(num)) {\n return true;\n }\n\n // FIXME: when opts.min is a string it's a dimension, skip a range validation\n // for now since it requires a type covertation which is not implmented yet\n if (opts.min !== null && num < opts.min && typeof opts.min !== 'string') {\n return true;\n }\n\n // FIXME: when opts.max is a string it's a dimension, skip a range validation\n // for now since it requires a type covertation which is not implmented yet\n if (opts.max !== null && num > opts.max && typeof opts.max !== 'string') {\n return true;\n }\n }\n\n return false;\n}\n\nfunction consumeFunction(token, getNextToken) {\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // balanced token consuming\n scan:\n do {\n switch (token.type) {\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n\n if (balanceStash.length === 0) {\n length++;\n break scan;\n }\n\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n// TODO: implement\n// can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed\n// https://drafts.csswg.org/css-values/#calc-notation\nfunction calc(next) {\n return function(token, getNextToken, opts) {\n if (token === null) {\n return 0;\n }\n\n if (token.type === FunctionToken && eqStrAny(token.value, calcFunctionNames)) {\n return consumeFunction(token, getNextToken);\n }\n\n return next(token, getNextToken, opts);\n };\n}\n\nfunction tokenType(expectedTokenType) {\n return function(token) {\n if (token === null || token.type !== expectedTokenType) {\n return 0;\n }\n\n return 1;\n };\n}\n\n// =========================\n// Complex types\n//\n\n// https://drafts.csswg.org/css-values-4/#custom-idents\n// 4.2. Author-defined Identifiers: the <custom-ident> type\n// Some properties accept arbitrary author-defined identifiers as a component value.\n// This generic data type is denoted by <custom-ident>, and represents any valid CSS identifier\n// that would not be misinterpreted as a pre-defined keyword in that property’s value definition.\n//\n// See also: https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident\nfunction customIdent(token) {\n if (token === null || token.type !== Ident) {\n return 0;\n }\n\n const name = token.value.toLowerCase();\n\n // The CSS-wide keywords are not valid <custom-ident>s\n if (eqStrAny(name, cssWideKeywords)) {\n return 0;\n }\n\n // The default keyword is reserved and is also not a valid <custom-ident>\n if (eqStr(name, 'default')) {\n return 0;\n }\n\n // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)\n // Specifications using <custom-ident> must specify clearly what other keywords\n // are excluded from <custom-ident>, if any—for example by saying that any pre-defined keywords\n // in that property’s value definition are excluded. Excluded keywords are excluded\n // in all ASCII case permutations.\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-values-4/#dashed-idents\n// The <dashed-ident> production is a <custom-ident>, with all the case-sensitivity that implies,\n// with the additional restriction that it must start with two dashes (U+002D HYPHEN-MINUS).\nfunction dashedIdent(token) {\n if (token === null || token.type !== Ident) {\n return 0;\n }\n\n // ... must start with two dashes (U+002D HYPHEN-MINUS)\n if (charCodeAt(token.value, 0) !== 0x002D || charCodeAt(token.value, 1) !== 0x002D) {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-variables/#typedef-custom-property-name\n// A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo.\n// The <custom-property-name> production corresponds to this: it’s defined as any <dashed-ident>\n// (a valid identifier that starts with two dashes), except -- itself, which is reserved for future use by CSS.\nfunction customPropertyName(token) {\n // ... it’s defined as any <dashed-ident>\n if (!dashedIdent(token)) {\n return 0;\n }\n\n // ... except -- itself, which is reserved for future use by CSS\n if (token.value === '--') {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-color-4/#hex-notation\n// The syntax of a <hex-color> is a <hash-token> token whose value consists of 3, 4, 6, or 8 hexadecimal digits.\n// In other words, a hex color is written as a hash character, \"#\", followed by some number of digits 0-9 or\n// letters a-f (the case of the letters doesn’t matter - #00ff00 is identical to #00FF00).\nfunction hexColor(token) {\n if (token === null || token.type !== Hash) {\n return 0;\n }\n\n const length = token.value.length;\n\n // valid values (length): #rgb (4), #rgba (5), #rrggbb (7), #rrggbbaa (9)\n if (length !== 4 && length !== 5 && length !== 7 && length !== 9) {\n return 0;\n }\n\n for (let i = 1; i < length; i++) {\n if (!isHexDigit(charCodeAt(token.value, i))) {\n return 0;\n }\n }\n\n return 1;\n}\n\nfunction idSelector(token) {\n if (token === null || token.type !== Hash) {\n return 0;\n }\n\n if (!isIdentifierStart(charCodeAt(token.value, 1), charCodeAt(token.value, 2), charCodeAt(token.value, 3))) {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-syntax/#any-value\n// It represents the entirety of what a valid declaration can have as its value.\nfunction declarationValue(token, getNextToken) {\n if (!token) {\n return 0;\n }\n\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // The <declaration-value> production matches any sequence of one or more tokens,\n // so long as the sequence does not contain ...\n scan:\n do {\n switch (token.type) {\n // ... <bad-string-token>, <bad-url-token>,\n case BadString:\n case BadUrl:\n break scan;\n\n // ... unmatched <)-token>, <]-token>, or <}-token>,\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n break;\n\n // ... or top-level <semicolon-token> tokens\n case Semicolon:\n if (balanceCloseType === 0) {\n break scan;\n }\n\n break;\n\n // ... or <delim-token> tokens with a value of \"!\"\n case Delim:\n if (balanceCloseType === 0 && token.value === '!') {\n break scan;\n }\n\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n// https://drafts.csswg.org/css-syntax/#any-value\n// The <any-value> production is identical to <declaration-value>, but also\n// allows top-level <semicolon-token> tokens and <delim-token> tokens\n// with a value of \"!\". It represents the entirety of what valid CSS can be in any context.\nfunction anyValue(token, getNextToken) {\n if (!token) {\n return 0;\n }\n\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // The <any-value> production matches any sequence of one or more tokens,\n // so long as the sequence ...\n scan:\n do {\n switch (token.type) {\n // ... does not contain <bad-string-token>, <bad-url-token>,\n case BadString:\n case BadUrl:\n break scan;\n\n // ... unmatched <)-token>, <]-token>, or <}-token>,\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n// =========================\n// Dimensions\n//\n\nfunction dimension(type) {\n if (type) {\n type = new Set(type);\n }\n\n return function(token, getNextToken, opts) {\n if (token === null || token.type !== Dimension) {\n return 0;\n }\n\n const numberEnd = consumeNumber(token.value, 0);\n\n // check unit\n if (type !== null) {\n // check for IE postfix hack, i.e. 123px\\0 or 123px\\9\n const reverseSolidusOffset = token.value.indexOf('\\\\', numberEnd);\n const unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset)\n ? token.value.substr(numberEnd)\n : token.value.substring(numberEnd, reverseSolidusOffset);\n\n if (type.has(unit.toLowerCase()) === false) {\n return 0;\n }\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, numberEnd)) {\n return 0;\n }\n\n return 1;\n };\n}\n\n// =========================\n// Percentage\n//\n\n// §5.5. Percentages: the <percentage> type\n// https://drafts.csswg.org/css-values-4/#percentages\nfunction percentage(token, getNextToken, opts) {\n // ... corresponds to the <percentage-token> production\n if (token === null || token.type !== Percentage) {\n return 0;\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, token.value.length - 1)) {\n return 0;\n }\n\n return 1;\n}\n\n// =========================\n// Numeric\n//\n\n// https://drafts.csswg.org/css-values-4/#numbers\n// The value <zero> represents a literal number with the value 0. Expressions that merely\n// evaluate to a <number> with the value 0 (for example, calc(0)) do not match <zero>;\n// only literal <number-token>s do.\nfunction zero(next) {\n if (typeof next !== 'function') {\n next = function() {\n return 0;\n };\n }\n\n return function(token, getNextToken, opts) {\n if (token !== null && token.type === NumberToken) {\n if (Number(token.value) === 0) {\n return 1;\n }\n }\n\n return next(token, getNextToken, opts);\n };\n}\n\n// § 5.3. Real Numbers: the <number> type\n// https://drafts.csswg.org/css-values-4/#numbers\n// Number values are denoted by <number>, and represent real numbers, possibly with a fractional component.\n// ... It corresponds to the <number-token> production\nfunction number(token, getNextToken, opts) {\n if (token === null) {\n return 0;\n }\n\n const numberEnd = consumeNumber(token.value, 0);\n const isNumber = numberEnd === token.value.length;\n if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) {\n return 0;\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, numberEnd)) {\n return 0;\n }\n\n return 1;\n}\n\n// §5.2. Integers: the <integer> type\n// https://drafts.csswg.org/css-values-4/#integers\nfunction integer(token, getNextToken, opts) {\n // ... corresponds to a subset of the <number-token> production\n if (token === null || token.type !== NumberToken) {\n return 0;\n }\n\n // The first digit of an integer may be immediately preceded by `-` or `+` to indicate the integer’s sign.\n let i = charCodeAt(token.value, 0) === 0x002B || // U+002B PLUS SIGN (+)\n charCodeAt(token.value, 0) === 0x002D ? 1 : 0; // U+002D HYPHEN-MINUS (-)\n\n // When written literally, an integer is one or more decimal digits 0 through 9 ...\n for (; i < token.value.length; i++) {\n if (!isDigit(charCodeAt(token.value, i))) {\n return 0;\n }\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, i)) {\n return 0;\n }\n\n return 1;\n}\n\n// token types\nexport const tokenTypes = {\n 'ident-token': tokenType(Ident),\n 'function-token': tokenType(FunctionToken),\n 'at-keyword-token': tokenType(AtKeyword),\n 'hash-token': tokenType(Hash),\n 'string-token': tokenType(StringToken),\n 'bad-string-token': tokenType(BadString),\n 'url-token': tokenType(Url),\n 'bad-url-token': tokenType(BadUrl),\n 'delim-token': tokenType(Delim),\n 'number-token': tokenType(NumberToken),\n 'percentage-token': tokenType(Percentage),\n 'dimension-token': tokenType(Dimension),\n 'whitespace-token': tokenType(WhiteSpace),\n 'CDO-token': tokenType(CDO),\n 'CDC-token': tokenType(CDC),\n 'colon-token': tokenType(Colon),\n 'semicolon-token': tokenType(Semicolon),\n 'comma-token': tokenType(Comma),\n '[-token': tokenType(LeftSquareBracket),\n ']-token': tokenType(RightSquareBracket),\n '(-token': tokenType(LeftParenthesis),\n ')-token': tokenType(RightParenthesis),\n '{-token': tokenType(LeftCurlyBracket),\n '}-token': tokenType(RightCurlyBracket)\n};\n\n// token production types\nexport const productionTypes = {\n // token type aliases\n 'string': tokenType(StringToken),\n 'ident': tokenType(Ident),\n\n // percentage\n 'percentage': calc(percentage),\n\n // numeric\n 'zero': zero(),\n 'number': calc(number),\n 'integer': calc(integer),\n\n // complex types\n 'custom-ident': customIdent,\n 'dashed-ident': dashedIdent,\n 'custom-property-name': customPropertyName,\n 'hex-color': hexColor,\n 'id-selector': idSelector, // element( <id-selector> )\n 'an-plus-b': anPlusB,\n 'urange': urange,\n 'declaration-value': declarationValue,\n 'any-value': anyValue\n};\n\nexport const unitGroups = [\n 'length',\n 'angle',\n 'time',\n 'frequency',\n 'resolution',\n 'flex',\n 'decibel',\n 'semitones'\n];\n\n// dimensions types depend on units set\nexport function createDemensionTypes(units) {\n const {\n angle,\n decibel,\n frequency,\n flex,\n length,\n resolution,\n semitones,\n time\n } = units || {};\n\n return {\n 'dimension': calc(dimension(null)),\n 'angle': calc(dimension(angle)),\n 'decibel': calc(dimension(decibel)),\n 'frequency': calc(dimension(frequency)),\n 'flex': calc(dimension(flex)),\n 'length': calc(zero(dimension(length))),\n 'resolution': calc(dimension(resolution)),\n 'semitones': calc(dimension(semitones)),\n 'time': calc(dimension(time))\n };\n}\n\nexport function createGenericTypes(units) {\n return {\n ...tokenTypes,\n ...productionTypes,\n ...createDemensionTypes(units)\n };\n};\n","export const length = [\n // absolute length units https://www.w3.org/TR/css-values-3/#lengths\n 'cm', 'mm', 'q', 'in', 'pt', 'pc', 'px',\n // font-relative length units https://drafts.csswg.org/css-values-4/#font-relative-lengths\n 'em', 'rem',\n 'ex', 'rex',\n 'cap', 'rcap',\n 'ch', 'rch',\n 'ic', 'ric',\n 'lh', 'rlh',\n // viewport-percentage lengths https://drafts.csswg.org/css-values-4/#viewport-relative-lengths\n 'vw', 'svw', 'lvw', 'dvw',\n 'vh', 'svh', 'lvh', 'dvh',\n 'vi', 'svi', 'lvi', 'dvi',\n 'vb', 'svb', 'lvb', 'dvb',\n 'vmin', 'svmin', 'lvmin', 'dvmin',\n 'vmax', 'svmax', 'lvmax', 'dvmax',\n // container relative lengths https://drafts.csswg.org/css-contain-3/#container-lengths\n 'cqw', 'cqh', 'cqi', 'cqb', 'cqmin', 'cqmax'\n];\nexport const angle = ['deg', 'grad', 'rad', 'turn']; // https://www.w3.org/TR/css-values-3/#angles\nexport const time = ['s', 'ms']; // https://www.w3.org/TR/css-values-3/#time\nexport const frequency = ['hz', 'khz']; // https://www.w3.org/TR/css-values-3/#frequency\nexport const resolution = ['dpi', 'dpcm', 'dppx', 'x']; // https://www.w3.org/TR/css-values-3/#resolution\nexport const flex = ['fr']; // https://drafts.csswg.org/css-grid/#fr-unit\nexport const decibel = ['db']; // https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume\nexport const semitones = ['st']; // https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch\n","import { createCustomError } from '../utils/create-custom-error.js';\n\nexport function SyntaxError(message, input, offset) {\n return Object.assign(createCustomError('SyntaxError', message), {\n input,\n offset,\n rawMessage: message,\n message: message + '\\n' +\n ' ' + input + '\\n' +\n '--' + new Array((offset || input.length) + 1).join('-') + '^'\n });\n};\n","import { SyntaxError } from './SyntaxError.js';\n\nconst TAB = 9;\nconst N = 10;\nconst F = 12;\nconst R = 13;\nconst SPACE = 32;\nconst NAME_CHAR = new Uint8Array(128).map((_, idx) =>\n /[a-zA-Z0-9\\-]/.test(String.fromCharCode(idx)) ? 1 : 0\n);\n\nexport class Scanner {\n constructor(str) {\n this.str = str;\n this.pos = 0;\n }\n\n charCodeAt(pos) {\n return pos < this.str.length ? this.str.charCodeAt(pos) : 0;\n }\n charCode() {\n return this.charCodeAt(this.pos);\n }\n isNameCharCode(code = this.charCode()) {\n return code < 128 && NAME_CHAR[code] === 1;\n }\n nextCharCode() {\n return this.charCodeAt(this.pos + 1);\n }\n nextNonWsCode(pos) {\n return this.charCodeAt(this.findWsEnd(pos));\n }\n skipWs() {\n this.pos = this.findWsEnd(this.pos);\n }\n findWsEnd(pos) {\n for (; pos < this.str.length; pos++) {\n const code = this.str.charCodeAt(pos);\n if (code !== R && code !== N && code !== F && code !== SPACE && code !== TAB) {\n break;\n }\n }\n\n return pos;\n }\n substringToPos(end) {\n return this.str.substring(this.pos, this.pos = end);\n }\n eat(code) {\n if (this.charCode() !== code) {\n this.error('Expect `' + String.fromCharCode(code) + '`');\n }\n\n this.pos++;\n }\n peek() {\n return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';\n }\n error(message) {\n throw new SyntaxError(message, this.str, this.pos);\n }\n\n scanSpaces() {\n return this.substringToPos(this.findWsEnd(this.pos));\n }\n scanWord() {\n let end = this.pos;\n\n for (; end < this.str.length; end++) {\n const code = this.str.charCodeAt(end);\n if (code >= 128 || NAME_CHAR[code] === 0) {\n break;\n }\n }\n\n if (this.pos === end) {\n this.error('Expect a keyword');\n }\n\n return this.substringToPos(end);\n }\n scanNumber() {\n let end = this.pos;\n\n for (; end < this.str.length; end++) {\n const code = this.str.charCodeAt(end);\n\n if (code < 48 || code > 57) {\n break;\n }\n }\n\n if (this.pos === end) {\n this.error('Expect a number');\n }\n\n return this.substringToPos(end);\n }\n scanString() {\n const end = this.str.indexOf('\\'', this.pos + 1);\n\n if (end === -1) {\n this.pos = this.str.length;\n this.error('Expect an apostrophe');\n }\n\n return this.substringToPos(end + 1);\n }\n};\n","import { Scanner } from './scanner.js';\n\nconst TAB = 9;\nconst N = 10;\nconst F = 12;\nconst R = 13;\nconst SPACE = 32;\nconst EXCLAMATIONMARK = 33; // !\nconst NUMBERSIGN = 35; // #\nconst AMPERSAND = 38; // &\nconst APOSTROPHE = 39; // '\nconst LEFTPARENTHESIS = 40; // (\nconst RIGHTPARENTHESIS = 41; // )\nconst ASTERISK = 42; // *\nconst PLUSSIGN = 43; // +\nconst COMMA = 44; // ,\nconst HYPERMINUS = 45; // -\nconst LESSTHANSIGN = 60; // <\nconst GREATERTHANSIGN = 62; // >\nconst QUESTIONMARK = 63; // ?\nconst COMMERCIALAT = 64; // @\nconst LEFTSQUAREBRACKET = 91; // [\nconst RIGHTSQUAREBRACKET = 93; // ]\nconst LEFTCURLYBRACKET = 123; // {\nconst VERTICALLINE = 124; // |\nconst RIGHTCURLYBRACKET = 125; // }\nconst INFINITY = 8734; // ∞\nconst COMBINATOR_PRECEDENCE = {\n ' ': 1,\n '&&': 2,\n '||': 3,\n '|': 4\n};\n\nfunction readMultiplierRange(scanner) {\n let min = null;\n let max = null;\n\n scanner.eat(LEFTCURLYBRACKET);\n scanner.skipWs();\n\n min = scanner.scanNumber(scanner);\n scanner.skipWs();\n\n if (scanner.charCode() === COMMA) {\n scanner.pos++;\n scanner.skipWs();\n\n if (scanner.charCode() !== RIGHTCURLYBRACKET) {\n max = scanner.scanNumber(scanner);\n scanner.skipWs();\n }\n } else {\n max = min;\n }\n\n scanner.eat(RIGHTCURLYBRACKET);\n\n return {\n min: Number(min),\n max: max ? Number(max) : 0\n };\n}\n\nfunction readMultiplier(scanner) {\n let range = null;\n let comma = false;\n\n switch (scanner.charCode()) {\n case ASTERISK:\n scanner.pos++;\n\n range = {\n min: 0,\n max: 0\n };\n\n break;\n\n case PLUSSIGN:\n scanner.pos++;\n\n range = {\n min: 1,\n max: 0\n };\n\n break;\n\n case QUESTIONMARK:\n scanner.pos++;\n\n range = {\n min: 0,\n max: 1\n };\n\n break;\n\n case NUMBERSIGN:\n scanner.pos++;\n\n comma = true;\n\n if (scanner.charCode() === LEFTCURLYBRACKET) {\n range = readMultiplierRange(scanner);\n } else if (scanner.charCode() === QUESTIONMARK) {\n // https://www.w3.org/TR/css-values-4/#component-multipliers\n // > the # and ? multipliers may be stacked as #?\n // In this case just treat \"#?\" as a single multiplier\n // { min: 0, max: 0, comma: true }\n scanner.pos++;\n range = {\n min: 0,\n max: 0\n };\n } else {\n range = {\n min: 1,\n max: 0\n };\n }\n\n break;\n\n case LEFTCURLYBRACKET:\n range = readMultiplierRange(scanner);\n break;\n\n default:\n return null;\n }\n\n return {\n type: 'Multiplier',\n comma,\n min: range.min,\n max: range.max,\n term: null\n };\n}\n\nfunction maybeMultiplied(scanner, node) {\n const multiplier = readMultiplier(scanner);\n\n if (multiplier !== null) {\n multiplier.term = node;\n\n // https://www.w3.org/TR/css-values-4/#component-multipliers\n // > The + and # multipliers may be stacked as +#;\n // Represent \"+#\" as nested multipliers:\n // { ...<multiplier #>,\n // term: {\n // ...<multipler +>,\n // term: node\n // }\n // }\n if (scanner.charCode() === NUMBERSIGN &&\n scanner.charCodeAt(scanner.pos - 1) === PLUSSIGN) {\n return maybeMultiplied(scanner, multiplier);\n }\n\n return multiplier;\n }\n\n return node;\n}\n\nfunction maybeToken(scanner) {\n const ch = scanner.peek();\n\n if (ch === '') {\n return null;\n }\n\n return maybeMultiplied(scanner, {\n type: 'Token',\n value: ch\n });\n}\n\nfunction readProperty(scanner) {\n let name;\n\n scanner.eat(LESSTHANSIGN);\n scanner.eat(APOSTROPHE);\n\n name = scanner.scanWord();\n\n scanner.eat(APOSTROPHE);\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Property',\n name\n });\n}\n\n// https://drafts.csswg.org/css-values-3/#numeric-ranges\n// 4.1. Range Restrictions and Range Definition Notation\n//\n// Range restrictions can be annotated in the numeric type notation using CSS bracketed\n// range notation—[min,max]—within the angle brackets, after the identifying keyword,\n// indicating a closed range between (and including) min and max.\n// For example, <integer [0, 10]> indicates an integer between 0 and 10, inclusive.\nfunction readTypeRange(scanner) {\n // use null for Infinity to make AST format JSON serializable/deserializable\n let min = null; // -Infinity\n let max = null; // Infinity\n let sign = 1;\n\n scanner.eat(LEFTSQUAREBRACKET);\n\n if (scanner.charCode() === HYPERMINUS) {\n scanner.peek();\n sign = -1;\n }\n\n if (sign == -1 && scanner.charCode() === INFINITY) {\n scanner.peek();\n } else {\n min = sign * Number(scanner.scanNumber(scanner));\n\n if (scanner.isNameCharCode()) {\n min += scanner.scanWord();\n }\n }\n\n scanner.skipWs();\n scanner.eat(COMMA);\n scanner.skipWs();\n\n if (scanner.charCode() === INFINITY) {\n scanner.peek();\n } else {\n sign = 1;\n\n if (scanner.charCode() === HYPERMINUS) {\n scanner.peek();\n sign = -1;\n }\n\n max = sign * Number(scanner.scanNumber(scanner));\n\n if (scanner.isNameCharCode()) {\n max += scanner.scanWord();\n }\n }\n\n scanner.eat(RIGHTSQUAREBRACKET);\n\n return {\n type: 'Range',\n min,\n max\n };\n}\n\nfunction readType(scanner) {\n let name;\n let opts = null;\n\n scanner.eat(LESSTHANSIGN);\n name = scanner.scanWord();\n\n // https://drafts.csswg.org/css-values-5/#boolean\n if (name === 'boolean-expr') {\n scanner.eat(LEFTSQUAREBRACKET);\n\n const implicitGroup = readImplicitGroup(scanner, RIGHTSQUAREBRACKET);\n\n scanner.eat(RIGHTSQUAREBRACKET);\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Boolean',\n term: implicitGroup.terms.length === 1\n ? implicitGroup.terms[0]\n : implicitGroup\n });\n }\n\n if (scanner.charCode() === LEFTPARENTHESIS &&\n scanner.nextCharCode() === RIGHTPARENTHESIS) {\n scanner.pos += 2;\n name += '()';\n }\n\n if (scanner.charCodeAt(scanner.findWsEnd(scanner.pos)) === LEFTSQUAREBRACKET) {\n scanner.skipWs();\n opts = readTypeRange(scanner);\n }\n\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Type',\n name,\n opts\n });\n}\n\nfunction readKeywordOrFunction(scanner) {\n const name = scanner.scanWord();\n\n if (scanner.charCode() === LEFTPARENTHESIS) {\n scanner.pos++;\n\n return {\n type: 'Function',\n name\n };\n }\n\n return maybeMultiplied(scanner, {\n type: 'Keyword',\n name\n });\n}\n\nfunction regroupTerms(terms, combinators) {\n function createGroup(terms, combinator) {\n return {\n type: 'Group',\n terms,\n combinator,\n disallowEmpty: false,\n explicit: false\n };\n }\n\n let combinator;\n\n combinators = Object.keys(combinators)\n .sort((a, b) => COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b]);\n\n while (combinators.length > 0) {\n combinator = combinators.shift();\n\n let i = 0;\n let subgroupStart = 0;\n\n for (; i < terms.length; i++) {\n const term = terms[i];\n\n if (term.type === 'Combinator') {\n if (term.value === combinator) {\n if (subgroupStart === -1) {\n subgroupStart = i - 1;\n }\n terms.splice(i, 1);\n i--;\n } else {\n if (subgroupStart !== -1 && i - subgroupStart > 1) {\n terms.splice(\n subgroupStart,\n i - subgroupStart,\n createGroup(terms.slice(subgroupStart, i), combinator)\n );\n i = subgroupStart + 1;\n }\n subgroupStart = -1;\n }\n }\n }\n\n if (subgroupStart !== -1 && combinators.length) {\n terms.splice(\n subgroupStart,\n i - subgroupStart,\n createGroup(terms.slice(subgroupStart, i), combinator)\n );\n }\n }\n\n return combinator;\n}\n\nfunction readImplicitGroup(scanner, stopCharCode) {\n const combinators = Object.create(null);\n const terms = [];\n let token;\n let prevToken = null;\n let prevTokenPos = scanner.pos;\n\n while (scanner.charCode() !== stopCharCode && (token = peek(scanner, stopCharCode))) {\n if (token.type !== 'Spaces') {\n if (token.type === 'Combinator') {\n // check for combinator in group beginning and double combinator sequence\n if (prevToken === null || prevToken.type === 'Combinator') {\n scanner.pos = prevTokenPos;\n scanner.error('Unexpected combinator');\n }\n\n combinators[token.value] = true;\n } else if (prevToken !== null && prevToken.type !== 'Combinator') {\n combinators[' '] = true; // a b\n terms.push({\n type: 'Combinator',\n value: ' '\n });\n }\n\n terms.push(token);\n prevToken = token;\n prevTokenPos = scanner.pos;\n }\n }\n\n // check for combinator in group ending\n if (prevToken !== null && prevToken.type === 'Combinator') {\n scanner.pos -= prevTokenPos;\n scanner.error('Unexpected combinator');\n }\n\n return {\n type: 'Group',\n terms,\n combinator: regroupTerms(terms, combinators) || ' ',\n disallowEmpty: false,\n explicit: false\n };\n}\n\nfunction readGroup(scanner, stopCharCode) {\n let result;\n\n scanner.eat(LEFTSQUAREBRACKET);\n result = readImplicitGroup(scanner, stopCharCode);\n scanner.eat(RIGHTSQUAREBRACKET);\n\n result.explicit = true;\n\n if (scanner.charCode() === EXCLAMATIONMARK) {\n scanner.pos++;\n result.disallowEmpty = true;\n }\n\n return result;\n}\n\nfunction peek(scanner, stopCharCode) {\n let code = scanner.charCode();\n\n switch (code) {\n case RIGHTSQUAREBRACKET:\n // don't eat, stop scan a group\n break;\n\n case LEFTSQUAREBRACKET:\n return maybeMultiplied(scanner, readGroup(scanner, stopCharCode));\n\n case LESSTHANSIGN:\n return scanner.nextCharCode() === APOSTROPHE\n ? readProperty(scanner)\n : readType(scanner);\n\n case VERTICALLINE:\n return {\n type: 'Combinator',\n value: scanner.substringToPos(\n scanner.pos + (scanner.nextCharCode() === VERTICALLINE ? 2 : 1)\n )\n };\n\n case AMPERSAND:\n scanner.pos++;\n scanner.eat(AMPERSAND);\n\n return {\n type: 'Combinator',\n value: '&&'\n };\n\n case COMMA:\n scanner.pos++;\n return {\n type: 'Comma'\n };\n\n case APOSTROPHE:\n return maybeMultiplied(scanner, {\n type: 'String',\n value: scanner.scanString()\n });\n\n case SPACE:\n case TAB:\n case N:\n case R:\n case F:\n return {\n type: 'Spaces',\n value: scanner.scanSpaces()\n };\n\n case COMMERCIALAT:\n code = scanner.nextCharCode();\n\n if (scanner.isNameCharCode(code)) {\n scanner.pos++;\n return {\n type: 'AtKeyword',\n name: scanner.scanWord()\n };\n }\n\n return maybeToken(scanner);\n\n case ASTERISK:\n case PLUSSIGN:\n case QUESTIONMARK:\n case NUMBERSIGN:\n case EXCLAMATIONMARK:\n // prohibited tokens (used as a multiplier start)\n break;\n\n case LEFTCURLYBRACKET:\n // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting\n // check next char isn't a number, because it's likely a disjoined multiplier\n code = scanner.nextCharCode();\n\n if (code < 48 || code > 57) {\n return maybeToken(scanner);\n }\n\n break;\n\n default:\n if (scanner.isNameCharCode(code)) {\n return readKeywordOrFunction(scanner);\n }\n\n return maybeToken(scanner);\n }\n}\n\nexport function parse(source) {\n const scanner = new Scanner(source);\n const result = readImplicitGroup(scanner);\n\n if (scanner.pos !== source.length) {\n scanner.error('Unexpected input');\n }\n\n // reduce redundant groups with single group term\n if (result.terms.length === 1 && result.terms[0].type === 'Group') {\n return result.terms[0];\n }\n\n return result;\n};\n","const noop = function() {};\n\nfunction ensureFunction(value) {\n return typeof value === 'function' ? value : noop;\n}\n\nexport function walk(node, options, context) {\n function walk(node) {\n enter.call(context, node);\n\n switch (node.type) {\n case 'Group':\n node.terms.forEach(walk);\n break;\n\n case 'Multiplier':\n case 'Boolean':\n walk(node.term);\n break;\n\n case 'Type':\n case 'Property':\n case 'Keyword':\n case 'AtKeyword':\n case 'Function':\n case 'String':\n case 'Token':\n case 'Comma':\n break;\n\n default:\n throw new Error('Unknown type: ' + node.type);\n }\n\n leave.call(context, node);\n }\n\n let enter = noop;\n let leave = noop;\n\n if (typeof options === 'function') {\n enter = options;\n } else if (options) {\n enter = ensureFunction(options.enter);\n leave = ensureFunction(options.leave);\n }\n\n if (enter === noop && leave === noop) {\n throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\\'t a function');\n }\n\n walk(node, context);\n};\n","import { tokenize } from '../tokenizer/index.js';\n\nconst astToTokens = {\n decorator(handlers) {\n const tokens = [];\n let curNode = null;\n\n return {\n ...handlers,\n node(node) {\n const tmp = curNode;\n curNode = node;\n handlers.node.call(this, node);\n curNode = tmp;\n },\n emit(value, type, auto) {\n tokens.push({\n type,\n value,\n node: auto ? null : curNode\n });\n },\n result() {\n return tokens;\n }\n };\n }\n};\n\nfunction stringToTokens(str) {\n const tokens = [];\n\n tokenize(str, (type, start, end) =>\n tokens.push({\n type,\n value: str.slice(start, end),\n node: null\n })\n );\n\n return tokens;\n}\n\nexport default function(value, syntax) {\n if (typeof value === 'string') {\n return stringToTokens(value);\n }\n\n return syntax.generate(value, astToTokens);\n};\n","import { parse } from '../definition-syntax/parse.js';\n\nexport const MATCH = { type: 'Match' };\nexport const MISMATCH = { type: 'Mismatch' };\nexport const DISALLOW_EMPTY = { type: 'DisallowEmpty' };\n\nconst LEFTPARENTHESIS = 40; // (\nconst RIGHTPARENTHESIS = 41; // )\n\nfunction createCondition(match, thenBranch, elseBranch) {\n // reduce node count\n if (thenBranch === MATCH && elseBranch === MISMATCH) {\n return match;\n }\n\n if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {\n return match;\n }\n\n if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {\n thenBranch = match.then;\n match = match.match;\n }\n\n return {\n type: 'If',\n match,\n then: thenBranch,\n else: elseBranch\n };\n}\n\nfunction isFunctionType(name) {\n return (\n name.length > 2 &&\n name.charCodeAt(name.length - 2) === LEFTPARENTHESIS &&\n name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS\n );\n}\n\nfunction isEnumCapatible(term) {\n return (\n term.type === 'Keyword' ||\n term.type === 'AtKeyword' ||\n term.type === 'Function' ||\n term.type === 'Type' && isFunctionType(term.name)\n );\n}\n\nfunction groupNode(terms, combinator = ' ', explicit = false) {\n return {\n type: 'Group',\n terms,\n combinator,\n disallowEmpty: false,\n explicit\n };\n}\n\nfunction replaceTypeInGraph(node, replacements, visited = new Set()) {\n if (!visited.has(node)) {\n visited.add(node);\n\n switch (node.type) {\n case 'If':\n node.match = replaceTypeInGraph(node.match, replacements, visited);\n node.then = replaceTypeInGraph(node.then, replacements, visited);\n node.else = replaceTypeInGraph(node.else, replacements, visited);\n break;\n\n case 'Type':\n return replacements[node.name] || node;\n }\n }\n\n return node;\n}\n\nfunction buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {\n switch (combinator) {\n case ' ': {\n // Juxtaposing components means that all of them must occur, in the given order.\n //\n // a b c\n // =\n // match a\n // then match b\n // then match c\n // then MATCH\n // else MISMATCH\n // else MISMATCH\n // else MISMATCH\n let result = MATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n\n result = createCondition(\n term,\n result,\n MISMATCH\n );\n };\n\n return result;\n }\n\n case '|': {\n // A bar (|) separates two or more alternatives: exactly one of them must occur.\n //\n // a | b | c\n // =\n // match a\n // then MATCH\n // else match b\n // then MATCH\n // else match c\n // then MATCH\n // else MISMATCH\n\n let result = MISMATCH;\n let map = null;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n let term = terms[i];\n\n // reduce sequence of keywords into a Enum\n if (isEnumCapatible(term)) {\n if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {\n map = Object.create(null);\n result = createCondition(\n {\n type: 'Enum',\n map\n },\n MATCH,\n result\n );\n }\n\n if (map !== null) {\n const key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();\n if (key in map === false) {\n map[key] = term;\n continue;\n }\n }\n }\n\n map = null;\n\n // create a new conditonal node\n result = createCondition(\n term,\n MATCH,\n result\n );\n };\n\n return result;\n }\n\n case '&&': {\n // A double ampersand (&&) separates two or more components,\n // all of which must occur, in any order.\n\n // Use MatchOnce for groups with a large number of terms,\n // since &&-groups produces at least N!-node trees\n if (terms.length > 5) {\n return {\n type: 'MatchOnce',\n terms,\n all: true\n };\n }\n\n // Use a combination tree for groups with small number of terms\n //\n // a && b && c\n // =\n // match a\n // then [b && c]\n // else match b\n // then [a && c]\n // else match c\n // then [a && b]\n // else MISMATCH\n //\n // a && b\n // =\n // match a\n // then match b\n // then MATCH\n // else MISMATCH\n // else match b\n // then match a\n // then MATCH\n // else MISMATCH\n // else MISMATCH\n let result = MISMATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n let thenClause;\n\n if (terms.length > 1) {\n thenClause = buildGroupMatchGraph(\n combinator,\n terms.filter(function(newGroupTerm) {\n return newGroupTerm !== term;\n }),\n false\n );\n } else {\n thenClause = MATCH;\n }\n\n result = createCondition(\n term,\n thenClause,\n result\n );\n };\n\n return result;\n }\n\n case '||': {\n // A double bar (||) separates two or more options:\n // one or more of them must occur, in any order.\n\n // Use MatchOnce for groups with a large number of terms,\n // since ||-groups produces at least N!-node trees\n if (terms.length > 5) {\n return {\n type: 'MatchOnce',\n terms,\n all: false\n };\n }\n\n // Use a combination tree for groups with small number of terms\n //\n // a || b || c\n // =\n // match a\n // then [b || c]\n // else match b\n // then [a || c]\n // else match c\n // then [a || b]\n // else MISMATCH\n //\n // a || b\n // =\n // match a\n // then match b\n // then MATCH\n // else MATCH\n // else match b\n // then match a\n // then MATCH\n // else MATCH\n // else MISMATCH\n let result = atLeastOneTermMatched ? MATCH : MISMATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n let thenClause;\n\n if (terms.length > 1) {\n thenClause = buildGroupMatchGraph(\n combinator,\n terms.filter(function(newGroupTerm) {\n return newGroupTerm !== term;\n }),\n true\n );\n } else {\n thenClause = MATCH;\n }\n\n result = createCondition(\n term,\n thenClause,\n result\n );\n };\n\n return result;\n }\n }\n}\n\nfunction buildMultiplierMatchGraph(node) {\n let result = MATCH;\n let matchTerm = buildMatchGraphInternal(node.term);\n\n if (node.max === 0) {\n // disable repeating of empty match to prevent infinite loop\n matchTerm = createCondition(\n matchTerm,\n DISALLOW_EMPTY,\n MISMATCH\n );\n\n // an occurrence count is not limited, make a cycle;\n // to collect more terms on each following matching mismatch\n result = createCondition(\n matchTerm,\n null, // will be a loop\n MISMATCH\n );\n\n result.then = createCondition(\n MATCH,\n MATCH,\n result // make a loop\n );\n\n if (node.comma) {\n result.then.else = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n } else {\n // create a match node chain for [min .. max] interval with optional matches\n for (let i = node.min || 1; i <= node.max; i++) {\n if (node.comma && result !== MATCH) {\n result = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n\n result = createCondition(\n matchTerm,\n createCondition(\n MATCH,\n MATCH,\n result\n ),\n MISMATCH\n );\n }\n }\n\n if (node.min === 0) {\n // allow zero match\n result = createCondition(\n MATCH,\n MATCH,\n result\n );\n } else {\n // create a match node chain to collect [0 ... min - 1] required matches\n for (let i = 0; i < node.min - 1; i++) {\n if (node.comma && result !== MATCH) {\n result = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n\n result = createCondition(\n matchTerm,\n result,\n MISMATCH\n );\n }\n }\n\n return result;\n}\n\nfunction buildMatchGraphInternal(node) {\n if (typeof node === 'function') {\n return {\n type: 'Generic',\n fn: node\n };\n }\n\n switch (node.type) {\n case 'Group': {\n let result = buildGroupMatchGraph(\n node.combinator,\n node.terms.map(buildMatchGraphInternal),\n false\n );\n\n if (node.disallowEmpty) {\n result = createCondition(\n result,\n DISALLOW_EMPTY,\n MISMATCH\n );\n }\n\n return result;\n }\n\n case 'Multiplier':\n return buildMultiplierMatchGraph(node);\n\n // https://drafts.csswg.org/css-values-5/#boolean\n case 'Boolean': {\n const term = buildMatchGraphInternal(node.term);\n // <boolean-expr[ <test> ]> = not <boolean-expr-group> | <boolean-expr-group> [ [ and <boolean-expr-group> ]* | [ or <boolean-expr-group> ]* ]\n const matchNode = buildMatchGraphInternal(groupNode([\n groupNode([\n { type: 'Keyword', name: 'not' },\n { type: 'Type', name: '!boolean-group' }\n ]),\n groupNode([\n { type: 'Type', name: '!boolean-group' },\n groupNode([\n { type: 'Multiplier', comma: false, min: 0, max: 0, term: groupNode([\n { type: 'Keyword', name: 'and' },\n { type: 'Type', name: '!boolean-group' }\n ]) },\n { type: 'Multiplier', comma: false, min: 0, max: 0, term: groupNode([\n { type: 'Keyword', name: 'or' },\n { type: 'Type', name: '!boolean-group' }\n ]) }\n ], '|')\n ])\n ], '|'));\n // <boolean-expr-group> = <test> | ( <boolean-expr[ <test> ]> ) | <general-enclosed>\n const booleanGroup = buildMatchGraphInternal(\n groupNode([\n { type: 'Type', name: '!term' },\n groupNode([\n { type: 'Token', value: '(' },\n { type: 'Type', name: '!self' },\n { type: 'Token', value: ')' }\n ]),\n { type: 'Type', name: 'general-enclosed' }\n ], '|')\n );\n\n replaceTypeInGraph(booleanGroup, { '!term': term, '!self': matchNode });\n replaceTypeInGraph(matchNode, { '!boolean-group': booleanGroup });\n\n return matchNode;\n }\n\n case 'Type':\n case 'Property':\n return {\n type: node.type,\n name: node.name,\n syntax: node\n };\n\n case 'Keyword':\n return {\n type: node.type,\n name: node.name.toLowerCase(),\n syntax: node\n };\n\n case 'AtKeyword':\n return {\n type: node.type,\n name: '@' + node.name.toLowerCase(),\n syntax: node\n };\n\n case 'Function':\n return {\n type: node.type,\n name: node.name.toLowerCase() + '(',\n syntax: node\n };\n\n case 'String':\n // convert a one char length String to a Token\n if (node.value.length === 3) {\n return {\n type: 'Token',\n value: node.value.charAt(1),\n syntax: node\n };\n }\n\n // otherwise use it as is\n return {\n type: node.type,\n value: node.value.substr(1, node.value.length - 2).replace(/\\\\'/g, '\\''),\n syntax: node\n };\n\n case 'Token':\n return {\n type: node.type,\n value: node.value,\n syntax: node\n };\n\n case 'Comma':\n return {\n type: node.type,\n syntax: node\n };\n\n default:\n throw new Error('Unknown node type:', node.type);\n }\n}\n\nexport function buildMatchGraph(syntaxTree, ref) {\n if (typeof syntaxTree === 'string') {\n syntaxTree = parse(syntaxTree);\n }\n\n return {\n type: 'MatchGraph',\n match: buildMatchGraphInternal(syntaxTree),\n syntax: ref || null,\n source: syntaxTree\n };\n}\n","import { MATCH, MISMATCH, DISALLOW_EMPTY } from './match-graph.js';\nimport * as TYPE from '../tokenizer/types.js';\n\nconst { hasOwnProperty } = Object.prototype;\nconst STUB = 0;\nconst TOKEN = 1;\nconst OPEN_SYNTAX = 2;\nconst CLOSE_SYNTAX = 3;\n\nconst EXIT_REASON_MATCH = 'Match';\nconst EXIT_REASON_MISMATCH = 'Mismatch';\nconst EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';\n\nconst ITERATION_LIMIT = 15000;\nexport let totalIterationCount = 0;\n\nfunction reverseList(list) {\n let prev = null;\n let next = null;\n let item = list;\n\n while (item !== null) {\n next = item.prev;\n item.prev = prev;\n prev = item;\n item = next;\n }\n\n return prev;\n}\n\nfunction areStringsEqualCaseInsensitive(testStr, referenceStr) {\n if (testStr.length !== referenceStr.length) {\n return false;\n }\n\n for (let i = 0; i < testStr.length; i++) {\n const referenceCode = referenceStr.charCodeAt(i);\n let testCode = testStr.charCodeAt(i);\n\n // testCode.toLowerCase() for U+0041 LATIN CAPITAL LETTER A (A) .. U+005A LATIN CAPITAL LETTER Z (Z).\n if (testCode >= 0x0041 && testCode <= 0x005A) {\n testCode = testCode | 32;\n }\n\n if (testCode !== referenceCode) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction isContextEdgeDelim(token) {\n if (token.type !== TYPE.Delim) {\n return false;\n }\n\n // Fix matching for unicode-range: U+30??, U+FF00-FF9F\n // Probably we need to check out previous match instead\n return token.value !== '?';\n}\n\nfunction isCommaContextStart(token) {\n if (token === null) {\n return true;\n }\n\n return (\n token.type === TYPE.Comma ||\n token.type === TYPE.Function ||\n token.type === TYPE.LeftParenthesis ||\n token.type === TYPE.LeftSquareBracket ||\n token.type === TYPE.LeftCurlyBracket ||\n isContextEdgeDelim(token)\n );\n}\n\nfunction isCommaContextEnd(token) {\n if (token === null) {\n return true;\n }\n\n return (\n token.type === TYPE.RightParenthesis ||\n token.type === TYPE.RightSquareBracket ||\n token.type === TYPE.RightCurlyBracket ||\n (token.type === TYPE.Delim && token.value === '/')\n );\n}\n\nfunction internalMatch(tokens, state, syntaxes) {\n function moveToNextToken() {\n do {\n tokenIndex++;\n token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;\n } while (token !== null && (token.type === TYPE.WhiteSpace || token.type === TYPE.Comment));\n }\n\n function getNextToken(offset) {\n const nextIndex = tokenIndex + offset;\n\n return nextIndex < tokens.length ? tokens[nextIndex] : null;\n }\n\n function stateSnapshotFromSyntax(nextState, prev) {\n return {\n nextState,\n matchStack,\n syntaxStack,\n thenStack,\n tokenIndex,\n prev\n };\n }\n\n function pushThenStack(nextState) {\n thenStack = {\n nextState,\n matchStack,\n syntaxStack,\n prev: thenStack\n };\n }\n\n function pushElseStack(nextState) {\n elseStack = stateSnapshotFromSyntax(nextState, elseStack);\n }\n\n function addTokenToMatch() {\n matchStack = {\n type: TOKEN,\n syntax: state.syntax,\n token,\n prev: matchStack\n };\n\n moveToNextToken();\n syntaxStash = null;\n\n if (tokenIndex > longestMatch) {\n longestMatch = tokenIndex;\n }\n }\n\n function openSyntax() {\n syntaxStack = {\n syntax: state.syntax,\n opts: state.syntax.opts || (syntaxStack !== null && syntaxStack.opts) || null,\n prev: syntaxStack\n };\n\n matchStack = {\n type: OPEN_SYNTAX,\n syntax: state.syntax,\n token: matchStack.token,\n prev: matchStack\n };\n }\n\n function closeSyntax() {\n if (matchStack.type === OPEN_SYNTAX) {\n matchStack = matchStack.prev;\n } else {\n matchStack = {\n type: CLOSE_SYNTAX,\n syntax: syntaxStack.syntax,\n token: matchStack.token,\n prev: matchStack\n };\n }\n\n syntaxStack = syntaxStack.prev;\n }\n\n let syntaxStack = null;\n let thenStack = null;\n let elseStack = null;\n\n // null – stashing allowed, nothing stashed\n // false – stashing disabled, nothing stashed\n // anithing else – fail stashable syntaxes, some syntax stashed\n let syntaxStash = null;\n\n let iterationCount = 0; // count iterations and prevent infinite loop\n let exitReason = null;\n\n let token = null;\n let tokenIndex = -1;\n let longestMatch = 0;\n let matchStack = {\n type: STUB,\n syntax: null,\n token: null,\n prev: null\n };\n\n moveToNextToken();\n\n while (exitReason === null && ++iterationCount < ITERATION_LIMIT) {\n // function mapList(list, fn) {\n // const result = [];\n // while (list) {\n // result.unshift(fn(list));\n // list = list.prev;\n // }\n // return result;\n // }\n // console.log('--\\n',\n // '#' + iterationCount,\n // require('util').inspect({\n // 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),\n // token: token && token.value,\n // tokenIndex,\n // syntax: syntax.type + (syntax.id ? ' #' + syntax.id : '')\n // }, { depth: null })\n // );\n switch (state.type) {\n case 'Match':\n if (thenStack === null) {\n // turn to MISMATCH when some tokens left unmatched\n if (token !== null) {\n // doesn't mismatch if just one token left and it's an IE hack\n if (tokenIndex !== tokens.length - 1 || (token.value !== '\\\\0' && token.value !== '\\\\9')) {\n state = MISMATCH;\n break;\n }\n }\n\n // break the main loop, return a result - MATCH\n exitReason = EXIT_REASON_MATCH;\n break;\n }\n\n // go to next syntax (`then` branch)\n state = thenStack.nextState;\n\n // check match is not empty\n if (state === DISALLOW_EMPTY) {\n if (thenStack.matchStack === matchStack) {\n state = MISMATCH;\n break;\n } else {\n state = MATCH;\n }\n }\n\n // close syntax if needed\n while (thenStack.syntaxStack !== syntaxStack) {\n closeSyntax();\n }\n\n // pop stack\n thenStack = thenStack.prev;\n break;\n\n case 'Mismatch':\n // when some syntax is stashed\n if (syntaxStash !== null && syntaxStash !== false) {\n // there is no else branches or a branch reduce match stack\n if (elseStack === null || tokenIndex > elseStack.tokenIndex) {\n // restore state from the stash\n elseStack = syntaxStash;\n syntaxStash = false; // disable stashing\n }\n } else if (elseStack === null) {\n // no else branches -> break the main loop\n // return a result - MISMATCH\n exitReason = EXIT_REASON_MISMATCH;\n break;\n }\n\n // go to next syntax (`else` branch)\n state = elseStack.nextState;\n\n // restore all the rest stack states\n thenStack = elseStack.thenStack;\n syntaxStack = elseStack.syntaxStack;\n matchStack = elseStack.matchStack;\n tokenIndex = elseStack.tokenIndex;\n token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;\n\n // pop stack\n elseStack = elseStack.prev;\n break;\n\n case 'MatchGraph':\n state = state.match;\n break;\n\n case 'If':\n // IMPORTANT: else stack push must go first,\n // since it stores the state of thenStack before changes\n if (state.else !== MISMATCH) {\n pushElseStack(state.else);\n }\n\n if (state.then !== MATCH) {\n pushThenStack(state.then);\n }\n\n state = state.match;\n break;\n\n case 'MatchOnce':\n state = {\n type: 'MatchOnceBuffer',\n syntax: state,\n index: 0,\n mask: 0\n };\n break;\n\n case 'MatchOnceBuffer': {\n const terms = state.syntax.terms;\n\n if (state.index === terms.length) {\n // no matches at all or it's required all terms to be matched\n if (state.mask === 0 || state.syntax.all) {\n state = MISMATCH;\n break;\n }\n\n // a partial match is ok\n state = MATCH;\n break;\n }\n\n // all terms are matched\n if (state.mask === (1 << terms.length) - 1) {\n state = MATCH;\n break;\n }\n\n for (; state.index < terms.length; state.index++) {\n const matchFlag = 1 << state.index;\n\n if ((state.mask & matchFlag) === 0) {\n // IMPORTANT: else stack push must go first,\n // since it stores the state of thenStack before changes\n pushElseStack(state);\n pushThenStack({\n type: 'AddMatchOnce',\n syntax: state.syntax,\n mask: state.mask | matchFlag\n });\n\n // match\n state = terms[state.index++];\n break;\n }\n }\n break;\n }\n\n case 'AddMatchOnce':\n state = {\n type: 'MatchOnceBuffer',\n syntax: state.syntax,\n index: 0,\n mask: state.mask\n };\n break;\n\n case 'Enum':\n if (token !== null) {\n let name = token.value.toLowerCase();\n\n // drop \\0 and \\9 hack from keyword name\n if (name.indexOf('\\\\') !== -1) {\n name = name.replace(/\\\\[09].*$/, '');\n }\n\n if (hasOwnProperty.call(state.map, name)) {\n state = state.map[name];\n break;\n }\n }\n\n state = MISMATCH;\n break;\n\n case 'Generic': {\n const opts = syntaxStack !== null ? syntaxStack.opts : null;\n const lastTokenIndex = tokenIndex + Math.floor(state.fn(token, getNextToken, opts));\n\n if (!isNaN(lastTokenIndex) && lastTokenIndex > tokenIndex) {\n while (tokenIndex < lastTokenIndex) {\n addTokenToMatch();\n }\n\n state = MATCH;\n } else {\n state = MISMATCH;\n }\n\n break;\n }\n\n case 'Type':\n case 'Property': {\n const syntaxDict = state.type === 'Type' ? 'types' : 'properties';\n const dictSyntax = hasOwnProperty.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null;\n\n if (!dictSyntax || !dictSyntax.match) {\n throw new Error(\n 'Bad syntax reference: ' +\n (state.type === 'Type'\n ? '<' + state.name + '>'\n : '<\\'' + state.name + '\\'>')\n );\n }\n\n // stash a syntax for types with low priority\n if (syntaxStash !== false && token !== null && state.type === 'Type') {\n const lowPriorityMatching =\n // https://drafts.csswg.org/css-values-4/#custom-idents\n // When parsing positionally-ambiguous keywords in a property value, a <custom-ident> production\n // can only claim the keyword if no other unfulfilled production can claim it.\n (state.name === 'custom-ident' && token.type === TYPE.Ident) ||\n\n // https://drafts.csswg.org/css-values-4/#lengths\n // ... if a `0` could be parsed as either a <number> or a <length> in a property (such as line-height),\n // it must parse as a <number>\n (state.name === 'length' && token.value === '0');\n\n if (lowPriorityMatching) {\n if (syntaxStash === null) {\n syntaxStash = stateSnapshotFromSyntax(state, elseStack);\n }\n\n state = MISMATCH;\n break;\n }\n }\n\n openSyntax();\n state = dictSyntax.matchRef || dictSyntax.match;\n break;\n }\n\n case 'Keyword': {\n const name = state.name;\n\n if (token !== null) {\n let keywordName = token.value;\n\n // drop \\0 and \\9 hack from keyword name\n if (keywordName.indexOf('\\\\') !== -1) {\n keywordName = keywordName.replace(/\\\\[09].*$/, '');\n }\n\n if (areStringsEqualCaseInsensitive(keywordName, name)) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n }\n\n state = MISMATCH;\n break;\n }\n\n case 'AtKeyword':\n case 'Function':\n if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n\n state = MISMATCH;\n break;\n\n case 'Token':\n if (token !== null && token.value === state.value) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n\n state = MISMATCH;\n break;\n\n case 'Comma':\n if (token !== null && token.type === TYPE.Comma) {\n if (isCommaContextStart(matchStack.token)) {\n state = MISMATCH;\n } else {\n addTokenToMatch();\n state = isCommaContextEnd(token) ? MISMATCH : MATCH;\n }\n } else {\n state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH : MISMATCH;\n }\n\n break;\n\n case 'String':\n let string = '';\n let lastTokenIndex = tokenIndex;\n\n for (; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) {\n string += tokens[lastTokenIndex].value;\n }\n\n if (areStringsEqualCaseInsensitive(string, state.value)) {\n while (tokenIndex < lastTokenIndex) {\n addTokenToMatch();\n }\n\n state = MATCH;\n } else {\n state = MISMATCH;\n }\n\n break;\n\n default:\n throw new Error('Unknown node type: ' + state.type);\n }\n }\n\n totalIterationCount += iterationCount;\n\n switch (exitReason) {\n case null:\n console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');\n exitReason = EXIT_REASON_ITERATION_LIMIT;\n matchStack = null;\n break;\n\n case EXIT_REASON_MATCH:\n while (syntaxStack !== null) {\n closeSyntax();\n }\n break;\n\n default:\n matchStack = null;\n }\n\n return {\n tokens,\n reason: exitReason,\n iterations: iterationCount,\n match: matchStack,\n longestMatch\n };\n}\n\nexport function matchAsList(tokens, matchGraph, syntaxes) {\n const matchResult = internalMatch(tokens, matchGraph, syntaxes || {});\n\n if (matchResult.match !== null) {\n let item = reverseList(matchResult.match).prev;\n\n matchResult.match = [];\n\n while (item !== null) {\n switch (item.type) {\n case OPEN_SYNTAX:\n case CLOSE_SYNTAX:\n matchResult.match.push({\n type: item.type,\n syntax: item.syntax\n });\n break;\n\n default:\n matchResult.match.push({\n token: item.token.value,\n node: item.token.node\n });\n break;\n }\n\n item = item.prev;\n }\n }\n\n return matchResult;\n}\n\nexport function matchAsTree(tokens, matchGraph, syntaxes) {\n const matchResult = internalMatch(tokens, matchGraph, syntaxes || {});\n\n if (matchResult.match === null) {\n return matchResult;\n }\n\n let item = matchResult.match;\n let host = matchResult.match = {\n syntax: matchGraph.syntax || null,\n match: []\n };\n const hostStack = [host];\n\n // revert a list and start with 2nd item since 1st is a stub item\n item = reverseList(item).prev;\n\n // build a tree\n while (item !== null) {\n switch (item.type) {\n case OPEN_SYNTAX:\n host.match.push(host = {\n syntax: item.syntax,\n match: []\n });\n hostStack.push(host);\n break;\n\n case CLOSE_SYNTAX:\n hostStack.pop();\n host = hostStack[hostStack.length - 1];\n break;\n\n default:\n host.match.push({\n syntax: item.syntax || null,\n token: item.token.value,\n node: item.token.node\n });\n }\n\n item = item.prev;\n }\n\n return matchResult;\n}\n","export function getTrace(node) {\n function shouldPutToTrace(syntax) {\n if (syntax === null) {\n return false;\n }\n\n return (\n syntax.type === 'Type' ||\n syntax.type === 'Property' ||\n syntax.type === 'Keyword'\n );\n }\n\n function hasMatch(matchNode) {\n if (Array.isArray(matchNode.match)) {\n // use for-loop for better perfomance\n for (let i = 0; i < matchNode.match.length; i++) {\n if (hasMatch(matchNode.match[i])) {\n if (shouldPutToTrace(matchNode.syntax)) {\n result.unshift(matchNode.syntax);\n }\n\n return true;\n }\n }\n } else if (matchNode.node === node) {\n result = shouldPutToTrace(matchNode.syntax)\n ? [matchNode.syntax]\n : [];\n\n return true;\n }\n\n return false;\n }\n\n let result = null;\n\n if (this.matched !== null) {\n hasMatch(this.matched);\n }\n\n return result;\n}\n\nexport function isType(node, type) {\n return testNode(this, node, match => match.type === 'Type' && match.name === type);\n}\n\nexport function isProperty(node, property) {\n return testNode(this, node, match => match.type === 'Property' && match.name === property);\n}\n\nexport function isKeyword(node) {\n return testNode(this, node, match => match.type === 'Keyword');\n}\n\nfunction testNode(match, node, fn) {\n const trace = getTrace.call(match, node);\n\n if (trace === null) {\n return false;\n }\n\n return trace.some(fn);\n}\n","import { List } from '../utils/List.js';\n\nfunction getFirstMatchNode(matchNode) {\n if ('node' in matchNode) {\n return matchNode.node;\n }\n\n return getFirstMatchNode(matchNode.match[0]);\n}\n\nfunction getLastMatchNode(matchNode) {\n if ('node' in matchNode) {\n return matchNode.node;\n }\n\n return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);\n}\n\nexport function matchFragments(lexer, ast, match, type, name) {\n function findFragments(matchNode) {\n if (matchNode.syntax !== null &&\n matchNode.syntax.type === type &&\n matchNode.syntax.name === name) {\n const start = getFirstMatchNode(matchNode);\n const end = getLastMatchNode(matchNode);\n\n lexer.syntax.walk(ast, function(node, item, list) {\n if (node === start) {\n const nodes = new List();\n\n do {\n nodes.appendData(item.data);\n\n if (item.data === end) {\n break;\n }\n\n item = item.next;\n } while (item !== null);\n\n fragments.push({\n parent: list,\n nodes\n });\n }\n });\n }\n\n if (Array.isArray(matchNode.match)) {\n matchNode.match.forEach(findFragments);\n }\n }\n\n const fragments = [];\n\n if (match.matched !== null) {\n findFragments(match.matched);\n }\n\n return fragments;\n}\n","import { List } from '../utils/List.js';\n\nconst { hasOwnProperty } = Object.prototype;\n\nfunction isValidNumber(value) {\n // Number.isInteger(value) && value >= 0\n return (\n typeof value === 'number' &&\n isFinite(value) &&\n Math.floor(value) === value &&\n value >= 0\n );\n}\n\nfunction isValidLocation(loc) {\n return (\n Boolean(loc) &&\n isValidNumber(loc.offset) &&\n isValidNumber(loc.line) &&\n isValidNumber(loc.column)\n );\n}\n\nfunction createNodeStructureChecker(type, fields) {\n return function checkNode(node, warn) {\n if (!node || node.constructor !== Object) {\n return warn(node, 'Type of node should be an Object');\n }\n\n for (let key in node) {\n let valid = true;\n\n if (hasOwnProperty.call(node, key) === false) {\n continue;\n }\n\n if (key === 'type') {\n if (node.type !== type) {\n warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');\n }\n } else if (key === 'loc') {\n if (node.loc === null) {\n continue;\n } else if (node.loc && node.loc.constructor === Object) {\n if (typeof node.loc.source !== 'string') {\n key += '.source';\n } else if (!isValidLocation(node.loc.start)) {\n key += '.start';\n } else if (!isValidLocation(node.loc.end)) {\n key += '.end';\n } else {\n continue;\n }\n }\n\n valid = false;\n } else if (fields.hasOwnProperty(key)) {\n valid = false;\n\n for (let i = 0; !valid && i < fields[key].length; i++) {\n const fieldType = fields[key][i];\n\n switch (fieldType) {\n case String:\n valid = typeof node[key] === 'string';\n break;\n\n case Boolean:\n valid = typeof node[key] === 'boolean';\n break;\n\n case null:\n valid = node[key] === null;\n break;\n\n default:\n if (typeof fieldType === 'string') {\n valid = node[key] && node[key].type === fieldType;\n } else if (Array.isArray(fieldType)) {\n valid = node[key] instanceof List;\n }\n }\n }\n } else {\n warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');\n }\n\n if (!valid) {\n warn(node, 'Bad value for `' + type + '.' + key + '`');\n }\n }\n\n for (const key in fields) {\n if (hasOwnProperty.call(fields, key) &&\n hasOwnProperty.call(node, key) === false) {\n warn(node, 'Field `' + type + '.' + key + '` is missed');\n }\n }\n };\n}\n\nfunction genTypesList(fieldTypes, path) {\n const docsTypes = [];\n\n for (let i = 0; i < fieldTypes.length; i++) {\n const fieldType = fieldTypes[i];\n if (fieldType === String || fieldType === Boolean) {\n docsTypes.push(fieldType.name.toLowerCase());\n } else if (fieldType === null) {\n docsTypes.push('null');\n } else if (typeof fieldType === 'string') {\n docsTypes.push(fieldType);\n } else if (Array.isArray(fieldType)) {\n docsTypes.push('List<' + (genTypesList(fieldType, path) || 'any') + '>'); // TODO: use type enum\n } else {\n throw new Error('Wrong value `' + fieldType + '` in `' + path + '` structure definition');\n }\n }\n\n return docsTypes.join(' | ');\n}\n\nfunction processStructure(name, nodeType) {\n const structure = nodeType.structure;\n const fields = {\n type: String,\n loc: true\n };\n const docs = {\n type: '\"' + name + '\"'\n };\n\n for (const key in structure) {\n if (hasOwnProperty.call(structure, key) === false) {\n continue;\n }\n\n const fieldTypes = fields[key] = Array.isArray(structure[key])\n ? structure[key].slice()\n : [structure[key]];\n\n docs[key] = genTypesList(fieldTypes, name + '.' + key);\n }\n\n return {\n docs,\n check: createNodeStructureChecker(name, fields)\n };\n}\n\nexport function getStructureFromConfig(config) {\n const structure = {};\n\n if (config.node) {\n for (const name in config.node) {\n if (hasOwnProperty.call(config.node, name)) {\n const nodeType = config.node[name];\n\n if (nodeType.structure) {\n structure[name] = processStructure(name, nodeType);\n } else {\n throw new Error('Missed `structure` field in `' + name + '` node type definition');\n }\n }\n }\n }\n\n return structure;\n};\n","import { SyntaxReferenceError, SyntaxMatchError } from './error.js';\nimport * as names from '../utils/names.js';\nimport { cssWideKeywords } from './generic-const.js';\nimport { createGenericTypes } from './generic.js';\nimport * as units from './units.js';\nimport { parse, generate, walk } from '../definition-syntax/index.js';\nimport prepareTokens from './prepare-tokens.js';\nimport { buildMatchGraph } from './match-graph.js';\nimport { matchAsTree } from './match.js';\nimport * as trace from './trace.js';\nimport { matchFragments } from './search.js';\nimport { getStructureFromConfig } from './structure.js';\n\nfunction dumpMapSyntax(map, compact, syntaxAsAst) {\n const result = {};\n\n for (const name in map) {\n if (map[name].syntax) {\n result[name] = syntaxAsAst\n ? map[name].syntax\n : generate(map[name].syntax, { compact });\n }\n }\n\n return result;\n}\n\nfunction dumpAtruleMapSyntax(map, compact, syntaxAsAst) {\n const result = {};\n\n for (const [name, atrule] of Object.entries(map)) {\n result[name] = {\n prelude: atrule.prelude && (\n syntaxAsAst\n ? atrule.prelude.syntax\n : generate(atrule.prelude.syntax, { compact })\n ),\n descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)\n };\n }\n\n return result;\n}\n\nfunction valueHasVar(tokens) {\n for (let i = 0; i < tokens.length; i++) {\n if (tokens[i].value.toLowerCase() === 'var(') {\n return true;\n }\n }\n\n return false;\n}\n\nfunction syntaxHasTopLevelCommaMultiplier(syntax) {\n const singleTerm = syntax.terms[0];\n\n return (\n syntax.explicit === false &&\n syntax.terms.length === 1 &&\n singleTerm.type === 'Multiplier' &&\n singleTerm.comma === true\n );\n}\n\nfunction buildMatchResult(matched, error, iterations) {\n return {\n matched,\n iterations,\n error,\n ...trace\n };\n}\n\nfunction matchSyntax(lexer, syntax, value, useCssWideKeywords) {\n const tokens = prepareTokens(value, lexer.syntax);\n let result;\n\n if (valueHasVar(tokens)) {\n return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));\n }\n\n if (useCssWideKeywords) {\n result = matchAsTree(tokens, lexer.cssWideKeywordsSyntax, lexer);\n }\n\n if (!useCssWideKeywords || !result.match) {\n result = matchAsTree(tokens, syntax.match, lexer);\n if (!result.match) {\n return buildMatchResult(\n null,\n new SyntaxMatchError(result.reason, syntax.syntax, value, result),\n result.iterations\n );\n }\n }\n\n return buildMatchResult(result.match, null, result.iterations);\n}\n\nexport class Lexer {\n constructor(config, syntax, structure) {\n this.cssWideKeywords = cssWideKeywords;\n this.syntax = syntax;\n this.generic = false;\n this.units = { ...units };\n this.atrules = Object.create(null);\n this.properties = Object.create(null);\n this.types = Object.create(null);\n this.structure = structure || getStructureFromConfig(config);\n\n if (config) {\n if (config.cssWideKeywords) {\n this.cssWideKeywords = config.cssWideKeywords;\n }\n\n if (config.units) {\n for (const group of Object.keys(units)) {\n if (Array.isArray(config.units[group])) {\n this.units[group] = config.units[group];\n }\n }\n }\n\n if (config.types) {\n for (const [name, type] of Object.entries(config.types)) {\n this.addType_(name, type);\n }\n }\n\n if (config.generic) {\n this.generic = true;\n for (const [name, value] of Object.entries(createGenericTypes(this.units))) {\n this.addType_(name, value);\n }\n }\n\n if (config.atrules) {\n for (const [name, atrule] of Object.entries(config.atrules)) {\n this.addAtrule_(name, atrule);\n }\n }\n\n if (config.properties) {\n for (const [name, property] of Object.entries(config.properties)) {\n this.addProperty_(name, property);\n }\n }\n }\n\n this.cssWideKeywordsSyntax = buildMatchGraph(this.cssWideKeywords.join(' | '));\n }\n\n checkStructure(ast) {\n function collectWarning(node, message) {\n warns.push({ node, message });\n }\n\n const structure = this.structure;\n const warns = [];\n\n this.syntax.walk(ast, function(node) {\n if (structure.hasOwnProperty(node.type)) {\n structure[node.type].check(node, collectWarning);\n } else {\n collectWarning(node, 'Unknown node type `' + node.type + '`');\n }\n });\n\n return warns.length ? warns : false;\n }\n\n createDescriptor(syntax, type, name, parent = null) {\n const ref = {\n type,\n name\n };\n const descriptor = {\n type,\n name,\n parent,\n serializable: typeof syntax === 'string' || (syntax && typeof syntax.type === 'string'),\n syntax: null,\n match: null,\n matchRef: null // used for properties when a syntax referenced as <'property'> in other syntax definitions\n };\n\n if (typeof syntax === 'function') {\n descriptor.match = buildMatchGraph(syntax, ref);\n } else {\n if (typeof syntax === 'string') {\n // lazy parsing on first access\n Object.defineProperty(descriptor, 'syntax', {\n get() {\n Object.defineProperty(descriptor, 'syntax', {\n value: parse(syntax)\n });\n\n return descriptor.syntax;\n }\n });\n } else {\n descriptor.syntax = syntax;\n }\n\n // lazy graph build on first access\n Object.defineProperty(descriptor, 'match', {\n get() {\n Object.defineProperty(descriptor, 'match', {\n value: buildMatchGraph(descriptor.syntax, ref)\n });\n\n return descriptor.match;\n }\n });\n\n if (type === 'Property') {\n Object.defineProperty(descriptor, 'matchRef', {\n get() {\n const syntax = descriptor.syntax;\n const value = syntaxHasTopLevelCommaMultiplier(syntax)\n ? buildMatchGraph({\n ...syntax,\n terms: [syntax.terms[0].term]\n }, ref)\n : null;\n\n Object.defineProperty(descriptor, 'matchRef', {\n value\n });\n\n return value;\n }\n });\n }\n }\n\n return descriptor;\n }\n addAtrule_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.atrules[name] = {\n type: 'Atrule',\n name: name,\n prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,\n descriptors: syntax.descriptors\n ? Object.keys(syntax.descriptors).reduce(\n (map, descName) => {\n map[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);\n return map;\n },\n Object.create(null)\n )\n : null\n };\n }\n addProperty_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.properties[name] = this.createDescriptor(syntax, 'Property', name);\n }\n addType_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.types[name] = this.createDescriptor(syntax, 'Type', name);\n }\n\n checkAtruleName(atruleName) {\n if (!this.getAtrule(atruleName)) {\n return new SyntaxReferenceError('Unknown at-rule', '@' + atruleName);\n }\n }\n checkAtrulePrelude(atruleName, prelude) {\n const error = this.checkAtruleName(atruleName);\n\n if (error) {\n return error;\n }\n\n const atrule = this.getAtrule(atruleName);\n\n if (!atrule.prelude && prelude) {\n return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');\n }\n\n if (atrule.prelude && !prelude) {\n if (!matchSyntax(this, atrule.prelude, '', false).matched) {\n return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');\n }\n }\n }\n checkAtruleDescriptorName(atruleName, descriptorName) {\n const error = this.checkAtruleName(atruleName);\n\n if (error) {\n return error;\n }\n\n const atrule = this.getAtrule(atruleName);\n const descriptor = names.keyword(descriptorName);\n\n if (!atrule.descriptors) {\n return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');\n }\n\n if (!atrule.descriptors[descriptor.name] &&\n !atrule.descriptors[descriptor.basename]) {\n return new SyntaxReferenceError('Unknown at-rule descriptor', descriptorName);\n }\n }\n checkPropertyName(propertyName) {\n if (!this.getProperty(propertyName)) {\n return new SyntaxReferenceError('Unknown property', propertyName);\n }\n }\n\n matchAtrulePrelude(atruleName, prelude) {\n const error = this.checkAtrulePrelude(atruleName, prelude);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n const atrule = this.getAtrule(atruleName);\n\n if (!atrule.prelude) {\n return buildMatchResult(null, null);\n }\n\n return matchSyntax(this, atrule.prelude, prelude || '', false);\n }\n matchAtruleDescriptor(atruleName, descriptorName, value) {\n const error = this.checkAtruleDescriptorName(atruleName, descriptorName);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n const atrule = this.getAtrule(atruleName);\n const descriptor = names.keyword(descriptorName);\n\n return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);\n }\n matchDeclaration(node) {\n if (node.type !== 'Declaration') {\n return buildMatchResult(null, new Error('Not a Declaration node'));\n }\n\n return this.matchProperty(node.property, node.value);\n }\n matchProperty(propertyName, value) {\n // don't match syntax for a custom property at the moment\n if (names.property(propertyName).custom) {\n return buildMatchResult(null, new Error('Lexer matching doesn\\'t applicable for custom properties'));\n }\n\n const error = this.checkPropertyName(propertyName);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n return matchSyntax(this, this.getProperty(propertyName), value, true);\n }\n matchType(typeName, value) {\n const typeSyntax = this.getType(typeName);\n\n if (!typeSyntax) {\n return buildMatchResult(null, new SyntaxReferenceError('Unknown type', typeName));\n }\n\n return matchSyntax(this, typeSyntax, value, false);\n }\n match(syntax, value) {\n if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {\n return buildMatchResult(null, new SyntaxReferenceError('Bad syntax'));\n }\n\n if (typeof syntax === 'string' || !syntax.match) {\n syntax = this.createDescriptor(syntax, 'Type', 'anonymous');\n }\n\n return matchSyntax(this, syntax, value, false);\n }\n\n findValueFragments(propertyName, value, type, name) {\n return matchFragments(this, value, this.matchProperty(propertyName, value), type, name);\n }\n findDeclarationValueFragments(declaration, type, name) {\n return matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);\n }\n findAllFragments(ast, type, name) {\n const result = [];\n\n this.syntax.walk(ast, {\n visit: 'Declaration',\n enter: (declaration) => {\n result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));\n }\n });\n\n return result;\n }\n\n getAtrule(atruleName, fallbackBasename = true) {\n const atrule = names.keyword(atruleName);\n const atruleEntry = atrule.vendor && fallbackBasename\n ? this.atrules[atrule.name] || this.atrules[atrule.basename]\n : this.atrules[atrule.name];\n\n return atruleEntry || null;\n }\n getAtrulePrelude(atruleName, fallbackBasename = true) {\n const atrule = this.getAtrule(atruleName, fallbackBasename);\n\n return atrule && atrule.prelude || null;\n }\n getAtruleDescriptor(atruleName, name) {\n return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators\n ? this.atrules[atruleName].declarators[name] || null\n : null;\n }\n getProperty(propertyName, fallbackBasename = true) {\n const property = names.property(propertyName);\n const propertyEntry = property.vendor && fallbackBasename\n ? this.properties[property.name] || this.properties[property.basename]\n : this.properties[property.name];\n\n return propertyEntry || null;\n }\n getType(name) {\n return hasOwnProperty.call(this.types, name) ? this.types[name] : null;\n }\n\n validate() {\n function syntaxRef(name, isType) {\n return isType ? `<${name}>` : `<'${name}'>`;\n }\n\n function validate(syntax, name, broken, descriptor) {\n if (broken.has(name)) {\n return broken.get(name);\n }\n\n broken.set(name, false);\n if (descriptor.syntax !== null) {\n walk(descriptor.syntax, function(node) {\n if (node.type !== 'Type' && node.type !== 'Property') {\n return;\n }\n\n const map = node.type === 'Type' ? syntax.types : syntax.properties;\n const brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;\n\n if (!hasOwnProperty.call(map, node.name)) {\n errors.push(`${syntaxRef(name, broken === brokenTypes)} used missed syntax definition ${syntaxRef(node.name, node.type === 'Type')}`);\n broken.set(name, true);\n } else if (validate(syntax, node.name, brokenMap, map[node.name])) {\n errors.push(`${syntaxRef(name, broken === brokenTypes)} used broken syntax definition ${syntaxRef(node.name, node.type === 'Type')}`);\n broken.set(name, true);\n }\n }, this);\n }\n }\n\n const errors = [];\n let brokenTypes = new Map();\n let brokenProperties = new Map();\n\n for (const key in this.types) {\n validate(this, key, brokenTypes, this.types[key]);\n }\n\n for (const key in this.properties) {\n validate(this, key, brokenProperties, this.properties[key]);\n }\n\n const brokenTypesArray = [...brokenTypes.keys()].filter(name => brokenTypes.get(name));\n const brokenPropertiesArray = [...brokenProperties.keys()].filter(name => brokenProperties.get(name));\n\n if (brokenTypesArray.length || brokenPropertiesArray.length) {\n return {\n errors,\n types: brokenTypesArray,\n properties: brokenPropertiesArray\n };\n }\n\n return null;\n }\n dump(syntaxAsAst, pretty) {\n return {\n generic: this.generic,\n cssWideKeywords: this.cssWideKeywords,\n units: this.units,\n types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),\n properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),\n atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)\n };\n }\n toString() {\n return JSON.stringify(this.dump());\n }\n};\n","function appendOrSet(a, b) {\n if (typeof b === 'string' && /^\\s*\\|/.test(b)) {\n return typeof a === 'string'\n ? a + b\n : b.replace(/^\\s*\\|\\s*/, '');\n }\n\n return b || null;\n}\n\nfunction sliceProps(obj, props) {\n const result = Object.create(null);\n\n for (const [key, value] of Object.entries(obj)) {\n if (value) {\n result[key] = {};\n for (const prop of Object.keys(value)) {\n if (props.includes(prop)) {\n result[key][prop] = value[prop];\n }\n }\n }\n }\n\n return result;\n}\n\nexport default function mix(dest, src) {\n const result = { ...dest };\n\n for (const [prop, value] of Object.entries(src)) {\n switch (prop) {\n case 'generic':\n result[prop] = Boolean(value);\n break;\n\n case 'cssWideKeywords':\n result[prop] = dest[prop]\n ? [...dest[prop], ...value]\n : value || [];\n break;\n\n case 'units':\n result[prop] = { ...dest[prop] };\n for (const [name, patch] of Object.entries(value)) {\n result[prop][name] = Array.isArray(patch) ? patch : [];\n }\n break;\n\n case 'atrules':\n result[prop] = { ...dest[prop] };\n\n for (const [name, atrule] of Object.entries(value)) {\n const exists = result[prop][name] || {};\n const current = result[prop][name] = {\n prelude: exists.prelude || null,\n descriptors: {\n ...exists.descriptors\n }\n };\n\n if (!atrule) {\n continue;\n }\n\n current.prelude = atrule.prelude\n ? appendOrSet(current.prelude, atrule.prelude)\n : current.prelude || null;\n\n for (const [descriptorName, descriptorValue] of Object.entries(atrule.descriptors || {})) {\n current.descriptors[descriptorName] = descriptorValue\n ? appendOrSet(current.descriptors[descriptorName], descriptorValue)\n : null;\n }\n\n if (!Object.keys(current.descriptors).length) {\n current.descriptors = null;\n }\n }\n break;\n\n case 'types':\n case 'properties':\n result[prop] = { ...dest[prop] };\n for (const [name, syntax] of Object.entries(value)) {\n result[prop][name] = appendOrSet(result[prop][name], syntax);\n }\n break;\n\n case 'scope':\n case 'features':\n result[prop] = { ...dest[prop] };\n for (const [name, props] of Object.entries(value)) {\n result[prop][name] = { ...result[prop][name], ...props };\n }\n break;\n\n case 'parseContext':\n result[prop] = {\n ...dest[prop],\n ...value\n };\n break;\n\n case 'atrule':\n case 'pseudo':\n result[prop] = {\n ...dest[prop],\n ...sliceProps(value, ['parse'])\n };\n break;\n\n case 'node':\n result[prop] = {\n ...dest[prop],\n ...sliceProps(value, ['name', 'structure', 'parse', 'generate', 'walkContext'])\n };\n break;\n }\n }\n\n return result;\n}\n","import { tokenize } from '../tokenizer/index.js';\nimport { createParser } from '../parser/create.js';\nimport { createGenerator } from '../generator/create.js';\nimport { createConvertor } from '../convertor/create.js';\nimport { createWalker } from '../walker/create.js';\nimport { Lexer } from '../lexer/Lexer.js';\nimport mix from './config/mix.js';\n\nfunction createSyntax(config) {\n const parse = createParser(config);\n const walk = createWalker(config);\n const generate = createGenerator(config);\n const { fromPlainObject, toPlainObject } = createConvertor(walk);\n\n const syntax = {\n lexer: null,\n createLexer: config => new Lexer(config, syntax, syntax.lexer.structure),\n\n tokenize,\n parse,\n generate,\n\n walk,\n find: walk.find,\n findLast: walk.findLast,\n findAll: walk.findAll,\n\n fromPlainObject,\n toPlainObject,\n\n fork(extension) {\n const base = mix({}, config); // copy of config\n\n return createSyntax(\n typeof extension === 'function'\n ? extension(base) // TODO: remove Object.assign as second parameter\n : mix(base, extension)\n );\n }\n };\n\n syntax.lexer = new Lexer({\n generic: config.generic,\n cssWideKeywords: config.cssWideKeywords,\n units: config.units,\n types: config.types,\n atrules: config.atrules,\n properties: config.properties,\n node: config.node\n }, syntax);\n\n return syntax;\n};\n\nexport default config => createSyntax(mix({}, config));\n","import { List } from '../utils/List.js';\n\nexport function createConvertor(walk) {\n return {\n fromPlainObject(ast) {\n walk(ast, {\n enter(node) {\n if (node.children && node.children instanceof List === false) {\n node.children = new List().fromArray(node.children);\n }\n }\n });\n\n return ast;\n },\n toPlainObject(ast) {\n walk(ast, {\n leave(node) {\n if (node.children && node.children instanceof List) {\n node.children = node.children.toArray();\n }\n }\n });\n\n return ast;\n }\n };\n};\n","import {\n isDigit,\n WhiteSpace,\n Comment,\n Ident,\n Number,\n Dimension\n} from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst N = 0x006E; // U+006E LATIN SMALL LETTER N (n)\nconst DISALLOW_SIGN = true;\nconst ALLOW_SIGN = false;\n\nfunction checkInteger(offset, disallowSign) {\n let pos = this.tokenStart + offset;\n const code = this.charCodeAt(pos);\n\n if (code === PLUSSIGN || code === HYPHENMINUS) {\n if (disallowSign) {\n this.error('Number sign is not allowed');\n }\n pos++;\n }\n\n for (; pos < this.tokenEnd; pos++) {\n if (!isDigit(this.charCodeAt(pos))) {\n this.error('Integer is expected', pos);\n }\n }\n}\n\nfunction checkTokenIsInteger(disallowSign) {\n return checkInteger.call(this, 0, disallowSign);\n}\n\nfunction expectCharCode(offset, code) {\n if (!this.cmpChar(this.tokenStart + offset, code)) {\n let msg = '';\n\n switch (code) {\n case N:\n msg = 'N is expected';\n break;\n case HYPHENMINUS:\n msg = 'HyphenMinus is expected';\n break;\n }\n\n this.error(msg, this.tokenStart + offset);\n }\n}\n\n// ... <signed-integer>\n// ... ['+' | '-'] <signless-integer>\nfunction consumeB() {\n let offset = 0;\n let sign = 0;\n let type = this.tokenType;\n\n while (type === WhiteSpace || type === Comment) {\n type = this.lookupType(++offset);\n }\n\n if (type !== Number) {\n if (this.isDelim(PLUSSIGN, offset) ||\n this.isDelim(HYPHENMINUS, offset)) {\n sign = this.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;\n\n do {\n type = this.lookupType(++offset);\n } while (type === WhiteSpace || type === Comment);\n\n if (type !== Number) {\n this.skip(offset);\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n }\n } else {\n return null;\n }\n }\n\n if (offset > 0) {\n this.skip(offset);\n }\n\n if (sign === 0) {\n type = this.charCodeAt(this.tokenStart);\n if (type !== PLUSSIGN && type !== HYPHENMINUS) {\n this.error('Number sign is expected');\n }\n }\n\n checkTokenIsInteger.call(this, sign !== 0);\n return sign === HYPHENMINUS ? '-' + this.consume(Number) : this.consume(Number);\n}\n\n// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb\nexport const name = 'AnPlusB';\nexport const structure = {\n a: [String, null],\n b: [String, null]\n};\n\nexport function parse() {\n /* eslint-disable brace-style*/\n const start = this.tokenStart;\n let a = null;\n let b = null;\n\n // <integer>\n if (this.tokenType === Number) {\n checkTokenIsInteger.call(this, ALLOW_SIGN);\n b = this.consume(Number);\n }\n\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n // -n- <signless-integer>\n // <dashndashdigit-ident>\n else if (this.tokenType === Ident && this.cmpChar(this.tokenStart, HYPHENMINUS)) {\n a = '-1';\n\n expectCharCode.call(this, 1, N);\n\n switch (this.tokenEnd - this.tokenStart) {\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n case 2:\n this.next();\n b = consumeB.call(this);\n break;\n\n // -n- <signless-integer>\n case 3:\n expectCharCode.call(this, 2, HYPHENMINUS);\n\n this.next();\n this.skipSC();\n\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n\n b = '-' + this.consume(Number);\n break;\n\n // <dashndashdigit-ident>\n default:\n expectCharCode.call(this, 2, HYPHENMINUS);\n checkInteger.call(this, 3, DISALLOW_SIGN);\n this.next();\n\n b = this.substrToCursor(start + 2);\n }\n }\n\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n // '+'? n- <signless-integer>\n // '+'? <ndashdigit-ident>\n else if (this.tokenType === Ident || (this.isDelim(PLUSSIGN) && this.lookupType(1) === Ident)) {\n let sign = 0;\n a = '1';\n\n // just ignore a plus\n if (this.isDelim(PLUSSIGN)) {\n sign = 1;\n this.next();\n }\n\n expectCharCode.call(this, 0, N);\n\n switch (this.tokenEnd - this.tokenStart) {\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n case 1:\n this.next();\n b = consumeB.call(this);\n break;\n\n // '+'? n- <signless-integer>\n case 2:\n expectCharCode.call(this, 1, HYPHENMINUS);\n\n this.next();\n this.skipSC();\n\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n\n b = '-' + this.consume(Number);\n break;\n\n // '+'? <ndashdigit-ident>\n default:\n expectCharCode.call(this, 1, HYPHENMINUS);\n checkInteger.call(this, 2, DISALLOW_SIGN);\n this.next();\n\n b = this.substrToCursor(start + sign + 1);\n }\n }\n\n // <ndashdigit-dimension>\n // <ndash-dimension> <signless-integer>\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n else if (this.tokenType === Dimension) {\n const code = this.charCodeAt(this.tokenStart);\n const sign = code === PLUSSIGN || code === HYPHENMINUS;\n let i = this.tokenStart + sign;\n\n for (; i < this.tokenEnd; i++) {\n if (!isDigit(this.charCodeAt(i))) {\n break;\n }\n }\n\n if (i === this.tokenStart + sign) {\n this.error('Integer is expected', this.tokenStart + sign);\n }\n\n expectCharCode.call(this, i - this.tokenStart, N);\n a = this.substring(start, i);\n\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n if (i + 1 === this.tokenEnd) {\n this.next();\n b = consumeB.call(this);\n } else {\n expectCharCode.call(this, i - this.tokenStart + 1, HYPHENMINUS);\n\n // <ndash-dimension> <signless-integer>\n if (i + 2 === this.tokenEnd) {\n this.next();\n this.skipSC();\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n b = '-' + this.consume(Number);\n }\n // <ndashdigit-dimension>\n else {\n checkInteger.call(this, i - this.tokenStart + 2, DISALLOW_SIGN);\n this.next();\n b = this.substrToCursor(i + 1);\n }\n }\n } else {\n this.error();\n }\n\n if (a !== null && a.charCodeAt(0) === PLUSSIGN) {\n a = a.substr(1);\n }\n\n if (b !== null && b.charCodeAt(0) === PLUSSIGN) {\n b = b.substr(1);\n }\n\n return {\n type: 'AnPlusB',\n loc: this.getLocation(start, this.tokenStart),\n a,\n b\n };\n}\n\nexport function generate(node) {\n if (node.a) {\n const a =\n node.a === '+1' && 'n' ||\n node.a === '1' && 'n' ||\n node.a === '-1' && '-n' ||\n node.a + 'n';\n\n if (node.b) {\n const b = node.b[0] === '-' || node.b[0] === '+'\n ? node.b\n : '+' + node.b;\n this.tokenize(a + b);\n } else {\n this.tokenize(a);\n }\n } else {\n this.tokenize(node.b);\n }\n}\n","import {\n AtKeyword,\n Semicolon,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../../tokenizer/index.js';\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilLeftCurlyBracketOrSemicolon, true);\n}\n\nfunction isDeclarationBlockAtrule() {\n for (let offset = 1, type; type = this.lookupType(offset); offset++) {\n if (type === RightCurlyBracket) {\n return true;\n }\n\n if (type === LeftCurlyBracket ||\n type === AtKeyword) {\n return false;\n }\n }\n\n return false;\n}\n\n\nexport const name = 'Atrule';\nexport const walkContext = 'atrule';\nexport const structure = {\n name: String,\n prelude: ['AtrulePrelude', 'Raw', null],\n block: ['Block', null]\n};\n\nexport function parse(isDeclaration = false) {\n const start = this.tokenStart;\n let name;\n let nameLowerCase;\n let prelude = null;\n let block = null;\n\n this.eat(AtKeyword);\n\n name = this.substrToCursor(start + 1);\n nameLowerCase = name.toLowerCase();\n this.skipSC();\n\n // parse prelude\n if (this.eof === false &&\n this.tokenType !== LeftCurlyBracket &&\n this.tokenType !== Semicolon) {\n if (this.parseAtrulePrelude) {\n prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name, isDeclaration), consumeRaw);\n } else {\n prelude = consumeRaw.call(this, this.tokenIndex);\n }\n\n this.skipSC();\n }\n\n switch (this.tokenType) {\n case Semicolon:\n this.next();\n break;\n\n case LeftCurlyBracket:\n if (hasOwnProperty.call(this.atrule, nameLowerCase) &&\n typeof this.atrule[nameLowerCase].block === 'function') {\n block = this.atrule[nameLowerCase].block.call(this, isDeclaration);\n } else {\n // TODO: should consume block content as Raw?\n block = this.Block(isDeclarationBlockAtrule.call(this));\n }\n\n break;\n }\n\n return {\n type: 'Atrule',\n loc: this.getLocation(start, this.tokenStart),\n name,\n prelude,\n block\n };\n}\n\nexport function generate(node) {\n this.token(AtKeyword, '@' + node.name);\n\n if (node.prelude !== null) {\n this.node(node.prelude);\n }\n\n if (node.block) {\n this.node(node.block);\n } else {\n this.token(Semicolon, ';');\n }\n}\n","import {\n Semicolon,\n LeftCurlyBracket\n} from '../../tokenizer/index.js';\n\nexport const name = 'AtrulePrelude';\nexport const walkContext = 'atrulePrelude';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(name) {\n let children = null;\n\n if (name !== null) {\n name = name.toLowerCase();\n }\n\n this.skipSC();\n\n if (hasOwnProperty.call(this.atrule, name) &&\n typeof this.atrule[name].prelude === 'function') {\n // custom consumer\n children = this.atrule[name].prelude.call(this);\n } else {\n // default consumer\n children = this.readSequence(this.scope.AtrulePrelude);\n }\n\n this.skipSC();\n\n if (this.eof !== true &&\n this.tokenType !== LeftCurlyBracket &&\n this.tokenType !== Semicolon) {\n this.error('Semicolon or block is expected');\n }\n\n return {\n type: 'AtrulePrelude',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import {\n Ident,\n String as StringToken,\n Delim,\n LeftSquareBracket,\n RightSquareBracket\n} from '../../tokenizer/index.js';\n\nconst DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)\nconst CIRCUMFLEXACCENT = 0x005E; // U+005E (^)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nfunction getAttributeName() {\n if (this.eof) {\n this.error('Unexpected end of input');\n }\n\n const start = this.tokenStart;\n let expectIdent = false;\n\n if (this.isDelim(ASTERISK)) {\n expectIdent = true;\n this.next();\n } else if (!this.isDelim(VERTICALLINE)) {\n this.eat(Ident);\n }\n\n if (this.isDelim(VERTICALLINE)) {\n if (this.charCodeAt(this.tokenStart + 1) !== EQUALSSIGN) {\n this.next();\n this.eat(Ident);\n } else if (expectIdent) {\n this.error('Identifier is expected', this.tokenEnd);\n }\n } else if (expectIdent) {\n this.error('Vertical line is expected');\n }\n\n return {\n type: 'Identifier',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start)\n };\n}\n\nfunction getOperator() {\n const start = this.tokenStart;\n const code = this.charCodeAt(start);\n\n if (code !== EQUALSSIGN && // =\n code !== TILDE && // ~=\n code !== CIRCUMFLEXACCENT && // ^=\n code !== DOLLARSIGN && // $=\n code !== ASTERISK && // *=\n code !== VERTICALLINE // |=\n ) {\n this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');\n }\n\n this.next();\n\n if (code !== EQUALSSIGN) {\n if (!this.isDelim(EQUALSSIGN)) {\n this.error('Equal sign is expected');\n }\n\n this.next();\n }\n\n return this.substrToCursor(start);\n}\n\n// '[' <wq-name> ']'\n// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'\nexport const name = 'AttributeSelector';\nexport const structure = {\n name: 'Identifier',\n matcher: [String, null],\n value: ['String', 'Identifier', null],\n flags: [String, null]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let name;\n let matcher = null;\n let value = null;\n let flags = null;\n\n this.eat(LeftSquareBracket);\n this.skipSC();\n\n name = getAttributeName.call(this);\n this.skipSC();\n\n if (this.tokenType !== RightSquareBracket) {\n // avoid case `[name i]`\n if (this.tokenType !== Ident) {\n matcher = getOperator.call(this);\n\n this.skipSC();\n\n value = this.tokenType === StringToken\n ? this.String()\n : this.Identifier();\n\n this.skipSC();\n }\n\n // attribute flags\n if (this.tokenType === Ident) {\n flags = this.consume(Ident);\n\n this.skipSC();\n }\n }\n\n this.eat(RightSquareBracket);\n\n return {\n type: 'AttributeSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n matcher,\n value,\n flags\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '[');\n this.node(node.name);\n\n if (node.matcher !== null) {\n this.tokenize(node.matcher);\n this.node(node.value);\n }\n\n if (node.flags !== null) {\n this.token(Ident, node.flags);\n }\n\n this.token(Delim, ']');\n}\n","import {\n WhiteSpace,\n Comment,\n Semicolon,\n AtKeyword,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nfunction consumeRaw() {\n return this.Raw(null, true);\n}\nfunction consumeRule() {\n return this.parseWithFallback(this.Rule, consumeRaw);\n}\nfunction consumeRawDeclaration() {\n return this.Raw(this.consumeUntilSemicolonIncluded, true);\n}\nfunction consumeDeclaration() {\n if (this.tokenType === Semicolon) {\n return consumeRawDeclaration.call(this, this.tokenIndex);\n }\n\n const node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);\n\n if (this.tokenType === Semicolon) {\n this.next();\n }\n\n return node;\n}\n\nexport const name = 'Block';\nexport const walkContext = 'block';\nexport const structure = {\n children: [[\n 'Atrule',\n 'Rule',\n 'Declaration'\n ]]\n};\n\nexport function parse(isStyleBlock) {\n const consumer = isStyleBlock ? consumeDeclaration : consumeRule;\n const start = this.tokenStart;\n let children = this.createList();\n\n this.eat(LeftCurlyBracket);\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case RightCurlyBracket:\n break scan;\n\n case WhiteSpace:\n case Comment:\n this.next();\n break;\n\n case AtKeyword:\n children.push(this.parseWithFallback(this.Atrule.bind(this, isStyleBlock), consumeRaw));\n break;\n\n default:\n if (isStyleBlock && this.isDelim(AMPERSAND)) {\n children.push(consumeRule.call(this));\n } else {\n children.push(consumer.call(this));\n }\n }\n }\n\n if (!this.eof) {\n this.eat(RightCurlyBracket);\n }\n\n return {\n type: 'Block',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(LeftCurlyBracket, '{');\n this.children(node, prev => {\n if (prev.type === 'Declaration') {\n this.token(Semicolon, ';');\n }\n });\n this.token(RightCurlyBracket, '}');\n}\n","import {\n Delim,\n LeftSquareBracket,\n RightSquareBracket\n} from '../../tokenizer/index.js';\n\nexport const name = 'Brackets';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n let children = null;\n\n this.eat(LeftSquareBracket);\n\n children = readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightSquareBracket);\n }\n\n return {\n type: 'Brackets',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '[');\n this.children(node);\n this.token(Delim, ']');\n}\n","import { CDC } from '../../tokenizer/index.js';\n\nexport const name = 'CDC';\nexport const structure = [];\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(CDC); // -->\n\n return {\n type: 'CDC',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(CDC, '-->');\n}\n","import { CDO } from '../../tokenizer/index.js';\n\nexport const name = 'CDO';\nexport const structure = [];\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(CDO); // <!--\n\n return {\n type: 'CDO',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(CDO, '<!--');\n}\n","import { Delim, Ident } from '../../tokenizer/index.js';\n\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\n\n// '.' ident\nexport const name = 'ClassSelector';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n this.eatDelim(FULLSTOP);\n\n return {\n type: 'ClassSelector',\n loc: this.getLocation(this.tokenStart - 1, this.tokenEnd),\n name: this.consume(Ident)\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '.');\n this.token(Ident, node.name);\n}\n","import { WhiteSpace, Delim } from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nexport const name = 'Combinator';\nexport const structure = {\n name: String\n};\n\n// + | > | ~ | /deep/\nexport function parse() {\n const start = this.tokenStart;\n let name;\n\n switch (this.tokenType) {\n case WhiteSpace:\n name = ' ';\n break;\n\n case Delim:\n switch (this.charCodeAt(this.tokenStart)) {\n case GREATERTHANSIGN:\n case PLUSSIGN:\n case TILDE:\n this.next();\n break;\n\n case SOLIDUS:\n this.next();\n this.eatIdent('deep');\n this.eatDelim(SOLIDUS);\n break;\n\n default:\n this.error('Combinator is expected');\n }\n\n name = this.substrToCursor(start);\n break;\n }\n\n return {\n type: 'Combinator',\n loc: this.getLocation(start, this.tokenStart),\n name\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import { Comment } from '../../tokenizer/index.js';\n\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\n\nexport const name = 'Comment';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let end = this.tokenEnd;\n\n this.eat(Comment);\n\n if ((end - start + 2) >= 2 &&\n this.charCodeAt(end - 2) === ASTERISK &&\n this.charCodeAt(end - 1) === SOLIDUS) {\n end -= 2;\n }\n\n return {\n type: 'Comment',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substring(start + 2, end)\n };\n}\n\nexport function generate(node) {\n this.token(Comment, '/*' + node.value + '*/');\n}\n","import {\n WhiteSpace,\n Comment,\n Ident,\n LeftParenthesis,\n RightParenthesis,\n Function as FunctionToken,\n Colon,\n EOF\n} from '../../tokenizer/index.js';\n\nconst likelyFeatureToken = new Set([Colon, RightParenthesis, EOF]);\n\nexport const name = 'Condition';\nexport const structure = {\n kind: String,\n children: [[\n 'Identifier',\n 'Feature',\n 'FeatureFunction',\n 'FeatureRange',\n 'SupportsDeclaration'\n ]]\n};\n\nfunction featureOrRange(kind) {\n if (this.lookupTypeNonSC(1) === Ident &&\n likelyFeatureToken.has(this.lookupTypeNonSC(2))) {\n return this.Feature(kind);\n }\n\n return this.FeatureRange(kind);\n}\n\nconst parentheses = {\n media: featureOrRange,\n container: featureOrRange,\n supports() {\n return this.SupportsDeclaration();\n }\n};\n\nexport function parse(kind = 'media') {\n const children = this.createList();\n\n scan: while (!this.eof) {\n switch (this.tokenType) {\n case Comment:\n case WhiteSpace:\n this.next();\n continue;\n\n case Ident:\n children.push(this.Identifier());\n break;\n\n case LeftParenthesis: {\n let term = this.parseWithFallback(\n () => parentheses[kind].call(this, kind),\n () => null\n );\n\n if (!term) {\n term = this.parseWithFallback(\n () => {\n this.eat(LeftParenthesis);\n const res = this.Condition(kind);\n this.eat(RightParenthesis);\n return res;\n },\n () => {\n return this.GeneralEnclosed(kind);\n }\n );\n }\n\n children.push(term);\n break;\n }\n\n case FunctionToken: {\n let term = this.parseWithFallback(\n () => this.FeatureFunction(kind),\n () => null\n );\n\n if (!term) {\n term = this.GeneralEnclosed(kind);\n }\n\n children.push(term);\n break;\n }\n\n default:\n break scan;\n }\n }\n\n if (children.isEmpty) {\n this.error('Condition is expected');\n }\n\n return {\n type: 'Condition',\n loc: this.getLocationFromList(children),\n kind,\n children\n };\n}\n\nexport function generate(node) {\n node.children.forEach(child => {\n if (child.type === 'Condition') {\n this.token(LeftParenthesis, '(');\n this.node(child);\n this.token(RightParenthesis, ')');\n } else {\n this.node(child);\n }\n });\n}\n\n","import { isCustomProperty } from '../../utils/names.js';\nimport {\n Ident,\n Hash,\n Colon,\n Semicolon,\n Delim,\n WhiteSpace\n} from '../../tokenizer/index.js';\n\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\nfunction consumeValueRaw() {\n return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, true);\n}\n\nfunction consumeCustomPropertyRaw() {\n return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, false);\n}\n\nfunction consumeValue() {\n const startValueToken = this.tokenIndex;\n const value = this.Value();\n\n if (value.type !== 'Raw' &&\n this.eof === false &&\n this.tokenType !== Semicolon &&\n this.isDelim(EXCLAMATIONMARK) === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return value;\n}\n\nexport const name = 'Declaration';\nexport const walkContext = 'declaration';\nexport const structure = {\n important: [Boolean, String],\n property: String,\n value: ['Value', 'Raw']\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const startToken = this.tokenIndex;\n const property = readProperty.call(this);\n const customProperty = isCustomProperty(property);\n const parseValue = customProperty ? this.parseCustomProperty : this.parseValue;\n const consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;\n let important = false;\n let value;\n\n this.skipSC();\n this.eat(Colon);\n\n const valueStart = this.tokenIndex;\n\n if (!customProperty) {\n this.skipSC();\n }\n\n if (parseValue) {\n value = this.parseWithFallback(consumeValue, consumeRaw);\n } else {\n value = consumeRaw.call(this, this.tokenIndex);\n }\n\n if (customProperty && value.type === 'Value' && value.children.isEmpty) {\n for (let offset = valueStart - this.tokenIndex; offset <= 0; offset++) {\n if (this.lookupType(offset) === WhiteSpace) {\n value.children.appendData({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n });\n break;\n }\n }\n }\n\n if (this.isDelim(EXCLAMATIONMARK)) {\n important = getImportant.call(this);\n this.skipSC();\n }\n\n // Do not include semicolon to range per spec\n // https://drafts.csswg.org/css-syntax/#declaration-diagram\n\n if (this.eof === false &&\n this.tokenType !== Semicolon &&\n this.isBalanceEdge(startToken) === false) {\n this.error();\n }\n\n return {\n type: 'Declaration',\n loc: this.getLocation(start, this.tokenStart),\n important,\n property,\n value\n };\n}\n\nexport function generate(node) {\n this.token(Ident, node.property);\n this.token(Colon, ':');\n this.node(node.value);\n\n if (node.important) {\n this.token(Delim, '!');\n this.token(Ident, node.important === true ? 'important' : node.important);\n }\n}\n\nfunction readProperty() {\n const start = this.tokenStart;\n\n // hacks\n if (this.tokenType === Delim) {\n switch (this.charCodeAt(this.tokenStart)) {\n case ASTERISK:\n case DOLLARSIGN:\n case PLUSSIGN:\n case NUMBERSIGN:\n case AMPERSAND:\n this.next();\n break;\n\n // TODO: not sure we should support this hack\n case SOLIDUS:\n this.next();\n if (this.isDelim(SOLIDUS)) {\n this.next();\n }\n break;\n }\n }\n\n if (this.tokenType === Hash) {\n this.eat(Hash);\n } else {\n this.eat(Ident);\n }\n\n return this.substrToCursor(start);\n}\n\n// ! ws* important\nfunction getImportant() {\n this.eat(Delim);\n this.skipSC();\n\n const important = this.consume(Ident);\n\n // store original value in case it differ from `important`\n // for better original source restoring and hacks like `!ie` support\n return important === 'important' ? true : important;\n}\n","import {\n WhiteSpace,\n Comment,\n Semicolon,\n AtKeyword\n} from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilSemicolonIncluded, true);\n}\n\nexport const name = 'DeclarationList';\nexport const structure = {\n children: [[\n 'Declaration',\n 'Atrule',\n 'Rule'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case WhiteSpace:\n case Comment:\n case Semicolon:\n this.next();\n break;\n\n case AtKeyword:\n children.push(this.parseWithFallback(this.Atrule.bind(this, true), consumeRaw));\n break;\n\n default:\n if (this.isDelim(AMPERSAND)) {\n children.push(this.parseWithFallback(this.Rule, consumeRaw));\n } else {\n children.push(this.parseWithFallback(this.Declaration, consumeRaw));\n }\n }\n }\n\n return {\n type: 'DeclarationList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, prev => {\n if (prev.type === 'Declaration') {\n this.token(Semicolon, ';');\n }\n });\n}\n\n","import { Dimension } from '../../tokenizer/index.js';\n\nexport const name = 'Dimension';\nexport const structure = {\n value: String,\n unit: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const value = this.consumeNumber(Dimension);\n\n return {\n type: 'Dimension',\n loc: this.getLocation(start, this.tokenStart),\n value,\n unit: this.substring(start + value.length, this.tokenStart)\n };\n}\n\nexport function generate(node) {\n this.token(Dimension, node.value + node.unit);\n}\n","import {\n Ident,\n Number,\n Dimension,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis,\n Colon,\n Delim\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\nexport const name = 'Feature';\nexport const structure = {\n kind: String,\n name: String,\n value: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]\n};\n\nexport function parse(kind) {\n const start = this.tokenStart;\n let name;\n let value = null;\n\n this.eat(LeftParenthesis);\n this.skipSC();\n\n name = this.consume(Ident);\n this.skipSC();\n\n if (this.tokenType !== RightParenthesis) {\n this.eat(Colon);\n this.skipSC();\n\n switch (this.tokenType) {\n case Number:\n if (this.lookupNonWSType(1) === Delim) {\n value = this.Ratio();\n } else {\n value = this.Number();\n }\n\n break;\n\n case Dimension:\n value = this.Dimension();\n break;\n\n case Ident:\n value = this.Identifier();\n break;\n\n case FunctionToken:\n value = this.parseWithFallback(\n () => {\n const res = this.Function(this.readSequence, this.scope.Value);\n\n this.skipSC();\n\n if (this.isDelim(SOLIDUS)) {\n this.error();\n }\n\n return res;\n },\n () => {\n return this.Ratio();\n }\n );\n break;\n\n default:\n this.error('Number, dimension, ratio or identifier is expected');\n }\n\n this.skipSC();\n }\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Feature',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n name,\n value\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.token(Ident, node.name);\n\n if (node.value !== null) {\n this.token(Colon, ':');\n this.node(node.value);\n }\n\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'FeatureFunction';\nexport const structure = {\n kind: String,\n feature: String,\n value: ['Declaration', 'Selector']\n};\n\nfunction getFeatureParser(kind, name) {\n const featuresOfKind = this.features[kind] || {};\n const parser = featuresOfKind[name];\n\n if (typeof parser !== 'function') {\n this.error(`Unknown feature ${name}()`);\n }\n\n return parser;\n}\n\nexport function parse(kind = 'unknown') {\n const start = this.tokenStart;\n const functionName = this.consumeFunctionName();\n const valueParser = getFeatureParser.call(this, kind, functionName.toLowerCase());\n\n this.skipSC();\n\n const value = this.parseWithFallback(\n () => {\n const startValueToken = this.tokenIndex;\n const value = valueParser.call(this);\n\n if (this.eof === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return value;\n },\n () => this.Raw(null, false)\n );\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'FeatureFunction',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n feature: functionName,\n value\n };\n}\n\nexport function generate(node) {\n this.token(FunctionToken, node.feature + '(');\n this.node(node.value);\n this.token(RightParenthesis, ')');\n}\n","import {\n Ident,\n Number,\n Dimension,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst LESSTHANSIGN = 0x003C; // U+003C LESS-THAN SIGN (<)\nconst EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\n\nexport const name = 'FeatureRange';\nexport const structure = {\n kind: String,\n left: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],\n leftComparison: String,\n middle: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],\n rightComparison: [String, null],\n right: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]\n};\n\nfunction readTerm() {\n this.skipSC();\n\n switch (this.tokenType) {\n case Number:\n if (this.isDelim(SOLIDUS, this.lookupOffsetNonSC(1))) {\n return this.Ratio();\n } else {\n return this.Number();\n }\n\n case Dimension:\n return this.Dimension();\n\n case Ident:\n return this.Identifier();\n\n case FunctionToken:\n return this.parseWithFallback(\n () => {\n const res = this.Function(this.readSequence, this.scope.Value);\n\n this.skipSC();\n\n if (this.isDelim(SOLIDUS)) {\n this.error();\n }\n\n return res;\n },\n () => {\n return this.Ratio();\n }\n );\n\n default:\n this.error('Number, dimension, ratio or identifier is expected');\n }\n}\n\nfunction readComparison(expectColon) {\n this.skipSC();\n\n if (this.isDelim(LESSTHANSIGN) ||\n this.isDelim(GREATERTHANSIGN)) {\n const value = this.source[this.tokenStart];\n\n this.next();\n\n if (this.isDelim(EQUALSSIGN)) {\n this.next();\n return value + '=';\n }\n\n return value;\n }\n\n if (this.isDelim(EQUALSSIGN)) {\n return '=';\n }\n\n this.error(`Expected ${expectColon ? '\":\", ' : ''}\"<\", \">\", \"=\" or \")\"`);\n}\n\nexport function parse(kind = 'unknown') {\n const start = this.tokenStart;\n\n this.skipSC();\n this.eat(LeftParenthesis);\n\n const left = readTerm.call(this);\n const leftComparison = readComparison.call(this, left.type === 'Identifier');\n const middle = readTerm.call(this);\n let rightComparison = null;\n let right = null;\n\n if (this.lookupNonWSType(0) !== RightParenthesis) {\n rightComparison = readComparison.call(this);\n right = readTerm.call(this);\n }\n\n this.skipSC();\n this.eat(RightParenthesis);\n\n return {\n type: 'FeatureRange',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n left,\n leftComparison,\n middle,\n rightComparison,\n right\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.node(node.left);\n this.tokenize(node.leftComparison);\n this.node(node.middle);\n\n if (node.right) {\n this.tokenize(node.rightComparison);\n this.node(node.right);\n }\n\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'Function';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [[]]\n};\n\n// <function-token> <sequence> )\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n const name = this.consumeFunctionName();\n const nameLowerCase = name.toLowerCase();\n let children;\n\n children = recognizer.hasOwnProperty(nameLowerCase)\n ? recognizer[nameLowerCase].call(this, recognizer)\n : readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Function',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'GeneralEnclosed';\nexport const structure = {\n kind: String,\n function: [String, null],\n children: [[]]\n};\n\n// <function-token> <any-value> )\n// ( <any-value> )\nexport function parse(kind) {\n const start = this.tokenStart;\n let functionName = null;\n\n if (this.tokenType === FunctionToken) {\n functionName = this.consumeFunctionName();\n } else {\n this.eat(LeftParenthesis);\n }\n\n const children = this.parseWithFallback(\n () => {\n const startValueToken = this.tokenIndex;\n const children = this.readSequence(this.scope.Value);\n\n if (this.eof === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return children;\n },\n () => this.createSingleNodeList(\n this.Raw(null, false)\n )\n );\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'GeneralEnclosed',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n function: functionName,\n children\n };\n}\n\nexport function generate(node) {\n if (node.function) {\n this.token(FunctionToken, node.function + '(');\n } else {\n this.token(LeftParenthesis, '(');\n }\n\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import { Hash } from '../../tokenizer/index.js';\n\n// '#' ident\nexport const xxx = 'XXX';\nexport const name = 'Hash';\nexport const structure = {\n value: String\n};\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(Hash);\n\n return {\n type: 'Hash',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start + 1)\n };\n}\nexport function generate(node) {\n this.token(Hash, '#' + node.value);\n}\n\n","import { Ident } from '../../tokenizer/index.js';\n\nexport const name = 'Identifier';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n return {\n type: 'Identifier',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n name: this.consume(Ident)\n };\n}\n\nexport function generate(node) {\n this.token(Ident, node.name);\n}\n","import { Hash, Delim } from '../../tokenizer/index.js';\n\nexport const name = 'IdSelector';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n // TODO: check value is an ident\n this.eat(Hash);\n\n return {\n type: 'IdSelector',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start + 1)\n };\n}\n\nexport function generate(node) {\n // Using Delim instead of Hash is a hack to avoid for a whitespace between ident and id-selector\n // in safe mode (e.g. \"a#id\"), because IE11 doesn't allow a sequence <ident-token> <hash-token>\n // without a whitespace in values (e.g. \"1px solid#000\")\n this.token(Delim, '#' + node.name);\n}\n","import { Ident, Delim } from '../../tokenizer/index.js';\n\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\n\nexport const name = 'Layer';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n let tokenStart = this.tokenStart;\n let name = this.consume(Ident);\n\n while (this.isDelim(FULLSTOP)) {\n this.eat(Delim);\n name += '.' + this.consume(Ident);\n }\n\n return {\n type: 'Layer',\n loc: this.getLocation(tokenStart, this.tokenStart),\n name\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'LayerList';\nexport const structure = {\n children: [[\n 'Layer'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n this.skipSC();\n\n while (!this.eof) {\n children.push(this.Layer());\n\n if (this.lookupTypeNonSC(0) !== Comma) {\n break;\n }\n\n this.skipSC();\n this.next();\n this.skipSC();\n }\n\n return {\n type: 'LayerList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import {\n Comma,\n EOF,\n Ident,\n LeftCurlyBracket,\n LeftParenthesis,\n Function as FunctionToken,\n Semicolon\n} from '../../tokenizer/index.js';\n\nexport const name = 'MediaQuery';\nexport const structure = {\n modifier: [String, null],\n mediaType: [String, null],\n condition: ['Condition', null]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let modifier = null;\n let mediaType = null;\n let condition = null;\n\n this.skipSC();\n\n if (this.tokenType === Ident && this.lookupTypeNonSC(1) !== LeftParenthesis) {\n // [ not | only ]? <media-type>\n const ident = this.consume(Ident);\n const identLowerCase = ident.toLowerCase();\n\n if (identLowerCase === 'not' || identLowerCase === 'only') {\n this.skipSC();\n modifier = identLowerCase;\n mediaType = this.consume(Ident);\n } else {\n mediaType = ident;\n }\n\n switch (this.lookupTypeNonSC(0)) {\n case Ident: {\n // and <media-condition-without-or>\n this.skipSC();\n this.eatIdent('and');\n condition = this.Condition('media');\n break;\n }\n\n case LeftCurlyBracket:\n case Semicolon:\n case Comma:\n case EOF:\n break;\n\n default:\n this.error('Identifier or parenthesis is expected');\n }\n } else {\n switch (this.tokenType) {\n case Ident:\n case LeftParenthesis:\n case FunctionToken: {\n // <media-condition>\n condition = this.Condition('media');\n break;\n }\n\n case LeftCurlyBracket:\n case Semicolon:\n case EOF:\n break;\n\n default:\n this.error('Identifier or parenthesis is expected');\n }\n }\n\n return {\n type: 'MediaQuery',\n loc: this.getLocation(start, this.tokenStart),\n modifier,\n mediaType,\n condition\n };\n}\n\nexport function generate(node) {\n if (node.mediaType) {\n if (node.modifier) {\n this.token(Ident, node.modifier);\n }\n\n this.token(Ident, node.mediaType);\n\n if (node.condition) {\n this.token(Ident, 'and');\n this.node(node.condition);\n }\n } else if (node.condition) {\n this.node(node.condition);\n }\n}\n\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'MediaQueryList';\nexport const structure = {\n children: [[\n 'MediaQuery'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n this.skipSC();\n\n while (!this.eof) {\n children.push(this.MediaQuery());\n\n if (this.tokenType !== Comma) {\n break;\n }\n\n this.next();\n }\n\n return {\n type: 'MediaQueryList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import { Delim } from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nexport const name = 'NestingSelector';\nexport const structure = {\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eatDelim(AMPERSAND);\n\n return {\n type: 'NestingSelector',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(Delim, '&');\n}\n","import { Ident } from '../../tokenizer/index.js';\n\nexport const name = 'Nth';\nexport const structure = {\n nth: ['AnPlusB', 'Identifier'],\n selector: ['SelectorList', null]\n};\n\nexport function parse() {\n this.skipSC();\n\n const start = this.tokenStart;\n let end = start;\n let selector = null;\n let nth;\n\n if (this.lookupValue(0, 'odd') || this.lookupValue(0, 'even')) {\n nth = this.Identifier();\n } else {\n nth = this.AnPlusB();\n }\n\n end = this.tokenStart;\n this.skipSC();\n\n if (this.lookupValue(0, 'of')) {\n this.next();\n\n selector = this.SelectorList();\n end = this.tokenStart;\n }\n\n return {\n type: 'Nth',\n loc: this.getLocation(start, end),\n nth,\n selector\n };\n}\n\nexport function generate(node) {\n this.node(node.nth);\n if (node.selector !== null) {\n this.token(Ident, 'of');\n this.node(node.selector);\n }\n}\n","import { Number as NumberToken } from '../../tokenizer/index.js';\n\nexport const name = 'Number';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'Number',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: this.consume(NumberToken)\n };\n}\n\nexport function generate(node) {\n this.token(NumberToken, node.value);\n}\n","// '/' | '*' | ',' | ':' | '+' | '-'\nexport const name = 'Operator';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.next();\n\n return {\n type: 'Operator',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import {\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Parentheses';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n let children = null;\n\n this.eat(LeftParenthesis);\n\n children = readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Parentheses',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import { Percentage } from '../../tokenizer/index.js';\n\nexport const name = 'Percentage';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'Percentage',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: this.consumeNumber(Percentage)\n };\n}\n\nexport function generate(node) {\n this.token(Percentage, node.value + '%');\n}\n","import {\n Ident,\n Function as FunctionToken,\n Colon,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'PseudoClassSelector';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [['Raw'], null]\n};\n\n// : [ <ident> | <function-token> <any-value>? ) ]\nexport function parse() {\n const start = this.tokenStart;\n let children = null;\n let name;\n let nameLowerCase;\n\n this.eat(Colon);\n\n if (this.tokenType === FunctionToken) {\n name = this.consumeFunctionName();\n nameLowerCase = name.toLowerCase();\n\n if (this.lookupNonWSType(0) == RightParenthesis) {\n children = this.createList();\n } else if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {\n this.skipSC();\n children = this.pseudo[nameLowerCase].call(this);\n this.skipSC();\n } else {\n children = this.createList();\n children.push(\n this.Raw(null, false)\n );\n }\n\n this.eat(RightParenthesis);\n } else {\n name = this.consume(Ident);\n }\n\n return {\n type: 'PseudoClassSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(Colon, ':');\n\n if (node.children === null) {\n this.token(Ident, node.name);\n } else {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n }\n}\n","import {\n Ident,\n Function as FunctionToken,\n Colon,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'PseudoElementSelector';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [['Raw'], null]\n};\n\n// :: [ <ident> | <function-token> <any-value>? ) ]\nexport function parse() {\n const start = this.tokenStart;\n let children = null;\n let name;\n let nameLowerCase;\n\n this.eat(Colon);\n this.eat(Colon);\n\n if (this.tokenType === FunctionToken) {\n name = this.consumeFunctionName();\n nameLowerCase = name.toLowerCase();\n\n if (this.lookupNonWSType(0) == RightParenthesis) {\n children = this.createList();\n } else if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {\n this.skipSC();\n children = this.pseudo[nameLowerCase].call(this);\n this.skipSC();\n } else {\n children = this.createList();\n children.push(\n this.Raw(null, false)\n );\n }\n\n this.eat(RightParenthesis);\n } else {\n name = this.consume(Ident);\n }\n\n return {\n type: 'PseudoElementSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(Colon, ':');\n this.token(Colon, ':');\n\n if (node.children === null) {\n this.token(Ident, node.name);\n } else {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n }\n}\n","import {\n Delim,\n Number as NumberToken,\n Function as FunctionToken\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\n// Media Queries Level 3 defines terms of <ratio> as a positive (not zero or negative)\n// integers (see https://drafts.csswg.org/mediaqueries-3/#values)\n// However, Media Queries Level 4 removes any definition of values\n// (see https://drafts.csswg.org/mediaqueries-4/#values) and refers to\n// CSS Values and Units for detail. In CSS Values and Units Level 4 a <ratio>\n// definition was added (see https://drafts.csswg.org/css-values-4/#ratios) which\n// defines ratio as \"<number [0,∞]> [ / <number [0,∞]> ]?\" and based on it\n// any constrains on terms were removed. Parser also doesn't test numbers\n// in any way to make possible for linting and fixing them by the tools using CSSTree.\n// An additional syntax examination may be applied by a lexer.\nfunction consumeTerm() {\n this.skipSC();\n\n switch (this.tokenType) {\n case NumberToken:\n return this.Number();\n\n case FunctionToken:\n return this.Function(this.readSequence, this.scope.Value);\n\n default:\n this.error('Number of function is expected');\n }\n}\n\nexport const name = 'Ratio';\nexport const structure = {\n left: ['Number', 'Function'],\n right: ['Number', 'Function', null]\n};\n\n// <number [0,∞]> [ / <number [0,∞]> ]?\nexport function parse() {\n const start = this.tokenStart;\n const left = consumeTerm.call(this);\n let right = null;\n\n this.skipSC();\n if (this.isDelim(SOLIDUS)) {\n this.eatDelim(SOLIDUS);\n right = consumeTerm.call(this);\n }\n\n return {\n type: 'Ratio',\n loc: this.getLocation(start, this.tokenStart),\n left,\n right\n };\n}\n\nexport function generate(node) {\n this.node(node.left);\n this.token(Delim, '/');\n if (node.right) {\n this.node(node.right);\n } else {\n this.node(NumberToken, 1);\n }\n}\n","import { WhiteSpace } from '../../tokenizer/index.js';\n\nfunction getOffsetExcludeWS() {\n if (this.tokenIndex > 0) {\n if (this.lookupType(-1) === WhiteSpace) {\n return this.tokenIndex > 1\n ? this.getTokenStart(this.tokenIndex - 1)\n : this.firstCharOffset;\n }\n }\n\n return this.tokenStart;\n}\n\nexport const name = 'Raw';\nexport const structure = {\n value: String\n};\n\nexport function parse(consumeUntil, excludeWhiteSpace) {\n const startOffset = this.getTokenStart(this.tokenIndex);\n let endOffset;\n\n this.skipUntilBalanced(this.tokenIndex, consumeUntil || this.consumeUntilBalanceEnd);\n\n if (excludeWhiteSpace && this.tokenStart > startOffset) {\n endOffset = getOffsetExcludeWS.call(this);\n } else {\n endOffset = this.tokenStart;\n }\n\n return {\n type: 'Raw',\n loc: this.getLocation(startOffset, endOffset),\n value: this.substring(startOffset, endOffset)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import { LeftCurlyBracket } from '../../tokenizer/index.js';\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilLeftCurlyBracket, true);\n}\n\nfunction consumePrelude() {\n const prelude = this.SelectorList();\n\n if (prelude.type !== 'Raw' &&\n this.eof === false &&\n this.tokenType !== LeftCurlyBracket) {\n this.error();\n }\n\n return prelude;\n}\n\nexport const name = 'Rule';\nexport const walkContext = 'rule';\nexport const structure = {\n prelude: ['SelectorList', 'Raw'],\n block: ['Block']\n};\n\nexport function parse() {\n const startToken = this.tokenIndex;\n const startOffset = this.tokenStart;\n let prelude;\n let block;\n\n if (this.parseRulePrelude) {\n prelude = this.parseWithFallback(consumePrelude, consumeRaw);\n } else {\n prelude = consumeRaw.call(this, startToken);\n }\n\n block = this.Block(true);\n\n return {\n type: 'Rule',\n loc: this.getLocation(startOffset, this.tokenStart),\n prelude,\n block\n };\n}\nexport function generate(node) {\n this.node(node.prelude);\n this.node(node.block);\n}\n\n","import {\n Ident,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Scope';\nexport const structure = {\n root: ['SelectorList', 'Raw', null],\n limit: ['SelectorList', 'Raw', null]\n};\n\nexport function parse() {\n let root = null;\n let limit = null;\n\n this.skipSC();\n\n const startOffset = this.tokenStart;\n if (this.tokenType === LeftParenthesis) {\n this.next();\n this.skipSC();\n root = this.parseWithFallback(\n this.SelectorList,\n () => this.Raw(false, true)\n );\n this.skipSC();\n this.eat(RightParenthesis);\n }\n\n if (this.lookupNonWSType(0) === Ident) {\n this.skipSC();\n this.eatIdent('to');\n this.skipSC();\n this.eat(LeftParenthesis);\n this.skipSC();\n limit = this.parseWithFallback(\n this.SelectorList,\n () => this.Raw(false, true)\n );\n this.skipSC();\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Scope',\n loc: this.getLocation(startOffset, this.tokenStart),\n root,\n limit\n };\n}\n\nexport function generate(node) {\n if (node.root) {\n this.token(LeftParenthesis, '(');\n this.node(node.root);\n this.token(RightParenthesis, ')');\n }\n\n if (node.limit) {\n this.token(Ident, 'to');\n this.token(LeftParenthesis, '(');\n this.node(node.limit);\n this.token(RightParenthesis, ')');\n }\n}\n","export const name = 'Selector';\nexport const structure = {\n children: [[\n 'TypeSelector',\n 'IdSelector',\n 'ClassSelector',\n 'AttributeSelector',\n 'PseudoClassSelector',\n 'PseudoElementSelector',\n 'Combinator'\n ]]\n};\n\nexport function parse() {\n const children = this.readSequence(this.scope.Selector);\n\n // nothing were consumed\n if (this.getFirstListNode(children) === null) {\n this.error('Selector is expected');\n }\n\n return {\n type: 'Selector',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'SelectorList';\nexport const walkContext = 'selector';\nexport const structure = {\n children: [[\n 'Selector',\n 'Raw'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n while (!this.eof) {\n children.push(this.Selector());\n\n if (this.tokenType === Comma) {\n this.next();\n continue;\n }\n\n break;\n }\n\n return {\n type: 'SelectorList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import {\n isHexDigit,\n isWhiteSpace,\n isValidEscape,\n consumeEscaped,\n decodeEscaped\n} from '../tokenizer/index.js';\n\nconst REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\nconst QUOTATION_MARK = 0x0022; // \"\nconst APOSTROPHE = 0x0027; // '\n\nexport function decode(str) {\n const len = str.length;\n const firstChar = str.charCodeAt(0);\n const start = firstChar === QUOTATION_MARK || firstChar === APOSTROPHE ? 1 : 0;\n const end = start === 1 && len > 1 && str.charCodeAt(len - 1) === firstChar ? len - 2 : len - 1;\n let decoded = '';\n\n for (let i = start; i <= end; i++) {\n let code = str.charCodeAt(i);\n\n if (code === REVERSE_SOLIDUS) {\n // special case at the ending\n if (i === end) {\n // if the next input code point is EOF, do nothing\n // otherwise include last quote as escaped\n if (i !== len - 1) {\n decoded = str.substr(i + 1);\n }\n break;\n }\n\n code = str.charCodeAt(++i);\n\n // consume escaped\n if (isValidEscape(REVERSE_SOLIDUS, code)) {\n const escapeStart = i - 1;\n const escapeEnd = consumeEscaped(str, escapeStart);\n\n i = escapeEnd - 1;\n decoded += decodeEscaped(str.substring(escapeStart + 1, escapeEnd));\n } else {\n // \\r\\n\n if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {\n i++;\n }\n }\n } else {\n decoded += str[i];\n }\n }\n\n return decoded;\n}\n\n// https://drafts.csswg.org/cssom/#serialize-a-string\n// § 2.1. Common Serializing Idioms\nexport function encode(str, apostrophe) {\n const quote = apostrophe ? '\\'' : '\"';\n const quoteCode = apostrophe ? APOSTROPHE : QUOTATION_MARK;\n let encoded = '';\n let wsBeforeHexIsNeeded = false;\n\n for (let i = 0; i < str.length; i++) {\n const code = str.charCodeAt(i);\n\n // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).\n if (code === 0x0000) {\n encoded += '\\uFFFD';\n continue;\n }\n\n // If the character is in the range [\\1-\\1f] (U+0001 to U+001F) or is U+007F,\n // the character escaped as code point.\n // Note: Do not compare with 0x0001 since 0x0000 is precessed before\n if (code <= 0x001f || code === 0x007F) {\n encoded += '\\\\' + code.toString(16);\n wsBeforeHexIsNeeded = true;\n continue;\n }\n\n // If the character is '\"' (U+0022) or \"\\\" (U+005C), the escaped character.\n if (code === quoteCode || code === REVERSE_SOLIDUS) {\n encoded += '\\\\' + str.charAt(i);\n wsBeforeHexIsNeeded = false;\n } else {\n if (wsBeforeHexIsNeeded && (isHexDigit(code) || isWhiteSpace(code))) {\n encoded += ' ';\n }\n\n // Otherwise, the character itself.\n encoded += str.charAt(i);\n wsBeforeHexIsNeeded = false;\n }\n }\n\n return quote + encoded + quote;\n}\n","import { String as StringToken } from '../../tokenizer/index.js';\nimport { decode, encode } from '../../utils/string.js';\n\nexport const name = 'String';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'String',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: decode(this.consume(StringToken))\n };\n}\n\nexport function generate(node) {\n this.token(StringToken, encode(node.value));\n}\n","import {\n WhiteSpace,\n Comment,\n AtKeyword,\n CDO,\n CDC\n} from '../../tokenizer/index.js';\n\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\n\nfunction consumeRaw() {\n return this.Raw(null, false);\n}\n\nexport const name = 'StyleSheet';\nexport const walkContext = 'stylesheet';\nexport const structure = {\n children: [[\n 'Comment',\n 'CDO',\n 'CDC',\n 'Atrule',\n 'Rule',\n 'Raw'\n ]]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const children = this.createList();\n let child;\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case WhiteSpace:\n this.next();\n continue;\n\n case Comment:\n // ignore comments except exclamation comments (i.e. /*! .. */) on top level\n if (this.charCodeAt(this.tokenStart + 2) !== EXCLAMATIONMARK) {\n this.next();\n continue;\n }\n\n child = this.Comment();\n break;\n\n case CDO: // <!--\n child = this.CDO();\n break;\n\n case CDC: // -->\n child = this.CDC();\n break;\n\n // CSS Syntax Module Level 3\n // §2.2 Error handling\n // At the \"top level\" of a stylesheet, an <at-keyword-token> starts an at-rule.\n case AtKeyword:\n child = this.parseWithFallback(this.Atrule, consumeRaw);\n break;\n\n // Anything else starts a qualified rule ...\n default:\n child = this.parseWithFallback(this.Rule, consumeRaw);\n }\n\n children.push(child);\n }\n\n return {\n type: 'StyleSheet',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import {\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'SupportsDeclaration';\nexport const structure = {\n declaration: 'Declaration'\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(LeftParenthesis);\n this.skipSC();\n\n const declaration = this.Declaration();\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'SupportsDeclaration',\n loc: this.getLocation(start, this.tokenStart),\n declaration\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.node(node.declaration);\n this.token(RightParenthesis, ')');\n}\n","import { Ident } from '../../tokenizer/index.js';\n\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\n\nfunction eatIdentifierOrAsterisk() {\n if (this.tokenType !== Ident &&\n this.isDelim(ASTERISK) === false) {\n this.error('Identifier or asterisk is expected');\n }\n\n this.next();\n}\n\nexport const name = 'TypeSelector';\nexport const structure = {\n name: String\n};\n\n// ident\n// ident|ident\n// ident|*\n// *\n// *|ident\n// *|*\n// |ident\n// |*\nexport function parse() {\n const start = this.tokenStart;\n\n if (this.isDelim(VERTICALLINE)) {\n this.next();\n eatIdentifierOrAsterisk.call(this);\n } else {\n eatIdentifierOrAsterisk.call(this);\n\n if (this.isDelim(VERTICALLINE)) {\n this.next();\n eatIdentifierOrAsterisk.call(this);\n }\n }\n\n return {\n type: 'TypeSelector',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import {\n isHexDigit,\n Ident,\n Number,\n Dimension\n} from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)\n\nfunction eatHexSequence(offset, allowDash) {\n let len = 0;\n\n for (let pos = this.tokenStart + offset; pos < this.tokenEnd; pos++) {\n const code = this.charCodeAt(pos);\n\n if (code === HYPHENMINUS && allowDash && len !== 0) {\n eatHexSequence.call(this, offset + len + 1, false);\n return -1;\n }\n\n if (!isHexDigit(code)) {\n this.error(\n allowDash && len !== 0\n ? 'Hyphen minus' + (len < 6 ? ' or hex digit' : '') + ' is expected'\n : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),\n pos\n );\n }\n\n if (++len > 6) {\n this.error('Too many hex digits', pos);\n };\n }\n\n this.next();\n return len;\n}\n\nfunction eatQuestionMarkSequence(max) {\n let count = 0;\n\n while (this.isDelim(QUESTIONMARK)) {\n if (++count > max) {\n this.error('Too many question marks');\n }\n\n this.next();\n }\n}\n\nfunction startsWith(code) {\n if (this.charCodeAt(this.tokenStart) !== code) {\n this.error((code === PLUSSIGN ? 'Plus sign' : 'Hyphen minus') + ' is expected');\n }\n}\n\n// https://drafts.csswg.org/css-syntax/#urange\n// Informally, the <urange> production has three forms:\n// U+0001\n// Defines a range consisting of a single code point, in this case the code point \"1\".\n// U+0001-00ff\n// Defines a range of codepoints between the first and the second value, in this case\n// the range between \"1\" and \"ff\" (255 in decimal) inclusive.\n// U+00??\n// Defines a range of codepoints where the \"?\" characters range over all hex digits,\n// in this case defining the same as the value U+0000-00ff.\n// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat \"?\" as a hexadecimal digit).\n//\n// <urange> =\n// u '+' <ident-token> '?'* |\n// u <dimension-token> '?'* |\n// u <number-token> '?'* |\n// u <number-token> <dimension-token> |\n// u <number-token> <number-token> |\n// u '+' '?'+\nfunction scanUnicodeRange() {\n let hexLength = 0;\n\n switch (this.tokenType) {\n case Number:\n // u <number-token> '?'*\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n hexLength = eatHexSequence.call(this, 1, true);\n\n if (this.isDelim(QUESTIONMARK)) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n break;\n }\n\n if (this.tokenType === Dimension ||\n this.tokenType === Number) {\n startsWith.call(this, HYPHENMINUS);\n eatHexSequence.call(this, 1, false);\n break;\n }\n\n break;\n\n case Dimension:\n // u <dimension-token> '?'*\n hexLength = eatHexSequence.call(this, 1, true);\n\n if (hexLength > 0) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n }\n\n break;\n\n default:\n // u '+' <ident-token> '?'*\n // u '+' '?'+\n this.eatDelim(PLUSSIGN);\n\n if (this.tokenType === Ident) {\n hexLength = eatHexSequence.call(this, 0, true);\n if (hexLength > 0) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n }\n break;\n }\n\n if (this.isDelim(QUESTIONMARK)) {\n this.next();\n eatQuestionMarkSequence.call(this, 5);\n break;\n }\n\n this.error('Hex digit or question mark is expected');\n }\n}\n\nexport const name = 'UnicodeRange';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n // U or u\n this.eatIdent('u');\n scanUnicodeRange.call(this);\n\n return {\n type: 'UnicodeRange',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import * as url from '../../utils/url.js';\nimport * as string from '../../utils/string.js';\nimport {\n Function as FunctionToken,\n String as StringToken,\n Url,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Url';\nexport const structure = {\n value: String\n};\n\n// <url-token> | <function-token> <string> )\nexport function parse() {\n const start = this.tokenStart;\n let value;\n\n switch (this.tokenType) {\n case Url:\n value = url.decode(this.consume(Url));\n break;\n\n case FunctionToken:\n if (!this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')) {\n this.error('Function name must be `url`');\n }\n\n this.eat(FunctionToken);\n this.skipSC();\n value = string.decode(this.consume(StringToken));\n this.skipSC();\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n break;\n\n default:\n this.error('Url or Function is expected');\n }\n\n return {\n type: 'Url',\n loc: this.getLocation(start, this.tokenStart),\n value\n };\n}\n\nexport function generate(node) {\n this.token(Url, url.encode(node.value));\n}\n","import {\n isHexDigit,\n isWhiteSpace,\n isValidEscape,\n consumeEscaped,\n decodeEscaped\n} from '../tokenizer/index.js';\n\nconst SPACE = 0x0020; // U+0020 SPACE\nconst REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\nconst QUOTATION_MARK = 0x0022; // \"\nconst APOSTROPHE = 0x0027; // '\nconst LEFTPARENTHESIS = 0x0028; // U+0028 LEFT PARENTHESIS (()\nconst RIGHTPARENTHESIS = 0x0029; // U+0029 RIGHT PARENTHESIS ())\n\nexport function decode(str) {\n const len = str.length;\n let start = 4; // length of \"url(\"\n let end = str.charCodeAt(len - 1) === RIGHTPARENTHESIS ? len - 2 : len - 1;\n let decoded = '';\n\n while (start < end && isWhiteSpace(str.charCodeAt(start))) {\n start++;\n }\n\n while (start < end && isWhiteSpace(str.charCodeAt(end))) {\n end--;\n }\n\n for (let i = start; i <= end; i++) {\n let code = str.charCodeAt(i);\n\n if (code === REVERSE_SOLIDUS) {\n // special case at the ending\n if (i === end) {\n // if the next input code point is EOF, do nothing\n // otherwise include last left parenthesis as escaped\n if (i !== len - 1) {\n decoded = str.substr(i + 1);\n }\n break;\n }\n\n code = str.charCodeAt(++i);\n\n // consume escaped\n if (isValidEscape(REVERSE_SOLIDUS, code)) {\n const escapeStart = i - 1;\n const escapeEnd = consumeEscaped(str, escapeStart);\n\n i = escapeEnd - 1;\n decoded += decodeEscaped(str.substring(escapeStart + 1, escapeEnd));\n } else {\n // \\r\\n\n if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {\n i++;\n }\n }\n } else {\n decoded += str[i];\n }\n }\n\n return decoded;\n}\n\nexport function encode(str) {\n let encoded = '';\n let wsBeforeHexIsNeeded = false;\n\n for (let i = 0; i < str.length; i++) {\n const code = str.charCodeAt(i);\n\n // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).\n if (code === 0x0000) {\n encoded += '\\uFFFD';\n continue;\n }\n\n // If the character is in the range [\\1-\\1f] (U+0001 to U+001F) or is U+007F,\n // the character escaped as code point.\n // Note: Do not compare with 0x0001 since 0x0000 is precessed before\n if (code <= 0x001f || code === 0x007F) {\n encoded += '\\\\' + code.toString(16);\n wsBeforeHexIsNeeded = true;\n continue;\n }\n\n if (code === SPACE ||\n code === REVERSE_SOLIDUS ||\n code === QUOTATION_MARK ||\n code === APOSTROPHE ||\n code === LEFTPARENTHESIS ||\n code === RIGHTPARENTHESIS) {\n encoded += '\\\\' + str.charAt(i);\n wsBeforeHexIsNeeded = false;\n } else {\n if (wsBeforeHexIsNeeded && isHexDigit(code)) {\n encoded += ' ';\n }\n\n encoded += str.charAt(i);\n wsBeforeHexIsNeeded = false;\n }\n }\n\n return 'url(' + encoded + ')';\n}\n","export const name = 'Value';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const children = this.readSequence(this.scope.Value);\n\n return {\n type: 'Value',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import { WhiteSpace } from '../../tokenizer/index.js';\n\nconst SPACE = Object.freeze({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n});\n\nexport const name = 'WhiteSpace';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n this.eat(WhiteSpace);\n return SPACE;\n\n // return {\n // type: 'WhiteSpace',\n // loc: this.getLocation(this.tokenStart, this.tokenEnd),\n // value: this.consume(WHITESPACE)\n // };\n}\n\nexport function generate(node) {\n this.token(WhiteSpace, node.value);\n}\n","import { cssWideKeywords } from '../../lexer/generic-const.js';\nimport definitions from '../../data.js';\nimport * as node from '../node/index.js';\n\nexport default {\n generic: true,\n cssWideKeywords,\n ...definitions,\n node\n};\n","export default {\n \"generic\": true,\n \"cssWideKeywords\": [\n \"initial\",\n \"inherit\",\n \"unset\",\n \"revert\",\n \"revert-layer\"\n ],\n \"units\": {\n \"angle\": [\n \"deg\",\n \"grad\",\n \"rad\",\n \"turn\"\n ],\n \"decibel\": [\n \"db\"\n ],\n \"flex\": [\n \"fr\"\n ],\n \"frequency\": [\n \"hz\",\n \"khz\"\n ],\n \"length\": [\n \"cm\",\n \"mm\",\n \"q\",\n \"in\",\n \"pt\",\n \"pc\",\n \"px\",\n \"em\",\n \"rem\",\n \"ex\",\n \"rex\",\n \"cap\",\n \"rcap\",\n \"ch\",\n \"rch\",\n \"ic\",\n \"ric\",\n \"lh\",\n \"rlh\",\n \"vw\",\n \"svw\",\n \"lvw\",\n \"dvw\",\n \"vh\",\n \"svh\",\n \"lvh\",\n \"dvh\",\n \"vi\",\n \"svi\",\n \"lvi\",\n \"dvi\",\n \"vb\",\n \"svb\",\n \"lvb\",\n \"dvb\",\n \"vmin\",\n \"svmin\",\n \"lvmin\",\n \"dvmin\",\n \"vmax\",\n \"svmax\",\n \"lvmax\",\n \"dvmax\",\n \"cqw\",\n \"cqh\",\n \"cqi\",\n \"cqb\",\n \"cqmin\",\n \"cqmax\"\n ],\n \"resolution\": [\n \"dpi\",\n \"dpcm\",\n \"dppx\",\n \"x\"\n ],\n \"semitones\": [\n \"st\"\n ],\n \"time\": [\n \"s\",\n \"ms\"\n ]\n },\n \"types\": {\n \"abs()\": \"abs( <calc-sum> )\",\n \"absolute-size\": \"xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large\",\n \"acos()\": \"acos( <calc-sum> )\",\n \"alpha-value\": \"<number>|<percentage>\",\n \"angle-percentage\": \"<angle>|<percentage>\",\n \"angular-color-hint\": \"<angle-percentage>\",\n \"angular-color-stop\": \"<color>&&<color-stop-angle>?\",\n \"angular-color-stop-list\": \"[<angular-color-stop> [, <angular-color-hint>]?]# , <angular-color-stop>\",\n \"animateable-feature\": \"scroll-position|contents|<custom-ident>\",\n \"asin()\": \"asin( <calc-sum> )\",\n \"atan()\": \"atan( <calc-sum> )\",\n \"atan2()\": \"atan2( <calc-sum> , <calc-sum> )\",\n \"attachment\": \"scroll|fixed|local\",\n \"attr()\": \"attr( <attr-name> <type-or-unit>? [, <attr-fallback>]? )\",\n \"attr-matcher\": \"['~'|'|'|'^'|'$'|'*']? '='\",\n \"attr-modifier\": \"i|s\",\n \"attribute-selector\": \"'[' <wq-name> ']'|'[' <wq-name> <attr-matcher> [<string-token>|<ident-token>] <attr-modifier>? ']'\",\n \"auto-repeat\": \"repeat( [auto-fill|auto-fit] , [<line-names>? <fixed-size>]+ <line-names>? )\",\n \"auto-track-list\": \"[<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>? <auto-repeat> [<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>?\",\n \"axis\": \"block|inline|x|y\",\n \"baseline-position\": \"[first|last]? baseline\",\n \"basic-shape\": \"<inset()>|<xywh()>|<rect()>|<circle()>|<ellipse()>|<polygon()>|<path()>\",\n \"bg-image\": \"none|<image>\",\n \"bg-layer\": \"<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>\",\n \"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>?]]\",\n \"bg-size\": \"[<length-percentage>|auto]{1,2}|cover|contain\",\n \"blur()\": \"blur( <length> )\",\n \"blend-mode\": \"normal|multiply|screen|overlay|darken|lighten|color-dodge|color-burn|hard-light|soft-light|difference|exclusion|hue|saturation|color|luminosity\",\n \"box\": \"border-box|padding-box|content-box\",\n \"brightness()\": \"brightness( <number-percentage> )\",\n \"calc()\": \"calc( <calc-sum> )\",\n \"calc-sum\": \"<calc-product> [['+'|'-'] <calc-product>]*\",\n \"calc-product\": \"<calc-value> ['*' <calc-value>|'/' <number>]*\",\n \"calc-value\": \"<number>|<dimension>|<percentage>|<calc-constant>|( <calc-sum> )\",\n \"calc-constant\": \"e|pi|infinity|-infinity|NaN\",\n \"cf-final-image\": \"<image>|<color>\",\n \"cf-mixing-image\": \"<percentage>?&&<image>\",\n \"circle()\": \"circle( [<shape-radius>]? [at <position>]? )\",\n \"clamp()\": \"clamp( <calc-sum>#{3} )\",\n \"class-selector\": \"'.' <ident-token>\",\n \"clip-source\": \"<url>\",\n \"color\": \"<color-base>|currentColor|<system-color>|<device-cmyk()>|<light-dark()>|<-non-standard-color>\",\n \"color-stop\": \"<color-stop-length>|<color-stop-angle>\",\n \"color-stop-angle\": \"<angle-percentage>{1,2}\",\n \"color-stop-length\": \"<length-percentage>{1,2}\",\n \"color-stop-list\": \"[<linear-color-stop> [, <linear-color-hint>]?]# , <linear-color-stop>\",\n \"color-interpolation-method\": \"in [<rectangular-color-space>|<polar-color-space> <hue-interpolation-method>?|<custom-color-space>]\",\n \"combinator\": \"'>'|'+'|'~'|['|' '|']\",\n \"common-lig-values\": \"[common-ligatures|no-common-ligatures]\",\n \"compat-auto\": \"searchfield|textarea|push-button|slider-horizontal|checkbox|radio|square-button|menulist|listbox|meter|progress-bar|button\",\n \"composite-style\": \"clear|copy|source-over|source-in|source-out|source-atop|destination-over|destination-in|destination-out|destination-atop|xor\",\n \"compositing-operator\": \"add|subtract|intersect|exclude\",\n \"compound-selector\": \"[<type-selector>? <subclass-selector>*]!\",\n \"compound-selector-list\": \"<compound-selector>#\",\n \"complex-selector\": \"<complex-selector-unit> [<combinator>? <complex-selector-unit>]*\",\n \"complex-selector-list\": \"<complex-selector>#\",\n \"conic-gradient()\": \"conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )\",\n \"contextual-alt-values\": \"[contextual|no-contextual]\",\n \"content-distribution\": \"space-between|space-around|space-evenly|stretch\",\n \"content-list\": \"[<string>|contents|<image>|<counter>|<quote>|<target>|<leader()>|<attr()>]+\",\n \"content-position\": \"center|start|end|flex-start|flex-end\",\n \"content-replacement\": \"<image>\",\n \"contrast()\": \"contrast( [<number-percentage>] )\",\n \"cos()\": \"cos( <calc-sum> )\",\n \"counter\": \"<counter()>|<counters()>\",\n \"counter()\": \"counter( <counter-name> , <counter-style>? )\",\n \"counter-name\": \"<custom-ident>\",\n \"counter-style\": \"<counter-style-name>|symbols( )\",\n \"counter-style-name\": \"<custom-ident>\",\n \"counters()\": \"counters( <counter-name> , <string> , <counter-style>? )\",\n \"cross-fade()\": \"cross-fade( <cf-mixing-image> , <cf-final-image>? )\",\n \"cubic-bezier-timing-function\": \"ease|ease-in|ease-out|ease-in-out|cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )\",\n \"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\",\n \"discretionary-lig-values\": \"[discretionary-ligatures|no-discretionary-ligatures]\",\n \"display-box\": \"contents|none\",\n \"display-inside\": \"flow|flow-root|table|flex|grid|ruby\",\n \"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\",\n \"display-legacy\": \"inline-block|inline-list-item|inline-table|inline-flex|inline-grid\",\n \"display-listitem\": \"<display-outside>?&&[flow|flow-root]?&&list-item\",\n \"display-outside\": \"block|inline|run-in\",\n \"drop-shadow()\": \"drop-shadow( <length>{2,3} <color>? )\",\n \"east-asian-variant-values\": \"[jis78|jis83|jis90|jis04|simplified|traditional]\",\n \"east-asian-width-values\": \"[full-width|proportional-width]\",\n \"element()\": \"element( <custom-ident> , [first|start|last|first-except]? )|element( <id-selector> )\",\n \"ellipse()\": \"ellipse( [<shape-radius>{2}]? [at <position>]? )\",\n \"ending-shape\": \"circle|ellipse\",\n \"env()\": \"env( <custom-ident> , <declaration-value>? )\",\n \"exp()\": \"exp( <calc-sum> )\",\n \"explicit-track-list\": \"[<line-names>? <track-size>]+ <line-names>?\",\n \"family-name\": \"<string>|<custom-ident>+\",\n \"feature-tag-value\": \"<string> [<integer>|on|off]?\",\n \"feature-type\": \"@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation\",\n \"feature-value-block\": \"<feature-type> '{' <feature-value-declaration-list> '}'\",\n \"feature-value-block-list\": \"<feature-value-block>+\",\n \"feature-value-declaration\": \"<custom-ident> : <integer>+ ;\",\n \"feature-value-declaration-list\": \"<feature-value-declaration>\",\n \"feature-value-name\": \"<custom-ident>\",\n \"fill-rule\": \"nonzero|evenodd\",\n \"filter-function\": \"<blur()>|<brightness()>|<contrast()>|<drop-shadow()>|<grayscale()>|<hue-rotate()>|<invert()>|<opacity()>|<saturate()>|<sepia()>\",\n \"filter-function-list\": \"[<filter-function>|<url>]+\",\n \"final-bg-layer\": \"<'background-color'>||<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>\",\n \"fixed-breadth\": \"<length-percentage>\",\n \"fixed-repeat\": \"repeat( [<integer [1,∞]>] , [<line-names>? <fixed-size>]+ <line-names>? )\",\n \"fixed-size\": \"<fixed-breadth>|minmax( <fixed-breadth> , <track-breadth> )|minmax( <inflexible-breadth> , <fixed-breadth> )\",\n \"font-stretch-absolute\": \"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|<percentage>\",\n \"font-variant-css21\": \"[normal|small-caps]\",\n \"font-weight-absolute\": \"normal|bold|<number [1,1000]>\",\n \"frequency-percentage\": \"<frequency>|<percentage>\",\n \"general-enclosed\": \"[<function-token> <any-value>? )]|[( <any-value>? )]\",\n \"generic-family\": \"<generic-script-specific>|<generic-complete>|<generic-incomplete>|<-non-standard-generic-family>\",\n \"generic-name\": \"serif|sans-serif|cursive|fantasy|monospace\",\n \"geometry-box\": \"<shape-box>|fill-box|stroke-box|view-box\",\n \"gradient\": \"<linear-gradient()>|<repeating-linear-gradient()>|<radial-gradient()>|<repeating-radial-gradient()>|<conic-gradient()>|<repeating-conic-gradient()>|<-legacy-gradient>\",\n \"grayscale()\": \"grayscale( <number-percentage> )\",\n \"grid-line\": \"auto|<custom-ident>|[<integer>&&<custom-ident>?]|[span&&[<integer>||<custom-ident>]]\",\n \"historical-lig-values\": \"[historical-ligatures|no-historical-ligatures]\",\n \"hsl()\": \"hsl( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsl( <hue> , <percentage> , <percentage> , <alpha-value>? )\",\n \"hsla()\": \"hsla( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsla( <hue> , <percentage> , <percentage> , <alpha-value>? )\",\n \"hue\": \"<number>|<angle>\",\n \"hue-rotate()\": \"hue-rotate( <angle> )\",\n \"hue-interpolation-method\": \"[shorter|longer|increasing|decreasing] hue\",\n \"hwb()\": \"hwb( [<hue>|none] [<percentage>|none] [<percentage>|none] [/ [<alpha-value>|none]]? )\",\n \"hypot()\": \"hypot( <calc-sum># )\",\n \"image\": \"<url>|<image()>|<image-set()>|<element()>|<paint()>|<cross-fade()>|<gradient>\",\n \"image()\": \"image( <image-tags>? [<image-src>? , <color>?]! )\",\n \"image-set()\": \"image-set( <image-set-option># )\",\n \"image-set-option\": \"[<image>|<string>] [<resolution>||type( <string> )]\",\n \"image-src\": \"<url>|<string>\",\n \"image-tags\": \"ltr|rtl\",\n \"inflexible-breadth\": \"<length-percentage>|min-content|max-content|auto\",\n \"inset()\": \"inset( <length-percentage>{1,4} [round <'border-radius'>]? )\",\n \"invert()\": \"invert( <number-percentage> )\",\n \"keyframes-name\": \"<custom-ident>|<string>\",\n \"keyframe-block\": \"<keyframe-selector># { <declaration-list> }\",\n \"keyframe-block-list\": \"<keyframe-block>+\",\n \"keyframe-selector\": \"from|to|<percentage>|<timeline-range-name> <percentage>\",\n \"lab()\": \"lab( [<percentage>|<number>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"layer()\": \"layer( <layer-name> )\",\n \"layer-name\": \"<ident> ['.' <ident>]*\",\n \"lch()\": \"lch( [<percentage>|<number>|none] [<percentage>|<number>|none] [<hue>|none] [/ [<alpha-value>|none]]? )\",\n \"leader()\": \"leader( <leader-type> )\",\n \"leader-type\": \"dotted|solid|space|<string>\",\n \"length-percentage\": \"<length>|<percentage>\",\n \"light-dark()\": \"light-dark( <color> , <color> )\",\n \"line-names\": \"'[' <custom-ident>* ']'\",\n \"line-name-list\": \"[<line-names>|<name-repeat>]+\",\n \"line-style\": \"none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset\",\n \"line-width\": \"<length>|thin|medium|thick\",\n \"linear-color-hint\": \"<length-percentage>\",\n \"linear-color-stop\": \"<color> <color-stop-length>?\",\n \"linear-gradient()\": \"linear-gradient( [[<angle>|to <side-or-corner>]||<color-interpolation-method>]? , <color-stop-list> )\",\n \"log()\": \"log( <calc-sum> , <calc-sum>? )\",\n \"mask-layer\": \"<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||<geometry-box>||[<geometry-box>|no-clip]||<compositing-operator>||<masking-mode>\",\n \"mask-position\": \"[<length-percentage>|left|center|right] [<length-percentage>|top|center|bottom]?\",\n \"mask-reference\": \"none|<image>|<mask-source>\",\n \"mask-source\": \"<url>\",\n \"masking-mode\": \"alpha|luminance|match-source\",\n \"matrix()\": \"matrix( <number>#{6} )\",\n \"matrix3d()\": \"matrix3d( <number>#{16} )\",\n \"max()\": \"max( <calc-sum># )\",\n \"media-and\": \"<media-in-parens> [and <media-in-parens>]+\",\n \"media-condition\": \"<media-not>|<media-and>|<media-or>|<media-in-parens>\",\n \"media-condition-without-or\": \"<media-not>|<media-and>|<media-in-parens>\",\n \"media-feature\": \"( [<mf-plain>|<mf-boolean>|<mf-range>] )\",\n \"media-in-parens\": \"( <media-condition> )|<media-feature>|<general-enclosed>\",\n \"media-not\": \"not <media-in-parens>\",\n \"media-or\": \"<media-in-parens> [or <media-in-parens>]+\",\n \"media-query\": \"<media-condition>|[not|only]? <media-type> [and <media-condition-without-or>]?\",\n \"media-query-list\": \"<media-query>#\",\n \"media-type\": \"<ident>\",\n \"mf-boolean\": \"<mf-name>\",\n \"mf-name\": \"<ident>\",\n \"mf-plain\": \"<mf-name> : <mf-value>\",\n \"mf-range\": \"<mf-name> ['<'|'>']? '='? <mf-value>|<mf-value> ['<'|'>']? '='? <mf-name>|<mf-value> '<' '='? <mf-name> '<' '='? <mf-value>|<mf-value> '>' '='? <mf-name> '>' '='? <mf-value>\",\n \"mf-value\": \"<number>|<dimension>|<ident>|<ratio>\",\n \"min()\": \"min( <calc-sum># )\",\n \"minmax()\": \"minmax( [<length-percentage>|min-content|max-content|auto] , [<length-percentage>|<flex>|min-content|max-content|auto] )\",\n \"mod()\": \"mod( <calc-sum> , <calc-sum> )\",\n \"name-repeat\": \"repeat( [<integer [1,∞]>|auto-fill] , <line-names>+ )\",\n \"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\",\n \"namespace-prefix\": \"<ident>\",\n \"ns-prefix\": \"[<ident-token>|'*']? '|'\",\n \"number-percentage\": \"<number>|<percentage>\",\n \"numeric-figure-values\": \"[lining-nums|oldstyle-nums]\",\n \"numeric-fraction-values\": \"[diagonal-fractions|stacked-fractions]\",\n \"numeric-spacing-values\": \"[proportional-nums|tabular-nums]\",\n \"nth\": \"<an-plus-b>|even|odd\",\n \"opacity()\": \"opacity( [<number-percentage>] )\",\n \"overflow-position\": \"unsafe|safe\",\n \"outline-radius\": \"<length>|<percentage>\",\n \"page-body\": \"<declaration>? [; <page-body>]?|<page-margin-box> <page-body>\",\n \"page-margin-box\": \"<page-margin-box-type> '{' <declaration-list> '}'\",\n \"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\",\n \"page-selector-list\": \"[<page-selector>#]?\",\n \"page-selector\": \"<pseudo-page>+|<ident> <pseudo-page>*\",\n \"page-size\": \"A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger\",\n \"path()\": \"path( [<fill-rule> ,]? <string> )\",\n \"paint()\": \"paint( <ident> , <declaration-value>? )\",\n \"perspective()\": \"perspective( [<length [0,∞]>|none] )\",\n \"polygon()\": \"polygon( <fill-rule>? , [<length-percentage> <length-percentage>]# )\",\n \"polar-color-space\": \"hsl|hwb|lch|oklch\",\n \"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>]]\",\n \"pow()\": \"pow( <calc-sum> , <calc-sum> )\",\n \"pseudo-class-selector\": \"':' <ident-token>|':' <function-token> <any-value> ')'\",\n \"pseudo-element-selector\": \"':' <pseudo-class-selector>|<legacy-pseudo-element-selector>\",\n \"pseudo-page\": \": [left|right|first|blank]\",\n \"quote\": \"open-quote|close-quote|no-open-quote|no-close-quote\",\n \"radial-gradient()\": \"radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )\",\n \"ratio\": \"<number [0,∞]> [/ <number [0,∞]>]?\",\n \"ray()\": \"ray( <angle>&&<ray-size>?&&contain?&&[at <position>]? )\",\n \"ray-size\": \"closest-side|closest-corner|farthest-side|farthest-corner|sides\",\n \"rectangular-color-space\": \"srgb|srgb-linear|display-p3|a98-rgb|prophoto-rgb|rec2020|lab|oklab|xyz|xyz-d50|xyz-d65\",\n \"relative-selector\": \"<combinator>? <complex-selector>\",\n \"relative-selector-list\": \"<relative-selector>#\",\n \"relative-size\": \"larger|smaller\",\n \"rem()\": \"rem( <calc-sum> , <calc-sum> )\",\n \"repeat-style\": \"repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}\",\n \"repeating-conic-gradient()\": \"repeating-conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )\",\n \"repeating-linear-gradient()\": \"repeating-linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )\",\n \"repeating-radial-gradient()\": \"repeating-radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )\",\n \"reversed-counter-name\": \"reversed( <counter-name> )\",\n \"rgb()\": \"rgb( <percentage>{3} [/ <alpha-value>]? )|rgb( <number>{3} [/ <alpha-value>]? )|rgb( <percentage>#{3} , <alpha-value>? )|rgb( <number>#{3} , <alpha-value>? )\",\n \"rgba()\": \"rgba( <percentage>{3} [/ <alpha-value>]? )|rgba( <number>{3} [/ <alpha-value>]? )|rgba( <percentage>#{3} , <alpha-value>? )|rgba( <number>#{3} , <alpha-value>? )\",\n \"rotate()\": \"rotate( [<angle>|<zero>] )\",\n \"rotate3d()\": \"rotate3d( <number> , <number> , <number> , [<angle>|<zero>] )\",\n \"rotateX()\": \"rotateX( [<angle>|<zero>] )\",\n \"rotateY()\": \"rotateY( [<angle>|<zero>] )\",\n \"rotateZ()\": \"rotateZ( [<angle>|<zero>] )\",\n \"round()\": \"round( <rounding-strategy>? , <calc-sum> , <calc-sum> )\",\n \"rounding-strategy\": \"nearest|up|down|to-zero\",\n \"saturate()\": \"saturate( <number-percentage> )\",\n \"scale()\": \"scale( [<number>|<percentage>]#{1,2} )\",\n \"scale3d()\": \"scale3d( [<number>|<percentage>]#{3} )\",\n \"scaleX()\": \"scaleX( [<number>|<percentage>] )\",\n \"scaleY()\": \"scaleY( [<number>|<percentage>] )\",\n \"scaleZ()\": \"scaleZ( [<number>|<percentage>] )\",\n \"scroll()\": \"scroll( [<axis>||<scroller>]? )\",\n \"scroller\": \"root|nearest|self\",\n \"self-position\": \"center|start|end|self-start|self-end|flex-start|flex-end\",\n \"shape-radius\": \"<length-percentage>|closest-side|farthest-side\",\n \"sign()\": \"sign( <calc-sum> )\",\n \"skew()\": \"skew( [<angle>|<zero>] , [<angle>|<zero>]? )\",\n \"skewX()\": \"skewX( [<angle>|<zero>] )\",\n \"skewY()\": \"skewY( [<angle>|<zero>] )\",\n \"sepia()\": \"sepia( <number-percentage> )\",\n \"shadow\": \"inset?&&<length>{2,4}&&<color>?\",\n \"shadow-t\": \"[<length>{2,3}&&<color>?]\",\n \"shape\": \"rect( <top> , <right> , <bottom> , <left> )|rect( <top> <right> <bottom> <left> )\",\n \"shape-box\": \"<box>|margin-box\",\n \"side-or-corner\": \"[left|right]||[top|bottom]\",\n \"sin()\": \"sin( <calc-sum> )\",\n \"single-animation\": \"<'animation-duration'>||<easing-function>||<'animation-delay'>||<single-animation-iteration-count>||<single-animation-direction>||<single-animation-fill-mode>||<single-animation-play-state>||[none|<keyframes-name>]||<single-animation-timeline>\",\n \"single-animation-direction\": \"normal|reverse|alternate|alternate-reverse\",\n \"single-animation-fill-mode\": \"none|forwards|backwards|both\",\n \"single-animation-iteration-count\": \"infinite|<number>\",\n \"single-animation-play-state\": \"running|paused\",\n \"single-animation-timeline\": \"auto|none|<dashed-ident>|<scroll()>|<view()>\",\n \"single-transition\": \"[none|<single-transition-property>]||<time>||<easing-function>||<time>||<transition-behavior-value>\",\n \"single-transition-property\": \"all|<custom-ident>\",\n \"size\": \"closest-side|farthest-side|closest-corner|farthest-corner|<length>|<length-percentage>{2}\",\n \"sqrt()\": \"sqrt( <calc-sum> )\",\n \"step-position\": \"jump-start|jump-end|jump-none|jump-both|start|end\",\n \"step-timing-function\": \"step-start|step-end|steps( <integer> [, <step-position>]? )\",\n \"subclass-selector\": \"<id-selector>|<class-selector>|<attribute-selector>|<pseudo-class-selector>\",\n \"supports-condition\": \"not <supports-in-parens>|<supports-in-parens> [and <supports-in-parens>]*|<supports-in-parens> [or <supports-in-parens>]*\",\n \"supports-in-parens\": \"( <supports-condition> )|<supports-feature>|<general-enclosed>\",\n \"supports-feature\": \"<supports-decl>|<supports-selector-fn>\",\n \"supports-decl\": \"( <declaration> )\",\n \"supports-selector-fn\": \"selector( <complex-selector> )\",\n \"symbol\": \"<string>|<image>|<custom-ident>\",\n \"system-color\": \"AccentColor|AccentColorText|ActiveText|ButtonBorder|ButtonFace|ButtonText|Canvas|CanvasText|Field|FieldText|GrayText|Highlight|HighlightText|LinkText|Mark|MarkText|SelectedItem|SelectedItemText|VisitedText\",\n \"tan()\": \"tan( <calc-sum> )\",\n \"target\": \"<target-counter()>|<target-counters()>|<target-text()>\",\n \"target-counter()\": \"target-counter( [<string>|<url>] , <custom-ident> , <counter-style>? )\",\n \"target-counters()\": \"target-counters( [<string>|<url>] , <custom-ident> , <string> , <counter-style>? )\",\n \"target-text()\": \"target-text( [<string>|<url>] , [content|before|after|first-letter]? )\",\n \"time-percentage\": \"<time>|<percentage>\",\n \"timeline-range-name\": \"cover|contain|entry|exit|entry-crossing|exit-crossing\",\n \"easing-function\": \"linear|<cubic-bezier-timing-function>|<step-timing-function>\",\n \"track-breadth\": \"<length-percentage>|<flex>|min-content|max-content|auto\",\n \"track-list\": \"[<line-names>? [<track-size>|<track-repeat>]]+ <line-names>?\",\n \"track-repeat\": \"repeat( [<integer [1,∞]>] , [<line-names>? <track-size>]+ <line-names>? )\",\n \"track-size\": \"<track-breadth>|minmax( <inflexible-breadth> , <track-breadth> )|fit-content( <length-percentage> )\",\n \"transform-function\": \"<matrix()>|<translate()>|<translateX()>|<translateY()>|<scale()>|<scaleX()>|<scaleY()>|<rotate()>|<skew()>|<skewX()>|<skewY()>|<matrix3d()>|<translate3d()>|<translateZ()>|<scale3d()>|<scaleZ()>|<rotate3d()>|<rotateX()>|<rotateY()>|<rotateZ()>|<perspective()>\",\n \"transform-list\": \"<transform-function>+\",\n \"transition-behavior-value\": \"normal|allow-discrete\",\n \"translate()\": \"translate( <length-percentage> , <length-percentage>? )\",\n \"translate3d()\": \"translate3d( <length-percentage> , <length-percentage> , <length> )\",\n \"translateX()\": \"translateX( <length-percentage> )\",\n \"translateY()\": \"translateY( <length-percentage> )\",\n \"translateZ()\": \"translateZ( <length> )\",\n \"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|%\",\n \"type-selector\": \"<wq-name>|<ns-prefix>? '*'\",\n \"var()\": \"var( <custom-property-name> , <declaration-value>? )\",\n \"view()\": \"view( [<axis>||<'view-timeline-inset'>]? )\",\n \"viewport-length\": \"auto|<length-percentage>\",\n \"visual-box\": \"content-box|padding-box|border-box\",\n \"wq-name\": \"<ns-prefix>? <ident-token>\",\n \"-legacy-gradient\": \"<-webkit-gradient()>|<-legacy-linear-gradient>|<-legacy-repeating-linear-gradient>|<-legacy-radial-gradient>|<-legacy-repeating-radial-gradient>\",\n \"-legacy-linear-gradient\": \"-moz-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-linear-gradient( <-legacy-linear-gradient-arguments> )\",\n \"-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> )\",\n \"-legacy-linear-gradient-arguments\": \"[<angle>|<side-or-corner>]? , <color-stop-list>\",\n \"-legacy-radial-gradient\": \"-moz-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-radial-gradient( <-legacy-radial-gradient-arguments> )\",\n \"-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> )\",\n \"-legacy-radial-gradient-arguments\": \"[<position> ,]? [[[<-legacy-radial-gradient-shape>||<-legacy-radial-gradient-size>]|[<length>|<percentage>]{2}] ,]? <color-stop-list>\",\n \"-legacy-radial-gradient-size\": \"closest-side|closest-corner|farthest-side|farthest-corner|contain|cover\",\n \"-legacy-radial-gradient-shape\": \"circle|ellipse\",\n \"-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\",\n \"-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\",\n \"-non-standard-image-rendering\": \"optimize-contrast|-moz-crisp-edges|-o-crisp-edges|-webkit-optimize-contrast\",\n \"-non-standard-overflow\": \"overlay|-moz-scrollbars-none|-moz-scrollbars-horizontal|-moz-scrollbars-vertical|-moz-hidden-unscrollable\",\n \"-non-standard-size\": \"intrinsic|min-intrinsic|-webkit-fill-available|-webkit-fit-content|-webkit-min-content|-webkit-max-content|-moz-available|-moz-fit-content|-moz-min-content|-moz-max-content\",\n \"-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>]* )\",\n \"-webkit-gradient-color-stop\": \"from( <color> )|color-stop( [<number-zero-one>|<percentage>] , <color> )|to( <color> )\",\n \"-webkit-gradient-point\": \"[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]\",\n \"-webkit-gradient-radius\": \"<length>|<percentage>\",\n \"-webkit-gradient-type\": \"linear|radial\",\n \"-webkit-mask-box-repeat\": \"repeat|stretch|round\",\n \"-ms-filter-function-list\": \"<-ms-filter-function>+\",\n \"-ms-filter-function\": \"<-ms-filter-function-progid>|<-ms-filter-function-legacy>\",\n \"-ms-filter-function-progid\": \"'progid:' [<ident-token> '.']* [<ident-token>|<function-token> <any-value>? )]\",\n \"-ms-filter-function-legacy\": \"<ident-token>|<function-token> <any-value>? )\",\n \"absolute-color-base\": \"<hex-color>|<absolute-color-function>|<named-color>|transparent\",\n \"absolute-color-function\": \"<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hwb()>|<lab()>|<lch()>|<oklab()>|<oklch()>|<color()>\",\n \"age\": \"child|young|old\",\n \"anchor-name\": \"<dashed-ident>\",\n \"attr-name\": \"<wq-name>\",\n \"attr-fallback\": \"<any-value>\",\n \"bg-clip\": \"<box>|border|text\",\n \"bottom\": \"<length>|auto\",\n \"container-name\": \"<custom-ident>\",\n \"container-condition\": \"not <query-in-parens>|<query-in-parens> [[and <query-in-parens>]*|[or <query-in-parens>]*]\",\n \"coord-box\": \"content-box|padding-box|border-box|fill-box|stroke-box|view-box\",\n \"generic-voice\": \"[<age>? <gender> <integer>?]\",\n \"gender\": \"male|female|neutral\",\n \"generic-script-specific\": \"generic( kai )|generic( fangsong )|generic( nastaliq )\",\n \"generic-complete\": \"serif|sans-serif|system-ui|cursive|fantasy|math|monospace\",\n \"generic-incomplete\": \"ui-serif|ui-sans-serif|ui-monospace|ui-rounded\",\n \"-non-standard-generic-family\": \"-apple-system|BlinkMacSystemFont\",\n \"left\": \"<length>|auto\",\n \"color-base\": \"<hex-color>|<color-function>|<named-color>|<color-mix()>|transparent\",\n \"color-function\": \"<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hwb()>|<lab()>|<lch()>|<oklab()>|<oklch()>|<color()>\",\n \"device-cmyk()\": \"<legacy-device-cmyk-syntax>|<modern-device-cmyk-syntax>\",\n \"legacy-device-cmyk-syntax\": \"device-cmyk( <number>#{4} )\",\n \"modern-device-cmyk-syntax\": \"device-cmyk( <cmyk-component>{4} [/ [<alpha-value>|none]]? )\",\n \"cmyk-component\": \"<number>|<percentage>|none\",\n \"color-mix()\": \"color-mix( <color-interpolation-method> , [<color>&&<percentage [0,100]>?]#{2} )\",\n \"color-space\": \"<rectangular-color-space>|<polar-color-space>|<custom-color-space>\",\n \"custom-color-space\": \"<dashed-ident>\",\n \"paint\": \"none|<color>|<url> [none|<color>]?|context-fill|context-stroke\",\n \"palette-identifier\": \"<dashed-ident>\",\n \"right\": \"<length>|auto\",\n \"scope-start\": \"<forgiving-selector-list>\",\n \"scope-end\": \"<forgiving-selector-list>\",\n \"forgiving-selector-list\": \"<complex-real-selector-list>\",\n \"forgiving-relative-selector-list\": \"<relative-real-selector-list>\",\n \"selector-list\": \"<complex-selector-list>\",\n \"complex-real-selector-list\": \"<complex-real-selector>#\",\n \"simple-selector-list\": \"<simple-selector>#\",\n \"relative-real-selector-list\": \"<relative-real-selector>#\",\n \"complex-selector-unit\": \"[<compound-selector>? <pseudo-compound-selector>*]!\",\n \"complex-real-selector\": \"<compound-selector> [<combinator>? <compound-selector>]*\",\n \"relative-real-selector\": \"<combinator>? <complex-real-selector>\",\n \"pseudo-compound-selector\": \"<pseudo-element-selector> <pseudo-class-selector>*\",\n \"simple-selector\": \"<type-selector>|<subclass-selector>\",\n \"legacy-pseudo-element-selector\": \"':' [before|after|first-line|first-letter]\",\n \"single-animation-composition\": \"replace|add|accumulate\",\n \"svg-length\": \"<percentage>|<length>|<number>\",\n \"svg-writing-mode\": \"lr-tb|rl-tb|tb-rl|lr|rl|tb\",\n \"top\": \"<length>|auto\",\n \"x\": \"<number>\",\n \"y\": \"<number>\",\n \"declaration\": \"<ident-token> : <declaration-value>? ['!' important]?\",\n \"declaration-list\": \"[<declaration>? ';']* <declaration>?\",\n \"url\": \"url( <string> <url-modifier>* )|<url-token>\",\n \"url-modifier\": \"<ident>|<function-token> <any-value> )\",\n \"number-zero-one\": \"<number [0,1]>\",\n \"number-one-or-greater\": \"<number [1,∞]>\",\n \"color()\": \"color( <colorspace-params> [/ [<alpha-value>|none]]? )\",\n \"colorspace-params\": \"[<predefined-rgb-params>|<xyz-params>]\",\n \"predefined-rgb-params\": \"<predefined-rgb> [<number>|<percentage>|none]{3}\",\n \"predefined-rgb\": \"srgb|srgb-linear|display-p3|a98-rgb|prophoto-rgb|rec2020\",\n \"xyz-params\": \"<xyz-space> [<number>|<percentage>|none]{3}\",\n \"xyz-space\": \"xyz|xyz-d50|xyz-d65\",\n \"oklab()\": \"oklab( [<percentage>|<number>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"oklch()\": \"oklch( [<percentage>|<number>|none] [<percentage>|<number>|none] [<hue>|none] [/ [<alpha-value>|none]]? )\",\n \"offset-path\": \"<ray()>|<url>|<basic-shape>\",\n \"rect()\": \"rect( [<length-percentage>|auto]{4} [round <'border-radius'>]? )\",\n \"xywh()\": \"xywh( <length-percentage>{2} <length-percentage [0,∞]>{2} [round <'border-radius'>]? )\",\n \"query-in-parens\": \"( <container-condition> )|( <size-feature> )|style( <style-query> )|<general-enclosed>\",\n \"size-feature\": \"<mf-plain>|<mf-boolean>|<mf-range>\",\n \"style-feature\": \"<declaration>\",\n \"style-query\": \"<style-condition>|<style-feature>\",\n \"style-condition\": \"not <style-in-parens>|<style-in-parens> [[and <style-in-parens>]*|[or <style-in-parens>]*]\",\n \"style-in-parens\": \"( <style-condition> )|( <style-feature> )|<general-enclosed>\",\n \"-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\",\n \"inset-area\": \"[[left|center|right|span-left|span-right|x-start|x-end|span-x-start|span-x-end|x-self-start|x-self-end|span-x-self-start|span-x-self-end|span-all]||[top|center|bottom|span-top|span-bottom|y-start|y-end|span-y-start|span-y-end|y-self-start|y-self-end|span-y-self-start|span-y-self-end|span-all]|[block-start|center|block-end|span-block-start|span-block-end|span-all]||[inline-start|center|inline-end|span-inline-start|span-inline-end|span-all]|[self-block-start|self-block-end|span-self-block-start|span-self-block-end|span-all]||[self-inline-start|self-inline-end|span-self-inline-start|span-self-inline-end|span-all]|[start|center|end|span-start|span-end|span-all]{1,2}|[self-start|center|self-end|span-self-start|span-self-end|span-all]{1,2}]\",\n \"position-area\": \"[[left|center|right|span-left|span-right|x-start|x-end|span-x-start|span-x-end|x-self-start|x-self-end|span-x-self-start|span-x-self-end|span-all]||[top|center|bottom|span-top|span-bottom|y-start|y-end|span-y-start|span-y-end|y-self-start|y-self-end|span-y-self-start|span-y-self-end|span-all]|[block-start|center|block-end|span-block-start|span-block-end|span-all]||[inline-start|center|inline-end|span-inline-start|span-inline-end|span-all]|[self-block-start|center|self-block-end|span-self-block-start|span-self-block-end|span-all]||[self-inline-start|center|self-inline-end|span-self-inline-start|span-self-inline-end|span-all]|[start|center|end|span-start|span-end|span-all]{1,2}|[self-start|center|self-end|span-self-start|span-self-end|span-all]{1,2}]\",\n \"anchor()\": \"anchor( <anchor-element>?&&<anchor-side> , <length-percentage>? )\",\n \"anchor-side\": \"inside|outside|top|left|right|bottom|start|end|self-start|self-end|<percentage>|center\",\n \"anchor-size()\": \"anchor-size( [<anchor-element>||<anchor-size>]? , <length-percentage>? )\",\n \"anchor-size\": \"width|height|block|inline|self-block|self-inline\",\n \"anchor-element\": \"<dashed-ident>\",\n \"try-size\": \"most-width|most-height|most-block-size|most-inline-size\",\n \"try-tactic\": \"flip-block||flip-inline||flip-start\",\n \"font-variant-css2\": \"normal|small-caps\",\n \"font-width-css3\": \"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded\",\n \"system-family-name\": \"caption|icon|menu|message-box|small-caption|status-bar\"\n },\n \"properties\": {\n \"--*\": \"<declaration-value>\",\n \"-ms-accelerator\": \"false|true\",\n \"-ms-block-progression\": \"tb|rl|bt|lr\",\n \"-ms-content-zoom-chaining\": \"none|chained\",\n \"-ms-content-zooming\": \"none|zoom\",\n \"-ms-content-zoom-limit\": \"<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>\",\n \"-ms-content-zoom-limit-max\": \"<percentage>\",\n \"-ms-content-zoom-limit-min\": \"<percentage>\",\n \"-ms-content-zoom-snap\": \"<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>\",\n \"-ms-content-zoom-snap-points\": \"snapInterval( <percentage> , <percentage> )|snapList( <percentage># )\",\n \"-ms-content-zoom-snap-type\": \"none|proximity|mandatory\",\n \"-ms-filter\": \"<string>\",\n \"-ms-flow-from\": \"[none|<custom-ident>]#\",\n \"-ms-flow-into\": \"[none|<custom-ident>]#\",\n \"-ms-grid-columns\": \"none|<track-list>|<auto-track-list>\",\n \"-ms-grid-rows\": \"none|<track-list>|<auto-track-list>\",\n \"-ms-high-contrast-adjust\": \"auto|none\",\n \"-ms-hyphenate-limit-chars\": \"auto|<integer>{1,3}\",\n \"-ms-hyphenate-limit-lines\": \"no-limit|<integer>\",\n \"-ms-hyphenate-limit-zone\": \"<percentage>|<length>\",\n \"-ms-ime-align\": \"auto|after\",\n \"-ms-overflow-style\": \"auto|none|scrollbar|-ms-autohiding-scrollbar\",\n \"-ms-scrollbar-3dlight-color\": \"<color>\",\n \"-ms-scrollbar-arrow-color\": \"<color>\",\n \"-ms-scrollbar-base-color\": \"<color>\",\n \"-ms-scrollbar-darkshadow-color\": \"<color>\",\n \"-ms-scrollbar-face-color\": \"<color>\",\n \"-ms-scrollbar-highlight-color\": \"<color>\",\n \"-ms-scrollbar-shadow-color\": \"<color>\",\n \"-ms-scrollbar-track-color\": \"<color>\",\n \"-ms-scroll-chaining\": \"chained|none\",\n \"-ms-scroll-limit\": \"<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>\",\n \"-ms-scroll-limit-x-max\": \"auto|<length>\",\n \"-ms-scroll-limit-x-min\": \"<length>\",\n \"-ms-scroll-limit-y-max\": \"auto|<length>\",\n \"-ms-scroll-limit-y-min\": \"<length>\",\n \"-ms-scroll-rails\": \"none|railed\",\n \"-ms-scroll-snap-points-x\": \"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )\",\n \"-ms-scroll-snap-points-y\": \"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )\",\n \"-ms-scroll-snap-type\": \"none|proximity|mandatory\",\n \"-ms-scroll-snap-x\": \"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>\",\n \"-ms-scroll-snap-y\": \"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>\",\n \"-ms-scroll-translation\": \"none|vertical-to-horizontal\",\n \"-ms-text-autospace\": \"none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space\",\n \"-ms-touch-select\": \"grippers|none\",\n \"-ms-user-select\": \"none|element|text\",\n \"-ms-wrap-flow\": \"auto|both|start|end|maximum|clear\",\n \"-ms-wrap-margin\": \"<length>\",\n \"-ms-wrap-through\": \"wrap|none\",\n \"-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\",\n \"-moz-binding\": \"<url>|none\",\n \"-moz-border-bottom-colors\": \"<color>+|none\",\n \"-moz-border-left-colors\": \"<color>+|none\",\n \"-moz-border-right-colors\": \"<color>+|none\",\n \"-moz-border-top-colors\": \"<color>+|none\",\n \"-moz-context-properties\": \"none|[fill|fill-opacity|stroke|stroke-opacity]#\",\n \"-moz-float-edge\": \"border-box|content-box|margin-box|padding-box\",\n \"-moz-force-broken-image-icon\": \"0|1\",\n \"-moz-image-region\": \"<shape>|auto\",\n \"-moz-orient\": \"inline|block|horizontal|vertical\",\n \"-moz-outline-radius\": \"<outline-radius>{1,4} [/ <outline-radius>{1,4}]?\",\n \"-moz-outline-radius-bottomleft\": \"<outline-radius>\",\n \"-moz-outline-radius-bottomright\": \"<outline-radius>\",\n \"-moz-outline-radius-topleft\": \"<outline-radius>\",\n \"-moz-outline-radius-topright\": \"<outline-radius>\",\n \"-moz-stack-sizing\": \"ignore|stretch-to-fit\",\n \"-moz-text-blink\": \"none|blink\",\n \"-moz-user-focus\": \"ignore|normal|select-after|select-before|select-menu|select-same|select-all|none\",\n \"-moz-user-input\": \"auto|none|enabled|disabled\",\n \"-moz-user-modify\": \"read-only|read-write|write-only\",\n \"-moz-window-dragging\": \"drag|no-drag\",\n \"-moz-window-shadow\": \"default|menu|tooltip|sheet|none\",\n \"-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\",\n \"-webkit-border-before\": \"<'border-width'>||<'border-style'>||<color>\",\n \"-webkit-border-before-color\": \"<color>\",\n \"-webkit-border-before-style\": \"<'border-style'>\",\n \"-webkit-border-before-width\": \"<'border-width'>\",\n \"-webkit-box-reflect\": \"[above|below|right|left]? <length>? <image>?\",\n \"-webkit-line-clamp\": \"none|<integer>\",\n \"-webkit-mask\": \"[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<box>|border|padding|content|text]||[<box>|border|padding|content]]#\",\n \"-webkit-mask-attachment\": \"<attachment>#\",\n \"-webkit-mask-clip\": \"[<box>|border|padding|content|text]#\",\n \"-webkit-mask-composite\": \"<composite-style>#\",\n \"-webkit-mask-image\": \"<mask-reference>#\",\n \"-webkit-mask-origin\": \"[<box>|border|padding|content]#\",\n \"-webkit-mask-position\": \"<position>#\",\n \"-webkit-mask-position-x\": \"[<length-percentage>|left|center|right]#\",\n \"-webkit-mask-position-y\": \"[<length-percentage>|top|center|bottom]#\",\n \"-webkit-mask-repeat\": \"<repeat-style>#\",\n \"-webkit-mask-repeat-x\": \"repeat|no-repeat|space|round\",\n \"-webkit-mask-repeat-y\": \"repeat|no-repeat|space|round\",\n \"-webkit-mask-size\": \"<bg-size>#\",\n \"-webkit-overflow-scrolling\": \"auto|touch\",\n \"-webkit-tap-highlight-color\": \"<color>\",\n \"-webkit-text-fill-color\": \"<color>\",\n \"-webkit-text-stroke\": \"<length>||<color>\",\n \"-webkit-text-stroke-color\": \"<color>\",\n \"-webkit-text-stroke-width\": \"<length>\",\n \"-webkit-touch-callout\": \"default|none\",\n \"-webkit-user-modify\": \"read-only|read-write|read-write-plaintext-only\",\n \"accent-color\": \"auto|<color>\",\n \"align-content\": \"normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>\",\n \"align-items\": \"normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]\",\n \"align-self\": \"auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>\",\n \"align-tracks\": \"[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#\",\n \"all\": \"initial|inherit|unset|revert|revert-layer\",\n \"anchor-name\": \"none|<dashed-ident>#\",\n \"anchor-scope\": \"none|all|<dashed-ident>#\",\n \"animation\": \"<single-animation>#\",\n \"animation-composition\": \"<single-animation-composition>#\",\n \"animation-delay\": \"<time>#\",\n \"animation-direction\": \"<single-animation-direction>#\",\n \"animation-duration\": \"<time>#\",\n \"animation-fill-mode\": \"<single-animation-fill-mode>#\",\n \"animation-iteration-count\": \"<single-animation-iteration-count>#\",\n \"animation-name\": \"[none|<keyframes-name>]#\",\n \"animation-play-state\": \"<single-animation-play-state>#\",\n \"animation-range\": \"[<'animation-range-start'> <'animation-range-end'>?]#\",\n \"animation-range-end\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"animation-range-start\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"animation-timing-function\": \"<easing-function>#\",\n \"animation-timeline\": \"<single-animation-timeline>#\",\n \"appearance\": \"none|auto|textfield|menulist-button|<compat-auto>\",\n \"aspect-ratio\": \"auto||<ratio>\",\n \"azimuth\": \"<angle>|[[left-side|far-left|left|center-left|center|center-right|right|far-right|right-side]||behind]|leftwards|rightwards\",\n \"backdrop-filter\": \"none|<filter-function-list>\",\n \"backface-visibility\": \"visible|hidden\",\n \"background\": \"[<bg-layer> ,]* <final-bg-layer>\",\n \"background-attachment\": \"<attachment>#\",\n \"background-blend-mode\": \"<blend-mode>#\",\n \"background-clip\": \"<bg-clip>#\",\n \"background-color\": \"<color>\",\n \"background-image\": \"<bg-image>#\",\n \"background-origin\": \"<box>#\",\n \"background-position\": \"<bg-position>#\",\n \"background-position-x\": \"[center|[[left|right|x-start|x-end]? <length-percentage>?]!]#\",\n \"background-position-y\": \"[center|[[top|bottom|y-start|y-end]? <length-percentage>?]!]#\",\n \"background-repeat\": \"<repeat-style>#\",\n \"background-size\": \"<bg-size>#\",\n \"block-size\": \"<'width'>\",\n \"border\": \"<line-width>||<line-style>||<color>\",\n \"border-block\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-block-color\": \"<'border-top-color'>{1,2}\",\n \"border-block-style\": \"<'border-top-style'>\",\n \"border-block-width\": \"<'border-top-width'>\",\n \"border-block-end\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-block-end-color\": \"<'border-top-color'>\",\n \"border-block-end-style\": \"<'border-top-style'>\",\n \"border-block-end-width\": \"<'border-top-width'>\",\n \"border-block-start\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-block-start-color\": \"<'border-top-color'>\",\n \"border-block-start-style\": \"<'border-top-style'>\",\n \"border-block-start-width\": \"<'border-top-width'>\",\n \"border-bottom\": \"<line-width>||<line-style>||<color>\",\n \"border-bottom-color\": \"<'border-top-color'>\",\n \"border-bottom-left-radius\": \"<length-percentage>{1,2}\",\n \"border-bottom-right-radius\": \"<length-percentage>{1,2}\",\n \"border-bottom-style\": \"<line-style>\",\n \"border-bottom-width\": \"<line-width>\",\n \"border-collapse\": \"collapse|separate\",\n \"border-color\": \"<color>{1,4}\",\n \"border-end-end-radius\": \"<length-percentage>{1,2}\",\n \"border-end-start-radius\": \"<length-percentage>{1,2}\",\n \"border-image\": \"<'border-image-source'>||<'border-image-slice'> [/ <'border-image-width'>|/ <'border-image-width'>? / <'border-image-outset'>]?||<'border-image-repeat'>\",\n \"border-image-outset\": \"[<length>|<number>]{1,4}\",\n \"border-image-repeat\": \"[stretch|repeat|round|space]{1,2}\",\n \"border-image-slice\": \"<number-percentage>{1,4}&&fill?\",\n \"border-image-source\": \"none|<image>\",\n \"border-image-width\": \"[<length-percentage>|<number>|auto]{1,4}\",\n \"border-inline\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-inline-end\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-inline-color\": \"<'border-top-color'>{1,2}\",\n \"border-inline-style\": \"<'border-top-style'>\",\n \"border-inline-width\": \"<'border-top-width'>\",\n \"border-inline-end-color\": \"<'border-top-color'>\",\n \"border-inline-end-style\": \"<'border-top-style'>\",\n \"border-inline-end-width\": \"<'border-top-width'>\",\n \"border-inline-start\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-inline-start-color\": \"<'border-top-color'>\",\n \"border-inline-start-style\": \"<'border-top-style'>\",\n \"border-inline-start-width\": \"<'border-top-width'>\",\n \"border-left\": \"<line-width>||<line-style>||<color>\",\n \"border-left-color\": \"<color>\",\n \"border-left-style\": \"<line-style>\",\n \"border-left-width\": \"<line-width>\",\n \"border-radius\": \"<length-percentage>{1,4} [/ <length-percentage>{1,4}]?\",\n \"border-right\": \"<line-width>||<line-style>||<color>\",\n \"border-right-color\": \"<color>\",\n \"border-right-style\": \"<line-style>\",\n \"border-right-width\": \"<line-width>\",\n \"border-spacing\": \"<length> <length>?\",\n \"border-start-end-radius\": \"<length-percentage>{1,2}\",\n \"border-start-start-radius\": \"<length-percentage>{1,2}\",\n \"border-style\": \"<line-style>{1,4}\",\n \"border-top\": \"<line-width>||<line-style>||<color>\",\n \"border-top-color\": \"<color>\",\n \"border-top-left-radius\": \"<length-percentage>{1,2}\",\n \"border-top-right-radius\": \"<length-percentage>{1,2}\",\n \"border-top-style\": \"<line-style>\",\n \"border-top-width\": \"<line-width>\",\n \"border-width\": \"<line-width>{1,4}\",\n \"bottom\": \"<length>|<percentage>|auto\",\n \"box-align\": \"start|center|end|baseline|stretch\",\n \"box-decoration-break\": \"slice|clone\",\n \"box-direction\": \"normal|reverse|inherit\",\n \"box-flex\": \"<number>\",\n \"box-flex-group\": \"<integer>\",\n \"box-lines\": \"single|multiple\",\n \"box-ordinal-group\": \"<integer>\",\n \"box-orient\": \"horizontal|vertical|inline-axis|block-axis|inherit\",\n \"box-pack\": \"start|center|end|justify\",\n \"box-shadow\": \"none|<shadow>#\",\n \"box-sizing\": \"content-box|border-box\",\n \"break-after\": \"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region\",\n \"break-before\": \"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region\",\n \"break-inside\": \"auto|avoid|avoid-page|avoid-column|avoid-region\",\n \"caption-side\": \"top|bottom|block-start|block-end|inline-start|inline-end\",\n \"caret\": \"<'caret-color'>||<'caret-shape'>\",\n \"caret-color\": \"auto|<color>\",\n \"caret-shape\": \"auto|bar|block|underscore\",\n \"clear\": \"none|left|right|both|inline-start|inline-end\",\n \"clip\": \"<shape>|auto\",\n \"clip-path\": \"<clip-source>|[<basic-shape>||<geometry-box>]|none\",\n \"clip-rule\": \"nonzero|evenodd\",\n \"color\": \"<color>\",\n \"color-interpolation-filters\": \"auto|sRGB|linearRGB\",\n \"color-scheme\": \"normal|[light|dark|<custom-ident>]+&&only?\",\n \"column-count\": \"<integer>|auto\",\n \"column-fill\": \"auto|balance\",\n \"column-gap\": \"normal|<length-percentage>\",\n \"column-rule\": \"<'column-rule-width'>||<'column-rule-style'>||<'column-rule-color'>\",\n \"column-rule-color\": \"<color>\",\n \"column-rule-style\": \"<'border-style'>\",\n \"column-rule-width\": \"<'border-width'>\",\n \"column-span\": \"none|all\",\n \"column-width\": \"<length>|auto\",\n \"columns\": \"<'column-width'>||<'column-count'>\",\n \"contain\": \"none|strict|content|[[size||inline-size]||layout||style||paint]\",\n \"contain-intrinsic-size\": \"[auto? [none|<length>]]{1,2}\",\n \"contain-intrinsic-block-size\": \"auto? [none|<length>]\",\n \"contain-intrinsic-height\": \"auto? [none|<length>]\",\n \"contain-intrinsic-inline-size\": \"auto? [none|<length>]\",\n \"contain-intrinsic-width\": \"auto? [none|<length>]\",\n \"container\": \"<'container-name'> [/ <'container-type'>]?\",\n \"container-name\": \"none|<custom-ident>+\",\n \"container-type\": \"normal||[size|inline-size]\",\n \"content\": \"normal|none|[<content-replacement>|<content-list>] [/ [<string>|<counter>]+]?\",\n \"content-visibility\": \"visible|auto|hidden\",\n \"counter-increment\": \"[<counter-name> <integer>?]+|none\",\n \"counter-reset\": \"[<counter-name> <integer>?|<reversed-counter-name> <integer>?]+|none\",\n \"counter-set\": \"[<counter-name> <integer>?]+|none\",\n \"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]]\",\n \"d\": \"none|path( <string> )\",\n \"cx\": \"<length>|<percentage>\",\n \"cy\": \"<length>|<percentage>\",\n \"direction\": \"ltr|rtl\",\n \"display\": \"[<display-outside>||<display-inside>]|<display-listitem>|<display-internal>|<display-box>|<display-legacy>|<-non-standard-display>\",\n \"dominant-baseline\": \"auto|use-script|no-change|reset-size|ideographic|alphabetic|hanging|mathematical|central|middle|text-after-edge|text-before-edge\",\n \"empty-cells\": \"show|hide\",\n \"field-sizing\": \"content|fixed\",\n \"fill\": \"<paint>\",\n \"fill-opacity\": \"<number-zero-one>\",\n \"fill-rule\": \"nonzero|evenodd\",\n \"filter\": \"none|<filter-function-list>|<-ms-filter-function-list>\",\n \"flex\": \"none|[<'flex-grow'> <'flex-shrink'>?||<'flex-basis'>]\",\n \"flex-basis\": \"content|<'width'>\",\n \"flex-direction\": \"row|row-reverse|column|column-reverse\",\n \"flex-flow\": \"<'flex-direction'>||<'flex-wrap'>\",\n \"flex-grow\": \"<number>\",\n \"flex-shrink\": \"<number>\",\n \"flex-wrap\": \"nowrap|wrap|wrap-reverse\",\n \"float\": \"left|right|none|inline-start|inline-end\",\n \"font\": \"[[<'font-style'>||<font-variant-css2>||<'font-weight'>||<font-width-css3>]? <'font-size'> [/ <'line-height'>]? <'font-family'>#]|<system-family-name>|<-non-standard-font>\",\n \"font-family\": \"[<family-name>|<generic-family>]#\",\n \"font-feature-settings\": \"normal|<feature-tag-value>#\",\n \"font-kerning\": \"auto|normal|none\",\n \"font-language-override\": \"normal|<string>\",\n \"font-optical-sizing\": \"auto|none\",\n \"font-palette\": \"normal|light|dark|<palette-identifier>\",\n \"font-variation-settings\": \"normal|[<string> <number>]#\",\n \"font-size\": \"<absolute-size>|<relative-size>|<length-percentage>\",\n \"font-size-adjust\": \"none|[ex-height|cap-height|ch-width|ic-width|ic-height]? [from-font|<number>]\",\n \"font-smooth\": \"auto|never|always|<absolute-size>|<length>\",\n \"font-stretch\": \"<font-stretch-absolute>\",\n \"font-style\": \"normal|italic|oblique <angle>?\",\n \"font-synthesis\": \"none|[weight||style||small-caps||position]\",\n \"font-synthesis-position\": \"auto|none\",\n \"font-synthesis-small-caps\": \"auto|none\",\n \"font-synthesis-style\": \"auto|none\",\n \"font-synthesis-weight\": \"auto|none\",\n \"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]\",\n \"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> )]\",\n \"font-variant-caps\": \"normal|small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps\",\n \"font-variant-east-asian\": \"normal|[<east-asian-variant-values>||<east-asian-width-values>||ruby]\",\n \"font-variant-emoji\": \"normal|text|emoji|unicode\",\n \"font-variant-ligatures\": \"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>]\",\n \"font-variant-numeric\": \"normal|[<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero]\",\n \"font-variant-position\": \"normal|sub|super\",\n \"font-weight\": \"<font-weight-absolute>|bolder|lighter\",\n \"forced-color-adjust\": \"auto|none|preserve-parent-color\",\n \"gap\": \"<'row-gap'> <'column-gap'>?\",\n \"grid\": \"<'grid-template'>|<'grid-template-rows'> / [auto-flow&&dense?] <'grid-auto-columns'>?|[auto-flow&&dense?] <'grid-auto-rows'>? / <'grid-template-columns'>\",\n \"grid-area\": \"<grid-line> [/ <grid-line>]{0,3}\",\n \"grid-auto-columns\": \"<track-size>+\",\n \"grid-auto-flow\": \"[row|column]||dense\",\n \"grid-auto-rows\": \"<track-size>+\",\n \"grid-column\": \"<grid-line> [/ <grid-line>]?\",\n \"grid-column-end\": \"<grid-line>\",\n \"grid-column-gap\": \"<length-percentage>\",\n \"grid-column-start\": \"<grid-line>\",\n \"grid-gap\": \"<'grid-row-gap'> <'grid-column-gap'>?\",\n \"grid-row\": \"<grid-line> [/ <grid-line>]?\",\n \"grid-row-end\": \"<grid-line>\",\n \"grid-row-gap\": \"<length-percentage>\",\n \"grid-row-start\": \"<grid-line>\",\n \"grid-template\": \"none|[<'grid-template-rows'> / <'grid-template-columns'>]|[<line-names>? <string> <track-size>? <line-names>?]+ [/ <explicit-track-list>]?\",\n \"grid-template-areas\": \"none|<string>+\",\n \"grid-template-columns\": \"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?\",\n \"grid-template-rows\": \"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?\",\n \"hanging-punctuation\": \"none|[first||[force-end|allow-end]||last]\",\n \"height\": \"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"hyphenate-character\": \"auto|<string>\",\n \"hyphenate-limit-chars\": \"[auto|<integer>]{1,3}\",\n \"hyphens\": \"none|manual|auto\",\n \"image-orientation\": \"from-image|<angle>|[<angle>? flip]\",\n \"image-rendering\": \"auto|crisp-edges|pixelated|optimizeSpeed|optimizeQuality|<-non-standard-image-rendering>\",\n \"image-resolution\": \"[from-image||<resolution>]&&snap?\",\n \"ime-mode\": \"auto|normal|active|inactive|disabled\",\n \"initial-letter\": \"normal|[<number> <integer>?]\",\n \"initial-letter-align\": \"[auto|alphabetic|hanging|ideographic]\",\n \"inline-size\": \"<'width'>\",\n \"input-security\": \"auto|none\",\n \"inset\": \"<'top'>{1,4}\",\n \"inset-block\": \"<'top'>{1,2}\",\n \"inset-block-end\": \"<'top'>\",\n \"inset-block-start\": \"<'top'>\",\n \"inset-inline\": \"<'top'>{1,2}\",\n \"inset-inline-end\": \"<'top'>\",\n \"inset-inline-start\": \"<'top'>\",\n \"interpolate-size\": \"numeric-only|allow-keywords\",\n \"isolation\": \"auto|isolate\",\n \"justify-content\": \"normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]\",\n \"justify-items\": \"normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|legacy|legacy&&[left|right|center]\",\n \"justify-self\": \"auto|normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]\",\n \"justify-tracks\": \"[normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]]#\",\n \"left\": \"<length>|<percentage>|auto\",\n \"letter-spacing\": \"normal|<length-percentage>\",\n \"line-break\": \"auto|loose|normal|strict|anywhere\",\n \"line-clamp\": \"none|<integer>\",\n \"line-height\": \"normal|<number>|<length>|<percentage>\",\n \"line-height-step\": \"<length>\",\n \"list-style\": \"<'list-style-type'>||<'list-style-position'>||<'list-style-image'>\",\n \"list-style-image\": \"<image>|none\",\n \"list-style-position\": \"inside|outside\",\n \"list-style-type\": \"<counter-style>|<string>|none\",\n \"margin\": \"[<length>|<percentage>|auto]{1,4}\",\n \"margin-block\": \"<'margin-left'>{1,2}\",\n \"margin-block-end\": \"<'margin-left'>\",\n \"margin-block-start\": \"<'margin-left'>\",\n \"margin-bottom\": \"<length>|<percentage>|auto\",\n \"margin-inline\": \"<'margin-left'>{1,2}\",\n \"margin-inline-end\": \"<'margin-left'>\",\n \"margin-inline-start\": \"<'margin-left'>\",\n \"margin-left\": \"<length>|<percentage>|auto\",\n \"margin-right\": \"<length>|<percentage>|auto\",\n \"margin-top\": \"<length>|<percentage>|auto\",\n \"margin-trim\": \"none|in-flow|all\",\n \"marker\": \"none|<url>\",\n \"marker-end\": \"none|<url>\",\n \"marker-mid\": \"none|<url>\",\n \"marker-start\": \"none|<url>\",\n \"mask\": \"<mask-layer>#\",\n \"mask-border\": \"<'mask-border-source'>||<'mask-border-slice'> [/ <'mask-border-width'>? [/ <'mask-border-outset'>]?]?||<'mask-border-repeat'>||<'mask-border-mode'>\",\n \"mask-border-mode\": \"luminance|alpha\",\n \"mask-border-outset\": \"[<length>|<number>]{1,4}\",\n \"mask-border-repeat\": \"[stretch|repeat|round|space]{1,2}\",\n \"mask-border-slice\": \"<number-percentage>{1,4} fill?\",\n \"mask-border-source\": \"none|<image>\",\n \"mask-border-width\": \"[<length-percentage>|<number>|auto]{1,4}\",\n \"mask-clip\": \"[<geometry-box>|no-clip]#\",\n \"mask-composite\": \"<compositing-operator>#\",\n \"mask-image\": \"<mask-reference>#\",\n \"mask-mode\": \"<masking-mode>#\",\n \"mask-origin\": \"<geometry-box>#\",\n \"mask-position\": \"<position>#\",\n \"mask-repeat\": \"<repeat-style>#\",\n \"mask-size\": \"<bg-size>#\",\n \"mask-type\": \"luminance|alpha\",\n \"masonry-auto-flow\": \"[pack|next]||[definite-first|ordered]\",\n \"math-depth\": \"auto-add|add( <integer> )|<integer>\",\n \"math-shift\": \"normal|compact\",\n \"math-style\": \"normal|compact\",\n \"max-block-size\": \"<'max-width'>\",\n \"max-height\": \"none|<length-percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"max-inline-size\": \"<'max-width'>\",\n \"max-lines\": \"none|<integer>\",\n \"max-width\": \"none|<length-percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"min-block-size\": \"<'min-width'>\",\n \"min-height\": \"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"min-inline-size\": \"<'min-width'>\",\n \"min-width\": \"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"mix-blend-mode\": \"<blend-mode>|plus-lighter\",\n \"object-fit\": \"fill|contain|cover|none|scale-down\",\n \"object-position\": \"<position>\",\n \"offset\": \"[<'offset-position'>? [<'offset-path'> [<'offset-distance'>||<'offset-rotate'>]?]?]! [/ <'offset-anchor'>]?\",\n \"offset-anchor\": \"auto|<position>\",\n \"offset-distance\": \"<length-percentage>\",\n \"offset-path\": \"none|<offset-path>||<coord-box>\",\n \"offset-position\": \"normal|auto|<position>\",\n \"offset-rotate\": \"[auto|reverse]||<angle>\",\n \"opacity\": \"<alpha-value>\",\n \"order\": \"<integer>\",\n \"orphans\": \"<integer>\",\n \"outline\": \"[<'outline-width'>||<'outline-style'>||<'outline-color'>]\",\n \"outline-color\": \"auto|<color>\",\n \"outline-offset\": \"<length>\",\n \"outline-style\": \"auto|<'border-style'>\",\n \"outline-width\": \"<line-width>\",\n \"overflow\": \"[visible|hidden|clip|scroll|auto]{1,2}|<-non-standard-overflow>\",\n \"overflow-anchor\": \"auto|none\",\n \"overflow-block\": \"visible|hidden|clip|scroll|auto\",\n \"overflow-clip-box\": \"padding-box|content-box\",\n \"overflow-clip-margin\": \"<visual-box>||<length [0,∞]>\",\n \"overflow-inline\": \"visible|hidden|clip|scroll|auto\",\n \"overflow-wrap\": \"normal|break-word|anywhere\",\n \"overflow-x\": \"visible|hidden|clip|scroll|auto\",\n \"overflow-y\": \"visible|hidden|clip|scroll|auto\",\n \"overlay\": \"none|auto\",\n \"overscroll-behavior\": \"[contain|none|auto]{1,2}\",\n \"overscroll-behavior-block\": \"contain|none|auto\",\n \"overscroll-behavior-inline\": \"contain|none|auto\",\n \"overscroll-behavior-x\": \"contain|none|auto\",\n \"overscroll-behavior-y\": \"contain|none|auto\",\n \"padding\": \"[<length>|<percentage>]{1,4}\",\n \"padding-block\": \"<'padding-left'>{1,2}\",\n \"padding-block-end\": \"<'padding-left'>\",\n \"padding-block-start\": \"<'padding-left'>\",\n \"padding-bottom\": \"<length>|<percentage>\",\n \"padding-inline\": \"<'padding-left'>{1,2}\",\n \"padding-inline-end\": \"<'padding-left'>\",\n \"padding-inline-start\": \"<'padding-left'>\",\n \"padding-left\": \"<length>|<percentage>\",\n \"padding-right\": \"<length>|<percentage>\",\n \"padding-top\": \"<length>|<percentage>\",\n \"page\": \"auto|<custom-ident>\",\n \"page-break-after\": \"auto|always|avoid|left|right|recto|verso\",\n \"page-break-before\": \"auto|always|avoid|left|right|recto|verso\",\n \"page-break-inside\": \"auto|avoid\",\n \"paint-order\": \"normal|[fill||stroke||markers]\",\n \"perspective\": \"none|<length>\",\n \"perspective-origin\": \"<position>\",\n \"place-content\": \"<'align-content'> <'justify-content'>?\",\n \"place-items\": \"<'align-items'> <'justify-items'>?\",\n \"place-self\": \"<'align-self'> <'justify-self'>?\",\n \"pointer-events\": \"auto|none|visiblePainted|visibleFill|visibleStroke|visible|painted|fill|stroke|all|inherit\",\n \"position\": \"static|relative|absolute|sticky|fixed|-webkit-sticky\",\n \"position-anchor\": \"auto|<anchor-name>\",\n \"position-area\": \"none|<position-area>\",\n \"position-try\": \"<'position-try-order'>? <'position-try-fallbacks'>\",\n \"position-try-fallbacks\": \"none|[[<dashed-ident>||<try-tactic>]|<'position-area'>]#\",\n \"position-try-order\": \"normal|<try-size>\",\n \"position-visibility\": \"always|[anchors-valid||anchors-visible||no-overflow]\",\n \"print-color-adjust\": \"economy|exact\",\n \"quotes\": \"none|auto|[<string> <string>]+\",\n \"r\": \"<length>|<percentage>\",\n \"resize\": \"none|both|horizontal|vertical|block|inline\",\n \"right\": \"<length>|<percentage>|auto\",\n \"rotate\": \"none|<angle>|[x|y|z|<number>{3}]&&<angle>\",\n \"row-gap\": \"normal|<length-percentage>\",\n \"ruby-align\": \"start|center|space-between|space-around\",\n \"ruby-merge\": \"separate|collapse|auto\",\n \"ruby-position\": \"[alternate||[over|under]]|inter-character\",\n \"rx\": \"<length>|<percentage>\",\n \"ry\": \"<length>|<percentage>\",\n \"scale\": \"none|[<number>|<percentage>]{1,3}\",\n \"scrollbar-color\": \"auto|<color>{2}\",\n \"scrollbar-gutter\": \"auto|stable&&both-edges?\",\n \"scrollbar-width\": \"auto|thin|none\",\n \"scroll-behavior\": \"auto|smooth\",\n \"scroll-margin\": \"<length>{1,4}\",\n \"scroll-margin-block\": \"<length>{1,2}\",\n \"scroll-margin-block-start\": \"<length>\",\n \"scroll-margin-block-end\": \"<length>\",\n \"scroll-margin-bottom\": \"<length>\",\n \"scroll-margin-inline\": \"<length>{1,2}\",\n \"scroll-margin-inline-start\": \"<length>\",\n \"scroll-margin-inline-end\": \"<length>\",\n \"scroll-margin-left\": \"<length>\",\n \"scroll-margin-right\": \"<length>\",\n \"scroll-margin-top\": \"<length>\",\n \"scroll-padding\": \"[auto|<length-percentage>]{1,4}\",\n \"scroll-padding-block\": \"[auto|<length-percentage>]{1,2}\",\n \"scroll-padding-block-start\": \"auto|<length-percentage>\",\n \"scroll-padding-block-end\": \"auto|<length-percentage>\",\n \"scroll-padding-bottom\": \"auto|<length-percentage>\",\n \"scroll-padding-inline\": \"[auto|<length-percentage>]{1,2}\",\n \"scroll-padding-inline-start\": \"auto|<length-percentage>\",\n \"scroll-padding-inline-end\": \"auto|<length-percentage>\",\n \"scroll-padding-left\": \"auto|<length-percentage>\",\n \"scroll-padding-right\": \"auto|<length-percentage>\",\n \"scroll-padding-top\": \"auto|<length-percentage>\",\n \"scroll-snap-align\": \"[none|start|end|center]{1,2}\",\n \"scroll-snap-coordinate\": \"none|<position>#\",\n \"scroll-snap-destination\": \"<position>\",\n \"scroll-snap-points-x\": \"none|repeat( <length-percentage> )\",\n \"scroll-snap-points-y\": \"none|repeat( <length-percentage> )\",\n \"scroll-snap-stop\": \"normal|always\",\n \"scroll-snap-type\": \"none|[x|y|block|inline|both] [mandatory|proximity]?\",\n \"scroll-snap-type-x\": \"none|mandatory|proximity\",\n \"scroll-snap-type-y\": \"none|mandatory|proximity\",\n \"scroll-timeline\": \"[<'scroll-timeline-name'>||<'scroll-timeline-axis'>]#\",\n \"scroll-timeline-axis\": \"[block|inline|x|y]#\",\n \"scroll-timeline-name\": \"[none|<dashed-ident>]#\",\n \"shape-image-threshold\": \"<alpha-value>\",\n \"shape-margin\": \"<length-percentage>\",\n \"shape-outside\": \"none|[<shape-box>||<basic-shape>]|<image>\",\n \"shape-rendering\": \"auto|optimizeSpeed|crispEdges|geometricPrecision\",\n \"stroke\": \"<paint>\",\n \"stroke-dasharray\": \"none|[<svg-length>+]#\",\n \"stroke-dashoffset\": \"<svg-length>\",\n \"stroke-linecap\": \"butt|round|square\",\n \"stroke-linejoin\": \"miter|round|bevel\",\n \"stroke-miterlimit\": \"<number-one-or-greater>\",\n \"stroke-opacity\": \"<'opacity'>\",\n \"stroke-width\": \"<svg-length>\",\n \"tab-size\": \"<integer>|<length>\",\n \"table-layout\": \"auto|fixed\",\n \"text-align\": \"start|end|left|right|center|justify|match-parent\",\n \"text-align-last\": \"auto|start|end|left|right|center|justify\",\n \"text-anchor\": \"start|middle|end\",\n \"text-combine-upright\": \"none|all|[digits <integer>?]\",\n \"text-decoration\": \"<'text-decoration-line'>||<'text-decoration-style'>||<'text-decoration-color'>||<'text-decoration-thickness'>\",\n \"text-decoration-color\": \"<color>\",\n \"text-decoration-line\": \"none|[underline||overline||line-through||blink]|spelling-error|grammar-error\",\n \"text-decoration-skip\": \"none|[objects||[spaces|[leading-spaces||trailing-spaces]]||edges||box-decoration]\",\n \"text-decoration-skip-ink\": \"auto|all|none\",\n \"text-decoration-style\": \"solid|double|dotted|dashed|wavy\",\n \"text-decoration-thickness\": \"auto|from-font|<length>|<percentage>\",\n \"text-emphasis\": \"<'text-emphasis-style'>||<'text-emphasis-color'>\",\n \"text-emphasis-color\": \"<color>\",\n \"text-emphasis-position\": \"auto|[over|under]&&[right|left]?\",\n \"text-emphasis-style\": \"none|[[filled|open]||[dot|circle|double-circle|triangle|sesame]]|<string>\",\n \"text-indent\": \"<length-percentage>&&hanging?&&each-line?\",\n \"text-justify\": \"auto|inter-character|inter-word|none\",\n \"text-orientation\": \"mixed|upright|sideways\",\n \"text-overflow\": \"[clip|ellipsis|<string>]{1,2}\",\n \"text-rendering\": \"auto|optimizeSpeed|optimizeLegibility|geometricPrecision\",\n \"text-shadow\": \"none|<shadow-t>#\",\n \"text-size-adjust\": \"none|auto|<percentage>\",\n \"text-spacing-trim\": \"space-all|normal|space-first|trim-start|trim-both|trim-all|auto\",\n \"text-transform\": \"none|capitalize|uppercase|lowercase|full-width|full-size-kana\",\n \"text-underline-offset\": \"auto|<length>|<percentage>\",\n \"text-underline-position\": \"auto|from-font|[under||[left|right]]\",\n \"text-wrap\": \"<'text-wrap-mode'>||<'text-wrap-style'>\",\n \"text-wrap-mode\": \"auto|wrap|nowrap\",\n \"text-wrap-style\": \"auto|balance|stable|pretty\",\n \"timeline-scope\": \"none|<dashed-ident>#\",\n \"top\": \"<length>|<percentage>|auto\",\n \"touch-action\": \"auto|none|[[pan-x|pan-left|pan-right]||[pan-y|pan-up|pan-down]||pinch-zoom]|manipulation\",\n \"transform\": \"none|<transform-list>\",\n \"transform-box\": \"content-box|border-box|fill-box|stroke-box|view-box\",\n \"transform-origin\": \"[<length-percentage>|left|center|right|top|bottom]|[[<length-percentage>|left|center|right]&&[<length-percentage>|top|center|bottom]] <length>?\",\n \"transform-style\": \"flat|preserve-3d\",\n \"transition\": \"<single-transition>#\",\n \"transition-behavior\": \"<transition-behavior-value>#\",\n \"transition-delay\": \"<time>#\",\n \"transition-duration\": \"<time>#\",\n \"transition-property\": \"none|<single-transition-property>#\",\n \"transition-timing-function\": \"<easing-function>#\",\n \"translate\": \"none|<length-percentage> [<length-percentage> <length>?]?\",\n \"unicode-bidi\": \"normal|embed|isolate|bidi-override|isolate-override|plaintext|-moz-isolate|-moz-isolate-override|-moz-plaintext|-webkit-isolate|-webkit-isolate-override|-webkit-plaintext\",\n \"user-select\": \"auto|text|none|contain|all\",\n \"vector-effect\": \"none|non-scaling-stroke|non-scaling-size|non-rotation|fixed-position\",\n \"vertical-align\": \"baseline|sub|super|text-top|text-bottom|middle|top|bottom|<percentage>|<length>\",\n \"view-timeline\": \"[<'view-timeline-name'> <'view-timeline-axis'>?]#\",\n \"view-timeline-axis\": \"[block|inline|x|y]#\",\n \"view-timeline-inset\": \"[[auto|<length-percentage>]{1,2}]#\",\n \"view-timeline-name\": \"none|<dashed-ident>#\",\n \"view-transition-name\": \"none|<custom-ident>\",\n \"visibility\": \"visible|hidden|collapse\",\n \"white-space\": \"normal|pre|nowrap|pre-wrap|pre-line|break-spaces|[<'white-space-collapse'>||<'text-wrap'>||<'white-space-trim'>]\",\n \"white-space-collapse\": \"collapse|discard|preserve|preserve-breaks|preserve-spaces|break-spaces\",\n \"widows\": \"<integer>\",\n \"width\": \"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|stretch|<-non-standard-size>\",\n \"will-change\": \"auto|<animateable-feature>#\",\n \"word-break\": \"normal|break-all|keep-all|break-word|auto-phrase\",\n \"word-spacing\": \"normal|<length>\",\n \"word-wrap\": \"normal|break-word\",\n \"writing-mode\": \"horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr|<svg-writing-mode>\",\n \"x\": \"<length>|<percentage>\",\n \"y\": \"<length>|<percentage>\",\n \"z-index\": \"auto|<integer>\",\n \"zoom\": \"normal|reset|<number>|<percentage>\",\n \"-moz-background-clip\": \"padding|border\",\n \"-moz-border-radius-bottomleft\": \"<'border-bottom-left-radius'>\",\n \"-moz-border-radius-bottomright\": \"<'border-bottom-right-radius'>\",\n \"-moz-border-radius-topleft\": \"<'border-top-left-radius'>\",\n \"-moz-border-radius-topright\": \"<'border-bottom-right-radius'>\",\n \"-moz-control-character-visibility\": \"visible|hidden\",\n \"-moz-osx-font-smoothing\": \"auto|grayscale\",\n \"-moz-user-select\": \"none|text|all|-moz-none\",\n \"-ms-flex-align\": \"start|end|center|baseline|stretch\",\n \"-ms-flex-item-align\": \"auto|start|end|center|baseline|stretch\",\n \"-ms-flex-line-pack\": \"start|end|center|justify|distribute|stretch\",\n \"-ms-flex-negative\": \"<'flex-shrink'>\",\n \"-ms-flex-pack\": \"start|end|center|justify|distribute\",\n \"-ms-flex-order\": \"<integer>\",\n \"-ms-flex-positive\": \"<'flex-grow'>\",\n \"-ms-flex-preferred-size\": \"<'flex-basis'>\",\n \"-ms-interpolation-mode\": \"nearest-neighbor|bicubic\",\n \"-ms-grid-column-align\": \"start|end|center|stretch\",\n \"-ms-grid-row-align\": \"start|end|center|stretch\",\n \"-ms-hyphenate-limit-last\": \"none|always|column|page|spread\",\n \"-webkit-background-clip\": \"[<box>|border|padding|content|text]#\",\n \"-webkit-column-break-after\": \"always|auto|avoid\",\n \"-webkit-column-break-before\": \"always|auto|avoid\",\n \"-webkit-column-break-inside\": \"always|auto|avoid\",\n \"-webkit-font-smoothing\": \"auto|none|antialiased|subpixel-antialiased\",\n \"-webkit-mask-box-image\": \"[<url>|<gradient>|none] [<length-percentage>{4} <-webkit-mask-box-repeat>{2}]?\",\n \"-webkit-print-color-adjust\": \"economy|exact\",\n \"-webkit-text-security\": \"none|circle|disc|square\",\n \"-webkit-user-drag\": \"none|element|auto\",\n \"-webkit-user-select\": \"auto|none|text|all\",\n \"alignment-baseline\": \"auto|baseline|before-edge|text-before-edge|middle|central|after-edge|text-after-edge|ideographic|alphabetic|hanging|mathematical\",\n \"baseline-shift\": \"baseline|sub|super|<svg-length>\",\n \"behavior\": \"<url>+\",\n \"cue\": \"<'cue-before'> <'cue-after'>?\",\n \"cue-after\": \"<url> <decibel>?|none\",\n \"cue-before\": \"<url> <decibel>?|none\",\n \"glyph-orientation-horizontal\": \"<angle>\",\n \"glyph-orientation-vertical\": \"<angle>\",\n \"kerning\": \"auto|<svg-length>\",\n \"pause\": \"<'pause-before'> <'pause-after'>?\",\n \"pause-after\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"pause-before\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"rest\": \"<'rest-before'> <'rest-after'>?\",\n \"rest-after\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"rest-before\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"src\": \"[<url> [format( <string># )]?|local( <family-name> )]#\",\n \"speak\": \"auto|never|always\",\n \"speak-as\": \"normal|spell-out||digits||[literal-punctuation|no-punctuation]\",\n \"unicode-range\": \"<urange>#\",\n \"voice-balance\": \"<number>|left|center|right|leftwards|rightwards\",\n \"voice-duration\": \"auto|<time>\",\n \"voice-family\": \"[[<family-name>|<generic-voice>] ,]* [<family-name>|<generic-voice>]|preserve\",\n \"voice-pitch\": \"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]\",\n \"voice-range\": \"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]\",\n \"voice-rate\": \"[normal|x-slow|slow|medium|fast|x-fast]||<percentage>\",\n \"voice-stress\": \"normal|strong|moderate|none|reduced\",\n \"voice-volume\": \"silent|[[x-soft|soft|medium|loud|x-loud]||<decibel>]\",\n \"white-space-trim\": \"none|discard-before||discard-after||discard-inner\"\n },\n \"atrules\": {\n \"charset\": {\n \"prelude\": \"<string>\",\n \"descriptors\": null\n },\n \"counter-style\": {\n \"prelude\": \"<counter-style-name>\",\n \"descriptors\": {\n \"additive-symbols\": \"[<integer>&&<symbol>]#\",\n \"fallback\": \"<counter-style-name>\",\n \"negative\": \"<symbol> <symbol>?\",\n \"pad\": \"<integer>&&<symbol>\",\n \"prefix\": \"<symbol>\",\n \"range\": \"[[<integer>|infinite]{2}]#|auto\",\n \"speak-as\": \"auto|bullets|numbers|words|spell-out|<counter-style-name>\",\n \"suffix\": \"<symbol>\",\n \"symbols\": \"<symbol>+\",\n \"system\": \"cyclic|numeric|alphabetic|symbolic|additive|[fixed <integer>?]|[extends <counter-style-name>]\"\n }\n },\n \"document\": {\n \"prelude\": \"[<url>|url-prefix( <string> )|domain( <string> )|media-document( <string> )|regexp( <string> )]#\",\n \"descriptors\": null\n },\n \"font-palette-values\": {\n \"prelude\": \"<dashed-ident>\",\n \"descriptors\": {\n \"base-palette\": \"light|dark|<integer [0,∞]>\",\n \"font-family\": \"<family-name>#\",\n \"override-colors\": \"[<integer [0,∞]> <absolute-color-base>]#\"\n }\n },\n \"font-face\": {\n \"prelude\": null,\n \"descriptors\": {\n \"ascent-override\": \"normal|<percentage>\",\n \"descent-override\": \"normal|<percentage>\",\n \"font-display\": \"[auto|block|swap|fallback|optional]\",\n \"font-family\": \"<family-name>\",\n \"font-feature-settings\": \"normal|<feature-tag-value>#\",\n \"font-variation-settings\": \"normal|[<string> <number>]#\",\n \"font-stretch\": \"<font-stretch-absolute>{1,2}\",\n \"font-style\": \"normal|italic|oblique <angle>{0,2}\",\n \"font-weight\": \"<font-weight-absolute>{1,2}\",\n \"line-gap-override\": \"normal|<percentage>\",\n \"size-adjust\": \"<percentage>\",\n \"src\": \"[<url> [format( <string># )]?|local( <family-name> )]#\",\n \"unicode-range\": \"<urange>#\"\n }\n },\n \"font-feature-values\": {\n \"prelude\": \"<family-name>#\",\n \"descriptors\": null\n },\n \"import\": {\n \"prelude\": \"[<string>|<url>] [layer|layer( <layer-name> )]? [supports( [<supports-condition>|<declaration>] )]? <media-query-list>?\",\n \"descriptors\": null\n },\n \"keyframes\": {\n \"prelude\": \"<keyframes-name>\",\n \"descriptors\": null\n },\n \"layer\": {\n \"prelude\": \"[<layer-name>#|<layer-name>?]\",\n \"descriptors\": null\n },\n \"media\": {\n \"prelude\": \"<media-query-list>\",\n \"descriptors\": null\n },\n \"namespace\": {\n \"prelude\": \"<namespace-prefix>? [<string>|<url>]\",\n \"descriptors\": null\n },\n \"page\": {\n \"prelude\": \"<page-selector-list>\",\n \"descriptors\": {\n \"bleed\": \"auto|<length>\",\n \"marks\": \"none|[crop||cross]\",\n \"page-orientation\": \"upright|rotate-left|rotate-right\",\n \"size\": \"<length>{1,2}|auto|[<page-size>||[portrait|landscape]]\"\n }\n },\n \"position-try\": {\n \"prelude\": \"<dashed-ident>\",\n \"descriptors\": {\n \"top\": \"<'top'>\",\n \"left\": \"<'left'>\",\n \"bottom\": \"<'bottom'>\",\n \"right\": \"<'right'>\",\n \"inset-block-start\": \"<'inset-block-start'>\",\n \"inset-block-end\": \"<'inset-block-end'>\",\n \"inset-inline-start\": \"<'inset-inline-start'>\",\n \"inset-inline-end\": \"<'inset-inline-end'>\",\n \"inset-block\": \"<'inset-block'>\",\n \"inset-inline\": \"<'inset-inline'>\",\n \"inset\": \"<'inset'>\",\n \"margin-top\": \"<'margin-top'>\",\n \"margin-left\": \"<'margin-left'>\",\n \"margin-bottom\": \"<'margin-bottom'>\",\n \"margin-right\": \"<'margin-right'>\",\n \"margin-block-start\": \"<'margin-block-start'>\",\n \"margin-block-end\": \"<'margin-block-end'>\",\n \"margin-inline-start\": \"<'margin-inline-start'>\",\n \"margin-inline-end\": \"<'margin-inline-end'>\",\n \"margin\": \"<'margin'>\",\n \"margin-block\": \"<'margin-block'>\",\n \"margin-inline\": \"<'margin-inline'>\",\n \"width\": \"<'width'>\",\n \"height\": \"<'height'>\",\n \"min-width\": \"<'min-width'>\",\n \"min-height\": \"<'min-height'>\",\n \"max-width\": \"<'max-width'>\",\n \"max-height\": \"<'max-height'>\",\n \"block-size\": \"<'block-size'>\",\n \"inline-size\": \"<'inline-size'>\",\n \"min-block-size\": \"<'min-block-size'>\",\n \"min-inline-size\": \"<'min-inline-size'>\",\n \"max-block-size\": \"<'max-block-size'>\",\n \"max-inline-size\": \"<'max-inline-size'>\",\n \"align-self\": \"<'align-self'>|anchor-center\",\n \"justify-self\": \"<'justify-self'>|anchor-center\"\n }\n },\n \"property\": {\n \"prelude\": \"<custom-property-name>\",\n \"descriptors\": {\n \"syntax\": \"<string>\",\n \"inherits\": \"true|false\",\n \"initial-value\": \"<declaration-value>?\"\n }\n },\n \"scope\": {\n \"prelude\": \"[( <scope-start> )]? [to ( <scope-end> )]?\",\n \"descriptors\": null\n },\n \"starting-style\": {\n \"prelude\": null,\n \"descriptors\": null\n },\n \"supports\": {\n \"prelude\": \"<supports-condition>\",\n \"descriptors\": null\n },\n \"container\": {\n \"prelude\": \"[<container-name>]? <container-condition>\",\n \"descriptors\": null\n },\n \"nest\": {\n \"prelude\": \"<complex-selector-list>\",\n \"descriptors\": null\n }\n }\n};","import {\n Ident,\n String as StringToken,\n Number as NumberToken,\n Function as FunctionToken,\n Url,\n Hash,\n Dimension,\n Percentage,\n LeftParenthesis,\n LeftSquareBracket,\n Comma,\n Delim\n} from '../../tokenizer/index.js';\n\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)\n\nexport default function defaultRecognizer(context) {\n switch (this.tokenType) {\n case Hash:\n return this.Hash();\n\n case Comma:\n return this.Operator();\n\n case LeftParenthesis:\n return this.Parentheses(this.readSequence, context.recognizer);\n\n case LeftSquareBracket:\n return this.Brackets(this.readSequence, context.recognizer);\n\n case StringToken:\n return this.String();\n\n case Dimension:\n return this.Dimension();\n\n case Percentage:\n return this.Percentage();\n\n case NumberToken:\n return this.Number();\n\n case FunctionToken:\n return this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')\n ? this.Url()\n : this.Function(this.readSequence, context.recognizer);\n\n case Url:\n return this.Url();\n\n case Ident:\n // check for unicode range, it should start with u+ or U+\n if (this.cmpChar(this.tokenStart, U) &&\n this.cmpChar(this.tokenStart + 1, PLUSSIGN)) {\n return this.UnicodeRange();\n } else {\n return this.Identifier();\n }\n\n case Delim: {\n const code = this.charCodeAt(this.tokenStart);\n\n if (code === SOLIDUS ||\n code === ASTERISK ||\n code === PLUSSIGN ||\n code === HYPHENMINUS) {\n return this.Operator(); // TODO: replace with Delim\n }\n\n // TODO: produce a node with Delim node type\n\n if (code === NUMBERSIGN) {\n this.error('Hex or identifier is expected', this.tokenStart + 1);\n }\n\n break;\n }\n }\n};\n","import getNode from './default.js';\n\nexport default {\n getNode\n};\n","import {\n Delim,\n Ident,\n Dimension,\n Percentage,\n Number as NumberToken,\n Hash,\n Colon,\n LeftSquareBracket\n} from '../../tokenizer/index.js';\n\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nfunction onWhiteSpace(next, children) {\n if (children.last !== null && children.last.type !== 'Combinator' &&\n next !== null && next.type !== 'Combinator') {\n children.push({ // FIXME: this.Combinator() should be used instead\n type: 'Combinator',\n loc: null,\n name: ' '\n });\n }\n}\n\nfunction getNode() {\n switch (this.tokenType) {\n case LeftSquareBracket:\n return this.AttributeSelector();\n\n case Hash:\n return this.IdSelector();\n\n case Colon:\n if (this.lookupType(1) === Colon) {\n return this.PseudoElementSelector();\n } else {\n return this.PseudoClassSelector();\n }\n\n case Ident:\n return this.TypeSelector();\n\n case NumberToken:\n case Percentage:\n return this.Percentage();\n\n case Dimension:\n // throws when .123ident\n if (this.charCodeAt(this.tokenStart) === FULLSTOP) {\n this.error('Identifier is expected', this.tokenStart + 1);\n }\n break;\n\n case Delim: {\n const code = this.charCodeAt(this.tokenStart);\n\n switch (code) {\n case PLUSSIGN:\n case GREATERTHANSIGN:\n case TILDE:\n case SOLIDUS: // /deep/\n return this.Combinator();\n\n case FULLSTOP:\n return this.ClassSelector();\n\n case ASTERISK:\n case VERTICALLINE:\n return this.TypeSelector();\n\n case NUMBERSIGN:\n return this.IdSelector();\n\n case AMPERSAND:\n return this.NestingSelector();\n }\n\n break;\n }\n }\n};\n\nexport default {\n onWhiteSpace,\n getNode\n};\n","import getNode from './default.js';\nimport expressionFn from '../function/expression.js';\nimport varFn from '../function/var.js';\n\nfunction isPlusMinusOperator(node) {\n return (\n node !== null &&\n node.type === 'Operator' &&\n (node.value[node.value.length - 1] === '-' || node.value[node.value.length - 1] === '+')\n );\n}\n\nexport default {\n getNode,\n onWhiteSpace(next, children) {\n if (isPlusMinusOperator(next)) {\n next.value = ' ' + next.value;\n }\n if (isPlusMinusOperator(children.last)) {\n children.last.value += ' ';\n }\n },\n 'expression': expressionFn,\n 'var': varFn\n};\n","// legacy IE function\n// expression( <any-value> )\nexport default function() {\n return this.createSingleNodeList(\n this.Raw(null, false)\n );\n}\n","import { Comma, WhiteSpace } from '../../tokenizer/index.js';\n\n// var( <ident> , <value>? )\nexport default function() {\n const children = this.createList();\n\n this.skipSC();\n\n // NOTE: Don't check more than a first argument is an ident, rest checks are for lexer\n children.push(this.Identifier());\n\n this.skipSC();\n\n if (this.tokenType === Comma) {\n children.push(this.Operator());\n\n const startIndex = this.tokenIndex;\n const value = this.parseCustomProperty\n ? this.Value(null)\n : this.Raw(this.consumeUntilExclamationMarkOrSemicolon, false);\n\n if (value.type === 'Value' && value.children.isEmpty) {\n for (let offset = startIndex - this.tokenIndex; offset <= 0; offset++) {\n if (this.lookupType(offset) === WhiteSpace) {\n value.children.appendData({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n });\n break;\n }\n }\n }\n\n children.push(value);\n }\n\n return children;\n};\n","import { Ident } from '../../tokenizer/index.js';\n\n// https://drafts.csswg.org/css-contain-3/#container-rule\n// The keywords `none`, `and`, `not`, and `or` are excluded from the <custom-ident> above.\nconst nonContainerNameKeywords = new Set(['none', 'and', 'not', 'or']);\n\nexport default {\n parse: {\n prelude() {\n const children = this.createList();\n\n if (this.tokenType === Ident) {\n const name = this.substring(this.tokenStart, this.tokenEnd);\n\n if (!nonContainerNameKeywords.has(name.toLowerCase())) {\n children.push(this.Identifier());\n }\n }\n\n children.push(this.Condition('container'));\n\n return children;\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude: null,\n block() {\n return this.Block(true);\n }\n }\n};\n","import {\n String as StringToken,\n Ident,\n Url,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nfunction parseWithFallback(parse, fallback) {\n return this.parseWithFallback(\n () => {\n try {\n return parse.call(this);\n } finally {\n this.skipSC();\n if (this.lookupNonWSType(0) !== RightParenthesis) {\n this.error();\n }\n }\n },\n fallback || (() => this.Raw(null, true))\n );\n}\n\nconst parseFunctions = {\n layer() {\n this.skipSC();\n\n const children = this.createList();\n const node = parseWithFallback.call(this, this.Layer);\n\n if (node.type !== 'Raw' || node.value !== '') {\n children.push(node);\n }\n\n return children;\n },\n supports() {\n this.skipSC();\n\n const children = this.createList();\n const node = parseWithFallback.call(\n this,\n this.Declaration,\n () => parseWithFallback.call(this, () => this.Condition('supports'))\n );\n\n if (node.type !== 'Raw' || node.value !== '') {\n children.push(node);\n }\n\n return children;\n }\n};\n\nexport default {\n parse: {\n prelude() {\n const children = this.createList();\n\n switch (this.tokenType) {\n case StringToken:\n children.push(this.String());\n break;\n\n case Url:\n case FunctionToken:\n children.push(this.Url());\n break;\n\n default:\n this.error('String or url() is expected');\n }\n\n this.skipSC();\n\n if (this.tokenType === Ident &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'layer')) {\n children.push(this.Identifier());\n } else if (\n this.tokenType === FunctionToken &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'layer(')\n ) {\n children.push(this.Function(null, parseFunctions));\n }\n\n this.skipSC();\n\n if (this.tokenType === FunctionToken &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'supports(')) {\n children.push(this.Function(null, parseFunctions));\n }\n\n if (this.lookupNonWSType(0) === Ident ||\n this.lookupNonWSType(0) === LeftParenthesis) {\n children.push(this.MediaQueryList());\n }\n\n return children;\n },\n block: null\n }\n};\n","import container from './container.js';\nimport fontFace from './font-face.js';\nimport importAtrule from './import.js';\nimport layer from './layer.js';\nimport media from './media.js';\nimport nest from './nest.js';\nimport page from './page.js';\nimport scope from './scope.js';\nimport startingStyle from './starting-style.js';\nimport supports from './supports.js';\n\nexport default {\n container,\n 'font-face': fontFace,\n import: importAtrule,\n layer,\n media,\n nest,\n page,\n scope,\n 'starting-style': startingStyle,\n supports\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.LayerList()\n );\n },\n block() {\n return this.Block(false);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.MediaQueryList()\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n },\n block() {\n return this.Block(true);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n },\n block() {\n return this.Block(true);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.Scope()\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude: null,\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.Condition('supports')\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","import { parseLanguageRangeList } from './lang.js';\n\nconst selectorList = {\n parse() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n }\n};\n\nconst selector = {\n parse() {\n return this.createSingleNodeList(\n this.Selector()\n );\n }\n};\n\nconst identList = {\n parse() {\n return this.createSingleNodeList(\n this.Identifier()\n );\n }\n};\n\nconst langList = {\n parse: parseLanguageRangeList\n};\n\nconst nth = {\n parse() {\n return this.createSingleNodeList(\n this.Nth()\n );\n }\n};\n\nexport default {\n 'dir': identList,\n 'has': selectorList,\n 'lang': langList,\n 'matches': selectorList,\n 'is': selectorList,\n '-moz-any': selectorList,\n '-webkit-any': selectorList,\n 'where': selectorList,\n 'not': selectorList,\n 'nth-child': nth,\n 'nth-last-child': nth,\n 'nth-last-of-type': nth,\n 'nth-of-type': nth,\n 'slotted': selector,\n 'host': selector,\n 'host-context': selector\n};\n","import { Comma, String as StringToken, Ident, RightParenthesis } from '../../tokenizer/index.js';\n\nexport function parseLanguageRangeList() {\n const children = this.createList();\n\n this.skipSC();\n\n loop: while (!this.eof) {\n switch (this.tokenType) {\n case Ident:\n children.push(this.Identifier());\n break;\n\n case StringToken:\n children.push(this.String());\n break;\n\n case Comma:\n children.push(this.Operator());\n break;\n\n case RightParenthesis:\n break loop;\n\n default:\n this.error('Identifier, string or comma is expected');\n }\n\n this.skipSC();\n }\n\n return children;\n}\n","import createSyntax from './create.js';\nimport lexerConfig from './config/lexer.js';\nimport parserConfig from './config/parser.js';\nimport walkerConfig from './config/walker.js';\n\nexport default createSyntax({\n ...lexerConfig,\n ...parserConfig,\n ...walkerConfig\n});\n","import * as scope from '../scope/index.js';\nimport atrule from '../atrule/index.js';\nimport pseudo from '../pseudo/index.js';\nimport * as node from '../node/index-parse.js';\n\nexport default {\n parseContext: {\n default: 'StyleSheet',\n stylesheet: 'StyleSheet',\n atrule: 'Atrule',\n atrulePrelude(options) {\n return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);\n },\n mediaQueryList: 'MediaQueryList',\n mediaQuery: 'MediaQuery',\n condition(options) {\n return this.Condition(options.kind);\n },\n rule: 'Rule',\n selectorList: 'SelectorList',\n selector: 'Selector',\n block() {\n return this.Block(true);\n },\n declarationList: 'DeclarationList',\n declaration: 'Declaration',\n value: 'Value'\n },\n features: {\n supports: {\n selector() {\n return this.Selector();\n }\n },\n container: {\n style() {\n return this.Declaration();\n }\n }\n },\n scope,\n atrule,\n pseudo,\n node\n};\n","import * as node from '../node/index.js';\n\nexport default {\n node\n};\n","import syntax from './syntax/index.js';\n\nexport * from './version.js';\nexport { default as createSyntax } from './syntax/create.js';\nexport { List } from './utils/List.js';\nexport { Lexer } from './lexer/Lexer.js';\nexport { tokenTypes, tokenNames, TokenStream, OffsetToLocation } from './tokenizer/index.js';\nexport * as definitionSyntax from './definition-syntax/index.js';\nexport { clone } from './utils/clone.js';\nexport * from './utils/names.js';\nexport * as ident from './utils/ident.js';\nexport * as string from './utils/string.js';\nexport * as url from './utils/url.js';\nexport const {\n tokenize,\n parse,\n generate,\n lexer,\n createLexer,\n\n walk,\n find,\n findLast,\n findAll,\n\n toPlainObject,\n fromPlainObject,\n\n fork\n} = syntax;\n"],"names":["util","has","Object","prototype","hasOwnProperty","hasNativeMap","Map","ArraySet","this","_array","_set","create","fromArray","aArray","aAllowDuplicates","set","i","len","length","add","size","getOwnPropertyNames","aStr","sStr","toSetString","isDuplicate","call","idx","push","indexOf","get","Error","at","aIdx","toArray","slice","exports","base64","encode","aValue","digit","encoded","vlq","toVLQSigned","VLQ_BASE","decode","aIndex","aOutParam","continuation","shifted","strLen","result","shift","charCodeAt","charAt","value","rest","intToCharMap","split","number","TypeError","charCode","MappingList","_sorted","_last","generatedLine","generatedColumn","unsortedForEach","aCallback","aThisArg","forEach","aMapping","mappingA","mappingB","lineA","lineB","columnA","columnB","compareByGeneratedPositionsInflated","sort","base64VLQ","SourceMapGenerator","aArgs","_file","getArg","_sourceRoot","_skipValidation","_ignoreInvalidMapping","_sources","_names","_mappings","_sourcesContents","_version","fromSourceMap","aSourceMapConsumer","generatorOps","sourceRoot","generator","assign","file","eachMapping","mapping","newMapping","generated","line","column","source","relative","original","originalLine","originalColumn","name","addMapping","sources","sourceFile","sourceRelative","content","sourceContentFor","setSourceContent","_validateMapping","String","aSourceFile","aSourceContent","keys","applySourceMap","aSourceMapPath","newSources","newNames","originalPositionFor","join","aGenerated","aOriginal","aSource","aName","message","console","warn","JSON","stringify","_serializeMappings","next","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","mappings","_generateSourcesContent","aSources","aSourceRoot","map","key","toJSON","version","names","sourcesContent","toString","aDefaultValue","arguments","urlRegexp","dataUrlRegexp","urlParse","aUrl","match","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","f","cache","normalize","aPath","isAbsolute","parts","start","part","up","splice","input","temp","unshift","pop","aRoot","aPathUrl","aRootUrl","joined","replace","test","level","index","lastIndexOf","Array","substr","supportsNullProto","identity","s","isProtoString","strcmp","aStr1","aStr2","fromSetString","compareByOriginalPositions","onlyCompareOriginal","cmp","compareByOriginalPositionsNoSource","compareByGeneratedPositionsDeflated","onlyCompareGenerated","compareByGeneratedPositionsDeflatedNoLine","parseSourceMapInput","str","parse","computeSourceURL","sourceURL","sourceMapURL","parsed","substring","Percentage","Dimension","WhiteSpace","CDC","Colon","Semicolon","Comma","LeftSquareBracket","RightSquareBracket","LeftParenthesis","RightParenthesis","LeftCurlyBracket","RightCurlyBracket","Comment","isDigit","code","isHexDigit","isUppercaseLetter","isNameStart","isLowercaseLetter","isLetter","isNonAscii","isName","isNonPrintable","isNewline","isWhiteSpace","isValidEscape","first","second","isIdentifierStart","third","isNumberStart","isBOM","CATEGORY","WhiteSpaceCategory","charCodeCategory","getCharCode","offset","getNewlineLength","cmpChar","testStr","referenceCode","cmpStr","end","referenceStr","testCode","findWhiteSpaceEnd","findDecimalNumberEnd","consumeEscaped","maxOffset","Math","min","consumeName","consumeNumber","sign","consumeBadUrlRemnants","decodeEscaped","escaped","parseInt","fromCodePoint","adoptBuffer","buffer","Uint32Array","max","computeLinesAndColumns","sourceLength","startOffset","lines","columns","startLine","startColumn","computed","OffsetToLocation","constructor","setSource","getLocation","filename","getLocationRange","OFFSET_MASK","TYPE_SHIFT","balancePair","Uint8Array","isBlockOpenerToken","tokenType","TokenStream","tokenize","reset","eof","tokenIndex","tokenStart","firstCharOffset","tokenEnd","offsetAndType","balance","tokenCount","balanceCloseType","balanceStart","fill","type","prevBalanceStart","balanceEnd","lookupType","lookupTypeNonSC","lookupOffset","lookupOffsetNonSC","lookupValue","getTokenStart","substrToCursor","isBalanceEdge","pos","isDelim","skip","skipSC","skipUntilBalanced","startToken","stopConsume","cursor","loop","forEachToken","fn","item","dump","tokens","chunk","onToken","consumeNumericToken","consumeIdentLikeToken","nameStartOffset","consumeUrlToken","consumeStringToken","endingCodePoint","nextCode","releasedCursors","List","createItem","data","prev","head","tail","allocateCursor","releaseCursor","updateCursors","prevOld","prevNew","nextOld","nextNew","Symbol","iterator","isEmpty","last","array","thisArg","forEachRight","reduce","initialValue","acc","reduceRight","some","appendData","filter","nextUntil","prevUntil","clear","copy","prepend","prependData","append","insert","before","insertData","remove","prependList","list","insertList","appendList","oldItem","newItemOrList","createCustomError","error","SyntaxError","errorStack","stack","TAB_REPLACEMENT","sourceFragment","baseLine","baseColumn","extraLines","processLines","padStart","maxNumLength","repeat","endLine","cutLeft","OFFSET_CORRECTION","MAX_LINE_LENGTH","Boolean","isNaN","formattedMessage","readSequence","recognizer","children","createList","space","context","child","getNode","undefined","onWhiteSpace","NOOP","createParseContext","fetchParseValues","dict","createParser","config","needPositions","onParseError","onParseErrorThrow","locationMap","parser","parseConfig","features","scope","atrule","pseudo","node","entries","parseContext","processConfig","parseAtrulePrelude","parseRulePrelude","parseValue","parseCustomProperty","consumeUntilBalanceEnd","consumeUntilLeftCurlyBracket","consumeUntilLeftCurlyBracketOrSemicolon","consumeUntilExclamationMarkOrSemicolon","consumeUntilSemicolonIncluded","createSingleNodeList","getFirstListNode","getLastListNode","parseWithFallback","consumer","fallback","startIndex","e","fallbackNode","lookupNonWSType","offsetStart","offsetEnd","consume","eat","consumeFunctionName","tokenName","m","toUpperCase","eatIdent","eatDelim","fromCharCode","getLocationFromList","loc","location","findWhiteSpaceStart","source_","options","positions","onComment","ast","trackNodes","Set","specPairs","safePairs","concat","createMap","pairs","isWhiteSpaceRequired","prevCode","nextCharCode","emit","spec","safe","processChildren","delimeter","processChunk","token","createGenerator","types","generate","handlers","publicApi","tokenBefore","decorator","sourceMap","activatedGenerated","activatedMapping","sourceMappingActive","origHandlersNode","nodeLine","nodeColumn","origHandlersEmit","auto","origHandlersResult","css","generateSourceMap","mode","noop","ensureFunction","invokeForType","getWalkersFromStructure","nodeType","structure","walkers","fieldTypes","walker","nullable","isArray","fieldType","walkContext","fields","createTypeIterator","reverse","contextName","useContext","walk","walkReducer","prevContextValue","field","ref","createFastTraveralMap","StyleSheet","Atrule","Rule","Block","DeclarationList","Declaration","createWalker","getTypesFromConfig","iteratorsNatural","iteratorsReverse","breakWalk","skipNode","fastTraversalIteratorsNatural","fastTraversalIteratorsReverse","root","walkNode","enterRet","enter","iterators","leave","ret","break","stylesheet","atrulePrelude","rule","selector","block","declaration","function","visit","find","found","findLast","findAll","internalGenerate","decorate","forceBraces","compact","combinator","terms","term","explicit","generateSequence","disallowEmpty","multiplier","comma","generateMultiplier","opts","generateTypeOpts","defaultLoc","fromLoc","point","buildLoc","extra","SyntaxReferenceError","referenceName","reference","SyntaxMatchError","syntax","matchResult","mismatchOffset","mismatchLength","longestMatch","mismatchNode","badNode","locateMismatch","rawMessage","keywords","properties","keyword","toLowerCase","descriptor","custom","isCustomProperty","vendor","getVendorPrefix","freeze","basename","prefix","property","hack","secondDashIndex","cssWideKeywords","DISALLOW_SIGN","getNextToken","checkInteger","valueOffset","disallowSign","consumeB","offset_","hexSequence","allowDash","hexlen","withQuestionMarkSequence","consumed","calcFunctionNames","eqStr","actual","expected","eqStrAny","isPostfixIeHack","outOfRange","numEnd","num","Number","calc","balanceStash","scan","consumeFunction","expectedTokenType","dashedIdent","dimension","numberEnd","reverseSolidusOffset","unit","zero","tokenTypes","productionTypes","consumedHexLength","startsWith","createDemensionTypes","units","angle","decibel","frequency","flex","resolution","semitones","time","NAME_CHAR","_","Scanner","isNameCharCode","nextNonWsCode","findWsEnd","skipWs","substringToPos","peek","scanSpaces","scanWord","scanNumber","scanString","COMBINATOR_PRECEDENCE","readMultiplierRange","scanner","maybeMultiplied","range","readMultiplier","maybeToken","ch","readType","implicitGroup","readImplicitGroup","readTypeRange","regroupTerms","combinators","createGroup","a","b","subgroupStart","stopCharCode","prevToken","prevTokenPos","readGroup","readProperty","readKeywordOrFunction","astToTokens","curNode","tmp","stringToTokens","MATCH","MISMATCH","DISALLOW_EMPTY","createCondition","thenBranch","elseBranch","else","then","isFunctionType","isEnumCapatible","groupNode","replaceTypeInGraph","replacements","visited","buildGroupMatchGraph","atLeastOneTermMatched","all","thenClause","newGroupTerm","buildMatchGraphInternal","matchTerm","buildMultiplierMatchGraph","matchNode","booleanGroup","buildMatchGraph","syntaxTree","EXIT_REASON_MATCH","totalIterationCount","reverseList","areStringsEqualCaseInsensitive","isCommaContextStart","isContextEdgeDelim","isCommaContextEnd","internalMatch","state","syntaxes","moveToNextToken","nextIndex","stateSnapshotFromSyntax","nextState","matchStack","syntaxStack","thenStack","pushThenStack","pushElseStack","elseStack","addTokenToMatch","syntaxStash","openSyntax","closeSyntax","iterationCount","exitReason","mask","matchFlag","lastTokenIndex","floor","syntaxDict","dictSyntax","matchRef","keywordName","string","reason","iterations","matchAsTree","matchGraph","hostStack","getTrace","shouldPutToTrace","matched","hasMatch","isType","testNode","isProperty","isKeyword","trace","getFirstMatchNode","getLastMatchNode","matchFragments","lexer","fragments","findFragments","nodes","parent","isValidNumber","isFinite","isValidLocation","createNodeStructureChecker","valid","genTypesList","docsTypes","processStructure","docs","check","dumpMapSyntax","syntaxAsAst","dumpAtruleMapSyntax","prelude","descriptors","buildMatchResult","matchSyntax","useCssWideKeywords","valueHasVar","cssWideKeywordsSyntax","Lexer","generic","atrules","getStructureFromConfig","group","addType_","addAtrule_","addProperty_","checkStructure","collectWarning","warns","createDescriptor","serializable","defineProperty","singleTerm","syntaxHasTopLevelCommaMultiplier","descName","checkAtruleName","atruleName","getAtrule","checkAtrulePrelude","checkAtruleDescriptorName","descriptorName","checkPropertyName","propertyName","getProperty","matchAtrulePrelude","matchAtruleDescriptor","matchDeclaration","matchProperty","matchType","typeName","typeSyntax","getType","findValueFragments","findDeclarationValueFragments","findAllFragments","apply","fallbackBasename","getAtrulePrelude","getAtruleDescriptor","declarators","validate","syntaxRef","broken","brokenMap","brokenTypes","brokenProperties","errors","brokenTypesArray","brokenPropertiesArray","pretty","appendOrSet","sliceProps","obj","props","prop","includes","mix","dest","src","patch","exists","current","descriptorValue","createSyntax","fromPlainObject","toPlainObject","createConvertor","createLexer","fork","extension","base","checkTokenIsInteger","expectCharCode","msg","consumeRaw","Raw","isDeclarationBlockAtrule","isDeclaration","nameLowerCase","AtrulePrelude","bind","getAttributeName","expectIdent","getOperator","matcher","flags","Identifier","consumeRule","consumeRawDeclaration","consumeDeclaration","isStyleBlock","likelyFeatureToken","kind","featureOrRange","Feature","FeatureRange","parentheses","media","container","supports","SupportsDeclaration","res","Condition","GeneralEnclosed","FeatureFunction","consumeValueRaw","consumeCustomPropertyRaw","consumeValue","startValueToken","Value","important","customProperty","valueStart","getImportant","Ratio","Function","feature","getFeatureParser","functionName","valueParser","left","leftComparison","middle","rightComparison","right","readTerm","readComparison","expectColon","xxx","Layer","modifier","mediaType","condition","ident","identLowerCase","MediaQuery","nth","AnPlusB","SelectorList","consumeTerm","getOffsetExcludeWS","consumeUntil","excludeWhiteSpace","endOffset","consumePrelude","limit","Selector","firstChar","decoded","escapeStart","escapeEnd","apostrophe","quote","quoteCode","wsBeforeHexIsNeeded","CDO","eatIdentifierOrAsterisk","eatHexSequence","eatQuestionMarkSequence","count","scanUnicodeRange","hexLength","defaultRecognizer","Hash","Operator","Parentheses","Brackets","Url","UnicodeRange","AttributeSelector","IdSelector","PseudoElementSelector","PseudoClassSelector","TypeSelector","Combinator","ClassSelector","NestingSelector","isPlusMinusOperator","nonContainerNameKeywords","nested","parseFunctions","layer","import","MediaQueryList","LayerList","nest","page","Scope","selectorList","identList","langList","Nth","default","mediaQueryList","mediaQuery","declarationList","style"],"sourceRoot":""}