undefined when no more characters are available.\n */\n next() {\n if (this.pos < this.string.length) {\n return this.string.charCodeAt(this.pos++);\n }\n }\n /**\n * `match` can be a character code or a function that takes a character code\n * and returns a boolean. If the next character in the stream 'matches'\n * the given argument, it is consumed and returned.\n * Otherwise, `false` is returned.\n */\n eat(match) {\n const ch = this.peek();\n const ok = typeof match === 'function' ? match(ch) : ch === match;\n if (ok) {\n this.next();\n }\n return ok;\n }\n /**\n * Repeatedly calls eat with the given argument, until it\n * fails. Returns true if any characters were eaten.\n */\n eatWhile(match) {\n const start = this.pos;\n while (!this.eof() && this.eat(match)) { /* */ }\n return this.pos !== start;\n }\n /**\n * Backs up the stream n characters. Backing it up further than the\n * start of the current token will cause things to break, so be careful.\n */\n backUp(n) {\n this.pos -= (n || 1);\n }\n /**\n * Get the string between the start of the current token and the\n * current stream position.\n */\n current() {\n return this.substring(this.start, this.pos);\n }\n /**\n * Returns substring for given range\n */\n substring(start, end) {\n return this.string.slice(start, end);\n }\n /**\n * Creates error object with current stream state\n */\n error(message, pos = this.pos) {\n return new ScannerError(`${message} at ${pos + 1}`, pos, this.string);\n }\n}\nclass ScannerError extends Error {\n constructor(message, pos, str) {\n super(message);\n this.pos = pos;\n this.string = str;\n }\n}\n\nexport default Scanner;\nexport { ScannerError, eatPair, eatQuoted, isAlpha, isAlphaNumeric, isAlphaNumericWord, isAlphaWord, isNumber, isQuote, isSpace, isWhiteSpace };\n//# sourceMappingURL=scanner.es.js.map\n","import Scanner, { isAlphaNumericWord, isSpace, isQuote as isQuote$1, isNumber, isAlpha, ScannerError } from '@emmetio/scanner';\n\nfunction tokenScanner(tokens) {\n return {\n tokens,\n start: 0,\n pos: 0,\n size: tokens.length\n };\n}\nfunction peek(scanner) {\n return scanner.tokens[scanner.pos];\n}\nfunction next(scanner) {\n return scanner.tokens[scanner.pos++];\n}\nfunction slice(scanner, from = scanner.start, to = scanner.pos) {\n return scanner.tokens.slice(from, to);\n}\nfunction readable(scanner) {\n return scanner.pos < scanner.size;\n}\nfunction consume(scanner, test) {\n const token = peek(scanner);\n if (token && test(token)) {\n scanner.pos++;\n return true;\n }\n return false;\n}\nfunction error(scanner, message, token = peek(scanner)) {\n if (token && token.start != null) {\n message += ` at ${token.start}`;\n }\n const err = new Error(message);\n err['pos'] = token && token.start;\n return err;\n}\n\nfunction abbreviation(abbr, options = {}) {\n const scanner = tokenScanner(abbr);\n const result = statements(scanner, options);\n if (readable(scanner)) {\n throw error(scanner, 'Unexpected character');\n }\n return result;\n}\nfunction statements(scanner, options) {\n const result = {\n type: 'TokenGroup',\n elements: []\n };\n let ctx = result;\n let node;\n const stack = [];\n while (readable(scanner)) {\n if (node = element(scanner, options) || group(scanner, options)) {\n ctx.elements.push(node);\n if (consume(scanner, isChildOperator)) {\n stack.push(ctx);\n ctx = node;\n }\n else if (consume(scanner, isSiblingOperator)) {\n continue;\n }\n else if (consume(scanner, isClimbOperator)) {\n do {\n if (stack.length) {\n ctx = stack.pop();\n }\n } while (consume(scanner, isClimbOperator));\n }\n }\n else {\n break;\n }\n }\n return result;\n}\n/**\n * Consumes group from given scanner\n */\nfunction group(scanner, options) {\n if (consume(scanner, isGroupStart)) {\n const result = statements(scanner, options);\n const token = next(scanner);\n if (isBracket(token, 'group', false)) {\n result.repeat = repeater(scanner);\n }\n return result;\n }\n}\n/**\n * Consumes single element from given scanner\n */\nfunction element(scanner, options) {\n let attr;\n const elem = {\n type: 'TokenElement',\n name: void 0,\n attributes: void 0,\n value: void 0,\n repeat: void 0,\n selfClose: false,\n elements: []\n };\n if (elementName(scanner, options)) {\n elem.name = slice(scanner);\n }\n while (readable(scanner)) {\n scanner.start = scanner.pos;\n if (!elem.repeat && !isEmpty(elem) && consume(scanner, isRepeater)) {\n elem.repeat = scanner.tokens[scanner.pos - 1];\n }\n else if (!elem.value && text(scanner)) {\n elem.value = getText(scanner);\n }\n else if (attr = shortAttribute(scanner, 'id', options) || shortAttribute(scanner, 'class', options) || attributeSet(scanner)) {\n if (!elem.attributes) {\n elem.attributes = Array.isArray(attr) ? attr.slice() : [attr];\n }\n else {\n elem.attributes = elem.attributes.concat(attr);\n }\n }\n else {\n if (!isEmpty(elem) && consume(scanner, isCloseOperator)) {\n elem.selfClose = true;\n if (!elem.repeat && consume(scanner, isRepeater)) {\n elem.repeat = scanner.tokens[scanner.pos - 1];\n }\n }\n break;\n }\n }\n return !isEmpty(elem) ? elem : void 0;\n}\n/**\n * Consumes attribute set from given scanner\n */\nfunction attributeSet(scanner) {\n if (consume(scanner, isAttributeSetStart)) {\n const attributes = [];\n let attr;\n while (readable(scanner)) {\n if (attr = attribute(scanner)) {\n attributes.push(attr);\n }\n else if (consume(scanner, isAttributeSetEnd)) {\n break;\n }\n else if (!consume(scanner, isWhiteSpace)) {\n throw error(scanner, `Unexpected \"${peek(scanner).type}\" token`);\n }\n }\n return attributes;\n }\n}\n/**\n * Consumes attribute shorthand (class or id) from given scanner\n */\nfunction shortAttribute(scanner, type, options) {\n if (isOperator(peek(scanner), type)) {\n scanner.pos++;\n const attr = {\n name: [createLiteral(type)]\n };\n // Consume expression after shorthand start for React-like components\n if (options.jsx && text(scanner)) {\n attr.value = getText(scanner);\n attr.expression = true;\n }\n else {\n attr.value = literal(scanner) ? slice(scanner) : void 0;\n }\n return attr;\n }\n}\n/**\n * Consumes single attribute from given scanner\n */\nfunction attribute(scanner) {\n if (quoted(scanner)) {\n // Consumed quoted value: it’s a value for default attribute\n return {\n value: slice(scanner)\n };\n }\n if (literal(scanner, true)) {\n return {\n name: slice(scanner),\n value: consume(scanner, isEquals) && (quoted(scanner) || literal(scanner, true))\n ? slice(scanner)\n : void 0\n };\n }\n}\nfunction repeater(scanner) {\n return isRepeater(peek(scanner))\n ? scanner.tokens[scanner.pos++]\n : void 0;\n}\n/**\n * Consumes quoted value from given scanner, if possible\n */\nfunction quoted(scanner) {\n const start = scanner.pos;\n const quote = peek(scanner);\n if (isQuote(quote)) {\n scanner.pos++;\n while (readable(scanner)) {\n if (isQuote(next(scanner), quote.single)) {\n scanner.start = start;\n return true;\n }\n }\n throw error(scanner, 'Unclosed quote', quote);\n }\n return false;\n}\n/**\n * Consumes literal (unquoted value) from given scanner\n */\nfunction literal(scanner, allowBrackets) {\n const start = scanner.pos;\n const brackets = {\n attribute: 0,\n expression: 0,\n group: 0\n };\n while (readable(scanner)) {\n const token = peek(scanner);\n if (brackets.expression) {\n // If we’re inside expression, we should consume all content in it\n if (isBracket(token, 'expression')) {\n brackets[token.context] += token.open ? 1 : -1;\n }\n }\n else if (isQuote(token) || isOperator(token) || isWhiteSpace(token) || isRepeater(token)) {\n break;\n }\n else if (isBracket(token)) {\n if (!allowBrackets) {\n break;\n }\n if (token.open) {\n brackets[token.context]++;\n }\n else if (!brackets[token.context]) {\n // Stop if found unmatched closing brace: it must be handled\n // by parent consumer\n break;\n }\n else {\n brackets[token.context]--;\n }\n }\n scanner.pos++;\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return true;\n }\n return false;\n}\n/**\n * Consumes element name from given scanner\n */\nfunction elementName(scanner, options) {\n const start = scanner.pos;\n if (options.jsx && consume(scanner, isCapitalizedLiteral)) {\n // Check for edge case: consume immediate capitalized class names\n // for React-like components, e.g. `Foo.Bar.Baz`\n while (readable(scanner)) {\n const { pos } = scanner;\n if (!consume(scanner, isClassNameOperator) || !consume(scanner, isCapitalizedLiteral)) {\n scanner.pos = pos;\n break;\n }\n }\n }\n while (readable(scanner) && consume(scanner, isElementName)) {\n // empty\n }\n if (scanner.pos !== start) {\n scanner.start = start;\n return true;\n }\n return false;\n}\n/**\n * Consumes text value from given scanner\n */\nfunction text(scanner) {\n const start = scanner.pos;\n if (consume(scanner, isTextStart)) {\n let brackets = 0;\n while (readable(scanner)) {\n const token = next(scanner);\n if (isBracket(token, 'expression')) {\n if (token.open) {\n brackets++;\n }\n else if (!brackets) {\n break;\n }\n else {\n brackets--;\n }\n }\n }\n scanner.start = start;\n return true;\n }\n return false;\n}\nfunction getText(scanner) {\n let from = scanner.start;\n let to = scanner.pos;\n if (isBracket(scanner.tokens[from], 'expression', true)) {\n from++;\n }\n if (isBracket(scanner.tokens[to - 1], 'expression', false)) {\n to--;\n }\n return slice(scanner, from, to);\n}\nfunction isBracket(token, context, isOpen) {\n return Boolean(token && token.type === 'Bracket'\n && (!context || token.context === context)\n && (isOpen == null || token.open === isOpen));\n}\nfunction isOperator(token, type) {\n return Boolean(token && token.type === 'Operator' && (!type || token.operator === type));\n}\nfunction isQuote(token, isSingle) {\n return Boolean(token && token.type === 'Quote' && (isSingle == null || token.single === isSingle));\n}\nfunction isWhiteSpace(token) {\n return Boolean(token && token.type === 'WhiteSpace');\n}\nfunction isEquals(token) {\n return isOperator(token, 'equal');\n}\nfunction isRepeater(token) {\n return Boolean(token && token.type === 'Repeater');\n}\nfunction isLiteral(token) {\n return token.type === 'Literal';\n}\nfunction isCapitalizedLiteral(token) {\n if (isLiteral(token)) {\n const ch = token.value.charCodeAt(0);\n return ch >= 65 && ch <= 90;\n }\n return false;\n}\nfunction isElementName(token) {\n return token.type === 'Literal' || token.type === 'RepeaterNumber' || token.type === 'RepeaterPlaceholder';\n}\nfunction isClassNameOperator(token) {\n return isOperator(token, 'class');\n}\nfunction isAttributeSetStart(token) {\n return isBracket(token, 'attribute', true);\n}\nfunction isAttributeSetEnd(token) {\n return isBracket(token, 'attribute', false);\n}\nfunction isTextStart(token) {\n return isBracket(token, 'expression', true);\n}\nfunction isGroupStart(token) {\n return isBracket(token, 'group', true);\n}\nfunction createLiteral(value) {\n return { type: 'Literal', value };\n}\nfunction isEmpty(elem) {\n return !elem.name && !elem.value && !elem.attributes;\n}\nfunction isChildOperator(token) {\n return isOperator(token, 'child');\n}\nfunction isSiblingOperator(token) {\n return isOperator(token, 'sibling');\n}\nfunction isClimbOperator(token) {\n return isOperator(token, 'climb');\n}\nfunction isCloseOperator(token) {\n return isOperator(token, 'close');\n}\n\n/**\n * If consumes escape character, sets current stream range to escaped value\n */\nfunction escaped(scanner) {\n if (scanner.eat(92 /* Escape */)) {\n scanner.start = scanner.pos;\n if (!scanner.eof()) {\n scanner.pos++;\n }\n return true;\n }\n return false;\n}\n\nfunction tokenize(source) {\n const scanner = new Scanner(source);\n const result = [];\n const ctx = {\n group: 0,\n attribute: 0,\n expression: 0,\n quote: 0\n };\n let ch = 0;\n let token;\n while (!scanner.eof()) {\n ch = scanner.peek();\n token = getToken(scanner, ctx);\n if (token) {\n result.push(token);\n if (token.type === 'Quote') {\n ctx.quote = ch === ctx.quote ? 0 : ch;\n }\n else if (token.type === 'Bracket') {\n ctx[token.context] += token.open ? 1 : -1;\n }\n }\n else {\n throw scanner.error('Unexpected character');\n }\n }\n return result;\n}\n/**\n * Returns next token from given scanner, if possible\n */\nfunction getToken(scanner, ctx) {\n return field(scanner, ctx)\n || repeaterPlaceholder(scanner)\n || repeaterNumber(scanner)\n || repeater$1(scanner)\n || whiteSpace(scanner)\n || literal$1(scanner, ctx)\n || operator(scanner)\n || quote(scanner)\n || bracket(scanner);\n}\n/**\n * Consumes literal from given scanner\n */\nfunction literal$1(scanner, ctx) {\n const start = scanner.pos;\n let value = '';\n while (!scanner.eof()) {\n // Consume escaped sequence no matter of context\n if (escaped(scanner)) {\n value += scanner.current();\n continue;\n }\n const ch = scanner.peek();\n if (ch === ctx.quote || ch === 36 /* Dollar */ || isAllowedOperator(ch, ctx)) {\n // 1. Found matching quote\n // 2. The `$` character has special meaning in every context\n // 3. Depending on context, some characters should be treated as operators\n break;\n }\n if (ctx.expression && ch === 125 /* CurlyBracketClose */) {\n break;\n }\n if (!ctx.quote && !ctx.expression) {\n // Consuming element name\n if (!ctx.attribute && !isElementName$1(ch)) {\n break;\n }\n if (isAllowedSpace(ch, ctx) || isAllowedRepeater(ch, ctx) || isQuote$1(ch) || bracketType(ch)) {\n // Stop for characters not allowed in unquoted literal\n break;\n }\n }\n value += scanner.string[scanner.pos++];\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return {\n type: 'Literal',\n value,\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes white space characters as string literal from given scanner\n */\nfunction whiteSpace(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(isSpace)) {\n return {\n type: 'WhiteSpace',\n start,\n end: scanner.pos,\n value: scanner.substring(start, scanner.pos)\n };\n }\n}\n/**\n * Consumes quote from given scanner\n */\nfunction quote(scanner) {\n const ch = scanner.peek();\n if (isQuote$1(ch)) {\n return {\n type: 'Quote',\n single: ch === 39 /* SingleQuote */,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes bracket from given scanner\n */\nfunction bracket(scanner) {\n const ch = scanner.peek();\n const context = bracketType(ch);\n if (context) {\n return {\n type: 'Bracket',\n open: isOpenBracket(ch),\n context,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes operator from given scanner\n */\nfunction operator(scanner) {\n const op = operatorType(scanner.peek());\n if (op) {\n return {\n type: 'Operator',\n operator: op,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes node repeat token from current stream position and returns its\n * parsed value\n */\nfunction repeater$1(scanner) {\n const start = scanner.pos;\n if (scanner.eat(42 /* Asterisk */)) {\n scanner.start = scanner.pos;\n let count = 1;\n let implicit = false;\n if (scanner.eatWhile(isNumber)) {\n count = Number(scanner.current());\n }\n else {\n implicit = true;\n }\n return {\n type: 'Repeater',\n count,\n value: 0,\n implicit,\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes repeater placeholder `$#` from given scanner\n */\nfunction repeaterPlaceholder(scanner) {\n const start = scanner.pos;\n if (scanner.eat(36 /* Dollar */) && scanner.eat(35 /* Hash */)) {\n return {\n type: 'RepeaterPlaceholder',\n value: void 0,\n start,\n end: scanner.pos\n };\n }\n scanner.pos = start;\n}\n/**\n * Consumes numbering token like `$` from given scanner state\n */\nfunction repeaterNumber(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(36 /* Dollar */)) {\n const size = scanner.pos - start;\n let reverse = false;\n let base = 1;\n let parent = 0;\n if (scanner.eat(64 /* At */)) {\n // Consume numbering modifiers\n while (scanner.eat(94 /* Climb */)) {\n parent++;\n }\n reverse = scanner.eat(45 /* Dash */);\n scanner.start = scanner.pos;\n if (scanner.eatWhile(isNumber)) {\n base = Number(scanner.current());\n }\n }\n scanner.start = start;\n return {\n type: 'RepeaterNumber',\n size,\n reverse,\n base,\n parent,\n start,\n end: scanner.pos\n };\n }\n}\nfunction field(scanner, ctx) {\n const start = scanner.pos;\n // Fields are allowed inside expressions and attributes\n if ((ctx.expression || ctx.attribute) && scanner.eat(36 /* Dollar */) && scanner.eat(123 /* CurlyBracketOpen */)) {\n scanner.start = scanner.pos;\n let index;\n let name = '';\n if (scanner.eatWhile(isNumber)) {\n // It’s a field\n index = Number(scanner.current());\n name = scanner.eat(58 /* Colon */) ? consumePlaceholder(scanner) : '';\n }\n else if (isAlpha(scanner.peek())) {\n // It’s a variable\n name = consumePlaceholder(scanner);\n }\n if (scanner.eat(125 /* CurlyBracketClose */)) {\n return {\n type: 'Field',\n index, name,\n start,\n end: scanner.pos\n };\n }\n throw scanner.error('Expecting }');\n }\n // If we reached here then there’s no valid field here, revert\n // back to starting position\n scanner.pos = start;\n}\n/**\n * Consumes a placeholder: value right after `:` in field. Could be empty\n */\nfunction consumePlaceholder(stream) {\n const stack = [];\n stream.start = stream.pos;\n while (!stream.eof()) {\n if (stream.eat(123 /* CurlyBracketOpen */)) {\n stack.push(stream.pos);\n }\n else if (stream.eat(125 /* CurlyBracketClose */)) {\n if (!stack.length) {\n stream.pos--;\n break;\n }\n stack.pop();\n }\n else {\n stream.pos++;\n }\n }\n if (stack.length) {\n stream.pos = stack.pop();\n throw stream.error(`Expecting }`);\n }\n return stream.current();\n}\n/**\n * Check if given character code is an operator and it’s allowed in current context\n */\nfunction isAllowedOperator(ch, ctx) {\n const op = operatorType(ch);\n if (!op || ctx.quote || ctx.expression) {\n // No operators inside quoted values or expressions\n return false;\n }\n // Inside attributes, only `equals` is allowed\n return !ctx.attribute || op === 'equal';\n}\n/**\n * Check if given character is a space character and is allowed to be consumed\n * as a space token in current context\n */\nfunction isAllowedSpace(ch, ctx) {\n return isSpace(ch) && !ctx.expression;\n}\n/**\n * Check if given character can be consumed as repeater in current context\n */\nfunction isAllowedRepeater(ch, ctx) {\n return ch === 42 /* Asterisk */ && !ctx.attribute && !ctx.expression;\n}\n/**\n * If given character is a bracket, returns it’s type\n */\nfunction bracketType(ch) {\n if (ch === 40 /* RoundBracketOpen */ || ch === 41 /* RoundBracketClose */) {\n return 'group';\n }\n if (ch === 91 /* SquareBracketOpen */ || ch === 93 /* SquareBracketClose */) {\n return 'attribute';\n }\n if (ch === 123 /* CurlyBracketOpen */ || ch === 125 /* CurlyBracketClose */) {\n return 'expression';\n }\n}\n/**\n * If given character is an operator, returns it’s type\n */\nfunction operatorType(ch) {\n return (ch === 62 /* Child */ && 'child')\n || (ch === 43 /* Sibling */ && 'sibling')\n || (ch === 94 /* Climb */ && 'climb')\n || (ch === 46 /* Dot */ && 'class')\n || (ch === 35 /* Hash */ && 'id')\n || (ch === 47 /* Slash */ && 'close')\n || (ch === 61 /* Equals */ && 'equal')\n || void 0;\n}\n/**\n * Check if given character is an open bracket\n */\nfunction isOpenBracket(ch) {\n return ch === 123 /* CurlyBracketOpen */\n || ch === 91 /* SquareBracketOpen */\n || ch === 40 /* RoundBracketOpen */;\n}\n/**\n * Check if given character is allowed in element name\n */\nfunction isElementName$1(ch) {\n return isAlphaNumericWord(ch)\n || ch === 45 /* Dash */\n || ch === 58 /* Colon */\n || ch === 33 /* Excl */;\n}\n\nconst operators = {\n child: '>',\n class: '.',\n climb: '^',\n id: '#',\n equal: '=',\n close: '/',\n sibling: '+'\n};\nconst tokenVisitor = {\n Literal(token) {\n return token.value;\n },\n Quote(token) {\n return token.single ? '\\'' : '\"';\n },\n Bracket(token) {\n if (token.context === 'attribute') {\n return token.open ? '[' : ']';\n }\n else if (token.context === 'expression') {\n return token.open ? '{' : '}';\n }\n else {\n return token.open ? '(' : '}';\n }\n },\n Operator(token) {\n return operators[token.operator];\n },\n Field(token, state) {\n if (token.index != null) {\n // It’s a field: by default, return TextMate-compatible field\n return token.name\n ? `\\${${token.index}:${token.name}}`\n : `\\${${token.index}`;\n }\n else if (token.name) {\n // It’s a variable\n return state.getVariable(token.name);\n }\n return '';\n },\n RepeaterPlaceholder(token, state) {\n // Find closest implicit repeater\n let repeater;\n for (let i = state.repeaters.length - 1; i >= 0; i--) {\n if (state.repeaters[i].implicit) {\n repeater = state.repeaters[i];\n break;\n }\n }\n state.inserted = true;\n return state.getText(repeater && repeater.value);\n },\n RepeaterNumber(token, state) {\n let value = 1;\n const lastIx = state.repeaters.length - 1;\n // const repeaterIx = Math.max(0, state.repeaters.length - 1 - token.parent);\n const repeater = state.repeaters[lastIx];\n if (repeater) {\n value = token.reverse\n ? token.base + repeater.count - repeater.value - 1\n : token.base + repeater.value;\n if (token.parent) {\n const parentIx = Math.max(0, lastIx - token.parent);\n if (parentIx !== lastIx) {\n const parentRepeater = state.repeaters[parentIx];\n value += repeater.count * parentRepeater.value;\n }\n }\n }\n let result = String(value);\n while (result.length < token.size) {\n result = '0' + result;\n }\n return result;\n },\n WhiteSpace(token) {\n return token.value;\n }\n};\n/**\n * Converts given value token to string\n */\nfunction stringify(token, state) {\n if (!tokenVisitor[token.type]) {\n throw new Error(`Unknown token ${token.type}`);\n }\n return tokenVisitor[token.type](token, state);\n}\n\nconst urlRegex = /^((https?:|ftp:|file:)?\\/\\/|(www|ftp)\\.)[^ ]*$/;\nconst emailRegex = /^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,5}$/;\n/**\n * Converts given token-based abbreviation into simplified and unrolled node-based\n * abbreviation\n */\nfunction convert(abbr, options = {}) {\n let textInserted = false;\n let cleanText;\n if (options.text) {\n if (Array.isArray(options.text)) {\n cleanText = options.text.filter(s => s.trim());\n }\n else {\n cleanText = options.text;\n }\n }\n const result = {\n type: 'Abbreviation',\n children: convertGroup(abbr, {\n inserted: false,\n repeaters: [],\n text: options.text,\n cleanText,\n repeatGuard: options.maxRepeat || Number.POSITIVE_INFINITY,\n getText(pos) {\n var _a;\n textInserted = true;\n let value;\n if (Array.isArray(options.text)) {\n if (pos !== undefined && pos >= 0 && pos < cleanText.length) {\n return cleanText[pos];\n }\n value = pos !== undefined ? options.text[pos] : options.text.join('\\n');\n }\n else {\n value = (_a = options.text) !== null && _a !== void 0 ? _a : '';\n }\n return value;\n },\n getVariable(name) {\n const varValue = options.variables && options.variables[name];\n return varValue != null ? varValue : name;\n }\n })\n };\n if (options.text != null && !textInserted) {\n // Text given but no implicitly repeated elements: insert it into\n // deepest child\n const deepest = deepestNode(last(result.children));\n if (deepest) {\n const text = Array.isArray(options.text) ? options.text.join('\\n') : options.text;\n insertText(deepest, text);\n if (deepest.name === 'a' && options.href) {\n // Automatically update value of `` element if inserting URL or email\n insertHref(deepest, text);\n }\n }\n }\n return result;\n}\n/**\n * Converts given statement to abbreviation nodes\n */\nfunction convertStatement(node, state) {\n let result = [];\n if (node.repeat) {\n // Node is repeated: we should create copies of given node\n // and supply context token with actual repeater state\n const original = node.repeat;\n const repeat = Object.assign({}, original);\n repeat.count = repeat.implicit && Array.isArray(state.text)\n ? state.cleanText.length\n : (repeat.count || 1);\n let items;\n state.repeaters.push(repeat);\n for (let i = 0; i < repeat.count; i++) {\n repeat.value = i;\n node.repeat = repeat;\n items = isGroup(node)\n ? convertGroup(node, state)\n : convertElement(node, state);\n if (repeat.implicit && !state.inserted) {\n // It’s an implicit repeater but no repeater placeholders found inside,\n // we should insert text into deepest node\n const target = last(items);\n const deepest = target && deepestNode(target);\n if (deepest) {\n insertText(deepest, state.getText(repeat.value));\n }\n }\n result = result.concat(items);\n // We should output at least one repeated item even if it’s reached\n // repeat limit\n if (--state.repeatGuard <= 0) {\n break;\n }\n }\n state.repeaters.pop();\n node.repeat = original;\n if (repeat.implicit) {\n state.inserted = true;\n }\n }\n else {\n result = result.concat(isGroup(node) ? convertGroup(node, state) : convertElement(node, state));\n }\n return result;\n}\nfunction convertElement(node, state) {\n let children = [];\n const elem = {\n type: 'AbbreviationNode',\n name: node.name && stringifyName(node.name, state),\n value: node.value && stringifyValue(node.value, state),\n attributes: void 0,\n children,\n repeat: node.repeat && Object.assign({}, node.repeat),\n selfClosing: node.selfClose,\n };\n let result = [elem];\n for (const child of node.elements) {\n children = children.concat(convertStatement(child, state));\n }\n if (node.attributes) {\n elem.attributes = [];\n for (const attr of node.attributes) {\n elem.attributes.push(convertAttribute(attr, state));\n }\n }\n // In case if current node is a text-only snippet without fields, we should\n // put all children as siblings\n if (!elem.name && !elem.attributes && elem.value && !elem.value.some(isField)) {\n // XXX it’s unclear that `children` is not bound to `elem`\n // due to concat operation\n result = result.concat(children);\n }\n else {\n elem.children = children;\n }\n return result;\n}\nfunction convertGroup(node, state) {\n let result = [];\n for (const child of node.elements) {\n result = result.concat(convertStatement(child, state));\n }\n if (node.repeat) {\n result = attachRepeater(result, node.repeat);\n }\n return result;\n}\nfunction convertAttribute(node, state) {\n let implied = false;\n let isBoolean = false;\n let valueType = node.expression ? 'expression' : 'raw';\n let value;\n const name = node.name && stringifyName(node.name, state);\n if (name && name[0] === '!') {\n implied = true;\n }\n if (name && name[name.length - 1] === '.') {\n isBoolean = true;\n }\n if (node.value) {\n const tokens = node.value.slice();\n if (isQuote(tokens[0])) {\n // It’s a quoted value: remove quotes from output but mark attribute\n // value as quoted\n const quote = tokens.shift();\n if (tokens.length && last(tokens).type === quote.type) {\n tokens.pop();\n }\n valueType = quote.single ? 'singleQuote' : 'doubleQuote';\n }\n else if (isBracket(tokens[0], 'expression', true)) {\n // Value is expression: remove brackets but mark value type\n valueType = 'expression';\n tokens.shift();\n if (isBracket(last(tokens), 'expression', false)) {\n tokens.pop();\n }\n }\n value = stringifyValue(tokens, state);\n }\n return {\n name: isBoolean || implied\n ? name.slice(implied ? 1 : 0, isBoolean ? -1 : void 0)\n : name,\n value,\n boolean: isBoolean,\n implied,\n valueType\n };\n}\n/**\n * Converts given token list to string\n */\nfunction stringifyName(tokens, state) {\n let str = '';\n for (let i = 0; i < tokens.length; i++) {\n str += stringify(tokens[i], state);\n }\n return str;\n}\n/**\n * Converts given token list to value list\n */\nfunction stringifyValue(tokens, state) {\n const result = [];\n let str = '';\n for (let i = 0, token; i < tokens.length; i++) {\n token = tokens[i];\n if (isField(token)) {\n // We should keep original fields in output since some editors has their\n // own syntax for field or doesn’t support fields at all so we should\n // capture actual field location in output stream\n if (str) {\n result.push(str);\n str = '';\n }\n result.push(token);\n }\n else {\n str += stringify(token, state);\n }\n }\n if (str) {\n result.push(str);\n }\n return result;\n}\nfunction isGroup(node) {\n return node.type === 'TokenGroup';\n}\nfunction isField(token) {\n return typeof token === 'object' && token.type === 'Field' && token.index != null;\n}\nfunction last(arr) {\n return arr[arr.length - 1];\n}\nfunction deepestNode(node) {\n return node.children.length ? deepestNode(last(node.children)) : node;\n}\nfunction insertText(node, text) {\n if (node.value) {\n const lastToken = last(node.value);\n if (typeof lastToken === 'string') {\n node.value[node.value.length - 1] += text;\n }\n else {\n node.value.push(text);\n }\n }\n else {\n node.value = [text];\n }\n}\nfunction insertHref(node, text) {\n var _a;\n let href = '';\n if (urlRegex.test(text)) {\n href = text;\n if (!/\\w+:/.test(href) && !href.startsWith('//')) {\n href = `http://${href}`;\n }\n }\n else if (emailRegex.test(text)) {\n href = `mailto:${text}`;\n }\n const hrefAttribute = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.find(attr => attr.name === 'href');\n if (!hrefAttribute) {\n node.attributes = [{ name: 'href', value: [href], valueType: 'doubleQuote' }];\n }\n else if (!hrefAttribute.value) {\n hrefAttribute.value = [href];\n }\n}\nfunction attachRepeater(items, repeater) {\n for (const item of items) {\n if (!item.repeat) {\n item.repeat = Object.assign({}, repeater);\n }\n }\n return items;\n}\n\n/**\n * Parses given abbreviation into node tree\n */\nfunction parseAbbreviation(abbr, options) {\n try {\n const tokens = typeof abbr === 'string' ? tokenize(abbr) : abbr;\n return convert(abbreviation(tokens, options), options);\n }\n catch (err) {\n if (err instanceof ScannerError && typeof abbr === 'string') {\n err.message += `\\n${abbr}\\n${'-'.repeat(err.pos)}^`;\n }\n throw err;\n }\n}\n\nexport default parseAbbreviation;\nexport { convert, getToken, abbreviation as parse, tokenize };\n//# sourceMappingURL=abbreviation.es.js.map\n","import Scanner, { isNumber, isAlpha, isAlphaWord, isQuote, isSpace, isAlphaNumericWord, ScannerError } from '@emmetio/scanner';\n\nfunction tokenize(abbr, isValue) {\n let brackets = 0;\n let token;\n const scanner = new Scanner(abbr);\n const tokens = [];\n while (!scanner.eof()) {\n token = getToken(scanner, brackets === 0 && !isValue);\n if (!token) {\n throw scanner.error('Unexpected character');\n }\n if (token.type === 'Bracket') {\n if (!brackets && token.open) {\n mergeTokens(scanner, tokens);\n }\n brackets += token.open ? 1 : -1;\n if (brackets < 0) {\n throw scanner.error('Unexpected bracket', token.start);\n }\n }\n tokens.push(token);\n // Forcibly consume next operator after unit-less numeric value or color:\n // next dash `-` must be used as value delimiter\n if (shouldConsumeDashAfter(token) && (token = operator(scanner))) {\n tokens.push(token);\n }\n }\n return tokens;\n}\n/**\n * Returns next token from given scanner, if possible\n */\nfunction getToken(scanner, short) {\n return field(scanner)\n || numberValue(scanner)\n || colorValue(scanner)\n || stringValue(scanner)\n || bracket(scanner)\n || operator(scanner)\n || whiteSpace(scanner)\n || literal(scanner, short);\n}\nfunction field(scanner) {\n const start = scanner.pos;\n if (scanner.eat(36 /* Dollar */) && scanner.eat(123 /* CurlyBracketOpen */)) {\n scanner.start = scanner.pos;\n let index;\n let name = '';\n if (scanner.eatWhile(isNumber)) {\n // It’s a field\n index = Number(scanner.current());\n name = scanner.eat(58 /* Colon */) ? consumePlaceholder(scanner) : '';\n }\n else if (isAlpha(scanner.peek())) {\n // It’s a variable\n name = consumePlaceholder(scanner);\n }\n if (scanner.eat(125 /* CurlyBracketClose */)) {\n return {\n type: 'Field',\n index, name,\n start,\n end: scanner.pos\n };\n }\n throw scanner.error('Expecting }');\n }\n // If we reached here then there’s no valid field here, revert\n // back to starting position\n scanner.pos = start;\n}\n/**\n * Consumes a placeholder: value right after `:` in field. Could be empty\n */\nfunction consumePlaceholder(stream) {\n const stack = [];\n stream.start = stream.pos;\n while (!stream.eof()) {\n if (stream.eat(123 /* CurlyBracketOpen */)) {\n stack.push(stream.pos);\n }\n else if (stream.eat(125 /* CurlyBracketClose */)) {\n if (!stack.length) {\n stream.pos--;\n break;\n }\n stack.pop();\n }\n else {\n stream.pos++;\n }\n }\n if (stack.length) {\n stream.pos = stack.pop();\n throw stream.error(`Expecting }`);\n }\n return stream.current();\n}\n/**\n * Consumes literal from given scanner\n * @param short Use short notation for consuming value.\n * The difference between “short” and “full” notation is that first one uses\n * alpha characters only and used for extracting keywords from abbreviation,\n * while “full” notation also supports numbers and dashes\n */\nfunction literal(scanner, short) {\n const start = scanner.pos;\n if (scanner.eat(isIdentPrefix)) {\n // SCSS or LESS variable\n // NB a bit dirty hack: if abbreviation starts with identifier prefix,\n // consume alpha characters only to allow embedded variables\n scanner.eatWhile(start ? isKeyword : isLiteral);\n }\n else if (scanner.eat(isAlphaWord)) {\n scanner.eatWhile(short ? isLiteral : isKeyword);\n }\n else {\n // Allow dots only at the beginning of literal\n scanner.eat(46 /* Dot */);\n scanner.eatWhile(isLiteral);\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return createLiteral(scanner, scanner.start = start);\n }\n}\nfunction createLiteral(scanner, start = scanner.start, end = scanner.pos) {\n return {\n type: 'Literal',\n value: scanner.substring(start, end),\n start,\n end\n };\n}\n/**\n * Consumes numeric CSS value (number with optional unit) from current stream,\n * if possible\n */\nfunction numberValue(scanner) {\n const start = scanner.pos;\n if (consumeNumber(scanner)) {\n scanner.start = start;\n const rawValue = scanner.current();\n // eat unit, which can be a % or alpha word\n scanner.start = scanner.pos;\n scanner.eat(37 /* Percent */) || scanner.eatWhile(isAlphaWord);\n return {\n type: 'NumberValue',\n value: Number(rawValue),\n rawValue,\n unit: scanner.current(),\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes quoted string value from given scanner\n */\nfunction stringValue(scanner) {\n const ch = scanner.peek();\n const start = scanner.pos;\n let finished = false;\n if (isQuote(ch)) {\n scanner.pos++;\n while (!scanner.eof()) {\n // Do not throw error on malformed string\n if (scanner.eat(ch)) {\n finished = true;\n break;\n }\n else {\n scanner.pos++;\n }\n }\n scanner.start = start;\n return {\n type: 'StringValue',\n value: scanner.substring(start + 1, scanner.pos - (finished ? 1 : 0)),\n quote: ch === 39 /* SingleQuote */ ? 'single' : 'double',\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes a color token from given string\n */\nfunction colorValue(scanner) {\n // supported color variations:\n // #abc → #aabbccc\n // #0 → #000000\n // #fff.5 → rgba(255, 255, 255, 0.5)\n // #t → transparent\n const start = scanner.pos;\n if (scanner.eat(35 /* Hash */)) {\n const valueStart = scanner.pos;\n let color = '';\n let alpha = '';\n if (scanner.eatWhile(isHex)) {\n color = scanner.substring(valueStart, scanner.pos);\n alpha = colorAlpha(scanner);\n }\n else if (scanner.eat(116 /* Transparent */)) {\n color = '0';\n alpha = colorAlpha(scanner) || '0';\n }\n else {\n alpha = colorAlpha(scanner);\n }\n if (color || alpha || scanner.eof()) {\n const { r, g, b, a } = parseColor(color, alpha);\n return {\n type: 'ColorValue',\n r, g, b, a,\n raw: scanner.substring(start + 1, scanner.pos),\n start,\n end: scanner.pos\n };\n }\n else {\n // Consumed # but no actual value: invalid color value, treat it as literal\n return createLiteral(scanner, start);\n }\n }\n scanner.pos = start;\n}\n/**\n * Consumes alpha value of color: `.1`\n */\nfunction colorAlpha(scanner) {\n const start = scanner.pos;\n if (scanner.eat(46 /* Dot */)) {\n scanner.start = start;\n if (scanner.eatWhile(isNumber)) {\n return scanner.current();\n }\n return '1';\n }\n return '';\n}\n/**\n * Consumes white space characters as string literal from given scanner\n */\nfunction whiteSpace(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(isSpace)) {\n return {\n type: 'WhiteSpace',\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes bracket from given scanner\n */\nfunction bracket(scanner) {\n const ch = scanner.peek();\n if (isBracket(ch)) {\n return {\n type: 'Bracket',\n open: ch === 40 /* RoundBracketOpen */,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes operator from given scanner\n */\nfunction operator(scanner) {\n const op = operatorType(scanner.peek());\n if (op) {\n return {\n type: 'Operator',\n operator: op,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Eats number value from given stream\n * @return Returns `true` if number was consumed\n */\nfunction consumeNumber(stream) {\n const start = stream.pos;\n stream.eat(45 /* Dash */);\n const afterNegative = stream.pos;\n const hasDecimal = stream.eatWhile(isNumber);\n const prevPos = stream.pos;\n if (stream.eat(46 /* Dot */)) {\n // It’s perfectly valid to have numbers like `1.`, which enforces\n // value to float unit type\n const hasFloat = stream.eatWhile(isNumber);\n if (!hasDecimal && !hasFloat) {\n // Lone dot\n stream.pos = prevPos;\n }\n }\n // Edge case: consumed dash only: not a number, bail-out\n if (stream.pos === afterNegative) {\n stream.pos = start;\n }\n return stream.pos !== start;\n}\nfunction isIdentPrefix(code) {\n return code === 64 /* At */ || code === 36 /* Dollar */;\n}\n/**\n * If given character is an operator, returns it’s type\n */\nfunction operatorType(ch) {\n return (ch === 43 /* Sibling */ && \"+\" /* Sibling */)\n || (ch === 33 /* Excl */ && \"!\" /* Important */)\n || (ch === 44 /* Comma */ && \",\" /* ArgumentDelimiter */)\n || (ch === 58 /* Colon */ && \":\" /* PropertyDelimiter */)\n || (ch === 45 /* Dash */ && \"-\" /* ValueDelimiter */)\n || void 0;\n}\n/**\n * Check if given code is a hex value (/0-9a-f/)\n */\nfunction isHex(code) {\n return isNumber(code) || isAlpha(code, 65, 70); // A-F\n}\nfunction isKeyword(code) {\n return isAlphaNumericWord(code) || code === 45 /* Dash */;\n}\nfunction isBracket(code) {\n return code === 40 /* RoundBracketOpen */ || code === 41 /* RoundBracketClose */;\n}\nfunction isLiteral(code) {\n return isAlphaWord(code) || code === 37 /* Percent */ || code === 47 /* Slash */;\n}\n/**\n * Parses given color value from abbreviation into RGBA format\n */\nfunction parseColor(value, alpha) {\n let r = '0';\n let g = '0';\n let b = '0';\n let a = Number(alpha != null && alpha !== '' ? alpha : 1);\n if (value === 't') {\n a = 0;\n }\n else {\n switch (value.length) {\n case 0:\n break;\n case 1:\n r = g = b = value + value;\n break;\n case 2:\n r = g = b = value;\n break;\n case 3:\n r = value[0] + value[0];\n g = value[1] + value[1];\n b = value[2] + value[2];\n break;\n default:\n value += value;\n r = value.slice(0, 2);\n g = value.slice(2, 4);\n b = value.slice(4, 6);\n }\n }\n return {\n r: parseInt(r, 16),\n g: parseInt(g, 16),\n b: parseInt(b, 16),\n a\n };\n}\n/**\n * Check if scanner reader must consume dash after given token.\n * Used in cases where user must explicitly separate numeric values\n */\nfunction shouldConsumeDashAfter(token) {\n return token.type === 'ColorValue' || (token.type === 'NumberValue' && !token.unit);\n}\n/**\n * Merges last adjacent tokens into a single literal.\n * This function is used to overcome edge case when function name was parsed\n * as a list of separate tokens. For example, a `scale3d()` value will be\n * parsed as literal and number tokens (`scale` and `3d`) which is a perfectly\n * valid abbreviation but undesired result. This function will detect last adjacent\n * literal and number values and combine them into single literal\n */\nfunction mergeTokens(scanner, tokens) {\n let start = 0;\n let end = 0;\n while (tokens.length) {\n const token = last(tokens);\n if (token.type === 'Literal' || token.type === 'NumberValue') {\n start = token.start;\n if (!end) {\n end = token.end;\n }\n tokens.pop();\n }\n else {\n break;\n }\n }\n if (start !== end) {\n tokens.push(createLiteral(scanner, start, end));\n }\n}\nfunction last(arr) {\n return arr[arr.length - 1];\n}\n\nfunction tokenScanner(tokens) {\n return {\n tokens,\n start: 0,\n pos: 0,\n size: tokens.length\n };\n}\nfunction peek(scanner) {\n return scanner.tokens[scanner.pos];\n}\nfunction readable(scanner) {\n return scanner.pos < scanner.size;\n}\nfunction consume(scanner, test) {\n if (test(peek(scanner))) {\n scanner.pos++;\n return true;\n }\n return false;\n}\nfunction error(scanner, message, token = peek(scanner)) {\n if (token && token.start != null) {\n message += ` at ${token.start}`;\n }\n const err = new Error(message);\n err['pos'] = token && token.start;\n return err;\n}\n\nfunction parser(tokens, options = {}) {\n const scanner = tokenScanner(tokens);\n const result = [];\n let property;\n while (readable(scanner)) {\n if (property = consumeProperty(scanner, options)) {\n result.push(property);\n }\n else if (!consume(scanner, isSiblingOperator)) {\n throw error(scanner, 'Unexpected token');\n }\n }\n return result;\n}\n/**\n * Consumes single CSS property\n */\nfunction consumeProperty(scanner, options) {\n let name;\n let important = false;\n let valueFragment;\n const value = [];\n const token = peek(scanner);\n const valueMode = !!options.value;\n if (!valueMode && isLiteral$1(token) && !isFunctionStart(scanner)) {\n scanner.pos++;\n name = token.value;\n // Consume any following value delimiter after property name\n consume(scanner, isValueDelimiter);\n }\n // Skip whitespace right after property name, if any\n if (valueMode) {\n consume(scanner, isWhiteSpace);\n }\n while (readable(scanner)) {\n if (consume(scanner, isImportant)) {\n important = true;\n }\n else if (valueFragment = consumeValue(scanner, valueMode)) {\n value.push(valueFragment);\n }\n else if (!consume(scanner, isFragmentDelimiter)) {\n break;\n }\n }\n if (name || value.length || important) {\n return { name, value, important };\n }\n}\n/**\n * Consumes single value fragment, e.g. all value tokens before comma\n */\nfunction consumeValue(scanner, inArgument) {\n const result = [];\n let token;\n let args;\n while (readable(scanner)) {\n token = peek(scanner);\n if (isValue(token)) {\n scanner.pos++;\n if (isLiteral$1(token) && (args = consumeArguments(scanner))) {\n result.push({\n type: 'FunctionCall',\n name: token.value,\n arguments: args\n });\n }\n else {\n result.push(token);\n }\n }\n else if (isValueDelimiter(token) || (inArgument && isWhiteSpace(token))) {\n scanner.pos++;\n }\n else {\n break;\n }\n }\n return result.length\n ? { type: 'CSSValue', value: result }\n : void 0;\n}\nfunction consumeArguments(scanner) {\n const start = scanner.pos;\n if (consume(scanner, isOpenBracket)) {\n const args = [];\n let value;\n while (readable(scanner) && !consume(scanner, isCloseBracket)) {\n if (value = consumeValue(scanner, true)) {\n args.push(value);\n }\n else if (!consume(scanner, isWhiteSpace) && !consume(scanner, isArgumentDelimiter)) {\n throw error(scanner, 'Unexpected token');\n }\n }\n scanner.start = start;\n return args;\n }\n}\nfunction isLiteral$1(token) {\n return token && token.type === 'Literal';\n}\nfunction isBracket$1(token, open) {\n return token && token.type === 'Bracket' && (open == null || token.open === open);\n}\nfunction isOpenBracket(token) {\n return isBracket$1(token, true);\n}\nfunction isCloseBracket(token) {\n return isBracket$1(token, false);\n}\nfunction isWhiteSpace(token) {\n return token && token.type === 'WhiteSpace';\n}\nfunction isOperator(token, operator) {\n return token && token.type === 'Operator' && (!operator || token.operator === operator);\n}\nfunction isSiblingOperator(token) {\n return isOperator(token, \"+\" /* Sibling */);\n}\nfunction isArgumentDelimiter(token) {\n return isOperator(token, \",\" /* ArgumentDelimiter */);\n}\nfunction isFragmentDelimiter(token) {\n return isArgumentDelimiter(token);\n}\nfunction isImportant(token) {\n return isOperator(token, \"!\" /* Important */);\n}\nfunction isValue(token) {\n return token.type === 'StringValue'\n || token.type === 'ColorValue'\n || token.type === 'NumberValue'\n || token.type === 'Literal'\n || token.type === 'Field';\n}\nfunction isValueDelimiter(token) {\n return isOperator(token, \":\" /* PropertyDelimiter */)\n || isOperator(token, \"-\" /* ValueDelimiter */);\n}\nfunction isFunctionStart(scanner) {\n const t1 = scanner.tokens[scanner.pos];\n const t2 = scanner.tokens[scanner.pos + 1];\n return t1 && t2 && isLiteral$1(t1) && t2.type === 'Bracket';\n}\n\n/**\n * Parses given abbreviation into property set\n */\nfunction parse(abbr, options) {\n try {\n const tokens = typeof abbr === 'string' ? tokenize(abbr, options && options.value) : abbr;\n return parser(tokens, options);\n }\n catch (err) {\n if (err instanceof ScannerError && typeof abbr === 'string') {\n err.message += `\\n${abbr}\\n${'-'.repeat(err.pos)}^`;\n }\n throw err;\n }\n}\n\nexport default parse;\nexport { getToken, parser, tokenize };\n","import { GlobalConfig } from 'emmet';\n\nexport interface EmmetEditorOptions extends CodeMirror.EditorConfiguration {\n emmet: EmmetConfig;\n}\n\nexport type EnableForSyntax = boolean | string[];\n\nexport interface EmmetConfig {\n /** Enables abbreviation marking in editor. Works in known syntaxes only */\n mark: EnableForSyntax;\n\n /**\n * Enables preview of marked abbreviation. Pass `true` to enable preview for\n * all syntaxes or array of modes or Emmet syntax types (`markup` or `stylesheet`)\n * where preview should be displayed\n */\n preview: EnableForSyntax;\n\n /** Mark HTML tag pairs in editor */\n markTagPairs: boolean;\n\n /**\n * Displays open tag preview when caret is inside its matching closing tag.\n * Preview is displayed only if open tag has attributes.\n * Works only if `markTagPairs` is enabled\n */\n previewOpenTag: boolean;\n\n /** Allow automatic tag pair rename, works only if `markTagPairs` is enabled */\n autoRenameTags: boolean;\n\n /** Quotes to use in generated HTML attribute values */\n attributeQuotes: 'single' | 'double';\n\n /** Style for self-closing elements (like `undefined when no more characters are available.\n */\n next() {\n if (this.pos < this.string.length) {\n return this.string.charCodeAt(this.pos++);\n }\n }\n /**\n * `match` can be a character code or a function that takes a character code\n * and returns a boolean. If the next character in the stream 'matches'\n * the given argument, it is consumed and returned.\n * Otherwise, `false` is returned.\n */\n eat(match) {\n const ch = this.peek();\n const ok = typeof match === 'function' ? match(ch) : ch === match;\n if (ok) {\n this.next();\n }\n return ok;\n }\n /**\n * Repeatedly calls eat with the given argument, until it\n * fails. Returns true if any characters were eaten.\n */\n eatWhile(match) {\n const start = this.pos;\n while (!this.eof() && this.eat(match)) { /* */ }\n return this.pos !== start;\n }\n /**\n * Backs up the stream n characters. Backing it up further than the\n * start of the current token will cause things to break, so be careful.\n */\n backUp(n) {\n this.pos -= (n || 1);\n }\n /**\n * Get the string between the start of the current token and the\n * current stream position.\n */\n current() {\n return this.substring(this.start, this.pos);\n }\n /**\n * Returns substring for given range\n */\n substring(start, end) {\n return this.string.slice(start, end);\n }\n /**\n * Creates error object with current stream state\n */\n error(message, pos = this.pos) {\n return new ScannerError(`${message} at ${pos + 1}`, pos, this.string);\n }\n}\nclass ScannerError extends Error {\n constructor(message, pos, str) {\n super(message);\n this.pos = pos;\n this.string = str;\n }\n}\n\nexport default Scanner;\nexport { ScannerError, eatPair, eatQuoted, isAlpha, isAlphaNumeric, isAlphaNumericWord, isAlphaWord, isNumber, isQuote, isSpace, isWhiteSpace };\n//# sourceMappingURL=scanner.es.js.map\n","import Scanner, { eatPair, isAlpha, isNumber, isQuote, isSpace, eatQuoted } from '@emmetio/scanner';\n\nconst defaultOptions = {\n xml: false,\n allTokens: false,\n special: {\n style: null,\n script: ['', 'text/javascript', 'application/x-javascript', 'javascript', 'typescript', 'ts', 'coffee', 'coffeescript']\n },\n empty: ['img', 'meta', 'link', 'br', 'base', 'hr', 'area', 'wbr', 'col', 'embed', 'input', 'param', 'source', 'track']\n};\n/** Options for `Scanner` utils */\nconst opt = { throws: false };\nfunction createOptions(options = {}) {\n return Object.assign(Object.assign({}, defaultOptions), options);\n}\n/**\n * Converts given string into array of character codes\n */\nfunction toCharCodes(str) {\n return str.split('').map(ch => ch.charCodeAt(0));\n}\n/**\n * Consumes array of character codes from given scanner\n */\nfunction consumeArray(scanner, codes) {\n const start = scanner.pos;\n for (let i = 0; i < codes.length; i++) {\n if (!scanner.eat(codes[i])) {\n scanner.pos = start;\n return false;\n }\n }\n scanner.start = start;\n return true;\n}\n/**\n * Consumes section from given string which starts with `open` character codes\n * and ends with `close` character codes\n * @return Returns `true` if section was consumed\n */\nfunction consumeSection(scanner, open, close, allowUnclosed) {\n const start = scanner.pos;\n if (consumeArray(scanner, open)) {\n // consumed `');\nconst piStart = toCharCodes('');\nconst erbStart = toCharCodes('<%');\nconst erbEnd = toCharCodes('%>');\n/**\n * Performs fast scan of given source code: for each tag found it invokes callback\n * with tag name, its type (open, close, self-close) and range in original source.\n * Unlike regular scanner, fast scanner doesn’t provide info about attributes to\n * reduce object allocations hence increase performance.\n * If `callback` returns `false`, scanner stops parsing.\n * @param special List of “special” HTML tags which should be ignored. Most likely\n * it’s a \"script\" and \"style\" tags.\n */\nfunction scan(source, callback, options) {\n const scanner = new Scanner(source);\n const special = options ? options.special : null;\n const allTokens = options ? options.allTokens : false;\n let type;\n let name;\n let nameStart;\n let nameEnd;\n let nameCodes;\n let found = false;\n let piName = null;\n while (!scanner.eof()) {\n const start = scanner.pos;\n if (cdata(scanner)) {\n if (allTokens && callback('#cdata', 4 /* CData */, scanner.start, scanner.pos) === false) {\n break;\n }\n }\n else if (comment(scanner)) {\n if (allTokens && callback('#comment', 6 /* Comment */, scanner.start, scanner.pos) === false) {\n break;\n }\n }\n else if (erb(scanner)) {\n if (allTokens && callback('#erb', 7 /* ERB */, scanner.start, scanner.pos) === false) {\n break;\n }\n }\n else if (piName = processingInstruction(scanner)) {\n if (allTokens && callback(piName, 5 /* ProcessingInstruction */, scanner.start, scanner.pos) === false) {\n break;\n }\n }\n else if (scanner.eat(60 /* LeftAngle */)) {\n // Maybe a tag name?\n type = scanner.eat(47 /* Slash */) ? 2 /* Close */ : 1 /* Open */;\n nameStart = scanner.pos;\n if (ident(scanner)) {\n // Consumed tag name\n nameEnd = scanner.pos;\n if (type !== 2 /* Close */) {\n skipAttributes(scanner);\n scanner.eatWhile(isSpace);\n if (scanner.eat(47 /* Slash */)) {\n type = 3 /* SelfClose */;\n }\n }\n if (scanner.eat(62 /* RightAngle */)) {\n // Tag properly closed\n name = scanner.substring(nameStart, nameEnd);\n if (callback(name, type, start, scanner.pos) === false) {\n break;\n }\n if (type === 1 /* Open */ && special && isSpecial(special, name, source, start, scanner.pos)) {\n // Found opening tag of special element: we should skip\n // scanner contents until we find closing tag\n nameCodes = toCharCodes(name);\n found = false;\n while (!scanner.eof()) {\n if (consumeClosing(scanner, nameCodes)) {\n found = true;\n break;\n }\n scanner.pos++;\n }\n if (found && callback(name, 2 /* Close */, scanner.start, scanner.pos) === false) {\n break;\n }\n }\n }\n }\n }\n else {\n scanner.pos++;\n }\n }\n}\n/**\n * Skips attributes in current tag context\n */\nfunction skipAttributes(scanner) {\n while (!scanner.eof()) {\n scanner.eatWhile(isSpace);\n if (attributeName(scanner)) {\n if (scanner.eat(61 /* Equals */)) {\n attributeValue(scanner);\n }\n }\n else if (isTerminator(scanner.peek())) {\n break;\n }\n else {\n scanner.pos++;\n }\n }\n}\n/**\n * Consumes closing tag with given name from scanner\n */\nfunction consumeClosing(scanner, name) {\n const start = scanner.pos;\n if (scanner.eat(60 /* LeftAngle */) && scanner.eat(47 /* Slash */) && consumeArray(scanner, name) && scanner.eat(62 /* RightAngle */)) {\n scanner.start = start;\n return true;\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Consumes CDATA from given scanner\n */\nfunction cdata(scanner) {\n return consumeSection(scanner, cdataOpen, cdataClose, true);\n}\n/**\n * Consumes comments from given scanner\n */\nfunction comment(scanner) {\n return consumeSection(scanner, commentOpen, commentClose, true);\n}\n/**\n * Consumes processing instruction from given scanner. If consumed, returns\n * processing instruction name\n */\nfunction processingInstruction(scanner) {\n const start = scanner.pos;\n if (consumeArray(scanner, piStart) && ident(scanner)) {\n const name = scanner.current();\n while (!scanner.eof()) {\n if (consumeArray(scanner, piEnd)) {\n break;\n }\n eatQuoted(scanner) || scanner.pos++;\n }\n scanner.start = start;\n return name;\n }\n scanner.pos = start;\n return null;\n}\n/**\n * Consumes ERB-style entity: `<% ... %>` or `<%= ... %>`\n */\nfunction erb(scanner) {\n const start = scanner.pos;\n if (consumeArray(scanner, erbStart)) {\n while (!scanner.eof()) {\n if (consumeArray(scanner, erbEnd)) {\n break;\n }\n eatQuoted(scanner) || scanner.pos++;\n }\n scanner.start = start;\n return true;\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Check if given tag name should be considered as special\n */\nfunction isSpecial(special, name, source, start, end) {\n if (name in special) {\n const typeValues = special[name];\n if (!Array.isArray(typeValues)) {\n return true;\n }\n const attrs = attributes(source.substring(start + name.length + 1, end - 1));\n return typeValues.includes(getAttributeValue(attrs, 'type') || '');\n }\n return false;\n}\n\n/**\n * Finds matched tag for given `pos` location in XML/HTML `source`\n */\nfunction match(source, pos, opt) {\n // Since we expect large input document, we’ll use pooling technique\n // for storing tag data to reduce memory pressure and improve performance\n const pool = [];\n const stack = [];\n const options = createOptions(opt);\n let result = null;\n scan(source, (name, type, start, end) => {\n if (type === 1 /* Open */ && isSelfClose(name, options)) {\n // Found empty element in HTML mode, mark is as self-closing\n type = 3 /* SelfClose */;\n }\n if (type === 1 /* Open */) {\n // Allocate tag object from pool\n stack.push(allocTag(pool, name, start, end));\n }\n else if (type === 3 /* SelfClose */) {\n if (start < pos && pos < end) {\n // Matched given self-closing tag\n result = {\n name,\n attributes: getAttributes(source, start, end, name),\n open: [start, end]\n };\n return false;\n }\n }\n else {\n const tag = last(stack);\n if (tag && tag.name === name) {\n // Matching closing tag found\n if (tag.start < pos && pos < end) {\n result = {\n name,\n attributes: getAttributes(source, tag.start, tag.end, name),\n open: [tag.start, tag.end],\n close: [start, end]\n };\n return false;\n }\n else if (stack.length) {\n // Release tag object for further re-use\n releaseTag(pool, stack.pop());\n }\n }\n }\n }, options);\n stack.length = pool.length = 0;\n return result;\n}\n/**\n * Returns balanced tag model: a list of all XML/HTML tags that could possibly match\n * given location when moving in outward direction\n */\nfunction balancedOutward(source, pos, opt) {\n const pool = [];\n const stack = [];\n const options = createOptions(opt);\n const result = [];\n scan(source, (name, type, start, end) => {\n if (type === 2 /* Close */) {\n const tag = last(stack);\n if (tag && tag.name === name) { // XXX check for invalid tag names?\n // Matching closing tag found, check if matched pair is a candidate\n // for outward balancing\n if (tag.start < pos && pos < end) {\n result.push({\n name,\n open: [tag.start, tag.end],\n close: [start, end]\n });\n }\n // Release tag object for further re-use\n releaseTag(pool, stack.pop());\n }\n }\n else if (type === 3 /* SelfClose */ || isSelfClose(name, options)) {\n if (start < pos && pos < end) {\n // Matched self-closed tag\n result.push({ name, open: [start, end] });\n }\n }\n else {\n stack.push(allocTag(pool, name, start, end));\n }\n }, options);\n stack.length = pool.length = 0;\n return result;\n}\n/**\n * Returns balanced tag model: a list of all XML/HTML tags that could possibly match\n * given location when moving in inward direction\n */\nfunction balancedInward(source, pos, opt) {\n // Collecting tags for inward balancing is a bit trickier: we have to store\n // first child of every matched tag until we find the one that matches given\n // location\n const pool = [];\n const stack = [];\n const options = createOptions(opt);\n const result = [];\n const alloc = (name, start, end) => {\n if (pool.length) {\n const tag = pool.pop();\n tag.name = name;\n tag.ranges.push(start, end);\n return tag;\n }\n return { name, ranges: [start, end] };\n };\n const release = (tag) => {\n tag.ranges.length = 0;\n tag.firstChild = void 0;\n pool.push(tag);\n };\n scan(source, (name, type, start, end) => {\n if (type === 2 /* Close */) {\n if (!stack.length) {\n // Some sort of lone closing tag, ignore it\n return;\n }\n let tag = last(stack);\n if (tag.name === name) { // XXX check for invalid tag names?\n // Matching closing tag found, check if matched pair is a candidate\n // for outward balancing\n if (tag.ranges[0] <= pos && pos <= end) {\n result.push({\n name,\n open: tag.ranges.slice(0, 2),\n close: [start, end]\n });\n while (tag.firstChild) {\n const child = tag.firstChild;\n const res = {\n name: child.name,\n open: child.ranges.slice(0, 2)\n };\n if (child.ranges.length > 2) {\n res.close = child.ranges.slice(2, 4);\n }\n result.push(res);\n release(tag);\n tag = child;\n }\n return false;\n }\n else {\n stack.pop();\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n // No first child in parent node: store current tag\n tag.ranges.push(start, end);\n parent.firstChild = tag;\n }\n else {\n release(tag);\n }\n }\n }\n }\n else if (type === 3 /* SelfClose */ || isSelfClose(name, options)) {\n if (start < pos && pos < end) {\n // Matched self-closed tag, no need to look further\n result.push({ name, open: [start, end] });\n return false;\n }\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n parent.firstChild = alloc(name, start, end);\n }\n }\n else {\n stack.push(alloc(name, start, end));\n }\n }, options);\n stack.length = pool.length = 0;\n return result;\n}\nfunction allocTag(pool, name, start, end) {\n if (pool.length) {\n const tag = pool.pop();\n tag.name = name;\n tag.start = start;\n tag.end = end;\n return tag;\n }\n return { name, start, end };\n}\nfunction releaseTag(pool, tag) {\n pool.push(tag);\n}\n/**\n * Returns parsed attributes from given source\n */\nfunction getAttributes(source, start, end, name) {\n const tokens = attributes(source.slice(start, end), name);\n tokens.forEach(attr => {\n attr.nameStart += start;\n attr.nameEnd += start;\n if (attr.value != null) {\n attr.valueStart += start;\n attr.valueEnd += start;\n }\n });\n return tokens;\n}\n/**\n * Check if given tag is self-close for current parsing context\n */\nfunction isSelfClose(name, options) {\n return !options.xml && options.empty.includes(name);\n}\nfunction last(arr) {\n return arr.length ? arr[arr.length - 1] : null;\n}\n\nexport default match;\nexport { attributes, balancedInward, balancedOutward, createOptions, scan };\n//# sourceMappingURL=html-matcher.es.js.map\n","import Scanner, { isSpace, isQuote } from '@emmetio/scanner';\n\n/**\n * Performs fast scan of given stylesheet (CSS, LESS, SCSS) source code and runs\n * callback for each token and its range found. The goal of this parser is to quickly\n * determine document structure: selector, property, value and block end.\n * It doesn’t provide detailed info about CSS atoms like compound selectors,\n * operators, quoted string etc. to reduce memory allocations: this data can be\n * parsed later on demand.\n */\nfunction scan(source, callback) {\n const scanner = new Scanner(source);\n const state = {\n start: -1,\n end: -1,\n propertyStart: -1,\n propertyEnd: -1,\n propertyDelimiter: -1,\n expression: 0,\n };\n let blockEnd;\n const notify = (type, delimiter = scanner.start, start = state.start, end = state.end) => {\n return callback(type, start, end, delimiter) === false;\n };\n while (!scanner.eof()) {\n if (comment(scanner) || whitespace(scanner)) {\n continue;\n }\n scanner.start = scanner.pos;\n if ((blockEnd = scanner.eat(125 /* RightCurly */)) || scanner.eat(59 /* Semicolon */)) {\n // Block or property end\n if (state.propertyStart !== -1) {\n // We have pending property\n if (notify(\"propertyName\" /* PropertyName */, state.propertyDelimiter, state.propertyStart, state.propertyEnd)) {\n return;\n }\n if (state.start === -1) {\n // Explicit property value state: emit empty value\n state.start = state.end = scanner.start;\n }\n if (notify(\"propertyValue\" /* PropertyValue */)) {\n return;\n }\n }\n else if (state.start !== -1 && notify(\"propertyName\" /* PropertyName */)) {\n // Flush consumed token\n return;\n }\n if (blockEnd) {\n state.start = scanner.start;\n state.end = scanner.pos;\n if (notify(\"blockEnd\" /* BlockEnd */)) {\n return;\n }\n }\n reset(state);\n }\n else if (scanner.eat(123 /* LeftCurly */)) {\n // Block start\n if (state.start === -1 && state.propertyStart === -1) {\n // No consumed selector, emit empty value as selector start\n state.start = state.end = scanner.pos;\n }\n if (state.propertyStart !== -1) {\n // Now we know that value that looks like property name-value pair\n // was actually a selector\n state.start = state.propertyStart;\n }\n if (notify(\"selector\" /* Selector */)) {\n return;\n }\n reset(state);\n }\n else if (scanner.eat(58 /* Colon */) && !isKnownSelectorColon(scanner, state)) {\n // Colon could be one of the following:\n // — property delimiter: `foo: bar`, must be in block context\n // — variable delimiter: `$foo: bar`, could be anywhere\n // — pseudo-selector: `a:hover`, could be anywhere (for LESS and SCSS)\n // — media query expression: `min-width: 100px`, must be inside expression context\n // Since I can’t easily detect `:` meaning for sure, we’ll update state\n // to accumulate possible property name-value pair or selector\n if (state.propertyStart === -1) {\n state.propertyStart = state.start;\n }\n state.propertyEnd = state.end;\n state.propertyDelimiter = scanner.pos - 1;\n state.start = state.end = -1;\n }\n else {\n if (state.start === -1) {\n state.start = scanner.pos;\n }\n if (scanner.eat(40 /* LeftRound */)) {\n state.expression++;\n }\n else if (scanner.eat(41 /* RightRound */)) {\n state.expression--;\n }\n else if (!literal(scanner)) {\n scanner.pos++;\n }\n state.end = scanner.pos;\n }\n }\n if (state.propertyStart !== -1) {\n // Pending property name\n if (notify(\"propertyName\" /* PropertyName */, state.propertyDelimiter, state.propertyStart, state.propertyEnd)) {\n return;\n }\n }\n if (state.start !== -1) {\n // There’s pending token in state\n notify(state.propertyStart !== -1 ? \"propertyValue\" /* PropertyValue */ : \"propertyName\" /* PropertyName */, -1);\n }\n}\nfunction whitespace(scanner) {\n return scanner.eatWhile(isSpace);\n}\n/**\n * Consumes CSS comments from scanner: `/* * /`\n * It’s possible that comment may not have closing part\n */\nfunction comment(scanner) {\n const start = scanner.pos;\n if (scanner.eat(47 /* Slash */) && scanner.eat(42 /* Asterisk */)) {\n scanner.start = start;\n while (!scanner.eof()) {\n if (scanner.eat(42 /* Asterisk */)) {\n if (scanner.eat(47 /* Slash */)) {\n return true;\n }\n continue;\n }\n scanner.pos++;\n }\n return true;\n }\n else {\n scanner.pos = start;\n }\n return false;\n}\n/**\n * Consumes single- or double-quoted string literal\n */\nfunction literal(scanner) {\n const ch = scanner.peek();\n if (isQuote(ch)) {\n scanner.start = scanner.pos++;\n while (!scanner.eof()) {\n if (scanner.eat(ch) || scanner.eat(10 /* LF */) || scanner.eat(13 /* CR */)) {\n break;\n }\n // Skip escape character, if any\n scanner.eat(92 /* Backslash */);\n scanner.pos++;\n }\n // Do not throw if string is incomplete\n return true;\n }\n}\nfunction reset(state) {\n state.start = state.end = state.propertyStart = state.propertyEnd = state.propertyDelimiter = -1;\n}\n/**\n * Check if current state is a known selector context for `:` delimiter\n */\nfunction isKnownSelectorColon(scanner, state) {\n // Either inside expression like `(min-width: 10px)` or pseudo-element `::before`\n return state.expression || scanner.eatWhile(58 /* Colon */);\n}\n\n// NB: no `Minus` operator, it must be handled differently\nconst operators = [\n 43 /* Plus */, 47 /* Division */, 42 /* Multiplication */,\n 44 /* Comma */\n];\n/**\n * Splits given CSS value into token list\n */\nfunction splitValue(value, offset = 0) {\n let start = -1;\n let expression = 0;\n let pos = 0;\n const result = [];\n const scanner = new Scanner(value);\n while (!scanner.eof()) {\n pos = scanner.pos;\n if (scanner.eat(isSpace) || scanner.eat(isOperator) || isMinusOperator(scanner)) {\n // Use space as value delimiter but only if not in expression context,\n // e.g. `1 2` are distinct values but `(1 2)` not\n if (!expression && start !== -1) {\n result.push([offset + start, offset + pos]);\n start = -1;\n }\n scanner.eatWhile(isSpace);\n }\n else {\n if (start === -1) {\n start = scanner.pos;\n }\n if (scanner.eat(40 /* LeftRound */)) {\n expression++;\n }\n else if (scanner.eat(41 /* RightRound */)) {\n expression--;\n }\n else if (!literal(scanner)) {\n scanner.pos++;\n }\n }\n }\n if (start !== -1 && start !== scanner.pos) {\n result.push([offset + start, offset + scanner.pos]);\n }\n return result;\n}\nfunction isOperator(ch) {\n return operators.includes(ch);\n}\n/**\n * Check if current scanner state is at minus operator\n */\nfunction isMinusOperator(scanner) {\n // Minus operator is tricky since CSS supports dashes in keyword names like\n // `no-repeat`\n const start = scanner.pos;\n if (scanner.eat(45 /* Minus */) && scanner.eat(isSpace)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\n\nfunction match(source, pos) {\n const pool = [];\n const stack = [];\n let result = null;\n let pendingProperty = null;\n const releasePending = () => {\n if (pendingProperty) {\n releaseRange(pool, pendingProperty);\n pendingProperty = null;\n }\n };\n scan(source, (type, start, end, delimiter) => {\n if (type === \"selector\" /* Selector */) {\n releasePending();\n stack.push(allocRange(pool, start, end, delimiter));\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n releasePending();\n const parent = stack.pop();\n if (parent && parent[0] < pos && pos < end) {\n result = {\n type: 'selector',\n start: parent[0],\n end,\n bodyStart: parent[2] + 1,\n bodyEnd: start\n };\n return false;\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n releasePending();\n pendingProperty = allocRange(pool, start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (pendingProperty && pendingProperty[0] < pos && pos < end) {\n result = {\n type: 'property',\n start: pendingProperty[0],\n end: delimiter + 1,\n bodyStart: start,\n bodyEnd: end\n };\n return false;\n }\n releasePending();\n }\n });\n return result;\n}\n/**\n * Returns balanced CSS model: a list of all ranges that could possibly match\n * given location when moving in outward direction\n */\nfunction balancedOutward(source, pos) {\n const pool = [];\n const stack = [];\n const result = [];\n let property = null;\n scan(source, (type, start, end, delimiter) => {\n if (type === \"selector\" /* Selector */) {\n stack.push(allocRange(pool, start, end, delimiter));\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n const left = stack.pop();\n if (left && left[0] < pos && end > pos) {\n // Matching section found\n const inner = innerRange(source, left[2] + 1, start);\n inner && push(result, inner);\n push(result, [left[0], end]);\n }\n left && releaseRange(pool, left);\n if (!stack.length) {\n return false;\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n property && releaseRange(pool, property);\n property = allocRange(pool, start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (property && property[0] < pos && Math.max(delimiter, end) > pos) {\n // Push full token and value range\n push(result, [start, end]);\n push(result, [property[0], delimiter !== -1 ? delimiter + 1 : end]);\n }\n }\n if (type !== \"propertyName\" /* PropertyName */ && property) {\n releaseRange(pool, property);\n property = null;\n }\n });\n return result;\n}\n/**\n * Returns balanced CSS selectors: a list of all ranges that could possibly match\n * given location when moving in inward direction\n */\nfunction balancedInward(source, pos) {\n // Collecting ranges for inward balancing is a bit trickier: we have to store\n // first child of every matched selector until we find the one that matches given\n // location\n const pool = [];\n const stack = [];\n const result = [];\n let pendingProperty = null;\n const alloc = (start, end, delimiter) => {\n if (pool.length) {\n const range = pool.pop();\n range.start = start;\n range.end = end;\n range.delimiter = delimiter;\n return range;\n }\n return { start, end, delimiter, firstChild: null };\n };\n const release = (range) => {\n range.firstChild = null;\n pool.push(range);\n };\n const releasePending = () => {\n if (pendingProperty) {\n release(pendingProperty);\n pendingProperty = null;\n }\n };\n /**\n * Pushes given inward range as a first child of current selector only if it’s\n * not set yet\n */\n const pushChild = (start, end, delimiter) => {\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n parent.firstChild = alloc(start, end, delimiter);\n }\n };\n scan(source, (type, start, end, delimiter) => {\n if (type === \"blockEnd\" /* BlockEnd */) {\n releasePending();\n let range = stack.pop();\n if (!range) {\n // Some sort of lone closing brace, ignore it\n return;\n }\n if (range.start <= pos && pos <= end) {\n // Matching selector found: add it and its inner range into result\n let inner = innerRange(source, range.delimiter + 1, start);\n push(result, [range.start, end]);\n inner && push(result, inner);\n while (range.firstChild) {\n const child = range.firstChild;\n inner = innerRange(source, child.delimiter + 1, child.end - 1);\n push(result, [child.start, child.end]);\n inner && push(result, inner);\n range = child;\n }\n return false;\n }\n else {\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n // No first child in parent node: store current selector\n range.end = end;\n parent.firstChild = range;\n }\n else {\n release(range);\n }\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n releasePending();\n pendingProperty = alloc(start, end, delimiter);\n pushChild(start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (pendingProperty) {\n if (pendingProperty.start <= pos && end >= pos) {\n // Direct hit into property, no need to look further\n push(result, [pendingProperty.start, delimiter + 1]);\n push(result, [start, end]);\n releasePending();\n return false;\n }\n const parent = last(stack);\n if (parent && parent.firstChild && parent.firstChild.start === pendingProperty.start) {\n // First child is an expected property name, update its range\n // to include property value\n parent.firstChild.end = delimiter !== -1 ? delimiter + 1 : end;\n }\n releasePending();\n }\n }\n else {\n // Selector start\n stack.push(alloc(start, end, delimiter));\n releasePending();\n }\n });\n stack.length = pool.length = 0;\n return result;\n}\n/**\n * Returns inner range for given selector bounds: narrows it to first non-empty\n * region. If resulting region is empty, returns `null`\n */\nfunction innerRange(source, start, end) {\n while (start < end && isSpace(source.charCodeAt(start))) {\n start++;\n }\n while (end > start && isSpace(source.charCodeAt(end - 1))) {\n end--;\n }\n return start !== end ? [start, end] : null;\n}\nfunction allocRange(pool, start, end, delimiter) {\n if (pool.length) {\n const range = pool.pop();\n range[0] = start;\n range[1] = end;\n range[2] = delimiter;\n return range;\n }\n return [start, end, delimiter];\n}\nfunction releaseRange(pool, range) {\n range && pool.push(range);\n return null;\n}\nfunction push(ranges, range) {\n const prev = ranges.length ? ranges[ranges.length - 1] : null;\n if ((!prev || prev[0] !== range[0] || prev[1] !== range[1]) && range[0] !== range[1]) {\n ranges.push(range);\n }\n}\nfunction last(arr) {\n return arr.length ? arr[arr.length - 1] : null;\n}\n\nexport default match;\nexport { balancedInward, balancedOutward, scan, splitValue };\n//# sourceMappingURL=css-matcher.es.js.map\n","import Scanner, { isAlphaNumericWord, isSpace, isQuote as isQuote$1, isNumber, isAlpha, ScannerError } from '@emmetio/scanner';\n\nfunction tokenScanner(tokens) {\n return {\n tokens,\n start: 0,\n pos: 0,\n size: tokens.length\n };\n}\nfunction peek(scanner) {\n return scanner.tokens[scanner.pos];\n}\nfunction next(scanner) {\n return scanner.tokens[scanner.pos++];\n}\nfunction slice(scanner, from = scanner.start, to = scanner.pos) {\n return scanner.tokens.slice(from, to);\n}\nfunction readable(scanner) {\n return scanner.pos < scanner.size;\n}\nfunction consume(scanner, test) {\n const token = peek(scanner);\n if (token && test(token)) {\n scanner.pos++;\n return true;\n }\n return false;\n}\nfunction error(scanner, message, token = peek(scanner)) {\n if (token && token.start != null) {\n message += ` at ${token.start}`;\n }\n const err = new Error(message);\n err['pos'] = token && token.start;\n return err;\n}\n\nfunction abbreviation(abbr, options = {}) {\n const scanner = tokenScanner(abbr);\n const result = statements(scanner, options);\n if (readable(scanner)) {\n throw error(scanner, 'Unexpected character');\n }\n return result;\n}\nfunction statements(scanner, options) {\n const result = {\n type: 'TokenGroup',\n elements: []\n };\n let ctx = result;\n let node;\n const stack = [];\n while (readable(scanner)) {\n if (node = element(scanner, options) || group(scanner, options)) {\n ctx.elements.push(node);\n if (consume(scanner, isChildOperator)) {\n stack.push(ctx);\n ctx = node;\n }\n else if (consume(scanner, isSiblingOperator)) {\n continue;\n }\n else if (consume(scanner, isClimbOperator)) {\n do {\n if (stack.length) {\n ctx = stack.pop();\n }\n } while (consume(scanner, isClimbOperator));\n }\n }\n else {\n break;\n }\n }\n return result;\n}\n/**\n * Consumes group from given scanner\n */\nfunction group(scanner, options) {\n if (consume(scanner, isGroupStart)) {\n const result = statements(scanner, options);\n const token = next(scanner);\n if (isBracket(token, 'group', false)) {\n result.repeat = repeater(scanner);\n }\n return result;\n }\n}\n/**\n * Consumes single element from given scanner\n */\nfunction element(scanner, options) {\n let attr;\n const elem = {\n type: 'TokenElement',\n name: void 0,\n attributes: void 0,\n value: void 0,\n repeat: void 0,\n selfClose: false,\n elements: []\n };\n if (elementName(scanner, options)) {\n elem.name = slice(scanner);\n }\n while (readable(scanner)) {\n scanner.start = scanner.pos;\n if (!elem.repeat && !isEmpty(elem) && consume(scanner, isRepeater)) {\n elem.repeat = scanner.tokens[scanner.pos - 1];\n }\n else if (!elem.value && text(scanner)) {\n elem.value = getText(scanner);\n }\n else if (attr = shortAttribute(scanner, 'id', options) || shortAttribute(scanner, 'class', options) || attributeSet(scanner)) {\n if (!elem.attributes) {\n elem.attributes = Array.isArray(attr) ? attr.slice() : [attr];\n }\n else {\n elem.attributes = elem.attributes.concat(attr);\n }\n }\n else {\n if (!isEmpty(elem) && consume(scanner, isCloseOperator)) {\n elem.selfClose = true;\n if (!elem.repeat && consume(scanner, isRepeater)) {\n elem.repeat = scanner.tokens[scanner.pos - 1];\n }\n }\n break;\n }\n }\n return !isEmpty(elem) ? elem : void 0;\n}\n/**\n * Consumes attribute set from given scanner\n */\nfunction attributeSet(scanner) {\n if (consume(scanner, isAttributeSetStart)) {\n const attributes = [];\n let attr;\n while (readable(scanner)) {\n if (attr = attribute(scanner)) {\n attributes.push(attr);\n }\n else if (consume(scanner, isAttributeSetEnd)) {\n break;\n }\n else if (!consume(scanner, isWhiteSpace)) {\n throw error(scanner, `Unexpected \"${peek(scanner).type}\" token`);\n }\n }\n return attributes;\n }\n}\n/**\n * Consumes attribute shorthand (class or id) from given scanner\n */\nfunction shortAttribute(scanner, type, options) {\n if (isOperator(peek(scanner), type)) {\n scanner.pos++;\n const attr = {\n name: [createLiteral(type)]\n };\n // Consume expression after shorthand start for React-like components\n if (options.jsx && text(scanner)) {\n attr.value = getText(scanner);\n attr.expression = true;\n }\n else {\n attr.value = literal(scanner) ? slice(scanner) : void 0;\n }\n return attr;\n }\n}\n/**\n * Consumes single attribute from given scanner\n */\nfunction attribute(scanner) {\n if (quoted(scanner)) {\n // Consumed quoted value: it’s a value for default attribute\n return {\n value: slice(scanner)\n };\n }\n if (literal(scanner, true)) {\n return {\n name: slice(scanner),\n value: consume(scanner, isEquals) && (quoted(scanner) || literal(scanner, true))\n ? slice(scanner)\n : void 0\n };\n }\n}\nfunction repeater(scanner) {\n return isRepeater(peek(scanner))\n ? scanner.tokens[scanner.pos++]\n : void 0;\n}\n/**\n * Consumes quoted value from given scanner, if possible\n */\nfunction quoted(scanner) {\n const start = scanner.pos;\n const quote = peek(scanner);\n if (isQuote(quote)) {\n scanner.pos++;\n while (readable(scanner)) {\n if (isQuote(next(scanner), quote.single)) {\n scanner.start = start;\n return true;\n }\n }\n throw error(scanner, 'Unclosed quote', quote);\n }\n return false;\n}\n/**\n * Consumes literal (unquoted value) from given scanner\n */\nfunction literal(scanner, allowBrackets) {\n const start = scanner.pos;\n const brackets = {\n attribute: 0,\n expression: 0,\n group: 0\n };\n while (readable(scanner)) {\n const token = peek(scanner);\n if (brackets.expression) {\n // If we’re inside expression, we should consume all content in it\n if (isBracket(token, 'expression')) {\n brackets[token.context] += token.open ? 1 : -1;\n }\n }\n else if (isQuote(token) || isOperator(token) || isWhiteSpace(token) || isRepeater(token)) {\n break;\n }\n else if (isBracket(token)) {\n if (!allowBrackets) {\n break;\n }\n if (token.open) {\n brackets[token.context]++;\n }\n else if (!brackets[token.context]) {\n // Stop if found unmatched closing brace: it must be handled\n // by parent consumer\n break;\n }\n else {\n brackets[token.context]--;\n }\n }\n scanner.pos++;\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return true;\n }\n return false;\n}\n/**\n * Consumes element name from given scanner\n */\nfunction elementName(scanner, options) {\n const start = scanner.pos;\n if (options.jsx && consume(scanner, isCapitalizedLiteral)) {\n // Check for edge case: consume immediate capitalized class names\n // for React-like components, e.g. `Foo.Bar.Baz`\n while (readable(scanner)) {\n const { pos } = scanner;\n if (!consume(scanner, isClassNameOperator) || !consume(scanner, isCapitalizedLiteral)) {\n scanner.pos = pos;\n break;\n }\n }\n }\n while (readable(scanner) && consume(scanner, isElementName)) {\n // empty\n }\n if (scanner.pos !== start) {\n scanner.start = start;\n return true;\n }\n return false;\n}\n/**\n * Consumes text value from given scanner\n */\nfunction text(scanner) {\n const start = scanner.pos;\n if (consume(scanner, isTextStart)) {\n let brackets = 0;\n while (readable(scanner)) {\n const token = next(scanner);\n if (isBracket(token, 'expression')) {\n if (token.open) {\n brackets++;\n }\n else if (!brackets) {\n break;\n }\n else {\n brackets--;\n }\n }\n }\n scanner.start = start;\n return true;\n }\n return false;\n}\nfunction getText(scanner) {\n let from = scanner.start;\n let to = scanner.pos;\n if (isBracket(scanner.tokens[from], 'expression', true)) {\n from++;\n }\n if (isBracket(scanner.tokens[to - 1], 'expression', false)) {\n to--;\n }\n return slice(scanner, from, to);\n}\nfunction isBracket(token, context, isOpen) {\n return Boolean(token && token.type === 'Bracket'\n && (!context || token.context === context)\n && (isOpen == null || token.open === isOpen));\n}\nfunction isOperator(token, type) {\n return Boolean(token && token.type === 'Operator' && (!type || token.operator === type));\n}\nfunction isQuote(token, isSingle) {\n return Boolean(token && token.type === 'Quote' && (isSingle == null || token.single === isSingle));\n}\nfunction isWhiteSpace(token) {\n return Boolean(token && token.type === 'WhiteSpace');\n}\nfunction isEquals(token) {\n return isOperator(token, 'equal');\n}\nfunction isRepeater(token) {\n return Boolean(token && token.type === 'Repeater');\n}\nfunction isLiteral(token) {\n return token.type === 'Literal';\n}\nfunction isCapitalizedLiteral(token) {\n if (isLiteral(token)) {\n const ch = token.value.charCodeAt(0);\n return ch >= 65 && ch <= 90;\n }\n return false;\n}\nfunction isElementName(token) {\n return token.type === 'Literal' || token.type === 'RepeaterNumber' || token.type === 'RepeaterPlaceholder';\n}\nfunction isClassNameOperator(token) {\n return isOperator(token, 'class');\n}\nfunction isAttributeSetStart(token) {\n return isBracket(token, 'attribute', true);\n}\nfunction isAttributeSetEnd(token) {\n return isBracket(token, 'attribute', false);\n}\nfunction isTextStart(token) {\n return isBracket(token, 'expression', true);\n}\nfunction isGroupStart(token) {\n return isBracket(token, 'group', true);\n}\nfunction createLiteral(value) {\n return { type: 'Literal', value };\n}\nfunction isEmpty(elem) {\n return !elem.name && !elem.value && !elem.attributes;\n}\nfunction isChildOperator(token) {\n return isOperator(token, 'child');\n}\nfunction isSiblingOperator(token) {\n return isOperator(token, 'sibling');\n}\nfunction isClimbOperator(token) {\n return isOperator(token, 'climb');\n}\nfunction isCloseOperator(token) {\n return isOperator(token, 'close');\n}\n\n/**\n * If consumes escape character, sets current stream range to escaped value\n */\nfunction escaped(scanner) {\n if (scanner.eat(92 /* Escape */)) {\n scanner.start = scanner.pos;\n if (!scanner.eof()) {\n scanner.pos++;\n }\n return true;\n }\n return false;\n}\n\nfunction tokenize(source) {\n const scanner = new Scanner(source);\n const result = [];\n const ctx = {\n group: 0,\n attribute: 0,\n expression: 0,\n quote: 0\n };\n let ch = 0;\n let token;\n while (!scanner.eof()) {\n ch = scanner.peek();\n token = getToken(scanner, ctx);\n if (token) {\n result.push(token);\n if (token.type === 'Quote') {\n ctx.quote = ch === ctx.quote ? 0 : ch;\n }\n else if (token.type === 'Bracket') {\n ctx[token.context] += token.open ? 1 : -1;\n }\n }\n else {\n throw scanner.error('Unexpected character');\n }\n }\n return result;\n}\n/**\n * Returns next token from given scanner, if possible\n */\nfunction getToken(scanner, ctx) {\n return field(scanner, ctx)\n || repeaterPlaceholder(scanner)\n || repeaterNumber(scanner)\n || repeater$1(scanner)\n || whiteSpace(scanner)\n || literal$1(scanner, ctx)\n || operator(scanner)\n || quote(scanner)\n || bracket(scanner);\n}\n/**\n * Consumes literal from given scanner\n */\nfunction literal$1(scanner, ctx) {\n const start = scanner.pos;\n let value = '';\n while (!scanner.eof()) {\n // Consume escaped sequence no matter of context\n if (escaped(scanner)) {\n value += scanner.current();\n continue;\n }\n const ch = scanner.peek();\n if (ch === ctx.quote || ch === 36 /* Dollar */ || isAllowedOperator(ch, ctx)) {\n // 1. Found matching quote\n // 2. The `$` character has special meaning in every context\n // 3. Depending on context, some characters should be treated as operators\n break;\n }\n if (ctx.expression && ch === 125 /* CurlyBracketClose */) {\n break;\n }\n if (!ctx.quote && !ctx.expression) {\n // Consuming element name\n if (!ctx.attribute && !isElementName$1(ch)) {\n break;\n }\n if (isAllowedSpace(ch, ctx) || isAllowedRepeater(ch, ctx) || isQuote$1(ch) || bracketType(ch)) {\n // Stop for characters not allowed in unquoted literal\n break;\n }\n }\n value += scanner.string[scanner.pos++];\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return {\n type: 'Literal',\n value,\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes white space characters as string literal from given scanner\n */\nfunction whiteSpace(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(isSpace)) {\n return {\n type: 'WhiteSpace',\n start,\n end: scanner.pos,\n value: scanner.substring(start, scanner.pos)\n };\n }\n}\n/**\n * Consumes quote from given scanner\n */\nfunction quote(scanner) {\n const ch = scanner.peek();\n if (isQuote$1(ch)) {\n return {\n type: 'Quote',\n single: ch === 39 /* SingleQuote */,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes bracket from given scanner\n */\nfunction bracket(scanner) {\n const ch = scanner.peek();\n const context = bracketType(ch);\n if (context) {\n return {\n type: 'Bracket',\n open: isOpenBracket(ch),\n context,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes operator from given scanner\n */\nfunction operator(scanner) {\n const op = operatorType(scanner.peek());\n if (op) {\n return {\n type: 'Operator',\n operator: op,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes node repeat token from current stream position and returns its\n * parsed value\n */\nfunction repeater$1(scanner) {\n const start = scanner.pos;\n if (scanner.eat(42 /* Asterisk */)) {\n scanner.start = scanner.pos;\n let count = 1;\n let implicit = false;\n if (scanner.eatWhile(isNumber)) {\n count = Number(scanner.current());\n }\n else {\n implicit = true;\n }\n return {\n type: 'Repeater',\n count,\n value: 0,\n implicit,\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes repeater placeholder `$#` from given scanner\n */\nfunction repeaterPlaceholder(scanner) {\n const start = scanner.pos;\n if (scanner.eat(36 /* Dollar */) && scanner.eat(35 /* Hash */)) {\n return {\n type: 'RepeaterPlaceholder',\n value: void 0,\n start,\n end: scanner.pos\n };\n }\n scanner.pos = start;\n}\n/**\n * Consumes numbering token like `$` from given scanner state\n */\nfunction repeaterNumber(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(36 /* Dollar */)) {\n const size = scanner.pos - start;\n let reverse = false;\n let base = 1;\n let parent = 0;\n if (scanner.eat(64 /* At */)) {\n // Consume numbering modifiers\n while (scanner.eat(94 /* Climb */)) {\n parent++;\n }\n reverse = scanner.eat(45 /* Dash */);\n scanner.start = scanner.pos;\n if (scanner.eatWhile(isNumber)) {\n base = Number(scanner.current());\n }\n }\n scanner.start = start;\n return {\n type: 'RepeaterNumber',\n size,\n reverse,\n base,\n parent,\n start,\n end: scanner.pos\n };\n }\n}\nfunction field(scanner, ctx) {\n const start = scanner.pos;\n // Fields are allowed inside expressions and attributes\n if ((ctx.expression || ctx.attribute) && scanner.eat(36 /* Dollar */) && scanner.eat(123 /* CurlyBracketOpen */)) {\n scanner.start = scanner.pos;\n let index;\n let name = '';\n if (scanner.eatWhile(isNumber)) {\n // It’s a field\n index = Number(scanner.current());\n name = scanner.eat(58 /* Colon */) ? consumePlaceholder(scanner) : '';\n }\n else if (isAlpha(scanner.peek())) {\n // It’s a variable\n name = consumePlaceholder(scanner);\n }\n if (scanner.eat(125 /* CurlyBracketClose */)) {\n return {\n type: 'Field',\n index, name,\n start,\n end: scanner.pos\n };\n }\n throw scanner.error('Expecting }');\n }\n // If we reached here then there’s no valid field here, revert\n // back to starting position\n scanner.pos = start;\n}\n/**\n * Consumes a placeholder: value right after `:` in field. Could be empty\n */\nfunction consumePlaceholder(stream) {\n const stack = [];\n stream.start = stream.pos;\n while (!stream.eof()) {\n if (stream.eat(123 /* CurlyBracketOpen */)) {\n stack.push(stream.pos);\n }\n else if (stream.eat(125 /* CurlyBracketClose */)) {\n if (!stack.length) {\n stream.pos--;\n break;\n }\n stack.pop();\n }\n else {\n stream.pos++;\n }\n }\n if (stack.length) {\n stream.pos = stack.pop();\n throw stream.error(`Expecting }`);\n }\n return stream.current();\n}\n/**\n * Check if given character code is an operator and it’s allowed in current context\n */\nfunction isAllowedOperator(ch, ctx) {\n const op = operatorType(ch);\n if (!op || ctx.quote || ctx.expression) {\n // No operators inside quoted values or expressions\n return false;\n }\n // Inside attributes, only `equals` is allowed\n return !ctx.attribute || op === 'equal';\n}\n/**\n * Check if given character is a space character and is allowed to be consumed\n * as a space token in current context\n */\nfunction isAllowedSpace(ch, ctx) {\n return isSpace(ch) && !ctx.expression;\n}\n/**\n * Check if given character can be consumed as repeater in current context\n */\nfunction isAllowedRepeater(ch, ctx) {\n return ch === 42 /* Asterisk */ && !ctx.attribute && !ctx.expression;\n}\n/**\n * If given character is a bracket, returns it’s type\n */\nfunction bracketType(ch) {\n if (ch === 40 /* RoundBracketOpen */ || ch === 41 /* RoundBracketClose */) {\n return 'group';\n }\n if (ch === 91 /* SquareBracketOpen */ || ch === 93 /* SquareBracketClose */) {\n return 'attribute';\n }\n if (ch === 123 /* CurlyBracketOpen */ || ch === 125 /* CurlyBracketClose */) {\n return 'expression';\n }\n}\n/**\n * If given character is an operator, returns it’s type\n */\nfunction operatorType(ch) {\n return (ch === 62 /* Child */ && 'child')\n || (ch === 43 /* Sibling */ && 'sibling')\n || (ch === 94 /* Climb */ && 'climb')\n || (ch === 46 /* Dot */ && 'class')\n || (ch === 35 /* Hash */ && 'id')\n || (ch === 47 /* Slash */ && 'close')\n || (ch === 61 /* Equals */ && 'equal')\n || void 0;\n}\n/**\n * Check if given character is an open bracket\n */\nfunction isOpenBracket(ch) {\n return ch === 123 /* CurlyBracketOpen */\n || ch === 91 /* SquareBracketOpen */\n || ch === 40 /* RoundBracketOpen */;\n}\n/**\n * Check if given character is allowed in element name\n */\nfunction isElementName$1(ch) {\n return isAlphaNumericWord(ch)\n || ch === 45 /* Dash */\n || ch === 58 /* Colon */\n || ch === 33 /* Excl */;\n}\n\nconst operators = {\n child: '>',\n class: '.',\n climb: '^',\n id: '#',\n equal: '=',\n close: '/',\n sibling: '+'\n};\nconst tokenVisitor = {\n Literal(token) {\n return token.value;\n },\n Quote(token) {\n return token.single ? '\\'' : '\"';\n },\n Bracket(token) {\n if (token.context === 'attribute') {\n return token.open ? '[' : ']';\n }\n else if (token.context === 'expression') {\n return token.open ? '{' : '}';\n }\n else {\n return token.open ? '(' : '}';\n }\n },\n Operator(token) {\n return operators[token.operator];\n },\n Field(token, state) {\n if (token.index != null) {\n // It’s a field: by default, return TextMate-compatible field\n return token.name\n ? `\\${${token.index}:${token.name}}`\n : `\\${${token.index}`;\n }\n else if (token.name) {\n // It’s a variable\n return state.getVariable(token.name);\n }\n return '';\n },\n RepeaterPlaceholder(token, state) {\n // Find closest implicit repeater\n let repeater;\n for (let i = state.repeaters.length - 1; i >= 0; i--) {\n if (state.repeaters[i].implicit) {\n repeater = state.repeaters[i];\n break;\n }\n }\n state.inserted = true;\n return state.getText(repeater && repeater.value);\n },\n RepeaterNumber(token, state) {\n let value = 1;\n const lastIx = state.repeaters.length - 1;\n // const repeaterIx = Math.max(0, state.repeaters.length - 1 - token.parent);\n const repeater = state.repeaters[lastIx];\n if (repeater) {\n value = token.reverse\n ? token.base + repeater.count - repeater.value - 1\n : token.base + repeater.value;\n if (token.parent) {\n const parentIx = Math.max(0, lastIx - token.parent);\n if (parentIx !== lastIx) {\n const parentRepeater = state.repeaters[parentIx];\n value += repeater.count * parentRepeater.value;\n }\n }\n }\n let result = String(value);\n while (result.length < token.size) {\n result = '0' + result;\n }\n return result;\n },\n WhiteSpace(token) {\n return token.value;\n }\n};\n/**\n * Converts given value token to string\n */\nfunction stringify(token, state) {\n if (!tokenVisitor[token.type]) {\n throw new Error(`Unknown token ${token.type}`);\n }\n return tokenVisitor[token.type](token, state);\n}\n\nconst urlRegex = /^((https?:|ftp:|file:)?\\/\\/|(www|ftp)\\.)[^ ]*$/;\nconst emailRegex = /^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,5}$/;\n/**\n * Converts given token-based abbreviation into simplified and unrolled node-based\n * abbreviation\n */\nfunction convert(abbr, options = {}) {\n let textInserted = false;\n let cleanText;\n if (options.text) {\n if (Array.isArray(options.text)) {\n cleanText = options.text.filter(s => s.trim());\n }\n else {\n cleanText = options.text;\n }\n }\n const result = {\n type: 'Abbreviation',\n children: convertGroup(abbr, {\n inserted: false,\n repeaters: [],\n text: options.text,\n cleanText,\n repeatGuard: options.maxRepeat || Number.POSITIVE_INFINITY,\n getText(pos) {\n var _a;\n textInserted = true;\n let value;\n if (Array.isArray(options.text)) {\n if (pos !== undefined && pos >= 0 && pos < cleanText.length) {\n return cleanText[pos];\n }\n value = pos !== undefined ? options.text[pos] : options.text.join('\\n');\n }\n else {\n value = (_a = options.text) !== null && _a !== void 0 ? _a : '';\n }\n return value;\n },\n getVariable(name) {\n const varValue = options.variables && options.variables[name];\n return varValue != null ? varValue : name;\n }\n })\n };\n if (options.text != null && !textInserted) {\n // Text given but no implicitly repeated elements: insert it into\n // deepest child\n const deepest = deepestNode(last(result.children));\n if (deepest) {\n const text = Array.isArray(options.text) ? options.text.join('\\n') : options.text;\n insertText(deepest, text);\n if (deepest.name === 'a' && options.href) {\n // Automatically update value of `` element if inserting URL or email\n insertHref(deepest, text);\n }\n }\n }\n return result;\n}\n/**\n * Converts given statement to abbreviation nodes\n */\nfunction convertStatement(node, state) {\n let result = [];\n if (node.repeat) {\n // Node is repeated: we should create copies of given node\n // and supply context token with actual repeater state\n const original = node.repeat;\n const repeat = Object.assign({}, original);\n repeat.count = repeat.implicit && Array.isArray(state.text)\n ? state.cleanText.length\n : (repeat.count || 1);\n let items;\n state.repeaters.push(repeat);\n for (let i = 0; i < repeat.count; i++) {\n repeat.value = i;\n node.repeat = repeat;\n items = isGroup(node)\n ? convertGroup(node, state)\n : convertElement(node, state);\n if (repeat.implicit && !state.inserted) {\n // It’s an implicit repeater but no repeater placeholders found inside,\n // we should insert text into deepest node\n const target = last(items);\n const deepest = target && deepestNode(target);\n if (deepest) {\n insertText(deepest, state.getText(repeat.value));\n }\n }\n result = result.concat(items);\n // We should output at least one repeated item even if it’s reached\n // repeat limit\n if (--state.repeatGuard <= 0) {\n break;\n }\n }\n state.repeaters.pop();\n node.repeat = original;\n if (repeat.implicit) {\n state.inserted = true;\n }\n }\n else {\n result = result.concat(isGroup(node) ? convertGroup(node, state) : convertElement(node, state));\n }\n return result;\n}\nfunction convertElement(node, state) {\n let children = [];\n const elem = {\n type: 'AbbreviationNode',\n name: node.name && stringifyName(node.name, state),\n value: node.value && stringifyValue(node.value, state),\n attributes: void 0,\n children,\n repeat: node.repeat && Object.assign({}, node.repeat),\n selfClosing: node.selfClose,\n };\n let result = [elem];\n for (const child of node.elements) {\n children = children.concat(convertStatement(child, state));\n }\n if (node.attributes) {\n elem.attributes = [];\n for (const attr of node.attributes) {\n elem.attributes.push(convertAttribute(attr, state));\n }\n }\n // In case if current node is a text-only snippet without fields, we should\n // put all children as siblings\n if (!elem.name && !elem.attributes && elem.value && !elem.value.some(isField)) {\n // XXX it’s unclear that `children` is not bound to `elem`\n // due to concat operation\n result = result.concat(children);\n }\n else {\n elem.children = children;\n }\n return result;\n}\nfunction convertGroup(node, state) {\n let result = [];\n for (const child of node.elements) {\n result = result.concat(convertStatement(child, state));\n }\n if (node.repeat) {\n result = attachRepeater(result, node.repeat);\n }\n return result;\n}\nfunction convertAttribute(node, state) {\n let implied = false;\n let isBoolean = false;\n let valueType = node.expression ? 'expression' : 'raw';\n let value;\n const name = node.name && stringifyName(node.name, state);\n if (name && name[0] === '!') {\n implied = true;\n }\n if (name && name[name.length - 1] === '.') {\n isBoolean = true;\n }\n if (node.value) {\n const tokens = node.value.slice();\n if (isQuote(tokens[0])) {\n // It’s a quoted value: remove quotes from output but mark attribute\n // value as quoted\n const quote = tokens.shift();\n if (tokens.length && last(tokens).type === quote.type) {\n tokens.pop();\n }\n valueType = quote.single ? 'singleQuote' : 'doubleQuote';\n }\n else if (isBracket(tokens[0], 'expression', true)) {\n // Value is expression: remove brackets but mark value type\n valueType = 'expression';\n tokens.shift();\n if (isBracket(last(tokens), 'expression', false)) {\n tokens.pop();\n }\n }\n value = stringifyValue(tokens, state);\n }\n return {\n name: isBoolean || implied\n ? name.slice(implied ? 1 : 0, isBoolean ? -1 : void 0)\n : name,\n value,\n boolean: isBoolean,\n implied,\n valueType\n };\n}\n/**\n * Converts given token list to string\n */\nfunction stringifyName(tokens, state) {\n let str = '';\n for (let i = 0; i < tokens.length; i++) {\n str += stringify(tokens[i], state);\n }\n return str;\n}\n/**\n * Converts given token list to value list\n */\nfunction stringifyValue(tokens, state) {\n const result = [];\n let str = '';\n for (let i = 0, token; i < tokens.length; i++) {\n token = tokens[i];\n if (isField(token)) {\n // We should keep original fields in output since some editors has their\n // own syntax for field or doesn’t support fields at all so we should\n // capture actual field location in output stream\n if (str) {\n result.push(str);\n str = '';\n }\n result.push(token);\n }\n else {\n str += stringify(token, state);\n }\n }\n if (str) {\n result.push(str);\n }\n return result;\n}\nfunction isGroup(node) {\n return node.type === 'TokenGroup';\n}\nfunction isField(token) {\n return typeof token === 'object' && token.type === 'Field' && token.index != null;\n}\nfunction last(arr) {\n return arr[arr.length - 1];\n}\nfunction deepestNode(node) {\n return node.children.length ? deepestNode(last(node.children)) : node;\n}\nfunction insertText(node, text) {\n if (node.value) {\n const lastToken = last(node.value);\n if (typeof lastToken === 'string') {\n node.value[node.value.length - 1] += text;\n }\n else {\n node.value.push(text);\n }\n }\n else {\n node.value = [text];\n }\n}\nfunction insertHref(node, text) {\n var _a;\n let href = '';\n if (urlRegex.test(text)) {\n href = text;\n if (!/\\w+:/.test(href) && !href.startsWith('//')) {\n href = `http://${href}`;\n }\n }\n else if (emailRegex.test(text)) {\n href = `mailto:${text}`;\n }\n const hrefAttribute = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.find(attr => attr.name === 'href');\n if (!hrefAttribute) {\n node.attributes = [{ name: 'href', value: [href], valueType: 'doubleQuote' }];\n }\n else if (!hrefAttribute.value) {\n hrefAttribute.value = [href];\n }\n}\nfunction attachRepeater(items, repeater) {\n for (const item of items) {\n if (!item.repeat) {\n item.repeat = Object.assign({}, repeater);\n }\n }\n return items;\n}\n\n/**\n * Parses given abbreviation into node tree\n */\nfunction parseAbbreviation(abbr, options) {\n try {\n const tokens = typeof abbr === 'string' ? tokenize(abbr) : abbr;\n return convert(abbreviation(tokens, options), options);\n }\n catch (err) {\n if (err instanceof ScannerError && typeof abbr === 'string') {\n err.message += `\\n${abbr}\\n${'-'.repeat(err.pos)}^`;\n }\n throw err;\n }\n}\n\nexport default parseAbbreviation;\nexport { convert, getToken, abbreviation as parse, tokenize };\n//# sourceMappingURL=abbreviation.es.js.map\n","import Scanner, { isNumber, isAlpha, isAlphaWord, isQuote, isSpace, isAlphaNumericWord, ScannerError } from '@emmetio/scanner';\n\nfunction tokenize(abbr, isValue) {\n let brackets = 0;\n let token;\n const scanner = new Scanner(abbr);\n const tokens = [];\n while (!scanner.eof()) {\n token = getToken(scanner, brackets === 0 && !isValue);\n if (!token) {\n throw scanner.error('Unexpected character');\n }\n if (token.type === 'Bracket') {\n if (!brackets && token.open) {\n mergeTokens(scanner, tokens);\n }\n brackets += token.open ? 1 : -1;\n if (brackets < 0) {\n throw scanner.error('Unexpected bracket', token.start);\n }\n }\n tokens.push(token);\n // Forcibly consume next operator after unit-less numeric value or color:\n // next dash `-` must be used as value delimiter\n if (shouldConsumeDashAfter(token) && (token = operator(scanner))) {\n tokens.push(token);\n }\n }\n return tokens;\n}\n/**\n * Returns next token from given scanner, if possible\n */\nfunction getToken(scanner, short) {\n return field(scanner)\n || numberValue(scanner)\n || colorValue(scanner)\n || stringValue(scanner)\n || bracket(scanner)\n || operator(scanner)\n || whiteSpace(scanner)\n || literal(scanner, short);\n}\nfunction field(scanner) {\n const start = scanner.pos;\n if (scanner.eat(36 /* Dollar */) && scanner.eat(123 /* CurlyBracketOpen */)) {\n scanner.start = scanner.pos;\n let index;\n let name = '';\n if (scanner.eatWhile(isNumber)) {\n // It’s a field\n index = Number(scanner.current());\n name = scanner.eat(58 /* Colon */) ? consumePlaceholder(scanner) : '';\n }\n else if (isAlpha(scanner.peek())) {\n // It’s a variable\n name = consumePlaceholder(scanner);\n }\n if (scanner.eat(125 /* CurlyBracketClose */)) {\n return {\n type: 'Field',\n index, name,\n start,\n end: scanner.pos\n };\n }\n throw scanner.error('Expecting }');\n }\n // If we reached here then there’s no valid field here, revert\n // back to starting position\n scanner.pos = start;\n}\n/**\n * Consumes a placeholder: value right after `:` in field. Could be empty\n */\nfunction consumePlaceholder(stream) {\n const stack = [];\n stream.start = stream.pos;\n while (!stream.eof()) {\n if (stream.eat(123 /* CurlyBracketOpen */)) {\n stack.push(stream.pos);\n }\n else if (stream.eat(125 /* CurlyBracketClose */)) {\n if (!stack.length) {\n stream.pos--;\n break;\n }\n stack.pop();\n }\n else {\n stream.pos++;\n }\n }\n if (stack.length) {\n stream.pos = stack.pop();\n throw stream.error(`Expecting }`);\n }\n return stream.current();\n}\n/**\n * Consumes literal from given scanner\n * @param short Use short notation for consuming value.\n * The difference between “short” and “full” notation is that first one uses\n * alpha characters only and used for extracting keywords from abbreviation,\n * while “full” notation also supports numbers and dashes\n */\nfunction literal(scanner, short) {\n const start = scanner.pos;\n if (scanner.eat(isIdentPrefix)) {\n // SCSS or LESS variable\n // NB a bit dirty hack: if abbreviation starts with identifier prefix,\n // consume alpha characters only to allow embedded variables\n scanner.eatWhile(start ? isKeyword : isLiteral);\n }\n else if (scanner.eat(isAlphaWord)) {\n scanner.eatWhile(short ? isLiteral : isKeyword);\n }\n else {\n // Allow dots only at the beginning of literal\n scanner.eat(46 /* Dot */);\n scanner.eatWhile(isLiteral);\n }\n if (start !== scanner.pos) {\n scanner.start = start;\n return createLiteral(scanner, scanner.start = start);\n }\n}\nfunction createLiteral(scanner, start = scanner.start, end = scanner.pos) {\n return {\n type: 'Literal',\n value: scanner.substring(start, end),\n start,\n end\n };\n}\n/**\n * Consumes numeric CSS value (number with optional unit) from current stream,\n * if possible\n */\nfunction numberValue(scanner) {\n const start = scanner.pos;\n if (consumeNumber(scanner)) {\n scanner.start = start;\n const rawValue = scanner.current();\n // eat unit, which can be a % or alpha word\n scanner.start = scanner.pos;\n scanner.eat(37 /* Percent */) || scanner.eatWhile(isAlphaWord);\n return {\n type: 'NumberValue',\n value: Number(rawValue),\n rawValue,\n unit: scanner.current(),\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes quoted string value from given scanner\n */\nfunction stringValue(scanner) {\n const ch = scanner.peek();\n const start = scanner.pos;\n let finished = false;\n if (isQuote(ch)) {\n scanner.pos++;\n while (!scanner.eof()) {\n // Do not throw error on malformed string\n if (scanner.eat(ch)) {\n finished = true;\n break;\n }\n else {\n scanner.pos++;\n }\n }\n scanner.start = start;\n return {\n type: 'StringValue',\n value: scanner.substring(start + 1, scanner.pos - (finished ? 1 : 0)),\n quote: ch === 39 /* SingleQuote */ ? 'single' : 'double',\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes a color token from given string\n */\nfunction colorValue(scanner) {\n // supported color variations:\n // #abc → #aabbccc\n // #0 → #000000\n // #fff.5 → rgba(255, 255, 255, 0.5)\n // #t → transparent\n const start = scanner.pos;\n if (scanner.eat(35 /* Hash */)) {\n const valueStart = scanner.pos;\n let color = '';\n let alpha = '';\n if (scanner.eatWhile(isHex)) {\n color = scanner.substring(valueStart, scanner.pos);\n alpha = colorAlpha(scanner);\n }\n else if (scanner.eat(116 /* Transparent */)) {\n color = '0';\n alpha = colorAlpha(scanner) || '0';\n }\n else {\n alpha = colorAlpha(scanner);\n }\n if (color || alpha || scanner.eof()) {\n const { r, g, b, a } = parseColor(color, alpha);\n return {\n type: 'ColorValue',\n r, g, b, a,\n raw: scanner.substring(start + 1, scanner.pos),\n start,\n end: scanner.pos\n };\n }\n else {\n // Consumed # but no actual value: invalid color value, treat it as literal\n return createLiteral(scanner, start);\n }\n }\n scanner.pos = start;\n}\n/**\n * Consumes alpha value of color: `.1`\n */\nfunction colorAlpha(scanner) {\n const start = scanner.pos;\n if (scanner.eat(46 /* Dot */)) {\n scanner.start = start;\n if (scanner.eatWhile(isNumber)) {\n return scanner.current();\n }\n return '1';\n }\n return '';\n}\n/**\n * Consumes white space characters as string literal from given scanner\n */\nfunction whiteSpace(scanner) {\n const start = scanner.pos;\n if (scanner.eatWhile(isSpace)) {\n return {\n type: 'WhiteSpace',\n start,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes bracket from given scanner\n */\nfunction bracket(scanner) {\n const ch = scanner.peek();\n if (isBracket(ch)) {\n return {\n type: 'Bracket',\n open: ch === 40 /* RoundBracketOpen */,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Consumes operator from given scanner\n */\nfunction operator(scanner) {\n const op = operatorType(scanner.peek());\n if (op) {\n return {\n type: 'Operator',\n operator: op,\n start: scanner.pos++,\n end: scanner.pos\n };\n }\n}\n/**\n * Eats number value from given stream\n * @return Returns `true` if number was consumed\n */\nfunction consumeNumber(stream) {\n const start = stream.pos;\n stream.eat(45 /* Dash */);\n const afterNegative = stream.pos;\n const hasDecimal = stream.eatWhile(isNumber);\n const prevPos = stream.pos;\n if (stream.eat(46 /* Dot */)) {\n // It’s perfectly valid to have numbers like `1.`, which enforces\n // value to float unit type\n const hasFloat = stream.eatWhile(isNumber);\n if (!hasDecimal && !hasFloat) {\n // Lone dot\n stream.pos = prevPos;\n }\n }\n // Edge case: consumed dash only: not a number, bail-out\n if (stream.pos === afterNegative) {\n stream.pos = start;\n }\n return stream.pos !== start;\n}\nfunction isIdentPrefix(code) {\n return code === 64 /* At */ || code === 36 /* Dollar */;\n}\n/**\n * If given character is an operator, returns it’s type\n */\nfunction operatorType(ch) {\n return (ch === 43 /* Sibling */ && \"+\" /* Sibling */)\n || (ch === 33 /* Excl */ && \"!\" /* Important */)\n || (ch === 44 /* Comma */ && \",\" /* ArgumentDelimiter */)\n || (ch === 58 /* Colon */ && \":\" /* PropertyDelimiter */)\n || (ch === 45 /* Dash */ && \"-\" /* ValueDelimiter */)\n || void 0;\n}\n/**\n * Check if given code is a hex value (/0-9a-f/)\n */\nfunction isHex(code) {\n return isNumber(code) || isAlpha(code, 65, 70); // A-F\n}\nfunction isKeyword(code) {\n return isAlphaNumericWord(code) || code === 45 /* Dash */;\n}\nfunction isBracket(code) {\n return code === 40 /* RoundBracketOpen */ || code === 41 /* RoundBracketClose */;\n}\nfunction isLiteral(code) {\n return isAlphaWord(code) || code === 37 /* Percent */ || code === 47 /* Slash */;\n}\n/**\n * Parses given color value from abbreviation into RGBA format\n */\nfunction parseColor(value, alpha) {\n let r = '0';\n let g = '0';\n let b = '0';\n let a = Number(alpha != null && alpha !== '' ? alpha : 1);\n if (value === 't') {\n a = 0;\n }\n else {\n switch (value.length) {\n case 0:\n break;\n case 1:\n r = g = b = value + value;\n break;\n case 2:\n r = g = b = value;\n break;\n case 3:\n r = value[0] + value[0];\n g = value[1] + value[1];\n b = value[2] + value[2];\n break;\n default:\n value += value;\n r = value.slice(0, 2);\n g = value.slice(2, 4);\n b = value.slice(4, 6);\n }\n }\n return {\n r: parseInt(r, 16),\n g: parseInt(g, 16),\n b: parseInt(b, 16),\n a\n };\n}\n/**\n * Check if scanner reader must consume dash after given token.\n * Used in cases where user must explicitly separate numeric values\n */\nfunction shouldConsumeDashAfter(token) {\n return token.type === 'ColorValue' || (token.type === 'NumberValue' && !token.unit);\n}\n/**\n * Merges last adjacent tokens into a single literal.\n * This function is used to overcome edge case when function name was parsed\n * as a list of separate tokens. For example, a `scale3d()` value will be\n * parsed as literal and number tokens (`scale` and `3d`) which is a perfectly\n * valid abbreviation but undesired result. This function will detect last adjacent\n * literal and number values and combine them into single literal\n */\nfunction mergeTokens(scanner, tokens) {\n let start = 0;\n let end = 0;\n while (tokens.length) {\n const token = last(tokens);\n if (token.type === 'Literal' || token.type === 'NumberValue') {\n start = token.start;\n if (!end) {\n end = token.end;\n }\n tokens.pop();\n }\n else {\n break;\n }\n }\n if (start !== end) {\n tokens.push(createLiteral(scanner, start, end));\n }\n}\nfunction last(arr) {\n return arr[arr.length - 1];\n}\n\nfunction tokenScanner(tokens) {\n return {\n tokens,\n start: 0,\n pos: 0,\n size: tokens.length\n };\n}\nfunction peek(scanner) {\n return scanner.tokens[scanner.pos];\n}\nfunction readable(scanner) {\n return scanner.pos < scanner.size;\n}\nfunction consume(scanner, test) {\n if (test(peek(scanner))) {\n scanner.pos++;\n return true;\n }\n return false;\n}\nfunction error(scanner, message, token = peek(scanner)) {\n if (token && token.start != null) {\n message += ` at ${token.start}`;\n }\n const err = new Error(message);\n err['pos'] = token && token.start;\n return err;\n}\n\nfunction parser(tokens, options = {}) {\n const scanner = tokenScanner(tokens);\n const result = [];\n let property;\n while (readable(scanner)) {\n if (property = consumeProperty(scanner, options)) {\n result.push(property);\n }\n else if (!consume(scanner, isSiblingOperator)) {\n throw error(scanner, 'Unexpected token');\n }\n }\n return result;\n}\n/**\n * Consumes single CSS property\n */\nfunction consumeProperty(scanner, options) {\n let name;\n let important = false;\n let valueFragment;\n const value = [];\n const token = peek(scanner);\n const valueMode = !!options.value;\n if (!valueMode && isLiteral$1(token) && !isFunctionStart(scanner)) {\n scanner.pos++;\n name = token.value;\n // Consume any following value delimiter after property name\n consume(scanner, isValueDelimiter);\n }\n // Skip whitespace right after property name, if any\n if (valueMode) {\n consume(scanner, isWhiteSpace);\n }\n while (readable(scanner)) {\n if (consume(scanner, isImportant)) {\n important = true;\n }\n else if (valueFragment = consumeValue(scanner, valueMode)) {\n value.push(valueFragment);\n }\n else if (!consume(scanner, isFragmentDelimiter)) {\n break;\n }\n }\n if (name || value.length || important) {\n return { name, value, important };\n }\n}\n/**\n * Consumes single value fragment, e.g. all value tokens before comma\n */\nfunction consumeValue(scanner, inArgument) {\n const result = [];\n let token;\n let args;\n while (readable(scanner)) {\n token = peek(scanner);\n if (isValue(token)) {\n scanner.pos++;\n if (isLiteral$1(token) && (args = consumeArguments(scanner))) {\n result.push({\n type: 'FunctionCall',\n name: token.value,\n arguments: args\n });\n }\n else {\n result.push(token);\n }\n }\n else if (isValueDelimiter(token) || (inArgument && isWhiteSpace(token))) {\n scanner.pos++;\n }\n else {\n break;\n }\n }\n return result.length\n ? { type: 'CSSValue', value: result }\n : void 0;\n}\nfunction consumeArguments(scanner) {\n const start = scanner.pos;\n if (consume(scanner, isOpenBracket)) {\n const args = [];\n let value;\n while (readable(scanner) && !consume(scanner, isCloseBracket)) {\n if (value = consumeValue(scanner, true)) {\n args.push(value);\n }\n else if (!consume(scanner, isWhiteSpace) && !consume(scanner, isArgumentDelimiter)) {\n throw error(scanner, 'Unexpected token');\n }\n }\n scanner.start = start;\n return args;\n }\n}\nfunction isLiteral$1(token) {\n return token && token.type === 'Literal';\n}\nfunction isBracket$1(token, open) {\n return token && token.type === 'Bracket' && (open == null || token.open === open);\n}\nfunction isOpenBracket(token) {\n return isBracket$1(token, true);\n}\nfunction isCloseBracket(token) {\n return isBracket$1(token, false);\n}\nfunction isWhiteSpace(token) {\n return token && token.type === 'WhiteSpace';\n}\nfunction isOperator(token, operator) {\n return token && token.type === 'Operator' && (!operator || token.operator === operator);\n}\nfunction isSiblingOperator(token) {\n return isOperator(token, \"+\" /* Sibling */);\n}\nfunction isArgumentDelimiter(token) {\n return isOperator(token, \",\" /* ArgumentDelimiter */);\n}\nfunction isFragmentDelimiter(token) {\n return isArgumentDelimiter(token);\n}\nfunction isImportant(token) {\n return isOperator(token, \"!\" /* Important */);\n}\nfunction isValue(token) {\n return token.type === 'StringValue'\n || token.type === 'ColorValue'\n || token.type === 'NumberValue'\n || token.type === 'Literal'\n || token.type === 'Field';\n}\nfunction isValueDelimiter(token) {\n return isOperator(token, \":\" /* PropertyDelimiter */)\n || isOperator(token, \"-\" /* ValueDelimiter */);\n}\nfunction isFunctionStart(scanner) {\n const t1 = scanner.tokens[scanner.pos];\n const t2 = scanner.tokens[scanner.pos + 1];\n return t1 && t2 && isLiteral$1(t1) && t2.type === 'Bracket';\n}\n\n/**\n * Parses given abbreviation into property set\n */\nfunction parse(abbr, options) {\n try {\n const tokens = typeof abbr === 'string' ? tokenize(abbr, options && options.value) : abbr;\n return parser(tokens, options);\n }\n catch (err) {\n if (err instanceof ScannerError && typeof abbr === 'string') {\n err.message += `\\n${abbr}\\n${'-'.repeat(err.pos)}^`;\n }\n throw err;\n }\n}\n\nexport default parse;\nexport { getToken, parser, tokenize };\n","import parse$2 from '@emmetio/abbreviation';\nexport { default as markupAbbreviation } from '@emmetio/abbreviation';\nimport parse$3 from '@emmetio/css-abbreviation';\nexport { default as stylesheetAbbreviation } from '@emmetio/css-abbreviation';\n\n/**\n * Merges attributes in current node: de-duplicates attributes with the same name\n * and merges class names\n */\nfunction mergeAttributes(node, config) {\n if (!node.attributes) {\n return;\n }\n const attributes = [];\n const lookup = {};\n for (const attr of node.attributes) {\n if (attr.name) {\n const attrName = attr.name;\n if (attrName in lookup) {\n const prev = lookup[attrName];\n if (attrName === 'class') {\n prev.value = mergeValue(prev.value, attr.value, ' ');\n }\n else {\n mergeDeclarations(prev, attr, config);\n }\n }\n else {\n // Create new attribute instance so we can safely modify it later\n attributes.push(lookup[attrName] = Object.assign({}, attr));\n }\n }\n else {\n attributes.push(attr);\n }\n }\n node.attributes = attributes;\n}\n/**\n * Merges two token lists into single list. Adjacent strings are merged together\n */\nfunction mergeValue(prev, next, glue) {\n if (prev && next) {\n if (prev.length && glue) {\n append(prev, glue);\n }\n for (const t of next) {\n append(prev, t);\n }\n return prev;\n }\n const result = prev || next;\n return result && result.slice();\n}\n/**\n * Merges data from `src` attribute into `dest` and returns it\n */\nfunction mergeDeclarations(dest, src, config) {\n dest.name = src.name;\n if (!config.options['output.reverseAttributes']) {\n dest.value = src.value;\n }\n // Keep high-priority properties\n if (!dest.implied) {\n dest.implied = src.implied;\n }\n if (!dest.boolean) {\n dest.boolean = src.boolean;\n }\n if (dest.valueType !== 'expression') {\n dest.valueType = src.valueType;\n }\n return dest;\n}\nfunction append(tokens, value) {\n const lastIx = tokens.length - 1;\n if (typeof tokens[lastIx] === 'string' && typeof value === 'string') {\n tokens[lastIx] += value;\n }\n else {\n tokens.push(value);\n }\n}\n\n/**\n * Walks over each child node of given markup abbreviation AST node (not including\n * given one) and invokes `fn` on each node.\n * The `fn` callback accepts context node, list of ancestor nodes and optional\n * state object\n */\nfunction walk(node, fn, state) {\n const ancestors = [node];\n const callback = (ctx) => {\n fn(ctx, ancestors, state);\n ancestors.push(ctx);\n ctx.children.forEach(callback);\n ancestors.pop();\n };\n node.children.forEach(callback);\n}\n/**\n * Finds node which is the deepest for in current node or node itself.\n */\nfunction findDeepest(node) {\n let parent;\n while (node.children.length) {\n parent = node;\n node = node.children[node.children.length - 1];\n }\n return { parent, node };\n}\nfunction isNode(node) {\n return node.type === 'AbbreviationNode';\n}\n\n/**\n * Finds matching snippet from `registry` and resolves it into a parsed abbreviation.\n * Resolved node is then updated or replaced with matched abbreviation tree.\n *\n * A HTML registry basically contains aliases to another Emmet abbreviations,\n * e.g. a predefined set of name, attributes and so on, possibly a complex\n * abbreviation with multiple elements. So we have to get snippet, parse it\n * and recursively resolve it.\n */\nfunction resolveSnippets(abbr, config) {\n const stack = [];\n const reversed = config.options['output.reverseAttributes'];\n const resolve = (child) => {\n const snippet = child.name && config.snippets[child.name];\n // A snippet in stack means circular reference.\n // It can be either a user error or a perfectly valid snippet like\n // \"img\": \"img[src alt]/\", e.g. an element with predefined shape.\n // In any case, simply stop parsing and keep element as is\n if (!snippet || stack.includes(snippet)) {\n return null;\n }\n const snippetAbbr = parse$2(snippet, config);\n stack.push(snippet);\n walkResolve(snippetAbbr, resolve);\n stack.pop();\n // Add attributes from current node into every top-level node of parsed abbreviation\n for (const topNode of snippetAbbr.children) {\n if (child.attributes) {\n const from = topNode.attributes || [];\n const to = child.attributes || [];\n topNode.attributes = reversed ? to.concat(from) : from.concat(to);\n }\n mergeNodes(child, topNode);\n }\n return snippetAbbr;\n };\n walkResolve(abbr, resolve);\n return abbr;\n}\nfunction walkResolve(node, resolve, config) {\n let children = [];\n for (const child of node.children) {\n const resolved = resolve(child);\n if (resolved) {\n children = children.concat(resolved.children);\n const deepest = findDeepest(resolved);\n if (isNode(deepest.node)) {\n deepest.node.children = deepest.node.children.concat(walkResolve(child, resolve));\n }\n }\n else {\n children.push(child);\n child.children = walkResolve(child, resolve);\n }\n }\n return node.children = children;\n}\n/**\n * Adds data from first node into second node\n */\nfunction mergeNodes(from, to) {\n if (from.selfClosing) {\n to.selfClosing = true;\n }\n if (from.value != null) {\n to.value = from.value;\n }\n if (from.repeat) {\n to.repeat = from.repeat;\n }\n}\n\nfunction createOutputStream(options, level = 0) {\n return {\n options,\n value: '',\n level,\n offset: 0,\n line: 0,\n column: 0\n };\n}\n/**\n * Pushes plain string into output stream without newline processing\n */\nfunction push(stream, text) {\n const processText = stream.options['output.text'];\n _push(stream, processText(text, stream.offset, stream.line, stream.column));\n}\n/**\n * Pushes given string with possible newline formatting into output\n */\nfunction pushString(stream, value) {\n // If given value contains newlines, we should push content line-by-line and\n // use `pushNewline()` to maintain proper line/column state\n const lines = splitByLines(value);\n for (let i = 0, il = lines.length - 1; i <= il; i++) {\n push(stream, lines[i]);\n if (i !== il) {\n pushNewline(stream, true);\n }\n }\n}\n/**\n * Pushes new line into given output stream\n */\nfunction pushNewline(stream, indent) {\n const baseIndent = stream.options['output.baseIndent'];\n const newline = stream.options['output.newline'];\n push(stream, newline + baseIndent);\n stream.line++;\n stream.column = baseIndent.length;\n if (indent) {\n pushIndent(stream, indent === true ? stream.level : indent);\n }\n}\n/**\n * Adds indentation of `size` to current output stream\n */\nfunction pushIndent(stream, size = stream.level) {\n const indent = stream.options['output.indent'];\n push(stream, indent.repeat(Math.max(size, 0)));\n}\n/**\n * Pushes field/tabstop into output stream\n */\nfunction pushField(stream, index, placeholder) {\n const field = stream.options['output.field'];\n // NB: use `_push` instead of `push` to skip text processing\n _push(stream, field(index, placeholder, stream.offset, stream.line, stream.column));\n}\n/**\n * Returns given tag name formatted according to given config\n */\nfunction tagName(name, config) {\n return strCase(name, config.options['output.tagCase']);\n}\n/**\n * Returns given attribute name formatted according to given config\n */\nfunction attrName(name, config) {\n return strCase(name, config.options['output.attributeCase']);\n}\n/**\n * Returns character for quoting value of given attribute\n */\nfunction attrQuote(attr, config, isOpen) {\n if (attr.valueType === 'expression') {\n return isOpen ? '{' : '}';\n }\n return config.options['output.attributeQuotes'] === 'single' ? '\\'' : '\"';\n}\n/**\n * Check if given attribute is boolean\n */\nfunction isBooleanAttribute(attr, config) {\n return attr.boolean\n || config.options['output.booleanAttributes'].includes((attr.name || '').toLowerCase());\n}\n/**\n * Returns a token for self-closing tag, depending on current options\n */\nfunction selfClose(config) {\n switch (config.options['output.selfClosingStyle']) {\n case 'xhtml': return ' /';\n case 'xml': return '/';\n default: return '';\n }\n}\n/**\n * Check if given tag name belongs to inline-level element\n * @param node Parsed node or tag name\n */\nfunction isInline(node, config) {\n if (typeof node === 'string') {\n return config.options.inlineElements.includes(node.toLowerCase());\n }\n // inline node is a node either with inline-level name or text-only node\n return node.name ? isInline(node.name, config) : Boolean(node.value && !node.attributes);\n}\n/**\n * Splits given text by lines\n */\nfunction splitByLines(text) {\n return text.split(/\\r\\n|\\r|\\n/g);\n}\n/**\n * Pushes raw string into output stream without any processing\n */\nfunction _push(stream, text) {\n stream.value += text;\n stream.offset += text.length;\n stream.column += text.length;\n}\nfunction strCase(str, type) {\n if (type) {\n return type === 'upper' ? str.toUpperCase() : str.toLowerCase();\n }\n return str;\n}\n\nconst elementMap = {\n p: 'span',\n ul: 'li',\n ol: 'li',\n table: 'tr',\n tr: 'td',\n tbody: 'tr',\n thead: 'tr',\n tfoot: 'tr',\n colgroup: 'col',\n select: 'option',\n optgroup: 'option',\n audio: 'source',\n video: 'source',\n object: 'param',\n map: 'area'\n};\nfunction implicitTag(node, ancestors, config) {\n if (!node.name && node.attributes) {\n resolveImplicitTag(node, ancestors, config);\n }\n}\nfunction resolveImplicitTag(node, ancestors, config) {\n const parent = getParentElement(ancestors);\n const contextName = config.context ? config.context.name : '';\n const parentName = lowercase(parent ? parent.name : contextName);\n node.name = elementMap[parentName]\n || (isInline(parentName, config) ? 'span' : 'div');\n}\nfunction lowercase(str) {\n return (str || '').toLowerCase();\n}\n/**\n * Returns closest element node from given ancestors list\n */\nfunction getParentElement(ancestors) {\n for (let i = ancestors.length - 1; i >= 0; i--) {\n const elem = ancestors[i];\n if (isNode(elem)) {\n return elem;\n }\n }\n}\n\nvar latin = {\n\t\"common\": [\"lorem\", \"ipsum\", \"dolor\", \"sit\", \"amet\", \"consectetur\", \"adipisicing\", \"elit\"],\n\t\"words\": [\"exercitationem\", \"perferendis\", \"perspiciatis\", \"laborum\", \"eveniet\",\n\t\t\"sunt\", \"iure\", \"nam\", \"nobis\", \"eum\", \"cum\", \"officiis\", \"excepturi\",\n\t\t\"odio\", \"consectetur\", \"quasi\", \"aut\", \"quisquam\", \"vel\", \"eligendi\",\n\t\t\"itaque\", \"non\", \"odit\", \"tempore\", \"quaerat\", \"dignissimos\",\n\t\t\"facilis\", \"neque\", \"nihil\", \"expedita\", \"vitae\", \"vero\", \"ipsum\",\n\t\t\"nisi\", \"animi\", \"cumque\", \"pariatur\", \"velit\", \"modi\", \"natus\",\n\t\t\"iusto\", \"eaque\", \"sequi\", \"illo\", \"sed\", \"ex\", \"et\", \"voluptatibus\",\n\t\t\"tempora\", \"veritatis\", \"ratione\", \"assumenda\", \"incidunt\", \"nostrum\",\n\t\t\"placeat\", \"aliquid\", \"fuga\", \"provident\", \"praesentium\", \"rem\",\n\t\t\"necessitatibus\", \"suscipit\", \"adipisci\", \"quidem\", \"possimus\",\n\t\t\"voluptas\", \"debitis\", \"sint\", \"accusantium\", \"unde\", \"sapiente\",\n\t\t\"voluptate\", \"qui\", \"aspernatur\", \"laudantium\", \"soluta\", \"amet\",\n\t\t\"quo\", \"aliquam\", \"saepe\", \"culpa\", \"libero\", \"ipsa\", \"dicta\",\n\t\t\"reiciendis\", \"nesciunt\", \"doloribus\", \"autem\", \"impedit\", \"minima\",\n\t\t\"maiores\", \"repudiandae\", \"ipsam\", \"obcaecati\", \"ullam\", \"enim\",\n\t\t\"totam\", \"delectus\", \"ducimus\", \"quis\", \"voluptates\", \"dolores\",\n\t\t\"molestiae\", \"harum\", \"dolorem\", \"quia\", \"voluptatem\", \"molestias\",\n\t\t\"magni\", \"distinctio\", \"omnis\", \"illum\", \"dolorum\", \"voluptatum\", \"ea\",\n\t\t\"quas\", \"quam\", \"corporis\", \"quae\", \"blanditiis\", \"atque\", \"deserunt\",\n\t\t\"laboriosam\", \"earum\", \"consequuntur\", \"hic\", \"cupiditate\",\n\t\t\"quibusdam\", \"accusamus\", \"ut\", \"rerum\", \"error\", \"minus\", \"eius\",\n\t\t\"ab\", \"ad\", \"nemo\", \"fugit\", \"officia\", \"at\", \"in\", \"id\", \"quos\",\n\t\t\"reprehenderit\", \"numquam\", \"iste\", \"fugiat\", \"sit\", \"inventore\",\n\t\t\"beatae\", \"repellendus\", \"magnam\", \"recusandae\", \"quod\", \"explicabo\",\n\t\t\"doloremque\", \"aperiam\", \"consequatur\", \"asperiores\", \"commodi\",\n\t\t\"optio\", \"dolor\", \"labore\", \"temporibus\", \"repellat\", \"veniam\",\n\t\t\"architecto\", \"est\", \"esse\", \"mollitia\", \"nulla\", \"a\", \"similique\",\n\t\t\"eos\", \"alias\", \"dolore\", \"tenetur\", \"deleniti\", \"porro\", \"facere\",\n\t\t\"maxime\", \"corrupti\"]\n};\n\nvar ru = {\n\t\"common\": [\"далеко-далеко\", \"за\", \"словесными\", \"горами\", \"в стране\", \"гласных\", \"и согласных\", \"живут\", \"рыбные\", \"тексты\"],\n\t\"words\": [\"вдали\", \"от всех\", \"они\", \"буквенных\", \"домах\", \"на берегу\", \"семантика\",\n\t\t\"большого\", \"языкового\", \"океана\", \"маленький\", \"ручеек\", \"даль\",\n\t\t\"журчит\", \"по всей\", \"обеспечивает\", \"ее\",\"всеми\", \"необходимыми\",\n\t\t\"правилами\", \"эта\", \"парадигматическая\", \"страна\", \"которой\", \"жаренные\",\n\t\t\"предложения\", \"залетают\", \"прямо\", \"рот\", \"даже\", \"всемогущая\",\n\t\t\"пунктуация\", \"не\", \"имеет\", \"власти\", \"над\", \"рыбными\", \"текстами\",\n\t\t\"ведущими\", \"безорфографичный\", \"образ\", \"жизни\", \"однажды\", \"одна\",\n\t\t\"маленькая\", \"строчка\",\"рыбного\", \"текста\", \"имени\", \"lorem\", \"ipsum\",\n\t\t\"решила\", \"выйти\", \"большой\", \"мир\", \"грамматики\", \"великий\", \"оксмокс\",\n\t\t\"предупреждал\", \"о\", \"злых\", \"запятых\", \"диких\", \"знаках\", \"вопроса\",\n\t\t\"коварных\", \"точках\", \"запятой\", \"но\", \"текст\", \"дал\", \"сбить\",\n\t\t\"себя\", \"толку\", \"он\", \"собрал\", \"семь\", \"своих\", \"заглавных\", \"букв\",\n\t\t\"подпоясал\", \"инициал\", \"за\", \"пояс\", \"пустился\", \"дорогу\",\n\t\t\"взобравшись\", \"первую\", \"вершину\", \"курсивных\", \"гор\", \"бросил\",\n\t\t\"последний\", \"взгляд\", \"назад\", \"силуэт\", \"своего\", \"родного\", \"города\",\n\t\t\"буквоград\", \"заголовок\", \"деревни\", \"алфавит\", \"подзаголовок\", \"своего\",\n\t\t\"переулка\", \"грустный\", \"реторический\", \"вопрос\", \"скатился\", \"его\",\n\t\t\"щеке\", \"продолжил\", \"свой\", \"путь\", \"дороге\", \"встретил\", \"рукопись\",\n\t\t\"она\", \"предупредила\", \"моей\", \"все\", \"переписывается\", \"несколько\",\n\t\t\"раз\", \"единственное\", \"что\", \"меня\", \"осталось\", \"это\", \"приставка\",\n\t\t\"возвращайся\", \"ты\", \"лучше\", \"свою\", \"безопасную\", \"страну\", \"послушавшись\",\n\t\t\"рукописи\", \"наш\", \"продолжил\", \"свой\", \"путь\", \"вскоре\", \"ему\",\n\t\t\"повстречался\", \"коварный\", \"составитель\", \"рекламных\", \"текстов\",\n\t\t\"напоивший\", \"языком\", \"речью\", \"заманивший\", \"свое\", \"агентство\",\n\t\t\"которое\", \"использовало\", \"снова\", \"снова\", \"своих\", \"проектах\",\n\t\t\"если\", \"переписали\", \"то\", \"живет\", \"там\", \"до\", \"сих\", \"пор\"]\n};\n\nvar sp = {\n\t\"common\": [\"mujer\", \"uno\", \"dolor\", \"más\", \"de\", \"poder\", \"mismo\", \"si\"],\n\t\"words\": [\"ejercicio\", \"preferencia\", \"perspicacia\", \"laboral\", \"paño\",\n\t\t\"suntuoso\", \"molde\", \"namibia\", \"planeador\", \"mirar\", \"demás\", \"oficinista\", \"excepción\",\n\t\t\"odio\", \"consecuencia\", \"casi\", \"auto\", \"chicharra\", \"velo\", \"elixir\",\n\t\t\"ataque\", \"no\", \"odio\", \"temporal\", \"cuórum\", \"dignísimo\",\n\t\t\"facilismo\", \"letra\", \"nihilista\", \"expedición\", \"alma\", \"alveolar\", \"aparte\",\n\t\t\"león\", \"animal\", \"como\", \"paria\", \"belleza\", \"modo\", \"natividad\",\n\t\t\"justo\", \"ataque\", \"séquito\", \"pillo\", \"sed\", \"ex\", \"y\", \"voluminoso\",\n\t\t\"temporalidad\", \"verdades\", \"racional\", \"asunción\", \"incidente\", \"marejada\",\n\t\t\"placenta\", \"amanecer\", \"fuga\", \"previsor\", \"presentación\", \"lejos\",\n\t\t\"necesariamente\", \"sospechoso\", \"adiposidad\", \"quindío\", \"pócima\",\n\t\t\"voluble\", \"débito\", \"sintió\", \"accesorio\", \"falda\", \"sapiencia\",\n\t\t\"volutas\", \"queso\", \"permacultura\", \"laudo\", \"soluciones\", \"entero\",\n\t\t\"pan\", \"litro\", \"tonelada\", \"culpa\", \"libertario\", \"mosca\", \"dictado\",\n\t\t\"reincidente\", \"nascimiento\", \"dolor\", \"escolar\", \"impedimento\", \"mínima\",\n\t\t\"mayores\", \"repugnante\", \"dulce\", \"obcecado\", \"montaña\", \"enigma\",\n\t\t\"total\", \"deletéreo\", \"décima\", \"cábala\", \"fotografía\", \"dolores\",\n\t\t\"molesto\", \"olvido\", \"paciencia\", \"resiliencia\", \"voluntad\", \"molestias\",\n\t\t\"magnífico\", \"distinción\", \"ovni\", \"marejada\", \"cerro\", \"torre\", \"y\",\n\t\t\"abogada\", \"manantial\", \"corporal\", \"agua\", \"crepúsculo\", \"ataque\", \"desierto\",\n\t\t\"laboriosamente\", \"angustia\", \"afortunado\", \"alma\", \"encefalograma\",\n\t\t\"materialidad\", \"cosas\", \"o\", \"renuncia\", \"error\", \"menos\", \"conejo\",\n\t\t\"abadía\", \"analfabeto\", \"remo\", \"fugacidad\", \"oficio\", \"en\", \"almácigo\", \"vos\", \"pan\",\n\t\t\"represión\", \"números\", \"triste\", \"refugiado\", \"trote\", \"inventor\",\n\t\t\"corchea\", \"repelente\", \"magma\", \"recusado\", \"patrón\", \"explícito\",\n\t\t\"paloma\", \"síndrome\", \"inmune\", \"autoinmune\", \"comodidad\",\n\t\t\"ley\", \"vietnamita\", \"demonio\", \"tasmania\", \"repeler\", \"apéndice\",\n\t\t\"arquitecto\", \"columna\", \"yugo\", \"computador\", \"mula\", \"a\", \"propósito\",\n\t\t\"fantasía\", \"alias\", \"rayo\", \"tenedor\", \"deleznable\", \"ventana\", \"cara\",\n\t\t\"anemia\", \"corrupto\"]\n};\n\nconst vocabularies = { ru, sp, latin };\nconst reLorem = /^lorem([a-z]*)(\\d*)(-\\d*)?$/i;\nfunction lorem(node, ancestors, config) {\n let m;\n if (node.name && (m = node.name.match(reLorem))) {\n const db = vocabularies[m[1]] || vocabularies.latin;\n const minWordCount = m[2] ? Math.max(1, Number(m[2])) : 30;\n const maxWordCount = m[3] ? Math.max(minWordCount, Number(m[3].slice(1))) : minWordCount;\n const wordCount = rand(minWordCount, maxWordCount);\n const repeat = node.repeat || findRepeater(ancestors);\n node.name = node.attributes = void 0;\n node.value = [paragraph(db, wordCount, !repeat || repeat.value === 0)];\n if (node.repeat && ancestors.length > 1) {\n resolveImplicitTag(node, ancestors, config);\n }\n }\n}\n/**\n * Returns random integer between from and to values\n */\nfunction rand(from, to) {\n return Math.floor(Math.random() * (to - from) + from);\n}\nfunction sample(arr, count) {\n const len = arr.length;\n const iterations = Math.min(len, count);\n const result = [];\n while (result.length < iterations) {\n const str = arr[rand(0, len)];\n if (!result.includes(str)) {\n result.push(str);\n }\n }\n return result;\n}\nfunction choice(val) {\n return val[rand(0, val.length - 1)];\n}\nfunction sentence(words, end) {\n if (words.length) {\n words = [capitalize(words[0])].concat(words.slice(1));\n }\n return words.join(' ') + (end || choice('?!...')); // more dots than question marks\n}\nfunction capitalize(word) {\n return word[0].toUpperCase() + word.slice(1);\n}\n/**\n * Insert commas at randomly selected words. This function modifies values\n * inside `words` array\n */\nfunction insertCommas(words) {\n if (words.length < 2) {\n return words;\n }\n words = words.slice();\n const len = words.length;\n const hasComma = /,$/;\n let totalCommas = 0;\n if (len > 3 && len <= 6) {\n totalCommas = rand(0, 1);\n }\n else if (len > 6 && len <= 12) {\n totalCommas = rand(0, 2);\n }\n else {\n totalCommas = rand(1, 4);\n }\n for (let i = 0, pos; i < totalCommas; i++) {\n pos = rand(0, len - 2);\n if (!hasComma.test(words[pos])) {\n words[pos] += ',';\n }\n }\n return words;\n}\n/**\n * Generate a paragraph of \"Lorem ipsum\" text\n * @param dict Words dictionary\n * @param wordCount Words count in paragraph\n * @param startWithCommon Should paragraph start with common \"lorem ipsum\" sentence.\n */\nfunction paragraph(dict, wordCount, startWithCommon) {\n const result = [];\n let totalWords = 0;\n let words;\n if (startWithCommon && dict.common) {\n words = dict.common.slice(0, wordCount);\n totalWords += words.length;\n result.push(sentence(insertCommas(words), '.'));\n }\n while (totalWords < wordCount) {\n words = sample(dict.words, Math.min(rand(2, 30), wordCount - totalWords));\n totalWords += words.length;\n result.push(sentence(insertCommas(words)));\n }\n return result.join(' ');\n}\nfunction findRepeater(ancestors) {\n for (let i = ancestors.length - 1; i >= 0; i--) {\n const element = ancestors[i];\n if (element.type === 'AbbreviationNode' && element.repeat) {\n return element.repeat;\n }\n }\n}\n\n/**\n * JSX transformer: replaces `class` and `for` attributes with `className` and\n * `htmlFor` attributes respectively\n */\nfunction jsx(node) {\n if (node.attributes) {\n node.attributes.forEach(rename);\n }\n}\nfunction rename(attr) {\n if (attr.name === 'class') {\n attr.name = 'className';\n }\n else if (attr.name === 'for') {\n attr.name = 'htmlFor';\n }\n}\n\n/**\n * XSL transformer: removes `select` attributes from certain nodes that contain\n * children\n */\nfunction xsl(node) {\n if (matchesName(node.name) && node.attributes && (node.children.length || node.value)) {\n node.attributes = node.attributes.filter(isAllowed);\n }\n}\nfunction isAllowed(attr) {\n return attr.name !== 'select';\n}\nfunction matchesName(name) {\n return name === 'xsl:variable' || name === 'xsl:with-param';\n}\n\nconst reElement = /^(-+)([a-z0-9]+[a-z0-9-]*)/i;\nconst reModifier = /^(_+)([a-z0-9]+[a-z0-9-_]*)/i;\nconst blockCandidates1 = (className) => /^[a-z]\\-/i.test(className);\nconst blockCandidates2 = (className) => /^[a-z]/i.test(className);\nfunction bem(node, ancestors, config) {\n expandClassNames(node);\n expandShortNotation(node, ancestors, config);\n}\n/**\n * Expands existing class names in BEM notation in given `node`.\n * For example, if node contains `b__el_mod` class name, this method ensures\n * that element contains `b__el` class as well\n */\nfunction expandClassNames(node) {\n const data = getBEMData(node);\n const classNames = [];\n for (const cl of data.classNames) {\n // remove all modifiers and element prefixes from class name to get a base element name\n const ix = cl.indexOf('_');\n if (ix > 0 && !cl.startsWith('-')) {\n classNames.push(cl.slice(0, ix));\n classNames.push(cl.slice(ix));\n }\n else {\n classNames.push(cl);\n }\n }\n if (classNames.length) {\n data.classNames = classNames.filter(uniqueClass);\n data.block = findBlockName(data.classNames);\n updateClass(node, data.classNames.join(' '));\n }\n}\n/**\n * Expands short BEM notation, e.g. `-element` and `_modifier`\n */\nfunction expandShortNotation(node, ancestors, config) {\n const data = getBEMData(node);\n const classNames = [];\n const { options } = config;\n const path = ancestors.slice(1).concat(node);\n for (let cl of data.classNames) {\n let prefix = '';\n let m;\n const originalClass = cl;\n // parse element definition (could be only one)\n if (m = cl.match(reElement)) {\n prefix = getBlockName(path, m[1].length, config.context) + options['bem.element'] + m[2];\n classNames.push(prefix);\n cl = cl.slice(m[0].length);\n }\n // parse modifiers definitions\n if (m = cl.match(reModifier)) {\n if (!prefix) {\n prefix = getBlockName(path, m[1].length);\n classNames.push(prefix);\n }\n classNames.push(`${prefix}${options['bem.modifier']}${m[2]}`);\n cl = cl.slice(m[0].length);\n }\n if (cl === originalClass) {\n // class name wasn’t modified: it’s not a BEM-specific class,\n // add it as-is into output\n classNames.push(originalClass);\n }\n }\n const arrClassNames = classNames.filter(uniqueClass);\n if (arrClassNames.length) {\n updateClass(node, arrClassNames.join(' '));\n }\n}\n/**\n * Returns BEM data from given abbreviation node\n */\nfunction getBEMData(node) {\n if (!node._bem) {\n let classValue = '';\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (attr.name === 'class' && attr.value) {\n classValue = stringifyValue(attr.value);\n break;\n }\n }\n }\n node._bem = parseBEM(classValue);\n }\n return node._bem;\n}\nfunction getBEMDataFromContext(context) {\n if (!context._bem) {\n context._bem = parseBEM(context.attributes && context.attributes.class || '');\n }\n return context._bem;\n}\n/**\n * Parses BEM data from given class name\n */\nfunction parseBEM(classValue) {\n const classNames = classValue ? classValue.split(/\\s+/) : [];\n return {\n classNames,\n block: findBlockName(classNames)\n };\n}\n/**\n * Returns block name for given `node` by `prefix`, which tells the depth of\n * of parent node lookup\n */\nfunction getBlockName(ancestors, depth = 0, context) {\n const maxParentIx = 0;\n let parentIx = Math.max(ancestors.length - depth, maxParentIx);\n do {\n const parent = ancestors[parentIx];\n if (parent) {\n const data = getBEMData(parent);\n if (data.block) {\n return data.block;\n }\n }\n } while (maxParentIx < parentIx--);\n if (context) {\n const data = getBEMDataFromContext(context);\n if (data.block) {\n return data.block;\n }\n }\n return '';\n}\nfunction findBlockName(classNames) {\n return find(classNames, blockCandidates1)\n || find(classNames, blockCandidates2)\n || void 0;\n}\n/**\n * Finds class name from given list which may be used as block name\n */\nfunction find(classNames, filter) {\n for (const cl of classNames) {\n if (reElement.test(cl) || reModifier.test(cl)) {\n break;\n }\n if (filter(cl)) {\n return cl;\n }\n }\n}\nfunction updateClass(node, value) {\n for (const attr of node.attributes) {\n if (attr.name === 'class') {\n attr.value = [value];\n break;\n }\n }\n}\nfunction stringifyValue(value) {\n let result = '';\n for (const t of value) {\n result += typeof t === 'string' ? t : t.name;\n }\n return result;\n}\nfunction uniqueClass(item, ix, arr) {\n return !!item && arr.indexOf(item) === ix;\n}\n\nfunction walk$1(abbr, visitor, state) {\n const callback = (ctx, index, items) => {\n const { parent, current } = state;\n state.parent = current;\n state.current = ctx;\n visitor(ctx, index, items, state, next);\n state.current = current;\n state.parent = parent;\n };\n const next = (node, index, items) => {\n state.ancestors.push(state.current);\n callback(node, index, items);\n state.ancestors.pop();\n };\n abbr.children.forEach(callback);\n}\nfunction createWalkState(config) {\n return {\n // @ts-ignore: Will set value in iterator\n current: null,\n parent: void 0,\n ancestors: [],\n config,\n field: 1,\n out: createOutputStream(config.options)\n };\n}\n\nconst caret = [{ type: 'Field', index: 0, name: '' }];\n/**\n * Check if given node is a snippet: a node without name and attributes\n */\nfunction isSnippet(node) {\n return node ? !node.name && !node.attributes : false;\n}\n/**\n * Check if given node is inline-level element, e.g. element with explicitly\n * defined node name\n */\nfunction isInlineElement(node, config) {\n return node ? isInline(node, config) : false;\n}\n/**\n * Check if given value token is a field\n */\nfunction isField(token) {\n return typeof token === 'object' && token.type === 'Field';\n}\nfunction pushTokens(tokens, state) {\n const { out } = state;\n let largestIndex = -1;\n for (const t of tokens) {\n if (typeof t === 'string') {\n pushString(out, t);\n }\n else {\n pushField(out, state.field + t.index, t.name);\n if (t.index > largestIndex) {\n largestIndex = t.index;\n }\n }\n }\n if (largestIndex !== -1) {\n state.field += largestIndex + 1;\n }\n}\n/**\n * Splits given value token by lines: returns array where each entry is a token list\n * for a single line\n */\nfunction splitByLines$1(tokens) {\n const result = [];\n let line = [];\n for (const t of tokens) {\n if (typeof t === 'string') {\n const lines = t.split(/\\r\\n?|\\n/g);\n line.push(lines.shift() || '');\n while (lines.length) {\n result.push(line);\n line = [lines.shift() || ''];\n }\n }\n else {\n line.push(t);\n }\n }\n line.length && result.push(line);\n return result;\n}\n/**\n * Check if given attribute should be outputted\n */\nfunction shouldOutputAttribute(attr) {\n // In case if attribute is implied, check if it has a defined value:\n // either non-empty value or quoted empty value\n return !attr.implied || attr.valueType !== 'raw' || (!!attr.value && attr.value.length > 0);\n}\n\n/**\n * Splits given string into template tokens.\n * Template is a string which contains placeholders which are uppercase names\n * between `[` and `]`, for example: `[PLACEHOLDER]`.\n * Unlike other templates, a placeholder may contain extra characters before and\n * after name: `[%PLACEHOLDER.]`. If data for `PLACEHOLDER` is defined, it will\n * be outputted with with these extra character, otherwise will be completely omitted.\n */\nfunction template(text) {\n const tokens = [];\n const scanner = { pos: 0, text };\n let placeholder;\n let offset = scanner.pos;\n let pos = scanner.pos;\n while (scanner.pos < scanner.text.length) {\n pos = scanner.pos;\n if (placeholder = consumePlaceholder(scanner)) {\n if (offset !== scanner.pos) {\n tokens.push(text.slice(offset, pos));\n }\n tokens.push(placeholder);\n offset = scanner.pos;\n }\n else {\n scanner.pos++;\n }\n }\n if (offset !== scanner.pos) {\n tokens.push(text.slice(offset));\n }\n return tokens;\n}\n/**\n * Consumes placeholder like `[#ID]` from given scanner\n */\nfunction consumePlaceholder(scanner) {\n if (peek(scanner) === 91 /* Start */) {\n const start = ++scanner.pos;\n let namePos = start;\n let afterPos = start;\n let stack = 1;\n while (scanner.pos < scanner.text.length) {\n const code = peek(scanner);\n if (isTokenStart(code)) {\n namePos = scanner.pos;\n while (isToken(peek(scanner))) {\n scanner.pos++;\n }\n afterPos = scanner.pos;\n }\n else {\n if (code === 91 /* Start */) {\n stack++;\n }\n else if (code === 93 /* End */) {\n if (--stack === 0) {\n return {\n before: scanner.text.slice(start, namePos),\n after: scanner.text.slice(afterPos, scanner.pos++),\n name: scanner.text.slice(namePos, afterPos)\n };\n }\n }\n scanner.pos++;\n }\n }\n }\n}\nfunction peek(scanner, pos = scanner.pos) {\n return scanner.text.charCodeAt(pos);\n}\nfunction isTokenStart(code) {\n return code >= 65 && code <= 90; // A-Z\n}\nfunction isToken(code) {\n return isTokenStart(code)\n || (code > 47 && code < 58) /* 0-9 */\n || code === 95 /* Underscore */\n || code === 45 /* Dash */;\n}\n\nfunction createCommentState(config) {\n const { options } = config;\n return {\n enabled: options['comment.enabled'],\n trigger: options['comment.trigger'],\n before: options['comment.before'] ? template(options['comment.before']) : void 0,\n after: options['comment.after'] ? template(options['comment.after']) : void 0\n };\n}\n/**\n * Adds comment prefix for given node, if required\n */\nfunction commentNodeBefore(node, state) {\n if (shouldComment(node, state) && state.comment.before) {\n output(node, state.comment.before, state);\n }\n}\n/**\n * Adds comment suffix for given node, if required\n */\nfunction commentNodeAfter(node, state) {\n if (shouldComment(node, state) && state.comment.after) {\n output(node, state.comment.after, state);\n }\n}\n/**\n * Check if given node should be commented\n */\nfunction shouldComment(node, state) {\n const { comment } = state;\n if (!comment.enabled || !comment.trigger || !node.name || !node.attributes) {\n return false;\n }\n for (const attr of node.attributes) {\n if (attr.name && comment.trigger.includes(attr.name)) {\n return true;\n }\n }\n return false;\n}\n/**\n * Pushes given template tokens into output stream\n */\nfunction output(node, tokens, state) {\n const attrs = {};\n const { out } = state;\n // Collect attributes payload\n for (const attr of node.attributes) {\n if (attr.name && attr.value) {\n attrs[attr.name.toUpperCase()] = attr.value;\n }\n }\n // Output parsed tokens\n for (const token of tokens) {\n if (typeof token === 'string') {\n pushString(out, token);\n }\n else if (attrs[token.name]) {\n pushString(out, token.before);\n pushTokens(attrs[token.name], state);\n pushString(out, token.after);\n }\n }\n}\n\nconst htmlTagRegex = /^<([\\w\\-:]+)[\\s>]/;\nfunction html(abbr, config) {\n const state = createWalkState(config);\n state.comment = createCommentState(config);\n walk$1(abbr, element, state);\n return state.out.value;\n}\n/**\n * Outputs `node` content to output stream of `state`\n * @param node Context node\n * @param index Index of `node` in `items`\n * @param items List of `node`’s siblings\n * @param state Current walk state\n */\nfunction element(node, index, items, state, next) {\n const { out, config } = state;\n const format = shouldFormat(node, index, items, state);\n // Pick offset level for current node\n const level = getIndent(state);\n out.level += level;\n format && pushNewline(out, true);\n if (node.name) {\n const name = tagName(node.name, config);\n commentNodeBefore(node, state);\n pushString(out, `<${name}`);\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (shouldOutputAttribute(attr)) {\n pushAttribute(attr, state);\n }\n }\n }\n if (node.selfClosing && !node.children.length && !node.value) {\n pushString(out, `${selfClose(config)}>`);\n }\n else {\n pushString(out, '>');\n if (!pushSnippet(node, state, next)) {\n if (node.value) {\n const innerFormat = node.value.some(hasNewline) || startsWithBlockTag(node.value, config);\n innerFormat && pushNewline(state.out, ++out.level);\n pushTokens(node.value, state);\n innerFormat && pushNewline(state.out, --out.level);\n }\n node.children.forEach(next);\n if (!node.value && !node.children.length) {\n const innerFormat = config.options['output.formatLeafNode']\n || config.options['output.formatForce'].includes(node.name);\n innerFormat && pushNewline(state.out, ++out.level);\n pushTokens(caret, state);\n innerFormat && pushNewline(state.out, --out.level);\n }\n }\n pushString(out, ``);\n commentNodeAfter(node, state);\n }\n }\n else if (!pushSnippet(node, state, next) && node.value) {\n // A text-only node (snippet)\n pushTokens(node.value, state);\n node.children.forEach(next);\n }\n if (format && index === items.length - 1 && state.parent) {\n const offset = isSnippet(state.parent) ? 0 : 1;\n pushNewline(out, out.level - offset);\n }\n out.level -= level;\n}\n/**\n * Outputs given attribute’s content into output stream\n */\nfunction pushAttribute(attr, state) {\n const { out, config } = state;\n if (attr.name) {\n const name = attrName(attr.name, config);\n const lQuote = attrQuote(attr, config, true);\n const rQuote = attrQuote(attr, config);\n let value = attr.value;\n if (isBooleanAttribute(attr, config) && !value) {\n // If attribute value is omitted and it’s a boolean value, check for\n // `compactBoolean` option: if it’s disabled, set value to attribute name\n // (XML style)\n if (!config.options['output.compactBoolean']) {\n value = [name];\n }\n }\n else if (!value) {\n value = caret;\n }\n pushString(out, ' ' + name);\n if (value) {\n pushString(out, '=' + lQuote);\n pushTokens(value, state);\n pushString(out, rQuote);\n }\n else if (config.options['output.selfClosingStyle'] !== 'html') {\n pushString(out, '=' + lQuote + rQuote);\n }\n }\n}\nfunction pushSnippet(node, state, next) {\n if (node.value && node.children.length) {\n // We have a value and child nodes. In case if value contains fields,\n // we should output children as a content of first field\n const fieldIx = node.value.findIndex(isField);\n if (fieldIx !== -1) {\n pushTokens(node.value.slice(0, fieldIx), state);\n const line = state.out.line;\n let pos = fieldIx + 1;\n node.children.forEach(next);\n // If there was a line change, trim leading whitespace for better result\n if (state.out.line !== line && typeof node.value[pos] === 'string') {\n pushString(state.out, node.value[pos++].trimLeft());\n }\n pushTokens(node.value.slice(pos), state);\n return true;\n }\n }\n return false;\n}\n/**\n * Check if given node should be formatted in its parent context\n */\nfunction shouldFormat(node, index, items, state) {\n const { config, parent } = state;\n if (!config.options['output.format']) {\n return false;\n }\n if (index === 0 && !parent) {\n // Do not format very first node\n return false;\n }\n // Do not format single child of snippet\n if (parent && isSnippet(parent) && items.length === 1) {\n return false;\n }\n /**\n * Adjacent text-only/snippet nodes\n */\n if (isSnippet(node)) {\n // Adjacent text-only/snippet nodes\n const format = isSnippet(items[index - 1]) || isSnippet(items[index + 1])\n // Has newlines: looks like wrapping code fragment\n || node.value.some(hasNewline)\n // Format as wrapper: contains children which will be outputted as field content\n || (node.value.some(isField) && node.children.length);\n if (format) {\n return true;\n }\n }\n if (isInline(node, config)) {\n // Check if inline node is the next sibling of block-level node\n if (index === 0) {\n // First node in parent: format if it’s followed by a block-level element\n for (let i = 0; i < items.length; i++) {\n if (!isInline(items[i], config)) {\n return true;\n }\n }\n }\n else if (!isInline(items[index - 1], config)) {\n // Node is right after block-level element\n return true;\n }\n if (config.options['output.inlineBreak']) {\n // check for adjacent inline elements before and after current element\n let adjacentInline = 1;\n let before = index;\n let after = index;\n while (isInlineElement(items[--before], config)) {\n adjacentInline++;\n }\n while (isInlineElement(items[++after], config)) {\n adjacentInline++;\n }\n if (adjacentInline >= config.options['output.inlineBreak']) {\n return true;\n }\n }\n // Edge case: inline node contains node that should receive formatting\n for (let i = 0, il = node.children.length; i < il; i++) {\n if (shouldFormat(node.children[i], i, node.children, state)) {\n return true;\n }\n }\n return false;\n }\n return true;\n}\n/**\n * Returns indentation offset for given node\n */\nfunction getIndent(state) {\n const { config, parent } = state;\n if (!parent || isSnippet(parent) || (parent.name && config.options['output.formatSkip'].includes(parent.name))) {\n return 0;\n }\n return 1;\n}\n/**\n * Check if given node value contains newlines\n */\nfunction hasNewline(value) {\n return typeof value === 'string' && /\\r|\\n/.test(value);\n}\n/**\n * Check if given node value starts with block-level tag\n */\nfunction startsWithBlockTag(value, config) {\n if (value.length && typeof value[0] === 'string') {\n const matches = htmlTagRegex.exec(value[0]);\n if ((matches === null || matches === void 0 ? void 0 : matches.length) && !config.options['inlineElements'].includes(matches[1].toLowerCase())) {\n return true;\n }\n }\n return false;\n}\n\nfunction indentFormat(abbr, config, options) {\n const state = createWalkState(config);\n state.options = options || {};\n walk$1(abbr, element$1, state);\n return state.out.value;\n}\n/**\n * Outputs `node` content to output stream of `state`\n * @param node Context node\n * @param index Index of `node` in `items`\n * @param items List of `node`’s siblings\n * @param state Current walk state\n */\nfunction element$1(node, index, items, state, next) {\n const { out, options } = state;\n const { primary, secondary } = collectAttributes(node);\n // Pick offset level for current node\n const level = state.parent ? 1 : 0;\n out.level += level;\n // Do not indent top-level elements\n if (shouldFormat$1(node, index, items, state)) {\n pushNewline(out, true);\n }\n if (node.name && (node.name !== 'div' || !primary.length)) {\n pushString(out, (options.beforeName || '') + node.name + (options.afterName || ''));\n }\n pushPrimaryAttributes(primary, state);\n pushSecondaryAttributes(secondary.filter(shouldOutputAttribute), state);\n if (node.selfClosing && !node.value && !node.children.length) {\n if (state.options.selfClose) {\n pushString(out, state.options.selfClose);\n }\n }\n else {\n pushValue(node, state);\n node.children.forEach(next);\n }\n out.level -= level;\n}\n/**\n * From given node, collects all attributes as `primary` (id, class) and\n * `secondary` (all the rest) lists. In most indent-based syntaxes, primary attribute\n * has special syntax\n */\nfunction collectAttributes(node) {\n const primary = [];\n const secondary = [];\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (isPrimaryAttribute(attr)) {\n primary.push(attr);\n }\n else {\n secondary.push(attr);\n }\n }\n }\n return { primary, secondary };\n}\n/**\n * Outputs given attributes as primary into output stream\n */\nfunction pushPrimaryAttributes(attrs, state) {\n for (const attr of attrs) {\n if (attr.value) {\n if (attr.name === 'class') {\n pushString(state.out, '.');\n // All whitespace characters must be replaced with dots in class names\n const tokens = attr.value.map(t => typeof t === 'string' ? t.replace(/\\s+/g, '.') : t);\n pushTokens(tokens, state);\n }\n else {\n // ID attribute\n pushString(state.out, '#');\n pushTokens(attr.value, state);\n }\n }\n }\n}\n/**\n * Outputs given attributes as secondary into output stream\n */\nfunction pushSecondaryAttributes(attrs, state) {\n if (attrs.length) {\n const { out, config, options } = state;\n options.beforeAttribute && pushString(out, options.beforeAttribute);\n for (let i = 0; i < attrs.length; i++) {\n const attr = attrs[i];\n pushString(out, attrName(attr.name || '', config));\n if (isBooleanAttribute(attr, config) && !attr.value) {\n if (!config.options['output.compactBoolean'] && options.booleanValue) {\n pushString(out, '=' + options.booleanValue);\n }\n }\n else {\n pushString(out, '=' + attrQuote(attr, config, true));\n pushTokens(attr.value || caret, state);\n pushString(out, attrQuote(attr, config));\n }\n if (i !== attrs.length - 1 && options.glueAttribute) {\n pushString(out, options.glueAttribute);\n }\n }\n options.afterAttribute && pushString(out, options.afterAttribute);\n }\n}\n/**\n * Outputs given node value into state output stream\n */\nfunction pushValue(node, state) {\n // We should either output value or add caret but for leaf nodes only (no children)\n if (!node.value && node.children.length) {\n return;\n }\n const value = node.value || caret;\n const lines = splitByLines$1(value);\n const { out, options } = state;\n if (lines.length === 1) {\n if (node.name || node.attributes) {\n push(out, ' ');\n }\n pushTokens(value, state);\n }\n else {\n // We should format multi-line value with terminating `|` character\n // and same line length\n const lineLengths = [];\n let maxLength = 0;\n // Calculate lengths of all lines and max line length\n for (const line of lines) {\n const len = valueLength(line);\n lineLengths.push(len);\n if (len > maxLength) {\n maxLength = len;\n }\n }\n // Output each line, padded to max length\n out.level++;\n for (let i = 0; i < lines.length; i++) {\n pushNewline(out, true);\n options.beforeTextLine && push(out, options.beforeTextLine);\n pushTokens(lines[i], state);\n if (options.afterTextLine) {\n push(out, ' '.repeat(maxLength - lineLengths[i]));\n push(out, options.afterTextLine);\n }\n }\n out.level--;\n }\n}\nfunction isPrimaryAttribute(attr) {\n return attr.name === 'class' || attr.name === 'id';\n}\n/**\n * Calculates string length from given tokens\n */\nfunction valueLength(tokens) {\n let len = 0;\n for (const token of tokens) {\n len += typeof token === 'string' ? token.length : token.name.length;\n }\n return len;\n}\nfunction shouldFormat$1(node, index, items, state) {\n // Do not format first top-level element or snippets\n if (!state.parent && index === 0) {\n return false;\n }\n return !isSnippet(node);\n}\n\nfunction haml(abbr, config) {\n return indentFormat(abbr, config, {\n beforeName: '%',\n beforeAttribute: '(',\n afterAttribute: ')',\n glueAttribute: ' ',\n afterTextLine: ' |',\n booleanValue: 'true',\n selfClose: '/'\n });\n}\n\nfunction slim(abbr, config) {\n return indentFormat(abbr, config, {\n beforeAttribute: ' ',\n glueAttribute: ' ',\n beforeTextLine: '| ',\n selfClose: '/'\n });\n}\n\nfunction pug(abbr, config) {\n return indentFormat(abbr, config, {\n beforeAttribute: '(',\n afterAttribute: ')',\n glueAttribute: ', ',\n beforeTextLine: '| ',\n selfClose: config.options['output.selfClosingStyle'] === 'xml' ? '/' : ''\n });\n}\n\nconst formatters = { html, haml, slim, pug };\n/**\n * Parses given Emmet abbreviation into a final abbreviation tree with all\n * required transformations applied\n */\nfunction parse(abbr, config) {\n let oldTextValue;\n if (typeof abbr === 'string') {\n let parseOpt = config;\n if (config.options['jsx.enabled']) {\n parseOpt = Object.assign(Object.assign({}, parseOpt), { jsx: true });\n }\n if (config.options['markup.href']) {\n parseOpt = Object.assign(Object.assign({}, parseOpt), { href: true });\n }\n abbr = parse$2(abbr, parseOpt);\n // remove text field before snippets(abbr, config) call\n // as abbreviation(abbr, parseOpt) already handled it\n oldTextValue = config.text;\n config.text = undefined;\n }\n // Run abbreviation resolve in two passes:\n // 1. Map each node to snippets, which are abbreviations as well. A single snippet\n // may produce multiple nodes\n // 2. Transform every resolved node\n abbr = resolveSnippets(abbr, config);\n walk(abbr, transform, config);\n config.text = oldTextValue !== null && oldTextValue !== void 0 ? oldTextValue : config.text;\n return abbr;\n}\n/**\n * Converts given abbreviation to string according to provided `config`\n */\nfunction stringify(abbr, config) {\n const formatter = formatters[config.syntax] || html;\n return formatter(abbr, config);\n}\n/**\n * Modifies given node and prepares it for output\n */\nfunction transform(node, ancestors, config) {\n implicitTag(node, ancestors, config);\n mergeAttributes(node, config);\n lorem(node, ancestors, config);\n if (config.syntax === 'xsl') {\n xsl(node);\n }\n if (config.options['jsx.enabled']) {\n jsx(node);\n }\n if (config.options['bem.enabled']) {\n bem(node, ancestors, config);\n }\n}\n\nconst reProperty = /^([a-z-]+)(?:\\s*:\\s*([^\\n\\r;]+?);*)?$/;\nconst opt = { value: true };\n/**\n * Creates structure for holding resolved CSS snippet\n */\nfunction createSnippet(key, value) {\n // A snippet could be a raw text snippet (e.g. arbitrary text string) or a\n // CSS property with possible values separated by `|`.\n // In latter case, we have to parse snippet as CSS abbreviation\n const m = value.match(reProperty);\n if (m) {\n const keywords = {};\n const parsed = m[2] ? m[2].split('|').map(parseValue) : [];\n for (const item of parsed) {\n for (const cssVal of item) {\n collectKeywords(cssVal, keywords);\n }\n }\n return {\n type: \"Property\" /* Property */,\n key,\n property: m[1],\n value: parsed,\n keywords,\n dependencies: []\n };\n }\n return { type: \"Raw\" /* Raw */, key, value };\n}\n/**\n * Nests more specific CSS properties into shorthand ones, e.g.\n * `background-position-x` -> `background-position` -> `background`\n */\nfunction nest(snippets) {\n snippets = snippets.slice().sort(snippetsSort);\n const stack = [];\n let prev;\n // For sorted list of CSS properties, create dependency graph where each\n // shorthand property contains its more specific one, e.g.\n // background -> background-position -> background-position-x\n for (const cur of snippets.filter(isProperty)) {\n // Check if current property belongs to one from parent stack.\n // Since `snippets` array is sorted, items are perfectly aligned\n // from shorthands to more specific variants\n while (stack.length) {\n prev = stack[stack.length - 1];\n if (cur.property.startsWith(prev.property)\n && cur.property.charCodeAt(prev.property.length) === 45 /* - */) {\n prev.dependencies.push(cur);\n stack.push(cur);\n break;\n }\n stack.pop();\n }\n if (!stack.length) {\n stack.push(cur);\n }\n }\n return snippets;\n}\n/**\n * A sorting function for array of snippets\n */\nfunction snippetsSort(a, b) {\n if (a.key === b.key) {\n return 0;\n }\n return a.key < b.key ? -1 : 1;\n}\nfunction parseValue(value) {\n return parse$3(value.trim(), opt)[0].value;\n}\nfunction isProperty(snippet) {\n return snippet.type === \"Property\" /* Property */;\n}\nfunction collectKeywords(cssVal, dest) {\n for (const v of cssVal.value) {\n if (v.type === 'Literal') {\n dest[v.value] = v;\n }\n else if (v.type === 'FunctionCall') {\n dest[v.name] = v;\n }\n else if (v.type === 'Field') {\n // Create literal from field, if available\n const value = v.name.trim();\n if (value) {\n dest[value] = { type: 'Literal', value };\n }\n }\n }\n}\n\n/**\n * Calculates how close `str1` matches `str2` using fuzzy match.\n * How matching works:\n * – first characters of both `str1` and `str2` *must* match\n * – `str1` length larger than `str2` length is allowed only when `unmatched` is true\n * – ideal match is when `str1` equals to `str2` (score: 1)\n * – next best match is `str2` starts with `str1` (score: 1 × percent of matched characters)\n * – other scores depend on how close characters of `str1` to the beginning of `str2`\n * @param partialMatch Allow length `str1` to be greater than `str2` length\n */\nfunction scoreMatch(str1, str2, partialMatch = false) {\n str1 = str1.toLowerCase();\n str2 = str2.toLowerCase();\n if (str1 === str2) {\n return 1;\n }\n // Both strings MUST start with the same character\n if (!str1 || !str2 || str1.charCodeAt(0) !== str2.charCodeAt(0)) {\n return 0;\n }\n const str1Len = str1.length;\n const str2Len = str2.length;\n if (!partialMatch && str1Len > str2Len) {\n return 0;\n }\n // Characters from `str1` which are closer to the beginning of a `str2` should\n // have higher score.\n // For example, if `str2` is `abcde`, it’s max score is:\n // 5 + 4 + 3 + 2 + 1 = 15 (sum of character positions in reverse order)\n // Matching `abd` against `abcde` should produce:\n // 5 + 4 + 2 = 11\n // Acronym bonus for match right after `-`. Matching `abd` against `abc-de`\n // should produce:\n // 6 + 5 + 4 (use `d` position in `abd`, not in abc-de`)\n const minLength = Math.min(str1Len, str2Len);\n const maxLength = Math.max(str1Len, str2Len);\n let i = 1;\n let j = 1;\n let score = maxLength;\n let ch1 = 0;\n let ch2 = 0;\n let found = false;\n let acronym = false;\n while (i < str1Len) {\n ch1 = str1.charCodeAt(i);\n found = false;\n acronym = false;\n while (j < str2Len) {\n ch2 = str2.charCodeAt(j);\n if (ch1 === ch2) {\n found = true;\n score += maxLength - (acronym ? i : j);\n break;\n }\n // add acronym bonus for exactly next match after unmatched `-`\n acronym = ch2 === 45 /* - */;\n j++;\n }\n if (!found) {\n if (!partialMatch) {\n return 0;\n }\n break;\n }\n i++;\n }\n const matchRatio = i / maxLength;\n const delta = maxLength - minLength;\n const maxScore = sum(maxLength) - sum(delta);\n return (score * matchRatio) / maxScore;\n}\n/**\n * Calculates sum of first `n` numbers, e.g. 1+2+3+...n\n */\nfunction sum(n) {\n return n * (n + 1) / 2;\n}\n\nfunction color(token, shortHex) {\n if (!token.r && !token.g && !token.b && !token.a) {\n return 'transparent';\n }\n else if (token.a === 1) {\n return asHex(token, shortHex);\n }\n return asRGB(token);\n}\n/**\n * Output given color as hex value\n * @param short Produce short value (e.g. #fff instead of #ffffff), if possible\n */\nfunction asHex(token, short) {\n const fn = (short && isShortHex(token.r) && isShortHex(token.g) && isShortHex(token.b))\n ? toShortHex : toHex;\n return '#' + fn(token.r) + fn(token.g) + fn(token.b);\n}\n/**\n * Output current color as `rgba?(...)` CSS color\n */\nfunction asRGB(token) {\n const values = [token.r, token.g, token.b];\n if (token.a !== 1) {\n values.push(frac(token.a, 8));\n }\n return `${values.length === 3 ? 'rgb' : 'rgba'}(${values.join(', ')})`;\n}\nfunction frac(num, digits = 4) {\n return num.toFixed(digits).replace(/\\.?0+$/, '');\n}\nfunction isShortHex(hex) {\n return !(hex % 17);\n}\nfunction toShortHex(num) {\n return (num >> 4).toString(16);\n}\nfunction toHex(num) {\n return pad(num.toString(16), 2);\n}\nfunction pad(value, len) {\n while (value.length < len) {\n value = '0' + value;\n }\n return value;\n}\n\nfunction css(abbr, config) {\n var _a;\n const out = createOutputStream(config.options);\n const format = config.options['output.format'];\n if (((_a = config.context) === null || _a === void 0 ? void 0 : _a.name) === \"@@section\" /* Section */) {\n // For section context, filter out unmatched snippets\n abbr = abbr.filter(node => node.snippet);\n }\n for (let i = 0; i < abbr.length; i++) {\n if (format && i !== 0) {\n pushNewline(out, true);\n }\n property(abbr[i], out, config);\n }\n return out.value;\n}\n/**\n * Outputs given abbreviation node into output stream\n */\nfunction property(node, out, config) {\n const isJSON = config.options['stylesheet.json'];\n if (node.name) {\n // It’s a CSS property\n const name = isJSON ? toCamelCase(node.name) : node.name;\n pushString(out, name + config.options['stylesheet.between']);\n if (node.value.length) {\n propertyValue(node, out, config);\n }\n else {\n pushField(out, 0, '');\n }\n if (isJSON) {\n // For CSS-in-JS, always finalize property with comma\n // NB: seems like `important` is not available in CSS-in-JS syntaxes\n push(out, ',');\n }\n else {\n outputImportant(node, out, true);\n push(out, config.options['stylesheet.after']);\n }\n }\n else {\n // It’s a regular snippet, output plain tokens without any additional formatting\n for (const cssVal of node.value) {\n for (const v of cssVal.value) {\n outputToken(v, out, config);\n }\n }\n outputImportant(node, out, node.value.length > 0);\n }\n}\nfunction propertyValue(node, out, config) {\n const isJSON = config.options['stylesheet.json'];\n const num = isJSON ? getSingleNumeric(node) : null;\n if (num && (!num.unit || num.unit === 'px')) {\n // For CSS-in-JS, if property contains single numeric value, output it\n // as JS number\n push(out, String(num.value));\n }\n else {\n const quote = getQuote(config);\n isJSON && push(out, quote);\n for (let i = 0; i < node.value.length; i++) {\n if (i !== 0) {\n push(out, ', ');\n }\n outputValue(node.value[i], out, config);\n }\n isJSON && push(out, quote);\n }\n}\nfunction outputImportant(node, out, separator) {\n if (node.important) {\n if (separator) {\n push(out, ' ');\n }\n push(out, '!important');\n }\n}\nfunction outputValue(value, out, config) {\n for (let i = 0, prevEnd = -1; i < value.value.length; i++) {\n const token = value.value[i];\n // Handle edge case: a field is written close to previous token like this: `foo${bar}`.\n // We should not add delimiter here\n if (i !== 0 && (token.type !== 'Field' || token.start !== prevEnd)) {\n push(out, ' ');\n }\n outputToken(token, out, config);\n prevEnd = token['end'];\n }\n}\nfunction outputToken(token, out, config) {\n if (token.type === 'ColorValue') {\n push(out, color(token, config.options['stylesheet.shortHex']));\n }\n else if (token.type === 'Literal') {\n pushString(out, token.value);\n }\n else if (token.type === 'NumberValue') {\n pushString(out, frac(token.value, 4) + token.unit);\n }\n else if (token.type === 'StringValue') {\n const quote = token.quote === 'double' ? '\"' : '\\'';\n pushString(out, quote + token.value + quote);\n }\n else if (token.type === 'Field') {\n pushField(out, token.index, token.name);\n }\n else if (token.type === 'FunctionCall') {\n push(out, token.name + '(');\n for (let i = 0; i < token.arguments.length; i++) {\n if (i) {\n push(out, ', ');\n }\n outputValue(token.arguments[i], out, config);\n }\n push(out, ')');\n }\n}\n/**\n * If value of given property is a single numeric value, returns this token\n */\nfunction getSingleNumeric(node) {\n if (node.value.length === 1) {\n const cssVal = node.value[0];\n if (cssVal.value.length === 1 && cssVal.value[0].type === 'NumberValue') {\n return cssVal.value[0];\n }\n }\n}\n/**\n * Converts kebab-case string to camelCase\n */\nfunction toCamelCase(str) {\n return str.replace(/\\-(\\w)/g, (_, letter) => letter.toUpperCase());\n}\nfunction getQuote(config) {\n return config.options['stylesheet.jsonDoubleQuotes'] ? '\"' : '\\'';\n}\n\nconst gradientName = 'lg';\n/**\n * Parses given Emmet abbreviation into a final abbreviation tree with all\n * required transformations applied\n */\nfunction parse$1(abbr, config) {\n var _a;\n const snippets = ((_a = config.cache) === null || _a === void 0 ? void 0 : _a.stylesheetSnippets) || convertSnippets(config.snippets);\n if (config.cache) {\n config.cache.stylesheetSnippets = snippets;\n }\n if (typeof abbr === 'string') {\n abbr = parse$3(abbr, { value: isValueScope(config) });\n }\n const filteredSnippets = getSnippetsForScope(snippets, config);\n for (const node of abbr) {\n resolveNode(node, filteredSnippets, config);\n }\n return abbr;\n}\n/**\n * Converts given raw snippets into internal snippets representation\n */\nfunction convertSnippets(snippets) {\n const result = [];\n for (const key of Object.keys(snippets)) {\n result.push(createSnippet(key, snippets[key]));\n }\n return nest(result);\n}\n/**\n * Resolves given node: finds matched CSS snippets using fuzzy match and resolves\n * keyword aliases from node value\n */\nfunction resolveNode(node, snippets, config) {\n if (!resolveGradient(node, config)) {\n const score = config.options['stylesheet.fuzzySearchMinScore'];\n if (isValueScope(config)) {\n // Resolve as value of given CSS property\n const propName = config.context.name;\n const snippet = snippets.find(s => s.type === \"Property\" /* Property */ && s.property === propName);\n resolveValueKeywords(node, config, snippet, score);\n node.snippet = snippet;\n }\n else if (node.name) {\n const snippet = findBestMatch(node.name, snippets, score, true);\n node.snippet = snippet;\n if (snippet) {\n if (snippet.type === \"Property\" /* Property */) {\n resolveAsProperty(node, snippet, config);\n }\n else {\n resolveAsSnippet(node, snippet);\n }\n }\n }\n }\n if (node.name || config.context) {\n // Resolve numeric values for CSS properties only\n resolveNumericValue(node, config);\n }\n return node;\n}\n/**\n * Resolves CSS gradient shortcut from given property, if possible\n */\nfunction resolveGradient(node, config) {\n let gradientFn = null;\n const cssVal = node.value.length === 1 ? node.value[0] : null;\n if (cssVal && cssVal.value.length === 1) {\n const v = cssVal.value[0];\n if (v.type === 'FunctionCall' && v.name === gradientName) {\n gradientFn = v;\n }\n }\n if (gradientFn || node.name === gradientName) {\n if (!gradientFn) {\n gradientFn = {\n type: 'FunctionCall',\n name: 'linear-gradient',\n arguments: [cssValue(field(0, ''))]\n };\n }\n else {\n gradientFn = Object.assign(Object.assign({}, gradientFn), { name: 'linear-gradient' });\n }\n if (!config.context) {\n node.name = 'background-image';\n }\n node.value = [cssValue(gradientFn)];\n return true;\n }\n return false;\n}\n/**\n * Resolves given parsed abbreviation node as CSS property\n */\nfunction resolveAsProperty(node, snippet, config) {\n const abbr = node.name;\n // Check for unmatched part of abbreviation\n // For example, in `dib` abbreviation the matched part is `d` and `ib` should\n // be considered as inline value. If unmatched fragment exists, we should check\n // if it matches actual value of snippet. If either explicit value is specified\n // or unmatched fragment did not resolve to to a keyword, we should consider\n // matched snippet as invalid\n const inlineValue = getUnmatchedPart(abbr, snippet.key);\n if (inlineValue) {\n if (node.value.length) {\n // Already have value: unmatched part indicates matched snippet is invalid\n return node;\n }\n const kw = resolveKeyword(inlineValue, config, snippet);\n if (!kw) {\n return node;\n }\n node.value.push(cssValue(kw));\n }\n node.name = snippet.property;\n if (node.value.length) {\n // Replace keyword alias from current abbreviation node with matched keyword\n resolveValueKeywords(node, config, snippet);\n }\n else if (snippet.value.length) {\n const defaultValue = snippet.value[0];\n // https://github.com/emmetio/emmet/issues/558\n // We should auto-select inserted value only if there’s multiple value\n // choice\n node.value = snippet.value.length === 1 || defaultValue.some(hasField)\n ? defaultValue\n : defaultValue.map(n => wrapWithField(n, config));\n }\n return node;\n}\nfunction resolveValueKeywords(node, config, snippet, minScore) {\n for (const cssVal of node.value) {\n const value = [];\n for (const token of cssVal.value) {\n if (token.type === 'Literal') {\n value.push(resolveKeyword(token.value, config, snippet, minScore) || token);\n }\n else if (token.type === 'FunctionCall') {\n // For function calls, we should find matching function call\n // and merge arguments\n const match = resolveKeyword(token.name, config, snippet, minScore);\n if (match && match.type === 'FunctionCall') {\n value.push(Object.assign(Object.assign({}, match), { arguments: token.arguments.concat(match.arguments.slice(token.arguments.length)) }));\n }\n else {\n value.push(token);\n }\n }\n else {\n value.push(token);\n }\n }\n cssVal.value = value;\n }\n}\n/**\n * Resolves given parsed abbreviation node as a snippet: a plain code chunk\n */\nfunction resolveAsSnippet(node, snippet) {\n // When resolving snippets, we have to do the following:\n // 1. Replace field placeholders with actual field tokens.\n // 2. If input values given, put them instead of fields\n let offset = 0;\n let m;\n const reField = /\\$\\{(\\d+)(:[^}]+)?\\}/g;\n const inputValue = node.value[0];\n const outputValue = [];\n while (m = reField.exec(snippet.value)) {\n if (offset !== m.index) {\n outputValue.push(literal(snippet.value.slice(offset, m.index)));\n }\n offset = m.index + m[0].length;\n if (inputValue && inputValue.value.length) {\n outputValue.push(inputValue.value.shift());\n }\n else {\n outputValue.push(field(Number(m[1]), m[2] ? m[2].slice(1) : ''));\n }\n }\n const tail = snippet.value.slice(offset);\n if (tail) {\n outputValue.push(literal(tail));\n }\n node.name = void 0;\n node.value = [cssValue(...outputValue)];\n return node;\n}\n/**\n * Finds best matching item from `items` array\n * @param abbr Abbreviation to match\n * @param items List of items for match\n * @param minScore The minimum score the best matched item should have to be a valid match.\n */\nfunction findBestMatch(abbr, items, minScore = 0, partialMatch = false) {\n let matchedItem = null;\n let maxScore = 0;\n for (const item of items) {\n const score = scoreMatch(abbr, getScoringPart(item), partialMatch);\n if (score === 1) {\n // direct hit, no need to look further\n return item;\n }\n if (score && score >= maxScore) {\n maxScore = score;\n matchedItem = item;\n }\n }\n return maxScore >= minScore ? matchedItem : null;\n}\nfunction getScoringPart(item) {\n return typeof item === 'string' ? item : item.key;\n}\n/**\n * Returns a part of `abbr` that wasn’t directly matched against `str`.\n * For example, if abbreviation `poas` is matched against `position`,\n * the unmatched part will be `as` since `a` wasn’t found in string stream\n */\nfunction getUnmatchedPart(abbr, str) {\n for (let i = 0, lastPos = 0; i < abbr.length; i++) {\n lastPos = str.indexOf(abbr[i], lastPos);\n if (lastPos === -1) {\n return abbr.slice(i);\n }\n lastPos++;\n }\n return '';\n}\n/**\n * Resolves given keyword shorthand into matched snippet keyword or global keyword,\n * if possible\n */\nfunction resolveKeyword(kw, config, snippet, minScore) {\n let ref;\n if (snippet) {\n if (ref = findBestMatch(kw, Object.keys(snippet.keywords), minScore)) {\n return snippet.keywords[ref];\n }\n for (const dep of snippet.dependencies) {\n if (ref = findBestMatch(kw, Object.keys(dep.keywords), minScore)) {\n return dep.keywords[ref];\n }\n }\n }\n if (ref = findBestMatch(kw, config.options['stylesheet.keywords'], minScore)) {\n return literal(ref);\n }\n return null;\n}\n/**\n * Resolves numeric values in given abbreviation node\n */\nfunction resolveNumericValue(node, config) {\n const aliases = config.options['stylesheet.unitAliases'];\n const unitless = config.options['stylesheet.unitless'];\n for (const v of node.value) {\n for (const t of v.value) {\n if (t.type === 'NumberValue') {\n if (t.unit) {\n t.unit = aliases[t.unit] || t.unit;\n }\n else if (t.value !== 0 && !unitless.includes(node.name)) {\n t.unit = t.rawValue.includes('.')\n ? config.options['stylesheet.floatUnit']\n : config.options['stylesheet.intUnit'];\n }\n }\n }\n }\n}\n/**\n * Constructs CSS value token\n */\nfunction cssValue(...args) {\n return {\n type: 'CSSValue',\n value: args\n };\n}\n/**\n * Constructs literal token\n */\nfunction literal(value) {\n return { type: 'Literal', value };\n}\n/**\n * Constructs field token\n */\nfunction field(index, name) {\n return { type: 'Field', index, name };\n}\n/**\n * Check if given value contains fields\n */\nfunction hasField(value) {\n for (const v of value.value) {\n if (v.type === 'Field' || (v.type === 'FunctionCall' && v.arguments.some(hasField))) {\n return true;\n }\n }\n return false;\n}\n/**\n * Wraps tokens of given abbreviation with fields\n */\nfunction wrapWithField(node, config, state = { index: 1 }) {\n let value = [];\n for (const v of node.value) {\n switch (v.type) {\n case 'ColorValue':\n value.push(field(state.index++, color(v, config.options['stylesheet.shortHex'])));\n break;\n case 'Literal':\n value.push(field(state.index++, v.value));\n break;\n case 'NumberValue':\n value.push(field(state.index++, `${v.value}${v.unit}`));\n break;\n case 'StringValue':\n const q = v.quote === 'single' ? '\\'' : '\"';\n value.push(field(state.index++, q + v.value + q));\n break;\n case 'FunctionCall':\n value.push(field(state.index++, v.name), literal('('));\n for (let i = 0, il = v.arguments.length; i < il; i++) {\n value = value.concat(wrapWithField(v.arguments[i], config, state).value);\n if (i !== il - 1) {\n value.push(literal(', '));\n }\n }\n value.push(literal(')'));\n break;\n default:\n value.push(v);\n }\n }\n return Object.assign(Object.assign({}, node), { value });\n}\n/**\n * Check if abbreviation should be expanded in CSS value context\n */\nfunction isValueScope(config) {\n if (config.context) {\n return config.context.name === \"@@value\" /* Value */ || !config.context.name.startsWith('@@');\n }\n return false;\n}\n/**\n * Returns snippets for given scope\n */\nfunction getSnippetsForScope(snippets, config) {\n if (config.context) {\n if (config.context.name === \"@@section\" /* Section */) {\n return snippets.filter(s => s.type === \"Raw\" /* Raw */);\n }\n if (config.context.name === \"@@property\" /* Property */) {\n return snippets.filter(s => s.type === \"Property\" /* Property */);\n }\n }\n return snippets;\n}\n\nvar markupSnippets = {\n\t\"a\": \"a[href]\",\n\t\"a:blank\": \"a[href='http://${0}' target='_blank' rel='noopener noreferrer']\",\n\t\"a:link\": \"a[href='http://${0}']\",\n\t\"a:mail\": \"a[href='mailto:${0}']\",\n\t\"a:tel\": \"a[href='tel:+${0}']\",\n\t\"abbr\": \"abbr[title]\",\n\t\"acr|acronym\": \"acronym[title]\",\n\t\"base\": \"base[href]/\",\n\t\"basefont\": \"basefont/\",\n\t\"br\": \"br/\",\n\t\"frame\": \"frame/\",\n\t\"hr\": \"hr/\",\n\t\"bdo\": \"bdo[dir]\",\n\t\"bdo:r\": \"bdo[dir=rtl]\",\n\t\"bdo:l\": \"bdo[dir=ltr]\",\n\t\"col\": \"col/\",\n\t\"link\": \"link[rel=stylesheet href]/\",\n\t\"link:css\": \"link[href='${1:style}.css']\",\n\t\"link:print\": \"link[href='${1:print}.css' media=print]\",\n\t\"link:favicon\": \"link[rel='shortcut icon' type=image/x-icon href='${1:favicon.ico}']\",\n\t\"link:mf|link:manifest\": \"link[rel='manifest' href='${1:manifest.json}']\",\n\t\"link:touch\": \"link[rel=apple-touch-icon href='${1:favicon.png}']\",\n\t\"link:rss\": \"link[rel=alternate type=application/rss+xml title=RSS href='${1:rss.xml}']\",\n\t\"link:atom\": \"link[rel=alternate type=application/atom+xml title=Atom href='${1:atom.xml}']\",\n\t\"link:im|link:import\": \"link[rel=import href='${1:component}.html']\",\n\t\"meta\": \"meta/\",\n\t\"meta:utf\": \"meta[http-equiv=Content-Type content='text/html;charset=UTF-8']\",\n\t\"meta:vp\": \"meta[name=viewport content='width=${1:device-width}, initial-scale=${2:1.0}']\",\n\t\"meta:compat\": \"meta[http-equiv=X-UA-Compatible content='${1:IE=7}']\",\n\t\"meta:edge\": \"meta:compat[content='${1:ie=edge}']\",\n\t\"meta:redirect\": \"meta[http-equiv=refresh content='0; url=${1:http://example.com}']\",\n\t\"meta:kw\": \"meta[name=keywords content]\",\n\t\"meta:desc\": \"meta[name=description content]\",\n\t\"style\": \"style\",\n\t\"script\": \"script\",\n\t\"script:src\": \"script[src]\",\n\t\"img\": \"img[src alt]/\",\n\t\"img:s|img:srcset\": \"img[srcset src alt]\",\n\t\"img:z|img:sizes\": \"img[sizes srcset src alt]\",\n\t\"picture\": \"picture\",\n\t\"src|source\": \"source/\",\n\t\"src:sc|source:src\": \"source[src type]\",\n\t\"src:s|source:srcset\": \"source[srcset]\",\n\t\"src:t|source:type\": \"source[srcset type='${1:image/}']\",\n\t\"src:z|source:sizes\": \"source[sizes srcset]\",\n\t\"src:m|source:media\": \"source[media='(${1:min-width: })' srcset]\",\n\t\"src:mt|source:media:type\": \"source:media[type='${2:image/}']\",\n\t\"src:mz|source:media:sizes\": \"source:media[sizes srcset]\",\n\t\"src:zt|source:sizes:type\": \"source[sizes srcset type='${1:image/}']\",\n\t\"iframe\": \"iframe[src frameborder=0]\",\n\t\"embed\": \"embed[src type]/\",\n\t\"object\": \"object[data type]\",\n\t\"param\": \"param[name value]/\",\n\t\"map\": \"map[name]\",\n\t\"area\": \"area[shape coords href alt]/\",\n\t\"area:d\": \"area[shape=default]\",\n\t\"area:c\": \"area[shape=circle]\",\n\t\"area:r\": \"area[shape=rect]\",\n\t\"area:p\": \"area[shape=poly]\",\n\t\"form\": \"form[action]\",\n\t\"form:get\": \"form[method=get]\",\n\t\"form:post\": \"form[method=post]\",\n\t\"label\": \"label[for]\",\n\t\"input\": \"input[type=${1:text}]/\",\n\t\"inp\": \"input[name=${1} id=${1}]\",\n\t\"input:h|input:hidden\": \"input[type=hidden name]\",\n\t\"input:t|input:text\": \"inp[type=text]\",\n\t\"input:search\": \"inp[type=search]\",\n\t\"input:email\": \"inp[type=email]\",\n\t\"input:url\": \"inp[type=url]\",\n\t\"input:p|input:password\": \"inp[type=password]\",\n\t\"input:datetime\": \"inp[type=datetime]\",\n\t\"input:date\": \"inp[type=date]\",\n\t\"input:datetime-local\": \"inp[type=datetime-local]\",\n\t\"input:month\": \"inp[type=month]\",\n\t\"input:week\": \"inp[type=week]\",\n\t\"input:time\": \"inp[type=time]\",\n\t\"input:tel\": \"inp[type=tel]\",\n\t\"input:number\": \"inp[type=number]\",\n\t\"input:color\": \"inp[type=color]\",\n\t\"input:c|input:checkbox\": \"inp[type=checkbox]\",\n\t\"input:r|input:radio\": \"inp[type=radio]\",\n\t\"input:range\": \"inp[type=range]\",\n\t\"input:f|input:file\": \"inp[type=file]\",\n\t\"input:s|input:submit\": \"input[type=submit value]\",\n\t\"input:i|input:image\": \"input[type=image src alt]\",\n\t\"input:b|input:btn|input:button\": \"input[type=button value]\",\n\t\"input:reset\": \"input:button[type=reset]\",\n\t\"isindex\": \"isindex/\",\n\t\"select\": \"select[name=${1} id=${1}]\",\n\t\"select:d|select:disabled\": \"select[disabled.]\",\n\t\"opt|option\": \"option[value]\",\n\t\"textarea\": \"textarea[name=${1} id=${1} cols=${2:30} rows=${3:10}]\",\n\t\"marquee\": \"marquee[behavior direction]\",\n\t\"menu:c|menu:context\": \"menu[type=context]\",\n\t\"menu:t|menu:toolbar\": \"menu[type=toolbar]\",\n\t\"video\": \"video[src]\",\n\t\"audio\": \"audio[src]\",\n\t\"html:xml\": \"html[xmlns=http://www.w3.org/1999/xhtml]\",\n\t\"keygen\": \"keygen/\",\n\t\"command\": \"command/\",\n\t\"btn:s|button:s|button:submit\" : \"button[type=submit]\",\n\t\"btn:r|button:r|button:reset\" : \"button[type=reset]\",\n\t\"btn:d|button:d|button:disabled\" : \"button[disabled.]\",\n\t\"fst:d|fset:d|fieldset:d|fieldset:disabled\" : \"fieldset[disabled.]\",\n\n\t\"bq\": \"blockquote\",\n\t\"fig\": \"figure\",\n\t\"figc\": \"figcaption\",\n\t\"pic\": \"picture\",\n\t\"ifr\": \"iframe\",\n\t\"emb\": \"embed\",\n\t\"obj\": \"object\",\n\t\"cap\": \"caption\",\n\t\"colg\": \"colgroup\",\n\t\"fst\": \"fieldset\",\n\t\"btn\": \"button\",\n\t\"optg\": \"optgroup\",\n\t\"tarea\": \"textarea\",\n\t\"leg\": \"legend\",\n\t\"sect\": \"section\",\n\t\"art\": \"article\",\n\t\"hdr\": \"header\",\n\t\"ftr\": \"footer\",\n\t\"adr\": \"address\",\n\t\"dlg\": \"dialog\",\n\t\"str\": \"strong\",\n\t\"prog\": \"progress\",\n\t\"mn\": \"main\",\n\t\"tem\": \"template\",\n\t\"fset\": \"fieldset\",\n\t\"datag\": \"datagrid\",\n\t\"datal\": \"datalist\",\n\t\"kg\": \"keygen\",\n\t\"out\": \"output\",\n\t\"det\": \"details\",\n\t\"sum\": \"summary\",\n\t\"cmd\": \"command\",\n\n\t\"ri:d|ri:dpr\": \"img:s\",\n\t\"ri:v|ri:viewport\": \"img:z\",\n\t\"ri:a|ri:art\": \"pic>src:m+img\",\n\t\"ri:t|ri:type\": \"pic>src:t+img\",\n\n\t\"!!!\": \"{}\",\n\t\"doc\": \"html[lang=${lang}]>(head>meta[charset=${charset}]+meta[http-equiv='X-UA-Compatible'][content='IE=edge']+meta:vp+title{${1:Document}})+body\",\n\t\"!|html:5\": \"!!!+doc\",\n\n\t\"c\": \"{}\",\n\t\"cc:ie\": \"{}\",\n\t\"cc:noie\": \"{${0}}\"\n};\n\nvar stylesheetSnippets = {\n\t\"@f\": \"@font-face {\\n\\tfont-family: ${1};\\n\\tsrc: url(${2});\\n}\",\n\t\"@ff\": \"@font-face {\\n\\tfont-family: '${1:FontName}';\\n\\tsrc: url('${2:FileName}.eot');\\n\\tsrc: url('${2:FileName}.eot?#iefix') format('embedded-opentype'),\\n\\t\\t url('${2:FileName}.woff') format('woff'),\\n\\t\\t url('${2:FileName}.ttf') format('truetype'),\\n\\t\\t url('${2:FileName}.svg#${1:FontName}') format('svg');\\n\\tfont-style: ${3:normal};\\n\\tfont-weight: ${4:normal};\\n}\",\n\t\"@i|@import\": \"@import url(${0});\",\n\t\"@kf\": \"@keyframes ${1:identifier} {\\n\\t${2}\\n}\",\n\t\"@m|@media\": \"@media ${1:screen} {\\n\\t${0}\\n}\",\n\t\"ac\": \"align-content:start|end|flex-start|flex-end|center|space-between|space-around|stretch|space-evenly\",\n\t\"ai\": \"align-items:start|end|flex-start|flex-end|center|baseline|stretch\",\n\t\"anim\": \"animation:${1:name} ${2:duration} ${3:timing-function} ${4:delay} ${5:iteration-count} ${6:direction} ${7:fill-mode}\",\n\t\"animdel\": \"animation-delay:time\",\n\t\"animdir\": \"animation-direction:normal|reverse|alternate|alternate-reverse\",\n\t\"animdur\": \"animation-duration:${1:0}s\",\n\t\"animfm\": \"animation-fill-mode:both|forwards|backwards\",\n\t\"animic\": \"animation-iteration-count:1|infinite\",\n\t\"animn\": \"animation-name\",\n\t\"animps\": \"animation-play-state:running|paused\",\n\t\"animtf\": \"animation-timing-function:linear|ease|ease-in|ease-out|ease-in-out|cubic-bezier(${1:0.1}, ${2:0.7}, ${3:1.0}, ${3:0.1})\",\n\t\"ap\": \"appearance:none\",\n\t\"as\": \"align-self:start|end|auto|flex-start|flex-end|center|baseline|stretch\",\n\t\"b\": \"bottom\",\n\t\"bd\": \"border:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdb\": \"border-bottom:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdbc\": \"border-bottom-color:${1:#000}\",\n\t\"bdbi\": \"border-bottom-image:url(${0})\",\n\t\"bdbk\": \"border-break:close\",\n\t\"bdbli\": \"border-bottom-left-image:url(${0})|continue\",\n\t\"bdblrs\": \"border-bottom-left-radius\",\n\t\"bdbri\": \"border-bottom-right-image:url(${0})|continue\",\n\t\"bdbrrs\": \"border-bottom-right-radius\",\n\t\"bdbs\": \"border-bottom-style\",\n\t\"bdbw\": \"border-bottom-width\",\n\t\"bdc\": \"border-color:${1:#000}\",\n\t\"bdci\": \"border-corner-image:url(${0})|continue\",\n\t\"bdcl\": \"border-collapse:collapse|separate\",\n\t\"bdf\": \"border-fit:repeat|clip|scale|stretch|overwrite|overflow|space\",\n\t\"bdi\": \"border-image:url(${0})\",\n\t\"bdl\": \"border-left:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdlc\": \"border-left-color:${1:#000}\",\n\t\"bdlen\": \"border-length\",\n\t\"bdli\": \"border-left-image:url(${0})\",\n\t\"bdls\": \"border-left-style\",\n\t\"bdlw\": \"border-left-width\",\n\t\"bdr\": \"border-right:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdrc\": \"border-right-color:${1:#000}\",\n\t\"bdri\": \"border-right-image:url(${0})\",\n\t\"bdrs\": \"border-radius\",\n\t\"bdrst\": \"border-right-style\",\n\t\"bdrw\": \"border-right-width\",\n\t\"bds\": \"border-style:none|hidden|dotted|dashed|solid|double|dot-dash|dot-dot-dash|wave|groove|ridge|inset|outset\",\n\t\"bdsp\": \"border-spacing\",\n\t\"bdt\": \"border-top:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdtc\": \"border-top-color:${1:#000}\",\n\t\"bdti\": \"border-top-image:url(${0})\",\n\t\"bdtli\": \"border-top-left-image:url(${0})|continue\",\n\t\"bdtlrs\": \"border-top-left-radius\",\n\t\"bdtri\": \"border-top-right-image:url(${0})|continue\",\n\t\"bdtrrs\": \"border-top-right-radius\",\n\t\"bdts\": \"border-top-style\",\n\t\"bdtw\": \"border-top-width\",\n\t\"bdw\": \"border-width\",\n\t\"bfv\": \"backface-visibility:hidden|visible\",\n\t\"bg\": \"background:${1:#000}\",\n\t\"bga\": \"background-attachment:fixed|scroll\",\n\t\"bgbk\": \"background-break:bounding-box|each-box|continuous\",\n\t\"bgc\": \"background-color:#${1:fff}\",\n\t\"bgcp\": \"background-clip:padding-box|border-box|content-box|no-clip\",\n\t\"bgi\": \"background-image:url(${0})\",\n\t\"bgo\": \"background-origin:padding-box|border-box|content-box\",\n\t\"bgp\": \"background-position:${1:0} ${2:0}\",\n\t\"bgpx\": \"background-position-x\",\n\t\"bgpy\": \"background-position-y\",\n\t\"bgr\": \"background-repeat:no-repeat|repeat-x|repeat-y|space|round\",\n\t\"bgsz\": \"background-size:contain|cover\",\n\t\"bxsh\": \"box-shadow:${1:inset }${2:hoff} ${3:voff} ${4:blur} ${5:#000}|none\",\n\t\"bxsz\": \"box-sizing:border-box|content-box|border-box\",\n\t\"c\": \"color:${1:#000}\",\n\t\"cr\": \"color:rgb(${1:0}, ${2:0}, ${3:0})\",\n\t\"cra\": \"color:rgba(${1:0}, ${2:0}, ${3:0}, ${4:.5})\",\n\t\"cl\": \"clear:both|left|right|none\",\n\t\"cm\": \"/* ${0} */\",\n\t\"cnt\": \"content:'${0}'|normal|open-quote|no-open-quote|close-quote|no-close-quote|attr(${0})|counter(${0})|counters(${0})\",\n\t\"coi\": \"counter-increment\",\n\t\"colm\": \"columns\",\n\t\"colmc\": \"column-count\",\n\t\"colmf\": \"column-fill\",\n\t\"colmg\": \"column-gap\",\n\t\"colmr\": \"column-rule\",\n\t\"colmrc\": \"column-rule-color\",\n\t\"colmrs\": \"column-rule-style\",\n\t\"colmrw\": \"column-rule-width\",\n\t\"colms\": \"column-span\",\n\t\"colmw\": \"column-width\",\n\t\"cor\": \"counter-reset\",\n\t\"cp\": \"clip:auto|rect(${1:top} ${2:right} ${3:bottom} ${4:left})\",\n\t\"cps\": \"caption-side:top|bottom\",\n\t\"cur\": \"cursor:pointer|auto|default|crosshair|hand|help|move|pointer|text\",\n\t\"d\": \"display:block|none|flex|inline-flex|inline|inline-block|grid|inline-grid|subgrid|list-item|run-in|compact|table|inline-table|table-caption|table-column|table-column-group|table-header-group|table-footer-group|table-row|table-row-group|table-cell|ruby|ruby-base|ruby-base-group|ruby-text|ruby-text-group\",\n\t\"ec\": \"empty-cells:show|hide\",\n\t\"f\": \"font:${1:1em} ${2:sans-serif}\",\n\t\"fd\": \"font-display:auto|block|swap|fallback|optional\",\n\t\"fef\": \"font-effect:none|engrave|emboss|outline\",\n\t\"fem\": \"font-emphasize\",\n\t\"femp\": \"font-emphasize-position:before|after\",\n\t\"fems\": \"font-emphasize-style:none|accent|dot|circle|disc\",\n\t\"ff\": \"font-family:serif|sans-serif|cursive|fantasy|monospace\",\n\t\"fft\": \"font-family:\\\"Times New Roman\\\", Times, Baskerville, Georgia, serif\",\n\t\"ffa\": \"font-family:Arial, \\\"Helvetica Neue\\\", Helvetica, sans-serif\",\n\t\"ffv\": \"font-family:Verdana, Geneva, sans-serif\",\n\t\"fl\": \"float:left|right|none\",\n\t\"fs\": \"font-style:italic|normal|oblique\",\n\t\"fsm\": \"font-smoothing:antialiased|subpixel-antialiased|none\",\n\t\"fst\": \"font-stretch:normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded\",\n\t\"fv\": \"font-variant:normal|small-caps\",\n\t\"fvs\": \"font-variation-settings:normal|inherit|initial|unset\",\n\t\"fw\": \"font-weight:normal|bold|bolder|lighter\",\n\t\"fx\": \"flex\",\n\t\"fxb\": \"flex-basis:fill|max-content|min-content|fit-content|content\",\n\t\"fxd\": \"flex-direction:row|row-reverse|column|column-reverse\",\n\t\"fxf\": \"flex-flow\",\n\t\"fxg\": \"flex-grow\",\n\t\"fxsh\": \"flex-shrink\",\n\t\"fxw\": \"flex-wrap:nowrap|wrap|wrap-reverse\",\n\t\"fsz\": \"font-size\",\n\t\"fsza\": \"font-size-adjust\",\n\t\"gtc\": \"grid-template-columns:repeat()|minmax()\",\n\t\"gtr\": \"grid-template-rows:repeat()|minmax()\",\n\t\"gta\": \"grid-template-areas\",\n\t\"gt\": \"grid-template\",\n\t\"gg\": \"grid-gap\",\n\t\"gcg\": \"grid-column-gap\",\n\t\"grg\": \"grid-row-gap\",\n\t\"gac\": \"grid-auto-columns:auto|minmax()\",\n\t\"gar\": \"grid-auto-rows:auto|minmax()\",\n\t\"gaf\": \"grid-auto-flow:row|column|dense|inherit|initial|unset\",\n\t\"gd\": \"grid\",\n\t\"gc\": \"grid-column\",\n\t\"gcs\": \"grid-column-start\",\n\t\"gce\": \"grid-column-end\",\n\t\"gr\": \"grid-row\",\n\t\"grs\": \"grid-row-start\",\n\t\"gre\": \"grid-row-end\",\n\t\"ga\": \"grid-area\",\n\t\"h\": \"height\",\n\t\"jc\": \"justify-content:start|end|stretch|flex-start|flex-end|center|space-between|space-around|space-evenly\",\n\t\"ji\": \"justify-items:start|end|center|stretch\",\n\t\"js\": \"justify-self:start|end|center|stretch\",\n\t\"l\": \"left\",\n\t\"lg\": \"background-image:linear-gradient(${1})\",\n\t\"lh\": \"line-height\",\n\t\"lis\": \"list-style\",\n\t\"lisi\": \"list-style-image\",\n\t\"lisp\": \"list-style-position:inside|outside\",\n\t\"list\": \"list-style-type:disc|circle|square|decimal|decimal-leading-zero|lower-roman|upper-roman\",\n\t\"lts\": \"letter-spacing:normal\",\n\t\"m\": \"margin\",\n\t\"mah\": \"max-height\",\n\t\"mar\": \"max-resolution\",\n\t\"maw\": \"max-width\",\n\t\"mb\": \"margin-bottom\",\n\t\"mih\": \"min-height\",\n\t\"mir\": \"min-resolution\",\n\t\"miw\": \"min-width\",\n\t\"ml\": \"margin-left\",\n\t\"mr\": \"margin-right\",\n\t\"mt\": \"margin-top\",\n\t\"ol\": \"outline\",\n\t\"olc\": \"outline-color:${1:#000}|invert\",\n\t\"olo\": \"outline-offset\",\n\t\"ols\": \"outline-style:none|dotted|dashed|solid|double|groove|ridge|inset|outset\",\n\t\"olw\": \"outline-width|thin|medium|thick\",\n\t\"op|opa\": \"opacity\",\n\t\"ord\": \"order\",\n\t\"ori\": \"orientation:landscape|portrait\",\n\t\"orp\": \"orphans\",\n\t\"ov\": \"overflow:hidden|visible|hidden|scroll|auto\",\n\t\"ovs\": \"overflow-style:scrollbar|auto|scrollbar|panner|move|marquee\",\n\t\"ovx\": \"overflow-x:hidden|visible|hidden|scroll|auto\",\n\t\"ovy\": \"overflow-y:hidden|visible|hidden|scroll|auto\",\n\t\"p\": \"padding\",\n\t\"pb\": \"padding-bottom\",\n\t\"pgba\": \"page-break-after:auto|always|left|right\",\n\t\"pgbb\": \"page-break-before:auto|always|left|right\",\n\t\"pgbi\": \"page-break-inside:auto|avoid\",\n\t\"pl\": \"padding-left\",\n\t\"pos\": \"position:relative|absolute|relative|fixed|static\",\n\t\"pr\": \"padding-right\",\n\t\"pt\": \"padding-top\",\n\t\"q\": \"quotes\",\n\t\"qen\": \"quotes:'\\\\201C' '\\\\201D' '\\\\2018' '\\\\2019'\",\n\t\"qru\": \"quotes:'\\\\00AB' '\\\\00BB' '\\\\201E' '\\\\201C'\",\n\t\"r\": \"right\",\n\t\"rsz\": \"resize:none|both|horizontal|vertical\",\n\t\"t\": \"top\",\n\t\"ta\": \"text-align:left|center|right|justify\",\n\t\"tal\": \"text-align-last:left|center|right\",\n\t\"tbl\": \"table-layout:fixed\",\n\t\"td\": \"text-decoration:none|underline|overline|line-through\",\n\t\"te\": \"text-emphasis:none|accent|dot|circle|disc|before|after\",\n\t\"th\": \"text-height:auto|font-size|text-size|max-size\",\n\t\"ti\": \"text-indent\",\n\t\"tj\": \"text-justify:auto|inter-word|inter-ideograph|inter-cluster|distribute|kashida|tibetan\",\n\t\"to\": \"text-outline:${1:0} ${2:0} ${3:#000}\",\n\t\"tov\": \"text-overflow:ellipsis|clip\",\n\t\"tr\": \"text-replace\",\n\t\"trf\": \"transform:${1}|skewX(${1:angle})|skewY(${1:angle})|scale(${1:x}, ${2:y})|scaleX(${1:x})|scaleY(${1:y})|scaleZ(${1:z})|scale3d(${1:x}, ${2:y}, ${3:z})|rotate(${1:angle})|rotateX(${1:angle})|rotateY(${1:angle})|rotateZ(${1:angle})|translate(${1:x}, ${2:y})|translateX(${1:x})|translateY(${1:y})|translateZ(${1:z})|translate3d(${1:tx}, ${2:ty}, ${3:tz})\",\n\t\"trfo\": \"transform-origin\",\n\t\"trfs\": \"transform-style:preserve-3d\",\n\t\"trs\": \"transition:${1:prop} ${2:time}\",\n\t\"trsde\": \"transition-delay:${1:time}\",\n\t\"trsdu\": \"transition-duration:${1:time}\",\n\t\"trsp\": \"transition-property:${1:prop}\",\n\t\"trstf\": \"transition-timing-function:${1:fn}\",\n\t\"tsh\": \"text-shadow:${1:hoff} ${2:voff} ${3:blur} ${4:#000}\",\n\t\"tt\": \"text-transform:uppercase|lowercase|capitalize|none\",\n\t\"tw\": \"text-wrap:none|normal|unrestricted|suppress\",\n\t\"us\": \"user-select:none\",\n\t\"v\": \"visibility:hidden|visible|collapse\",\n\t\"va\": \"vertical-align:top|super|text-top|middle|baseline|bottom|text-bottom|sub\",\n\t\"w\": \"width\",\n\t\"whs\": \"white-space:nowrap|pre|pre-wrap|pre-line|normal\",\n\t\"whsc\": \"white-space-collapse:normal|keep-all|loose|break-strict|break-all\",\n\t\"wid\": \"widows\",\n\t\"wm\": \"writing-mode:lr-tb|lr-tb|lr-bt|rl-tb|rl-bt|tb-rl|tb-lr|bt-lr|bt-rl\",\n\t\"wob\": \"word-break:normal|keep-all|break-all\",\n\t\"wos\": \"word-spacing\",\n\t\"wow\": \"word-wrap:none|unrestricted|suppress|break-word|normal\",\n\t\"z\": \"z-index\",\n\t\"zom\": \"zoom:1\"\n};\n\nvar xslSnippets = {\n \"tm|tmatch\": \"xsl:template[match mode]\",\n \"tn|tname\": \"xsl:template[name]\",\n \"call\": \"xsl:call-template[name]\",\n \"ap\": \"xsl:apply-templates[select mode]\",\n \"api\": \"xsl:apply-imports\",\n \"imp\": \"xsl:import[href]\",\n \"inc\": \"xsl:include[href]\",\n \"ch\": \"xsl:choose\",\n \"wh|xsl:when\": \"xsl:when[test]\",\n \"ot\": \"xsl:otherwise\",\n \"if\": \"xsl:if[test]\",\n \"par\": \"xsl:param[name]\",\n \"pare\": \"xsl:param[name select]\",\n \"var\": \"xsl:variable[name]\",\n \"vare\": \"xsl:variable[name select]\",\n \"wp\": \"xsl:with-param[name select]\",\n \"key\": \"xsl:key[name match use]\",\n \"elem\": \"xsl:element[name]\",\n \"attr\": \"xsl:attribute[name]\",\n \"attrs\": \"xsl:attribute-set[name]\",\n \"cp\": \"xsl:copy[select]\",\n \"co\": \"xsl:copy-of[select]\",\n \"val\": \"xsl:value-of[select]\",\n \"for|each\": \"xsl:for-each[select]\",\n \"tex\": \"xsl:text\",\n \"com\": \"xsl:comment\",\n \"msg\": \"xsl:message[terminate=no]\",\n \"fall\": \"xsl:fallback\",\n \"num\": \"xsl:number[value]\",\n \"nam\": \"namespace-alias[stylesheet-prefix result-prefix]\",\n \"pres\": \"xsl:preserve-space[elements]\",\n \"strip\": \"xsl:strip-space[elements]\",\n \"proc\": \"xsl:processing-instruction[name]\",\n \"sort\": \"xsl:sort[select order]\",\n \"choose\": \"xsl:choose>xsl:when+xsl:otherwise\",\n \"xsl\": \"!!!+xsl:stylesheet[version=1.0 xmlns:xsl=http://www.w3.org/1999/XSL/Transform]>{\\n|}\",\n \"!!!\": \"{}\"\n};\n\nvar pugSnippets = {\n\t\"!!!\": \"{doctype html}\"\n};\n\nvar variables = {\n\t\"lang\": \"en\",\n\t\"locale\": \"en-US\",\n\t\"charset\": \"UTF-8\",\n\t\"indentation\": \"\\t\",\n\t\"newline\": \"\\n\"\n};\n\n/**\n * Default syntaxes for abbreviation types\n */\nconst defaultSyntaxes = {\n markup: 'html',\n stylesheet: 'css'\n};\nconst defaultOptions = {\n 'inlineElements': [\n 'a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo',\n 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i',\n 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'object', 'q',\n 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup',\n 'textarea', 'tt', 'u', 'var'\n ],\n 'output.indent': '\\t',\n 'output.baseIndent': '',\n 'output.newline': '\\n',\n 'output.tagCase': '',\n 'output.attributeCase': '',\n 'output.attributeQuotes': 'double',\n 'output.format': true,\n 'output.formatLeafNode': false,\n 'output.formatSkip': ['html'],\n 'output.formatForce': ['body'],\n 'output.inlineBreak': 3,\n 'output.compactBoolean': false,\n 'output.booleanAttributes': [\n 'contenteditable', 'seamless', 'async', 'autofocus',\n 'autoplay', 'checked', 'controls', 'defer', 'disabled', 'formnovalidate',\n 'hidden', 'ismap', 'loop', 'multiple', 'muted', 'novalidate', 'readonly',\n 'required', 'reversed', 'selected', 'typemustmatch'\n ],\n 'output.reverseAttributes': false,\n 'output.selfClosingStyle': 'html',\n 'output.field': (index, placeholder) => placeholder,\n 'output.text': text => text,\n 'markup.href': true,\n 'comment.enabled': false,\n 'comment.trigger': ['id', 'class'],\n 'comment.before': '',\n 'comment.after': '\\n',\n 'bem.enabled': false,\n 'bem.element': '__',\n 'bem.modifier': '_',\n 'jsx.enabled': false,\n 'stylesheet.keywords': ['auto', 'inherit', 'unset', 'none'],\n 'stylesheet.unitless': ['z-index', 'line-height', 'opacity', 'font-weight', 'zoom', 'flex', 'flex-grow', 'flex-shrink'],\n 'stylesheet.shortHex': true,\n 'stylesheet.between': ': ',\n 'stylesheet.after': ';',\n 'stylesheet.intUnit': 'px',\n 'stylesheet.floatUnit': 'em',\n 'stylesheet.unitAliases': { e: 'em', p: '%', x: 'ex', r: 'rem' },\n 'stylesheet.json': false,\n 'stylesheet.jsonDoubleQuotes': false,\n 'stylesheet.fuzzySearchMinScore': 0\n};\nconst defaultConfig = {\n type: 'markup',\n syntax: 'html',\n variables,\n snippets: {},\n options: defaultOptions\n};\n/**\n * Default per-syntax config\n */\nconst syntaxConfig = {\n markup: {\n snippets: parseSnippets(markupSnippets),\n },\n xhtml: {\n options: {\n 'output.selfClosingStyle': 'xhtml'\n }\n },\n xml: {\n options: {\n 'output.selfClosingStyle': 'xml'\n }\n },\n xsl: {\n snippets: parseSnippets(xslSnippets),\n options: {\n 'output.selfClosingStyle': 'xml'\n }\n },\n jsx: {\n options: {\n 'jsx.enabled': true\n }\n },\n pug: {\n snippets: parseSnippets(pugSnippets)\n },\n stylesheet: {\n snippets: parseSnippets(stylesheetSnippets)\n },\n sass: {\n options: {\n 'stylesheet.after': ''\n }\n },\n stylus: {\n options: {\n 'stylesheet.between': ' ',\n 'stylesheet.after': '',\n }\n }\n};\n/**\n * Parses raw snippets definitions with possibly multiple keys into a plan\n * snippet map\n */\nfunction parseSnippets(snippets) {\n const result = {};\n Object.keys(snippets).forEach(k => {\n for (const name of k.split('|')) {\n result[name] = snippets[k];\n }\n });\n return result;\n}\nfunction resolveConfig(config = {}, globals = {}) {\n const type = config.type || 'markup';\n const syntax = config.syntax || defaultSyntaxes[type];\n return Object.assign(Object.assign(Object.assign({}, defaultConfig), config), { type,\n syntax, variables: mergedData(type, syntax, 'variables', config, globals), snippets: mergedData(type, syntax, 'snippets', config, globals), options: mergedData(type, syntax, 'options', config, globals) });\n}\nfunction mergedData(type, syntax, key, config, globals = {}) {\n const typeDefaults = syntaxConfig[type];\n const typeOverride = globals[type];\n const syntaxDefaults = syntaxConfig[syntax];\n const syntaxOverride = globals[syntax];\n return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultConfig[key]), (typeDefaults && typeDefaults[key])), (syntaxDefaults && syntaxDefaults[key])), (typeOverride && typeOverride[key])), (syntaxOverride && syntaxOverride[key])), config[key]);\n}\n\n/**\n * Creates structure for scanning given string in backward direction\n */\nfunction backwardScanner(text, start = 0) {\n return { text, start, pos: text.length };\n}\n/**\n * Check if given scanner position is at start of scanned text\n */\nfunction sol(scanner) {\n return scanner.pos === scanner.start;\n}\n/**\n * “Peeks” character code an current scanner location without advancing it\n */\nfunction peek$1(scanner, offset = 0) {\n return scanner.text.charCodeAt(scanner.pos - 1 + offset);\n}\n/**\n * Returns current character code and moves character location one symbol back\n */\nfunction previous(scanner) {\n if (!sol(scanner)) {\n return scanner.text.charCodeAt(--scanner.pos);\n }\n}\n/**\n * Consumes current character code if it matches given `match` code or function\n */\nfunction consume(scanner, match) {\n if (sol(scanner)) {\n return false;\n }\n const ok = typeof match === 'function'\n ? match(peek$1(scanner))\n : match === peek$1(scanner);\n if (ok) {\n scanner.pos--;\n }\n return !!ok;\n}\nfunction consumeWhile(scanner, match) {\n const start = scanner.pos;\n while (consume(scanner, match)) {\n // empty\n }\n return scanner.pos < start;\n}\n\n/**\n * Check if given character code is a quote\n */\nfunction isQuote(c) {\n return c === 39 /* SingleQuote */ || c === 34 /* DoubleQuote */;\n}\n/**\n * Consumes quoted value, if possible\n * @return Returns `true` is value was consumed\n */\nfunction consumeQuoted(scanner) {\n const start = scanner.pos;\n const quote = previous(scanner);\n if (isQuote(quote)) {\n while (!sol(scanner)) {\n if (previous(scanner) === quote && peek$1(scanner) !== 92 /* Escape */) {\n return true;\n }\n }\n }\n scanner.pos = start;\n return false;\n}\n\nconst bracePairs = {\n [91 /* SquareL */]: 93 /* SquareR */,\n [40 /* RoundL */]: 41 /* RoundR */,\n [123 /* CurlyL */]: 125 /* CurlyR */,\n};\n\n/**\n * Check if given reader’s current position points at the end of HTML tag\n */\nfunction isHtml(scanner) {\n const start = scanner.pos;\n if (!consume(scanner, 62 /* AngleRight */)) {\n return false;\n }\n let ok = false;\n consume(scanner, 47 /* Slash */); // possibly self-closed element\n while (!sol(scanner)) {\n consumeWhile(scanner, isWhiteSpace);\n if (consumeIdent(scanner)) {\n // ate identifier: could be a tag name, boolean attribute or unquoted\n // attribute value\n if (consume(scanner, 47 /* Slash */)) {\n // either closing tag or invalid tag\n ok = consume(scanner, 60 /* AngleLeft */);\n break;\n }\n else if (consume(scanner, 60 /* AngleLeft */)) {\n // opening tag\n ok = true;\n break;\n }\n else if (consume(scanner, isWhiteSpace)) {\n // boolean attribute\n continue;\n }\n else if (consume(scanner, 61 /* Equals */)) {\n // simple unquoted value or invalid attribute\n if (consumeIdent(scanner)) {\n continue;\n }\n break;\n }\n else if (consumeAttributeWithUnquotedValue(scanner)) {\n // identifier was a part of unquoted value\n ok = true;\n break;\n }\n // invalid tag\n break;\n }\n if (consumeAttribute(scanner)) {\n continue;\n }\n break;\n }\n scanner.pos = start;\n return ok;\n}\n/**\n * Consumes HTML attribute from given string.\n * @return `true` if attribute was consumed.\n */\nfunction consumeAttribute(scanner) {\n return consumeAttributeWithQuotedValue(scanner) || consumeAttributeWithUnquotedValue(scanner);\n}\nfunction consumeAttributeWithQuotedValue(scanner) {\n const start = scanner.pos;\n if (consumeQuoted(scanner) && consume(scanner, 61 /* Equals */) && consumeIdent(scanner)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\nfunction consumeAttributeWithUnquotedValue(scanner) {\n const start = scanner.pos;\n const stack = [];\n while (!sol(scanner)) {\n const ch = peek$1(scanner);\n if (isCloseBracket(ch)) {\n stack.push(ch);\n }\n else if (isOpenBracket(ch)) {\n if (stack.pop() !== bracePairs[ch]) {\n // Unexpected open bracket\n break;\n }\n }\n else if (!isUnquotedValue(ch)) {\n break;\n }\n scanner.pos--;\n }\n if (start !== scanner.pos && consume(scanner, 61 /* Equals */) && consumeIdent(scanner)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Consumes HTML identifier from stream\n */\nfunction consumeIdent(scanner) {\n return consumeWhile(scanner, isIdent);\n}\n/**\n * Check if given character code belongs to HTML identifier\n */\nfunction isIdent(ch) {\n return ch === 58 /* Colon */ || ch === 45 /* Dash */ || isAlpha(ch) || isNumber(ch);\n}\n/**\n * Check if given character code is alpha code (letter though A to Z)\n */\nfunction isAlpha(ch) {\n ch &= ~32; // quick hack to convert any char code to uppercase char code\n return ch >= 65 && ch <= 90; // A-Z\n}\n/**\n * Check if given code is a number\n */\nfunction isNumber(ch) {\n return ch > 47 && ch < 58;\n}\n/**\n * Check if given code is a whitespace\n */\nfunction isWhiteSpace(ch) {\n return ch === 32 /* Space */ || ch === 9 /* Tab */;\n}\n/**\n * Check if given code may belong to unquoted attribute value\n */\nfunction isUnquotedValue(ch) {\n return !isNaN(ch) && ch !== 61 /* Equals */ && !isWhiteSpace(ch) && !isQuote(ch);\n}\nfunction isOpenBracket(ch) {\n return ch === 123 /* CurlyL */ || ch === 40 /* RoundL */ || ch === 91 /* SquareL */;\n}\nfunction isCloseBracket(ch) {\n return ch === 125 /* CurlyR */ || ch === 41 /* RoundR */ || ch === 93 /* SquareR */;\n}\n\nconst code = (ch) => ch.charCodeAt(0);\nconst specialChars = '#.*:$-_!@%^+>/'.split('').map(code);\nconst defaultOptions$1 = {\n type: 'markup',\n lookAhead: true,\n prefix: ''\n};\n/**\n * Extracts Emmet abbreviation from given string.\n * The goal of this module is to extract abbreviation from current editor’s line,\n * e.g. like this: `.foo[title=bar|]` -> `.foo[title=bar]`, where\n * `|` is a current caret position.\n * @param line A text line where abbreviation should be expanded\n * @param pos Caret position in line. If not given, uses end of line\n * @param options Extracting options\n */\nfunction extractAbbreviation(line, pos = line.length, options = {}) {\n // make sure `pos` is within line range\n const opt = Object.assign(Object.assign({}, defaultOptions$1), options);\n pos = Math.min(line.length, Math.max(0, pos == null ? line.length : pos));\n if (opt.lookAhead) {\n pos = offsetPastAutoClosed(line, pos, opt);\n }\n let ch;\n const start = getStartOffset(line, pos, opt.prefix || '');\n if (start === -1) {\n return void 0;\n }\n const scanner = backwardScanner(line, start);\n scanner.pos = pos;\n const stack = [];\n while (!sol(scanner)) {\n ch = peek$1(scanner);\n if (stack.includes(125 /* CurlyR */)) {\n if (ch === 125 /* CurlyR */) {\n stack.push(ch);\n scanner.pos--;\n continue;\n }\n if (ch !== 123 /* CurlyL */) {\n scanner.pos--;\n continue;\n }\n }\n if (isCloseBrace(ch, opt.type)) {\n stack.push(ch);\n }\n else if (isOpenBrace(ch, opt.type)) {\n if (stack.pop() !== bracePairs[ch]) {\n // unexpected brace\n break;\n }\n }\n else if (stack.includes(93 /* SquareR */) || stack.includes(125 /* CurlyR */)) {\n // respect all characters inside attribute sets or text nodes\n scanner.pos--;\n continue;\n }\n else if (isHtml(scanner) || !isAbbreviation(ch)) {\n break;\n }\n scanner.pos--;\n }\n if (!stack.length && scanner.pos !== pos) {\n // Found something, remove some invalid symbols from the\n // beginning and return abbreviation\n const abbreviation = line.slice(scanner.pos, pos).replace(/^[*+>^]+/, '');\n return {\n abbreviation,\n location: pos - abbreviation.length,\n start: options.prefix\n ? start - options.prefix.length\n : pos - abbreviation.length,\n end: pos\n };\n }\n}\n/**\n * Returns new `line` index which is right after characters beyound `pos` that\n * editor will likely automatically close, e.g. }, ], and quotes\n */\nfunction offsetPastAutoClosed(line, pos, options) {\n // closing quote is allowed only as a next character\n if (isQuote(line.charCodeAt(pos))) {\n pos++;\n }\n // offset pointer until non-autoclosed character is found\n while (isCloseBrace(line.charCodeAt(pos), options.type)) {\n pos++;\n }\n return pos;\n}\n/**\n * Returns start offset (left limit) in `line` where we should stop looking for\n * abbreviation: it’s nearest to `pos` location of `prefix` token\n */\nfunction getStartOffset(line, pos, prefix) {\n if (!prefix) {\n return 0;\n }\n const scanner = backwardScanner(line);\n const compiledPrefix = prefix.split('').map(code);\n scanner.pos = pos;\n let result;\n while (!sol(scanner)) {\n if (consumePair(scanner, 93 /* SquareR */, 91 /* SquareL */) || consumePair(scanner, 125 /* CurlyR */, 123 /* CurlyL */)) {\n continue;\n }\n result = scanner.pos;\n if (consumeArray(scanner, compiledPrefix)) {\n return result;\n }\n scanner.pos--;\n }\n return -1;\n}\n/**\n * Consumes full character pair, if possible\n */\nfunction consumePair(scanner, close, open) {\n const start = scanner.pos;\n if (consume(scanner, close)) {\n while (!sol(scanner)) {\n if (consume(scanner, open)) {\n return true;\n }\n scanner.pos--;\n }\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Consumes all character codes from given array, right-to-left, if possible\n */\nfunction consumeArray(scanner, arr) {\n const start = scanner.pos;\n let consumed = false;\n for (let i = arr.length - 1; i >= 0 && !sol(scanner); i--) {\n if (!consume(scanner, arr[i])) {\n break;\n }\n consumed = i === 0;\n }\n if (!consumed) {\n scanner.pos = start;\n }\n return consumed;\n}\nfunction isAbbreviation(ch) {\n return (ch > 64 && ch < 91) // uppercase letter\n || (ch > 96 && ch < 123) // lowercase letter\n || (ch > 47 && ch < 58) // number\n || specialChars.includes(ch); // special character\n}\nfunction isOpenBrace(ch, syntax) {\n return ch === 40 /* RoundL */ || (syntax === 'markup' && (ch === 91 /* SquareL */ || ch === 123 /* CurlyL */));\n}\nfunction isCloseBrace(ch, syntax) {\n return ch === 41 /* RoundR */ || (syntax === 'markup' && (ch === 93 /* SquareR */ || ch === 125 /* CurlyR */));\n}\n\nfunction expandAbbreviation(abbr, config) {\n const resolvedConfig = resolveConfig(config);\n return resolvedConfig.type === 'stylesheet'\n ? stylesheet(abbr, resolvedConfig)\n : markup(abbr, resolvedConfig);\n}\n/**\n * Expands given *markup* abbreviation (e.g. regular Emmet abbreviation that\n * produces structured output like HTML) and outputs it according to options\n * provided in config\n */\nfunction markup(abbr, config) {\n return stringify(parse(abbr, config), config);\n}\n/**\n * Expands given *stylesheet* abbreviation (a special Emmet abbreviation designed for\n * stylesheet languages like CSS, SASS etc.) and outputs it according to options\n * provided in config\n */\nfunction stylesheet(abbr, config) {\n return css(parse$1(abbr, config), config);\n}\n\nexport default expandAbbreviation;\nexport { extractAbbreviation as extract, markup, parse as parseMarkup, parse$1 as parseStylesheet, convertSnippets as parseStylesheetSnippets, resolveConfig, stringify as stringifyMarkup, css as stringifyStylesheet, stylesheet };\n//# sourceMappingURL=emmet.es.js.map\n","import { scan, attributes, createOptions } from '@emmetio/html-matcher';\nimport { scan as scan$1, splitValue } from '@emmetio/css-matcher';\nimport expand, { stylesheetAbbreviation, markupAbbreviation } from 'emmet';\n\nconst pairs = {\n '{': '}',\n '[': ']',\n '(': ')'\n};\nconst pairsEnd = [];\nfor (const key of Object.keys(pairs)) {\n pairsEnd.push(pairs[key]);\n}\n/**\n * Returns `true` if given character code is a space\n */\nfunction isSpace(code) {\n return code === 32 /* space */\n || code === 9 /* tab */\n || code === 160 /* non-breaking space */\n || code === 10 /* LF */\n || code === 13; /* CR */\n}\nfunction pushRange(ranges, range) {\n const prev = ranges[ranges.length - 1];\n if (range && range[0] !== range[1] && (!prev || prev[0] !== range[0] || prev[1] !== range[1])) {\n ranges.push(range);\n }\n}\n/**\n * Returns ranges of tokens in given value. Tokens are space-separated words.\n */\nfunction tokenList(value, offset = 0) {\n const ranges = [];\n const len = value.length;\n let pos = 0;\n let start = 0;\n let end = 0;\n while (pos < len) {\n end = pos;\n const ch = value.charCodeAt(pos++);\n if (isSpace(ch)) {\n if (start !== end) {\n ranges.push([offset + start, offset + end]);\n }\n while (isSpace(value.charCodeAt(pos))) {\n pos++;\n }\n start = pos;\n }\n }\n if (start !== pos) {\n ranges.push([offset + start, offset + pos]);\n }\n return ranges;\n}\n/**\n * Check if given character is a quote\n */\nfunction isQuote(ch) {\n return ch === '\"' || ch === '\\'';\n}\n/**\n * Returns value of given attribute, parsed by Emmet HTML matcher\n */\nfunction attributeValue(attr) {\n const { value } = attr;\n return value && isQuoted(value)\n ? value.slice(1, -1)\n : value;\n}\nfunction attributeValueRange(tag, attr, offset = 0) {\n let valueStart = attr.valueStart;\n let valueEnd = attr.valueEnd;\n if (isQuote(tag[valueStart])) {\n valueStart++;\n }\n if (isQuote(tag[valueEnd - 1]) && valueEnd > valueStart) {\n valueEnd--;\n }\n return [offset + valueStart, offset + valueEnd];\n}\n/**\n * Check if given value is either quoted or written as expression\n */\nfunction isQuoted(value) {\n return !!value && (isQuotedString(value) || isExprString(value));\n}\n/**\n * Check if given string is quoted with single or double quotes\n */\nfunction isQuotedString(str) {\n return str.length > 1 && isQuote(str[0]) && str[0] === str.slice(-1);\n}\n/**\n * Check if given string contains expression, e.g. wrapped with `{` and `}`\n */\nfunction isExprString(str) {\n return str[0] === '{' && str.slice(-1) === '}';\n}\n/**\n * Returns last element of given array\n */\nfunction last(arr) {\n return arr.length > 0 ? arr[arr.length - 1] : undefined;\n}\n\n/**\n * Check if there’s open or self-closing tag under given `pos` location in source code.\n * If found, returns its name, range in source and parsed attributes\n */\nfunction getOpenTag(code, pos) {\n let tag = void 0;\n // Find open or self-closing tag, closest to given position\n scan(code, (name, type, start, end) => {\n if (start < pos && end > pos) {\n tag = { name, type, start, end };\n if (type === 1 /* Open */ || type === 3 /* SelfClose */) {\n tag.attributes = shiftAttributeRanges(attributes(code.slice(start, end), name), start);\n }\n return false;\n }\n if (end > pos) {\n return false;\n }\n });\n return tag;\n}\n/**\n * Returns list of matched tags in given source code\n */\nfunction getTagMatches(code, options) {\n const opt = createOptions(options);\n const stack = [];\n const result = [];\n scan(code, (name, type, start, end) => {\n if (type === 3 /* SelfClose */) {\n result.push({ name, open: [start, end] });\n }\n else if (type === 1 /* Open */) {\n const item = { name, open: [start, end] };\n stack.push(item);\n result.push(item);\n }\n else {\n // Handle closing tag\n while (stack.length) {\n const item = stack.pop();\n if (item.name === name) {\n item.close = [start, end];\n break;\n }\n }\n }\n }, opt);\n return result;\n}\n/**\n * Finds tag match for given position\n */\nfunction findTagMatch(source, pos, options) {\n if (typeof source === 'string') {\n source = getTagMatches(source, options);\n }\n let candidate;\n source.some(match => {\n const start = match.open[0];\n const end = match.close ? match.close[1] : match.open[1];\n if (pos < start) {\n // All the following tags will be after given position, stop searching\n return true;\n }\n if (pos > start && pos < end) {\n candidate = match;\n }\n });\n return candidate;\n}\n/**\n * Returns list of ranges for Select Next/Previous Item action\n */\nfunction selectItemHTML(code, pos, isPrev) {\n return isPrev ? selectPreviousItem(code, pos) : selectNextItem(code, pos);\n}\n/**\n * Returns list of ranges for Select Next Item action\n */\nfunction selectNextItem(code, pos) {\n let result = void 0;\n // Find open or self-closing tag, closest to given position\n scan(code, (name, type, start, end) => {\n if ((type === 1 /* Open */ || type === 3 /* SelfClose */) && end > pos) {\n // Found open or self-closing tag\n result = getTagSelectionModel(code, name, start, end);\n return false;\n }\n });\n return result;\n}\n/**\n * Returns list of ranges for Select Previous Item action\n */\nfunction selectPreviousItem(code, pos) {\n let lastType = null;\n let lastName = '';\n let lastStart = -1;\n let lastEnd = -1;\n // We should find the closest open or self-closing tag left to given `pos`.\n scan(code, (name, type, start, end) => {\n if (start >= pos) {\n return false;\n }\n if (type === 1 /* Open */ || type === 3 /* SelfClose */) {\n // Found open or self-closing tag\n lastName = name;\n lastType = type;\n lastStart = start;\n lastEnd = end;\n }\n });\n if (lastType !== null) {\n return getTagSelectionModel(code, lastName, lastStart, lastEnd);\n }\n}\n/**\n * Parses open or self-closing tag in `start:end` range of `code` and returns its\n * model for selecting items\n * @param code Document source code\n * @param name Name of matched tag\n */\nfunction getTagSelectionModel(code, name, start, end) {\n const ranges = [\n // Add tag name range\n [start + 1, start + 1 + name.length]\n ];\n // Parse and add attributes ranges\n const tagSrc = code.slice(start, end);\n for (const attr of attributes(tagSrc, name)) {\n if (attr.value != null) {\n // Attribute with value\n pushRange(ranges, [start + attr.nameStart, start + attr.valueEnd]);\n // Add (unquoted) value range\n const val = valueRange(attr);\n if (val[0] !== val[1]) {\n pushRange(ranges, [start + val[0], start + val[1]]);\n if (attr.name === 'class') {\n // For class names, split value into space-separated tokens\n const tokens = tokenList(tagSrc.slice(val[0], val[1]), start + val[0]);\n for (const token of tokens) {\n pushRange(ranges, token);\n }\n }\n }\n }\n else {\n // Attribute without value (boolean)\n pushRange(ranges, [start + attr.nameStart, start + attr.nameEnd]);\n }\n }\n return { start, end, ranges };\n}\n/**\n * Returns value range of given attribute. Value range is unquoted.\n */\nfunction valueRange(attr) {\n const value = attr.value;\n const ch = value[0];\n const lastCh = value[value.length - 1];\n if (ch === '\"' || ch === '\\'') {\n return [\n attr.valueStart + 1,\n attr.valueEnd - (lastCh === ch ? 1 : 0)\n ];\n }\n if (ch === '{' && lastCh === '}') {\n return [\n attr.valueStart + 1,\n attr.valueEnd - 1\n ];\n }\n return [attr.valueStart, attr.valueEnd];\n}\nfunction shiftAttributeRanges(attrs, offset) {\n attrs.forEach(attr => {\n attr.nameStart += offset;\n attr.nameEnd += offset;\n if ('value' in attr) {\n attr.valueStart += offset;\n attr.valueEnd += offset;\n }\n });\n return attrs;\n}\n\n/**\n * Returns context CSS section for given location in source code\n * @param properties Parse inner properties\n */\nfunction getCSSSection(code, pos, properties) {\n const stack = [];\n const pool = [];\n let result;\n scan$1(code, (type, start, end, delimiter) => {\n if (start > pos && !stack.length) {\n return false;\n }\n if (type === \"selector\" /* Selector */) {\n stack.push(allocRange(pool, start, end, delimiter));\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n const sel = stack.pop();\n if (sel && sel[0] <= pos && pos <= end) {\n result = {\n start: sel[0],\n end,\n bodyStart: sel[2] + 1,\n bodyEnd: start\n };\n return false;\n }\n releaseRange(pool, sel);\n }\n });\n if (result && properties) {\n result.properties = parseProperties(code, result.bodyStart, result.bodyEnd);\n }\n return result;\n}\n/**\n * Returns list of ranges for Select Next/Previous CSS Item action\n */\nfunction selectItemCSS(code, pos, isPrev) {\n return isPrev ? selectPreviousItem$1(code, pos) : selectNextItem$1(code, pos);\n}\n/**\n * Returns regions for selecting next item in CSS\n */\nfunction selectNextItem$1(code, pos) {\n let result = void 0;\n let pendingProperty = void 0;\n scan$1(code, (type, start, end, delimiter) => {\n if (start < pos) {\n return;\n }\n if (type === \"selector\" /* Selector */) {\n result = { start, end, ranges: [[start, end]] };\n return false;\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n pendingProperty = [start, end, delimiter];\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n result = {\n start,\n end: delimiter !== -1 ? delimiter + 1 : end,\n ranges: []\n };\n if (pendingProperty) {\n // Full property range\n result.start = pendingProperty[0];\n pushRange(result.ranges, [pendingProperty[0], result.end]);\n }\n // Full value range\n pushRange(result.ranges, [start, end]);\n // Value fragments\n for (const r of splitValue(code.substring(start, end))) {\n pushRange(result.ranges, [r[0] + start, r[1] + start]);\n }\n return false;\n }\n else if (pendingProperty) {\n result = {\n start: pendingProperty[0],\n end: pendingProperty[1],\n ranges: [[pendingProperty[0], pendingProperty[1]]]\n };\n return false;\n }\n });\n return result;\n}\n/**\n * Returns regions for selecting previous item in CSS\n */\nfunction selectPreviousItem$1(code, pos) {\n const state = {\n type: null,\n start: -1,\n end: -1,\n valueStart: -1,\n valueEnd: -1,\n valueDelimiter: -1,\n };\n scan$1(code, (type, start, end, delimiter) => {\n // Accumulate context until we reach given position\n if (start >= pos && type !== \"propertyValue\" /* PropertyValue */) {\n return false;\n }\n if (type === \"selector\" /* Selector */ || type === \"propertyName\" /* PropertyName */) {\n state.start = start;\n state.end = end;\n state.type = type;\n state.valueStart = state.valueEnd = state.valueDelimiter = -1;\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n state.valueStart = start;\n state.valueEnd = end;\n state.valueDelimiter = delimiter;\n }\n });\n if (state.type === \"selector\" /* Selector */) {\n return {\n start: state.start,\n end: state.end,\n ranges: [[state.start, state.end]]\n };\n }\n if (state.type === \"propertyName\" /* PropertyName */) {\n const result = {\n start: state.start,\n end: state.end,\n ranges: []\n };\n if (state.valueStart !== -1) {\n result.end = state.valueDelimiter !== -1 ? state.valueDelimiter + 1 : state.valueEnd;\n // Full property range\n pushRange(result.ranges, [state.start, result.end]);\n // Full value range\n pushRange(result.ranges, [state.valueStart, state.valueEnd]);\n // Value fragments\n for (const r of splitValue(code.substring(state.valueStart, state.valueEnd))) {\n pushRange(result.ranges, [r[0] + state.valueStart, r[1] + state.valueStart]);\n }\n }\n else {\n pushRange(result.ranges, [state.start, state.end]);\n }\n return result;\n }\n}\n/**\n * Parses properties in `from:to` fragment of `code`. Note that `from:to` must\n * point to CSS section content, e.g. *inside* `{` and `}` (or top-level code context),\n * all properties found in nested sections will be ignored\n */\nfunction parseProperties(code, from = 0, to = code.length) {\n const fragment = code.substring(from, to);\n const result = [];\n const pool = [];\n let pendingName;\n let nested = 0;\n let before = from;\n scan$1(fragment, (type, start, end, delimiter) => {\n if (type === \"selector\" /* Selector */) {\n nested++;\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n nested--;\n before = from + end;\n }\n else if (!nested) {\n if (type === \"propertyName\" /* PropertyName */) {\n if (pendingName) {\n // Create property with empty value\n const valuePos = pendingName[2];\n result.push(createProperty(fragment, pendingName, before, valuePos, valuePos, valuePos, from));\n releaseRange(pool, pendingName);\n before = from + start;\n }\n pendingName = allocRange(pool, start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (pendingName) {\n result.push(createProperty(fragment, pendingName, before, start, end, delimiter, from));\n releaseRange(pool, pendingName);\n pendingName = void 0;\n }\n before = from + delimiter + 1;\n }\n }\n });\n return result;\n}\nfunction createProperty(code, name, before, start, end, delimiter, offset = 0) {\n return {\n name: [offset + name[0], offset + name[1]],\n value: [offset + start, offset + end],\n valueTokens: splitValue(code.substring(start, end), offset + start),\n before,\n after: offset + delimiter + 1,\n };\n}\n/**\n * Allocates new token range from pool\n */\nfunction allocRange(pool, start, end, delimiter) {\n if (pool.length) {\n const range = pool.pop();\n range[0] = start;\n range[1] = end;\n range[2] = delimiter;\n return range;\n }\n return [start, end, delimiter];\n}\n/**\n * Releases given token range and pushes it back into the pool\n */\nfunction releaseRange(pool, range) {\n range && pool.push(range);\n return null;\n}\n\n/**\n * Returns HTML context for given location in source code\n */\nfunction getHTMLContext(code, pos, opt = {}) {\n const result = {\n type: 'html',\n ancestors: [],\n current: null,\n css: null\n };\n // Since we expect large input document, we’ll use pooling technique\n // for storing tag data to reduce memory pressure and improve performance\n const pool = [];\n const stack = [];\n const options = createOptions({ xml: opt.xml, allTokens: true });\n scan(code, (name, type, start, end) => {\n if (start >= pos) {\n // Moved beyond location, stop parsing\n return false;\n }\n if (start < pos && pos < end) {\n // Direct hit on element\n result.current = { name, type, range: [start, end] };\n return false;\n }\n if (type === 1 /* Open */ && isSelfClose(name, options)) {\n // Found empty element in HTML mode, mark is as self-closing\n type = 3 /* SelfClose */;\n }\n if (type === 1 /* Open */) {\n // Allocate tag object from pool\n stack.push(allocItem(pool, name, type, start, end));\n }\n else if (type === 2 /* Close */ && stack.length && last(stack).name === name) {\n // Release tag object for further re-use\n releaseItem(pool, stack.pop());\n }\n }, options);\n // Record stack elements as ancestors\n stack.forEach(item => {\n result.ancestors.push({\n name: item.name,\n range: [item.start, item.end]\n });\n });\n if (!opt.skipCSS) {\n // Detect if position is inside CSS context\n result.css = detectCSSContextFromHTML(code, pos, result);\n }\n return result;\n}\n/**\n * Returns CSS context for given location in source code\n */\nfunction getCSSContext(code, pos, embedded) {\n const result = {\n type: 'css',\n ancestors: [],\n current: null,\n inline: false,\n embedded\n };\n const pool = [];\n const stack = [];\n scan$1(code, (type, start, end) => {\n if (start >= pos) {\n // Token behind specified location, stop parsing\n return false;\n }\n if (start < pos && pos <= end) {\n // Direct hit on token\n result.current = {\n name: code.slice(start, end),\n type,\n range: [start, end]\n };\n return false;\n }\n switch (type) {\n case \"selector\" /* Selector */:\n case \"propertyName\" /* PropertyName */:\n stack.push(allocItem(pool, code.slice(start, end), type, start, end));\n break;\n case \"propertyValue\" /* PropertyValue */:\n case \"blockEnd\" /* BlockEnd */:\n releaseItem(pool, stack.pop());\n break;\n }\n });\n stack.forEach(item => {\n result.ancestors.push({\n name: item.name,\n type: item.type,\n range: [item.start, item.end]\n });\n });\n return result;\n}\n/**\n * Returns embedded stylesheet syntax from given HTML context\n */\nfunction getEmbeddedStyleSyntax(code, ctx) {\n const parent = last(ctx.ancestors);\n if (parent && parent.name === 'style') {\n for (const attr of attributes(code.slice(parent.range[0], parent.range[1]), parent.name)) {\n if (attr.name === 'type') {\n return attributeValue(attr);\n }\n }\n }\n}\n/**\n * Returns context for Emmet abbreviation from given HTML context\n */\nfunction getMarkupAbbreviationContext(code, ctx) {\n const parent = last(ctx.ancestors);\n if (parent) {\n const attrs = {};\n for (const attr of attributes(code.slice(parent.range[0], parent.range[1]), parent.name)) {\n attrs[attr.name] = attributeValue(attr) || '';\n }\n return {\n name: parent.name,\n attributes: attrs\n };\n }\n}\n/**\n * Returns context for Emmet abbreviation from given CSS context\n */\nfunction getStylesheetAbbreviationContext(ctx) {\n if (ctx.inline) {\n return { name: \"@@property\" /* Property */ };\n }\n const parent = last(ctx.ancestors);\n let scope = \"@@global\" /* Global */;\n if (ctx.current) {\n if (ctx.current.type === \"propertyValue\" /* PropertyValue */ && parent) {\n scope = parent.name;\n }\n else if ((ctx.current.type === \"selector\" /* Selector */ || ctx.current.type === \"propertyName\" /* PropertyName */) && !parent) {\n scope = \"@@section\" /* Section */;\n }\n }\n return {\n name: scope\n };\n}\n/**\n * Tries to detect CSS context from given HTML context and returns it\n */\nfunction detectCSSContextFromHTML(code, pos, ctx) {\n let cssCtx = null;\n if (ctx.current) {\n // Maybe inline CSS?\n const elem = ctx.current;\n if (elem.type === 1 /* Open */ || elem.type === 2 /* Close */) {\n const tag = code.slice(elem.range[0], elem.range[1]);\n attributes(tag, elem.name).some(attr => {\n if (attr.name === 'style' && attr.value != null) {\n const [valueStart, valueEnd] = attributeValueRange(tag, attr, elem.range[0]);\n if (pos >= valueStart && pos <= valueEnd) {\n cssCtx = getCSSContext(code.slice(valueStart, valueEnd), pos - valueStart, [valueStart, valueEnd]);\n applyOffset(cssCtx, valueStart);\n cssCtx.inline = true;\n return true;\n }\n }\n });\n }\n }\n else if (ctx.ancestors.length) {\n // Maybe inside ` tag\n const styleStart = parent.range[1];\n let styleEnd = code.length;\n scan(code.slice(parent.range[1]), (name, type, start) => {\n if (name === parent.name && type === 2 /* Close */) {\n styleEnd = start + styleStart;\n return false;\n }\n });\n cssCtx = getCSSContext(code.slice(styleStart, styleEnd), pos - styleStart, [styleStart, styleEnd]);\n applyOffset(cssCtx, styleStart);\n }\n }\n return cssCtx;\n}\n/**\n * Check if given tag is self-close for current parsing context\n */\nfunction isSelfClose(name, options) {\n return !options.xml && options.empty.includes(name);\n}\nfunction allocItem(pool, name, type, start, end) {\n if (pool.length) {\n const tag = pool.pop();\n tag.name = name;\n tag.type = type;\n tag.start = start;\n tag.end = end;\n return tag;\n }\n return { name, type, start, end };\n}\nfunction releaseItem(pool, item) {\n if (item) {\n pool.push(item);\n }\n}\nfunction applyOffset(ctx, offset) {\n ctx.ancestors.forEach(item => {\n offsetRange(item.range, offset);\n });\n if (ctx.current) {\n offsetRange(ctx.current.range, offset);\n }\n}\nfunction offsetRange(range, offset) {\n range[0] += offset;\n range[1] += offset;\n}\n\nconst JSX_PREFIX = '<';\nconst reJSXAbbrStart = /^[a-zA-Z.#\\[\\(]$/;\nconst reWordBound = /^[\\s>;\"\\']?[a-zA-Z.#!@\\[\\(]$/;\nconst reStylesheetWordBound = /^[\\s;\"\\']?[a-zA-Z!@]$/;\n/**\n * Controller for tracking Emmet abbreviations in editor as user types.\n * Controller designed to be extended ad-hoc in editor plugins, overriding some\n * methods `mark()` to match editor behavior\n */\nclass AbbreviationTrackingController {\n constructor() {\n this.cache = new Map();\n this.trackers = new Map();\n this.lastPos = new Map();\n }\n /**\n * Returns last known location of caret in given editor\n */\n getLastPost(editor) {\n return this.lastPos.get(editor.id);\n }\n /**\n * Sets last known caret location for given editor\n */\n setLastPos(editor, pos) {\n this.lastPos.set(editor.id, pos);\n }\n /**\n * Returns abbreviation tracker for given editor, if any\n */\n getTracker(editor) {\n return this.trackers.get(editor.id);\n }\n /**\n * Detects if user is typing abbreviation at given location\n */\n typingAbbreviation(editor, pos) {\n var _a;\n // Start tracking only if user starts abbreviation typing: entered first\n // character at the word bound\n // NB: get last 2 characters: first should be a word bound(or empty),\n // second must be abbreviation start\n const prefix = editor.substr(Math.max(0, pos - 2), pos);\n const syntax = editor.syntax();\n let start = -1;\n let end = pos;\n let offset = 0;\n if (editor.isJSX(syntax)) {\n // In JSX, abbreviations should be prefixed\n if (prefix.length === 2 && prefix[0] === JSX_PREFIX && reJSXAbbrStart.test(prefix[1])) {\n start = pos - 2;\n offset = JSX_PREFIX.length;\n }\n }\n else if (reWordBound.test(prefix)) {\n start = pos - 1;\n }\n if (start >= 0) {\n // Check if there’s paired character\n const lastCh = prefix[prefix.length - 1];\n if (lastCh in pairs && editor.substr(pos, pos + 1) === pairs[lastCh]) {\n end++;\n }\n const config = this.getActivationContext(editor, pos);\n if (config) {\n if (config.type === 'stylesheet' && !reStylesheetWordBound.test(prefix)) {\n // Additional check for stylesheet abbreviation start: it’s slightly\n // differs from markup prefix, but we need activation context\n // to ensure that context under caret is CSS\n return;\n }\n const tracker = this.startTracking(editor, start, end, { offset, config });\n if (tracker && tracker.type === \"abbreviation\" /* Abbreviation */ && ((_a = config.context) === null || _a === void 0 ? void 0 : _a.name) === \"@@section\" /* Section */) {\n // Make a silly check for section context: if user start typing\n // CSS selector at the end of file, it will be treated as property\n // name and provide unrelated completion by default.\n // We should check if captured abbreviation actually matched\n // snippet to continue. Otherwise, ignore this abbreviation.\n // By default, unresolved abbreviations are converted to CSS properties,\n // e.g. `a` → `a: ;`. If that’s the case, stop tracking\n const { abbreviation, preview } = tracker;\n if (preview.startsWith(abbreviation) && /^:\\s*;?$/.test(preview.slice(abbreviation.length))) {\n this.stopTracking(editor);\n return;\n }\n }\n return tracker;\n }\n }\n }\n /**\n * Starts abbreviation tracking for given editor\n * @param start Location of abbreviation start\n * @param pos Current caret position, must be greater that `start`\n */\n startTracking(editor, start, pos, params) {\n const config = (params === null || params === void 0 ? void 0 : params.config) || editor.config(start);\n const tracker = this.createTracker(editor, [start, pos], Object.assign({ config }, params));\n if (tracker) {\n this.trackers.set(editor.id, tracker);\n return tracker;\n }\n this.trackers.delete(editor.id);\n }\n /**\n * Stops abbreviation tracking in given editor instance\n */\n stopTracking(editor, params) {\n const tracker = this.getTracker(editor);\n if (tracker) {\n editor.unmark(tracker);\n if (tracker.forced && !(params === null || params === void 0 ? void 0 : params.skipRemove)) {\n // Contents of forced abbreviation must be removed\n editor.replace('', tracker.range[0], tracker.range[1]);\n }\n if (params === null || params === void 0 ? void 0 : params.force) {\n this.cache.delete(editor.id);\n }\n else {\n // Store tracker in history to restore it if user continues editing\n this.storeTracker(editor, tracker);\n }\n this.trackers.delete(editor.id);\n }\n }\n /**\n * Creates abbreviation tracker for given range in editor. Parses contents\n * of abbreviation in range and returns either valid abbreviation tracker,\n * error tracker or `null` if abbreviation cannot be created from given range\n */\n createTracker(editor, range, params) {\n if (range[0] >= range[1]) {\n // Invalid range\n return null;\n }\n let abbreviation = editor.substr(range[0], range[1]);\n const { config } = params;\n if (params.offset) {\n abbreviation = abbreviation.slice(params.offset);\n }\n // Basic validation: do not allow empty abbreviations\n // or newlines in abbreviations\n if (!abbreviation || /[\\r\\n]/.test(abbreviation)) {\n return null;\n }\n const base = {\n abbreviation,\n range,\n config,\n forced: !!params.forced,\n offset: params.offset || 0,\n lastPos: range[1],\n lastLength: editor.size(),\n };\n try {\n let parsedAbbr;\n let simple = false;\n if (config.type === 'stylesheet') {\n parsedAbbr = stylesheetAbbreviation(abbreviation);\n }\n else {\n parsedAbbr = markupAbbreviation(abbreviation, {\n jsx: config.syntax === 'jsx'\n });\n simple = this.isSimpleMarkupAbbreviation(parsedAbbr);\n }\n const previewConfig = editor.previewConfig(config);\n return Object.assign(Object.assign({}, base), { type: \"abbreviation\" /* Abbreviation */, simple, preview: expand(parsedAbbr, previewConfig) });\n }\n catch (error) {\n return Object.assign(Object.assign({}, base), { type: \"error\" /* Error */, error });\n }\n }\n /**\n * Stores given tracker in separate cache to restore later\n */\n storeTracker(editor, tracker) {\n this.cache.set(editor.id, tracker);\n }\n /**\n * Returns stored tracker for given editor proxy, if any\n */\n getStoredTracker(editor) {\n return this.cache.get(editor.id);\n }\n /**\n * Tries to restore abbreviation tracker for given editor at specified position\n */\n restoreTracker(editor, pos) {\n const tracker = this.getStoredTracker(editor);\n if (tracker && tracker.range[0] <= pos && tracker.range[1] >= pos) {\n const [from, to] = tracker.range;\n if (editor.substr(from + tracker.offset, to) === tracker.abbreviation) {\n this.trackers.set(editor.id, tracker);\n tracker.lastLength = editor.size();\n return tracker;\n }\n }\n }\n /**\n * Handle content change in given editor instance\n */\n handleChange(editor, pos) {\n const tracker = this.getTracker(editor);\n const editorLastPos = this.getLastPost(editor);\n this.setLastPos(editor, pos);\n if (!tracker) {\n // No active tracker, check if we user is actually typing it\n if (editorLastPos != null && editorLastPos === pos - 1 && editor.allowTracking(pos)) {\n return this.typingAbbreviation(editor, pos);\n }\n return;\n }\n const { lastPos } = tracker;\n let { range } = tracker;\n if (lastPos < range[0] || lastPos > range[1]) {\n // Updated content outside abbreviation: reset tracker\n this.stopTracking(editor);\n return;\n }\n const length = editor.size();\n const delta = length - tracker.lastLength;\n range = range.slice();\n // Modify range and validate it: if it leads to invalid abbreviation, reset tracker\n updateRange(range, delta, lastPos);\n // Handle edge case: empty forced abbreviation is allowed\n if (range[0] === range[1] && tracker.forced) {\n tracker.abbreviation = '';\n return tracker;\n }\n const nextTracker = this.createTracker(editor, range, tracker);\n if (!nextTracker || (!tracker.forced && !isValidTracker(nextTracker, range, pos))) {\n this.stopTracking(editor);\n return;\n }\n nextTracker.lastPos = pos;\n this.trackers.set(editor.id, nextTracker);\n editor.mark(nextTracker);\n return nextTracker;\n }\n /**\n * Handle selection (caret) change in given editor instance\n */\n handleSelectionChange(editor, pos) {\n this.setLastPos(editor, pos);\n const tracker = this.getTracker(editor) || this.restoreTracker(editor, pos);\n if (tracker) {\n tracker.lastPos = pos;\n return tracker;\n }\n }\n /**\n * Detects and returns valid abbreviation activation context for given location\n * in editor which can be used for abbreviation expanding.\n * For example, in given HTML code:\n * `from and to values\n */\nfunction rand(from, to) {\n return Math.floor(Math.random() * (to - from) + from);\n}\nfunction sample(arr, count) {\n const len = arr.length;\n const iterations = Math.min(len, count);\n const result = [];\n while (result.length < iterations) {\n const str = arr[rand(0, len)];\n if (!result.includes(str)) {\n result.push(str);\n }\n }\n return result;\n}\nfunction choice(val) {\n return val[rand(0, val.length - 1)];\n}\nfunction sentence(words, end) {\n if (words.length) {\n words = [capitalize(words[0])].concat(words.slice(1));\n }\n return words.join(' ') + (end || choice('?!...')); // more dots than question marks\n}\nfunction capitalize(word) {\n return word[0].toUpperCase() + word.slice(1);\n}\n/**\n * Insert commas at randomly selected words. This function modifies values\n * inside `words` array\n */\nfunction insertCommas(words) {\n if (words.length < 2) {\n return words;\n }\n words = words.slice();\n const len = words.length;\n const hasComma = /,$/;\n let totalCommas = 0;\n if (len > 3 && len <= 6) {\n totalCommas = rand(0, 1);\n }\n else if (len > 6 && len <= 12) {\n totalCommas = rand(0, 2);\n }\n else {\n totalCommas = rand(1, 4);\n }\n for (let i = 0, pos; i < totalCommas; i++) {\n pos = rand(0, len - 2);\n if (!hasComma.test(words[pos])) {\n words[pos] += ',';\n }\n }\n return words;\n}\n/**\n * Generate a paragraph of \"Lorem ipsum\" text\n * @param dict Words dictionary\n * @param wordCount Words count in paragraph\n * @param startWithCommon Should paragraph start with common \"lorem ipsum\" sentence.\n */\nfunction paragraph(dict, wordCount, startWithCommon) {\n const result = [];\n let totalWords = 0;\n let words;\n if (startWithCommon && dict.common) {\n words = dict.common.slice(0, wordCount);\n totalWords += words.length;\n result.push(sentence(insertCommas(words), '.'));\n }\n while (totalWords < wordCount) {\n words = sample(dict.words, Math.min(rand(2, 30), wordCount - totalWords));\n totalWords += words.length;\n result.push(sentence(insertCommas(words)));\n }\n return result.join(' ');\n}\nfunction findRepeater(ancestors) {\n for (let i = ancestors.length - 1; i >= 0; i--) {\n const element = ancestors[i];\n if (element.type === 'AbbreviationNode' && element.repeat) {\n return element.repeat;\n }\n }\n}\n\n/**\n * JSX transformer: replaces `class` and `for` attributes with `className` and\n * `htmlFor` attributes respectively\n */\nfunction jsx(node) {\n if (node.attributes) {\n node.attributes.forEach(rename);\n }\n}\nfunction rename(attr) {\n if (attr.name === 'class') {\n attr.name = 'className';\n }\n else if (attr.name === 'for') {\n attr.name = 'htmlFor';\n }\n}\n\n/**\n * XSL transformer: removes `select` attributes from certain nodes that contain\n * children\n */\nfunction xsl(node) {\n if (matchesName(node.name) && node.attributes && (node.children.length || node.value)) {\n node.attributes = node.attributes.filter(isAllowed);\n }\n}\nfunction isAllowed(attr) {\n return attr.name !== 'select';\n}\nfunction matchesName(name) {\n return name === 'xsl:variable' || name === 'xsl:with-param';\n}\n\nconst reElement = /^(-+)([a-z0-9]+[a-z0-9-]*)/i;\nconst reModifier = /^(_+)([a-z0-9]+[a-z0-9-_]*)/i;\nconst blockCandidates1 = (className) => /^[a-z]\\-/i.test(className);\nconst blockCandidates2 = (className) => /^[a-z]/i.test(className);\nfunction bem(node, ancestors, config) {\n expandClassNames(node);\n expandShortNotation(node, ancestors, config);\n}\n/**\n * Expands existing class names in BEM notation in given `node`.\n * For example, if node contains `b__el_mod` class name, this method ensures\n * that element contains `b__el` class as well\n */\nfunction expandClassNames(node) {\n const data = getBEMData(node);\n const classNames = [];\n for (const cl of data.classNames) {\n // remove all modifiers and element prefixes from class name to get a base element name\n const ix = cl.indexOf('_');\n if (ix > 0 && !cl.startsWith('-')) {\n classNames.push(cl.slice(0, ix));\n classNames.push(cl.slice(ix));\n }\n else {\n classNames.push(cl);\n }\n }\n if (classNames.length) {\n data.classNames = classNames.filter(uniqueClass);\n data.block = findBlockName(data.classNames);\n updateClass(node, data.classNames.join(' '));\n }\n}\n/**\n * Expands short BEM notation, e.g. `-element` and `_modifier`\n */\nfunction expandShortNotation(node, ancestors, config) {\n const data = getBEMData(node);\n const classNames = [];\n const { options } = config;\n const path = ancestors.slice(1).concat(node);\n for (let cl of data.classNames) {\n let prefix = '';\n let m;\n const originalClass = cl;\n // parse element definition (could be only one)\n if (m = cl.match(reElement)) {\n prefix = getBlockName(path, m[1].length, config.context) + options['bem.element'] + m[2];\n classNames.push(prefix);\n cl = cl.slice(m[0].length);\n }\n // parse modifiers definitions\n if (m = cl.match(reModifier)) {\n if (!prefix) {\n prefix = getBlockName(path, m[1].length);\n classNames.push(prefix);\n }\n classNames.push(`${prefix}${options['bem.modifier']}${m[2]}`);\n cl = cl.slice(m[0].length);\n }\n if (cl === originalClass) {\n // class name wasn’t modified: it’s not a BEM-specific class,\n // add it as-is into output\n classNames.push(originalClass);\n }\n }\n const arrClassNames = classNames.filter(uniqueClass);\n if (arrClassNames.length) {\n updateClass(node, arrClassNames.join(' '));\n }\n}\n/**\n * Returns BEM data from given abbreviation node\n */\nfunction getBEMData(node) {\n if (!node._bem) {\n let classValue = '';\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (attr.name === 'class' && attr.value) {\n classValue = stringifyValue(attr.value);\n break;\n }\n }\n }\n node._bem = parseBEM(classValue);\n }\n return node._bem;\n}\nfunction getBEMDataFromContext(context) {\n if (!context._bem) {\n context._bem = parseBEM(context.attributes && context.attributes.class || '');\n }\n return context._bem;\n}\n/**\n * Parses BEM data from given class name\n */\nfunction parseBEM(classValue) {\n const classNames = classValue ? classValue.split(/\\s+/) : [];\n return {\n classNames,\n block: findBlockName(classNames)\n };\n}\n/**\n * Returns block name for given `node` by `prefix`, which tells the depth of\n * of parent node lookup\n */\nfunction getBlockName(ancestors, depth = 0, context) {\n const maxParentIx = 0;\n let parentIx = Math.max(ancestors.length - depth, maxParentIx);\n do {\n const parent = ancestors[parentIx];\n if (parent) {\n const data = getBEMData(parent);\n if (data.block) {\n return data.block;\n }\n }\n } while (maxParentIx < parentIx--);\n if (context) {\n const data = getBEMDataFromContext(context);\n if (data.block) {\n return data.block;\n }\n }\n return '';\n}\nfunction findBlockName(classNames) {\n return find(classNames, blockCandidates1)\n || find(classNames, blockCandidates2)\n || void 0;\n}\n/**\n * Finds class name from given list which may be used as block name\n */\nfunction find(classNames, filter) {\n for (const cl of classNames) {\n if (reElement.test(cl) || reModifier.test(cl)) {\n break;\n }\n if (filter(cl)) {\n return cl;\n }\n }\n}\nfunction updateClass(node, value) {\n for (const attr of node.attributes) {\n if (attr.name === 'class') {\n attr.value = [value];\n break;\n }\n }\n}\nfunction stringifyValue(value) {\n let result = '';\n for (const t of value) {\n result += typeof t === 'string' ? t : t.name;\n }\n return result;\n}\nfunction uniqueClass(item, ix, arr) {\n return !!item && arr.indexOf(item) === ix;\n}\n\nfunction walk$1(abbr, visitor, state) {\n const callback = (ctx, index, items) => {\n const { parent, current } = state;\n state.parent = current;\n state.current = ctx;\n visitor(ctx, index, items, state, next);\n state.current = current;\n state.parent = parent;\n };\n const next = (node, index, items) => {\n state.ancestors.push(state.current);\n callback(node, index, items);\n state.ancestors.pop();\n };\n abbr.children.forEach(callback);\n}\nfunction createWalkState(config) {\n return {\n // @ts-ignore: Will set value in iterator\n current: null,\n parent: void 0,\n ancestors: [],\n config,\n field: 1,\n out: createOutputStream(config.options)\n };\n}\n\nconst caret = [{ type: 'Field', index: 0, name: '' }];\n/**\n * Check if given node is a snippet: a node without name and attributes\n */\nfunction isSnippet(node) {\n return node ? !node.name && !node.attributes : false;\n}\n/**\n * Check if given node is inline-level element, e.g. element with explicitly\n * defined node name\n */\nfunction isInlineElement(node, config) {\n return node ? isInline(node, config) : false;\n}\n/**\n * Check if given value token is a field\n */\nfunction isField(token) {\n return typeof token === 'object' && token.type === 'Field';\n}\nfunction pushTokens(tokens, state) {\n const { out } = state;\n let largestIndex = -1;\n for (const t of tokens) {\n if (typeof t === 'string') {\n pushString(out, t);\n }\n else {\n pushField(out, state.field + t.index, t.name);\n if (t.index > largestIndex) {\n largestIndex = t.index;\n }\n }\n }\n if (largestIndex !== -1) {\n state.field += largestIndex + 1;\n }\n}\n/**\n * Splits given value token by lines: returns array where each entry is a token list\n * for a single line\n */\nfunction splitByLines$1(tokens) {\n const result = [];\n let line = [];\n for (const t of tokens) {\n if (typeof t === 'string') {\n const lines = t.split(/\\r\\n?|\\n/g);\n line.push(lines.shift() || '');\n while (lines.length) {\n result.push(line);\n line = [lines.shift() || ''];\n }\n }\n else {\n line.push(t);\n }\n }\n line.length && result.push(line);\n return result;\n}\n/**\n * Check if given attribute should be outputted\n */\nfunction shouldOutputAttribute(attr) {\n // In case if attribute is implied, check if it has a defined value:\n // either non-empty value or quoted empty value\n return !attr.implied || attr.valueType !== 'raw' || (!!attr.value && attr.value.length > 0);\n}\n\n/**\n * Splits given string into template tokens.\n * Template is a string which contains placeholders which are uppercase names\n * between `[` and `]`, for example: `[PLACEHOLDER]`.\n * Unlike other templates, a placeholder may contain extra characters before and\n * after name: `[%PLACEHOLDER.]`. If data for `PLACEHOLDER` is defined, it will\n * be outputted with with these extra character, otherwise will be completely omitted.\n */\nfunction template(text) {\n const tokens = [];\n const scanner = { pos: 0, text };\n let placeholder;\n let offset = scanner.pos;\n let pos = scanner.pos;\n while (scanner.pos < scanner.text.length) {\n pos = scanner.pos;\n if (placeholder = consumePlaceholder(scanner)) {\n if (offset !== scanner.pos) {\n tokens.push(text.slice(offset, pos));\n }\n tokens.push(placeholder);\n offset = scanner.pos;\n }\n else {\n scanner.pos++;\n }\n }\n if (offset !== scanner.pos) {\n tokens.push(text.slice(offset));\n }\n return tokens;\n}\n/**\n * Consumes placeholder like `[#ID]` from given scanner\n */\nfunction consumePlaceholder(scanner) {\n if (peek(scanner) === 91 /* Start */) {\n const start = ++scanner.pos;\n let namePos = start;\n let afterPos = start;\n let stack = 1;\n while (scanner.pos < scanner.text.length) {\n const code = peek(scanner);\n if (isTokenStart(code)) {\n namePos = scanner.pos;\n while (isToken(peek(scanner))) {\n scanner.pos++;\n }\n afterPos = scanner.pos;\n }\n else {\n if (code === 91 /* Start */) {\n stack++;\n }\n else if (code === 93 /* End */) {\n if (--stack === 0) {\n return {\n before: scanner.text.slice(start, namePos),\n after: scanner.text.slice(afterPos, scanner.pos++),\n name: scanner.text.slice(namePos, afterPos)\n };\n }\n }\n scanner.pos++;\n }\n }\n }\n}\nfunction peek(scanner, pos = scanner.pos) {\n return scanner.text.charCodeAt(pos);\n}\nfunction isTokenStart(code) {\n return code >= 65 && code <= 90; // A-Z\n}\nfunction isToken(code) {\n return isTokenStart(code)\n || (code > 47 && code < 58) /* 0-9 */\n || code === 95 /* Underscore */\n || code === 45 /* Dash */;\n}\n\nfunction createCommentState(config) {\n const { options } = config;\n return {\n enabled: options['comment.enabled'],\n trigger: options['comment.trigger'],\n before: options['comment.before'] ? template(options['comment.before']) : void 0,\n after: options['comment.after'] ? template(options['comment.after']) : void 0\n };\n}\n/**\n * Adds comment prefix for given node, if required\n */\nfunction commentNodeBefore(node, state) {\n if (shouldComment(node, state) && state.comment.before) {\n output(node, state.comment.before, state);\n }\n}\n/**\n * Adds comment suffix for given node, if required\n */\nfunction commentNodeAfter(node, state) {\n if (shouldComment(node, state) && state.comment.after) {\n output(node, state.comment.after, state);\n }\n}\n/**\n * Check if given node should be commented\n */\nfunction shouldComment(node, state) {\n const { comment } = state;\n if (!comment.enabled || !comment.trigger || !node.name || !node.attributes) {\n return false;\n }\n for (const attr of node.attributes) {\n if (attr.name && comment.trigger.includes(attr.name)) {\n return true;\n }\n }\n return false;\n}\n/**\n * Pushes given template tokens into output stream\n */\nfunction output(node, tokens, state) {\n const attrs = {};\n const { out } = state;\n // Collect attributes payload\n for (const attr of node.attributes) {\n if (attr.name && attr.value) {\n attrs[attr.name.toUpperCase()] = attr.value;\n }\n }\n // Output parsed tokens\n for (const token of tokens) {\n if (typeof token === 'string') {\n pushString(out, token);\n }\n else if (attrs[token.name]) {\n pushString(out, token.before);\n pushTokens(attrs[token.name], state);\n pushString(out, token.after);\n }\n }\n}\n\nconst htmlTagRegex = /^<([\\w\\-:]+)[\\s>]/;\nfunction html(abbr, config) {\n const state = createWalkState(config);\n state.comment = createCommentState(config);\n walk$1(abbr, element, state);\n return state.out.value;\n}\n/**\n * Outputs `node` content to output stream of `state`\n * @param node Context node\n * @param index Index of `node` in `items`\n * @param items List of `node`’s siblings\n * @param state Current walk state\n */\nfunction element(node, index, items, state, next) {\n const { out, config } = state;\n const format = shouldFormat(node, index, items, state);\n // Pick offset level for current node\n const level = getIndent(state);\n out.level += level;\n format && pushNewline(out, true);\n if (node.name) {\n const name = tagName(node.name, config);\n commentNodeBefore(node, state);\n pushString(out, `<${name}`);\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (shouldOutputAttribute(attr)) {\n pushAttribute(attr, state);\n }\n }\n }\n if (node.selfClosing && !node.children.length && !node.value) {\n pushString(out, `${selfClose(config)}>`);\n }\n else {\n pushString(out, '>');\n if (!pushSnippet(node, state, next)) {\n if (node.value) {\n const innerFormat = node.value.some(hasNewline) || startsWithBlockTag(node.value, config);\n innerFormat && pushNewline(state.out, ++out.level);\n pushTokens(node.value, state);\n innerFormat && pushNewline(state.out, --out.level);\n }\n node.children.forEach(next);\n if (!node.value && !node.children.length) {\n const innerFormat = config.options['output.formatLeafNode']\n || config.options['output.formatForce'].includes(node.name);\n innerFormat && pushNewline(state.out, ++out.level);\n pushTokens(caret, state);\n innerFormat && pushNewline(state.out, --out.level);\n }\n }\n pushString(out, ``);\n commentNodeAfter(node, state);\n }\n }\n else if (!pushSnippet(node, state, next) && node.value) {\n // A text-only node (snippet)\n pushTokens(node.value, state);\n node.children.forEach(next);\n }\n if (format && index === items.length - 1 && state.parent) {\n const offset = isSnippet(state.parent) ? 0 : 1;\n pushNewline(out, out.level - offset);\n }\n out.level -= level;\n}\n/**\n * Outputs given attribute’s content into output stream\n */\nfunction pushAttribute(attr, state) {\n const { out, config } = state;\n if (attr.name) {\n const name = attrName(attr.name, config);\n const lQuote = attrQuote(attr, config, true);\n const rQuote = attrQuote(attr, config);\n let value = attr.value;\n if (isBooleanAttribute(attr, config) && !value) {\n // If attribute value is omitted and it’s a boolean value, check for\n // `compactBoolean` option: if it’s disabled, set value to attribute name\n // (XML style)\n if (!config.options['output.compactBoolean']) {\n value = [name];\n }\n }\n else if (!value) {\n value = caret;\n }\n pushString(out, ' ' + name);\n if (value) {\n pushString(out, '=' + lQuote);\n pushTokens(value, state);\n pushString(out, rQuote);\n }\n else if (config.options['output.selfClosingStyle'] !== 'html') {\n pushString(out, '=' + lQuote + rQuote);\n }\n }\n}\nfunction pushSnippet(node, state, next) {\n if (node.value && node.children.length) {\n // We have a value and child nodes. In case if value contains fields,\n // we should output children as a content of first field\n const fieldIx = node.value.findIndex(isField);\n if (fieldIx !== -1) {\n pushTokens(node.value.slice(0, fieldIx), state);\n const line = state.out.line;\n let pos = fieldIx + 1;\n node.children.forEach(next);\n // If there was a line change, trim leading whitespace for better result\n if (state.out.line !== line && typeof node.value[pos] === 'string') {\n pushString(state.out, node.value[pos++].trimLeft());\n }\n pushTokens(node.value.slice(pos), state);\n return true;\n }\n }\n return false;\n}\n/**\n * Check if given node should be formatted in its parent context\n */\nfunction shouldFormat(node, index, items, state) {\n const { config, parent } = state;\n if (!config.options['output.format']) {\n return false;\n }\n if (index === 0 && !parent) {\n // Do not format very first node\n return false;\n }\n // Do not format single child of snippet\n if (parent && isSnippet(parent) && items.length === 1) {\n return false;\n }\n /**\n * Adjacent text-only/snippet nodes\n */\n if (isSnippet(node)) {\n // Adjacent text-only/snippet nodes\n const format = isSnippet(items[index - 1]) || isSnippet(items[index + 1])\n // Has newlines: looks like wrapping code fragment\n || node.value.some(hasNewline)\n // Format as wrapper: contains children which will be outputted as field content\n || (node.value.some(isField) && node.children.length);\n if (format) {\n return true;\n }\n }\n if (isInline(node, config)) {\n // Check if inline node is the next sibling of block-level node\n if (index === 0) {\n // First node in parent: format if it’s followed by a block-level element\n for (let i = 0; i < items.length; i++) {\n if (!isInline(items[i], config)) {\n return true;\n }\n }\n }\n else if (!isInline(items[index - 1], config)) {\n // Node is right after block-level element\n return true;\n }\n if (config.options['output.inlineBreak']) {\n // check for adjacent inline elements before and after current element\n let adjacentInline = 1;\n let before = index;\n let after = index;\n while (isInlineElement(items[--before], config)) {\n adjacentInline++;\n }\n while (isInlineElement(items[++after], config)) {\n adjacentInline++;\n }\n if (adjacentInline >= config.options['output.inlineBreak']) {\n return true;\n }\n }\n // Edge case: inline node contains node that should receive formatting\n for (let i = 0, il = node.children.length; i < il; i++) {\n if (shouldFormat(node.children[i], i, node.children, state)) {\n return true;\n }\n }\n return false;\n }\n return true;\n}\n/**\n * Returns indentation offset for given node\n */\nfunction getIndent(state) {\n const { config, parent } = state;\n if (!parent || isSnippet(parent) || (parent.name && config.options['output.formatSkip'].includes(parent.name))) {\n return 0;\n }\n return 1;\n}\n/**\n * Check if given node value contains newlines\n */\nfunction hasNewline(value) {\n return typeof value === 'string' && /\\r|\\n/.test(value);\n}\n/**\n * Check if given node value starts with block-level tag\n */\nfunction startsWithBlockTag(value, config) {\n if (value.length && typeof value[0] === 'string') {\n const matches = htmlTagRegex.exec(value[0]);\n if ((matches === null || matches === void 0 ? void 0 : matches.length) && !config.options['inlineElements'].includes(matches[1].toLowerCase())) {\n return true;\n }\n }\n return false;\n}\n\nfunction indentFormat(abbr, config, options) {\n const state = createWalkState(config);\n state.options = options || {};\n walk$1(abbr, element$1, state);\n return state.out.value;\n}\n/**\n * Outputs `node` content to output stream of `state`\n * @param node Context node\n * @param index Index of `node` in `items`\n * @param items List of `node`’s siblings\n * @param state Current walk state\n */\nfunction element$1(node, index, items, state, next) {\n const { out, options } = state;\n const { primary, secondary } = collectAttributes(node);\n // Pick offset level for current node\n const level = state.parent ? 1 : 0;\n out.level += level;\n // Do not indent top-level elements\n if (shouldFormat$1(node, index, items, state)) {\n pushNewline(out, true);\n }\n if (node.name && (node.name !== 'div' || !primary.length)) {\n pushString(out, (options.beforeName || '') + node.name + (options.afterName || ''));\n }\n pushPrimaryAttributes(primary, state);\n pushSecondaryAttributes(secondary.filter(shouldOutputAttribute), state);\n if (node.selfClosing && !node.value && !node.children.length) {\n if (state.options.selfClose) {\n pushString(out, state.options.selfClose);\n }\n }\n else {\n pushValue(node, state);\n node.children.forEach(next);\n }\n out.level -= level;\n}\n/**\n * From given node, collects all attributes as `primary` (id, class) and\n * `secondary` (all the rest) lists. In most indent-based syntaxes, primary attribute\n * has special syntax\n */\nfunction collectAttributes(node) {\n const primary = [];\n const secondary = [];\n if (node.attributes) {\n for (const attr of node.attributes) {\n if (isPrimaryAttribute(attr)) {\n primary.push(attr);\n }\n else {\n secondary.push(attr);\n }\n }\n }\n return { primary, secondary };\n}\n/**\n * Outputs given attributes as primary into output stream\n */\nfunction pushPrimaryAttributes(attrs, state) {\n for (const attr of attrs) {\n if (attr.value) {\n if (attr.name === 'class') {\n pushString(state.out, '.');\n // All whitespace characters must be replaced with dots in class names\n const tokens = attr.value.map(t => typeof t === 'string' ? t.replace(/\\s+/g, '.') : t);\n pushTokens(tokens, state);\n }\n else {\n // ID attribute\n pushString(state.out, '#');\n pushTokens(attr.value, state);\n }\n }\n }\n}\n/**\n * Outputs given attributes as secondary into output stream\n */\nfunction pushSecondaryAttributes(attrs, state) {\n if (attrs.length) {\n const { out, config, options } = state;\n options.beforeAttribute && pushString(out, options.beforeAttribute);\n for (let i = 0; i < attrs.length; i++) {\n const attr = attrs[i];\n pushString(out, attrName(attr.name || '', config));\n if (isBooleanAttribute(attr, config) && !attr.value) {\n if (!config.options['output.compactBoolean'] && options.booleanValue) {\n pushString(out, '=' + options.booleanValue);\n }\n }\n else {\n pushString(out, '=' + attrQuote(attr, config, true));\n pushTokens(attr.value || caret, state);\n pushString(out, attrQuote(attr, config));\n }\n if (i !== attrs.length - 1 && options.glueAttribute) {\n pushString(out, options.glueAttribute);\n }\n }\n options.afterAttribute && pushString(out, options.afterAttribute);\n }\n}\n/**\n * Outputs given node value into state output stream\n */\nfunction pushValue(node, state) {\n // We should either output value or add caret but for leaf nodes only (no children)\n if (!node.value && node.children.length) {\n return;\n }\n const value = node.value || caret;\n const lines = splitByLines$1(value);\n const { out, options } = state;\n if (lines.length === 1) {\n if (node.name || node.attributes) {\n push(out, ' ');\n }\n pushTokens(value, state);\n }\n else {\n // We should format multi-line value with terminating `|` character\n // and same line length\n const lineLengths = [];\n let maxLength = 0;\n // Calculate lengths of all lines and max line length\n for (const line of lines) {\n const len = valueLength(line);\n lineLengths.push(len);\n if (len > maxLength) {\n maxLength = len;\n }\n }\n // Output each line, padded to max length\n out.level++;\n for (let i = 0; i < lines.length; i++) {\n pushNewline(out, true);\n options.beforeTextLine && push(out, options.beforeTextLine);\n pushTokens(lines[i], state);\n if (options.afterTextLine) {\n push(out, ' '.repeat(maxLength - lineLengths[i]));\n push(out, options.afterTextLine);\n }\n }\n out.level--;\n }\n}\nfunction isPrimaryAttribute(attr) {\n return attr.name === 'class' || attr.name === 'id';\n}\n/**\n * Calculates string length from given tokens\n */\nfunction valueLength(tokens) {\n let len = 0;\n for (const token of tokens) {\n len += typeof token === 'string' ? token.length : token.name.length;\n }\n return len;\n}\nfunction shouldFormat$1(node, index, items, state) {\n // Do not format first top-level element or snippets\n if (!state.parent && index === 0) {\n return false;\n }\n return !isSnippet(node);\n}\n\nfunction haml(abbr, config) {\n return indentFormat(abbr, config, {\n beforeName: '%',\n beforeAttribute: '(',\n afterAttribute: ')',\n glueAttribute: ' ',\n afterTextLine: ' |',\n booleanValue: 'true',\n selfClose: '/'\n });\n}\n\nfunction slim(abbr, config) {\n return indentFormat(abbr, config, {\n beforeAttribute: ' ',\n glueAttribute: ' ',\n beforeTextLine: '| ',\n selfClose: '/'\n });\n}\n\nfunction pug(abbr, config) {\n return indentFormat(abbr, config, {\n beforeAttribute: '(',\n afterAttribute: ')',\n glueAttribute: ', ',\n beforeTextLine: '| ',\n selfClose: config.options['output.selfClosingStyle'] === 'xml' ? '/' : ''\n });\n}\n\nconst formatters = { html, haml, slim, pug };\n/**\n * Parses given Emmet abbreviation into a final abbreviation tree with all\n * required transformations applied\n */\nfunction parse(abbr, config) {\n let oldTextValue;\n if (typeof abbr === 'string') {\n let parseOpt = config;\n if (config.options['jsx.enabled']) {\n parseOpt = Object.assign(Object.assign({}, parseOpt), { jsx: true });\n }\n if (config.options['markup.href']) {\n parseOpt = Object.assign(Object.assign({}, parseOpt), { href: true });\n }\n abbr = parse$2(abbr, parseOpt);\n // remove text field before snippets(abbr, config) call\n // as abbreviation(abbr, parseOpt) already handled it\n oldTextValue = config.text;\n config.text = undefined;\n }\n // Run abbreviation resolve in two passes:\n // 1. Map each node to snippets, which are abbreviations as well. A single snippet\n // may produce multiple nodes\n // 2. Transform every resolved node\n abbr = resolveSnippets(abbr, config);\n walk(abbr, transform, config);\n config.text = oldTextValue !== null && oldTextValue !== void 0 ? oldTextValue : config.text;\n return abbr;\n}\n/**\n * Converts given abbreviation to string according to provided `config`\n */\nfunction stringify(abbr, config) {\n const formatter = formatters[config.syntax] || html;\n return formatter(abbr, config);\n}\n/**\n * Modifies given node and prepares it for output\n */\nfunction transform(node, ancestors, config) {\n implicitTag(node, ancestors, config);\n mergeAttributes(node, config);\n lorem(node, ancestors, config);\n if (config.syntax === 'xsl') {\n xsl(node);\n }\n if (config.options['jsx.enabled']) {\n jsx(node);\n }\n if (config.options['bem.enabled']) {\n bem(node, ancestors, config);\n }\n}\n\nconst reProperty = /^([a-z-]+)(?:\\s*:\\s*([^\\n\\r;]+?);*)?$/;\nconst opt = { value: true };\n/**\n * Creates structure for holding resolved CSS snippet\n */\nfunction createSnippet(key, value) {\n // A snippet could be a raw text snippet (e.g. arbitrary text string) or a\n // CSS property with possible values separated by `|`.\n // In latter case, we have to parse snippet as CSS abbreviation\n const m = value.match(reProperty);\n if (m) {\n const keywords = {};\n const parsed = m[2] ? m[2].split('|').map(parseValue) : [];\n for (const item of parsed) {\n for (const cssVal of item) {\n collectKeywords(cssVal, keywords);\n }\n }\n return {\n type: \"Property\" /* Property */,\n key,\n property: m[1],\n value: parsed,\n keywords,\n dependencies: []\n };\n }\n return { type: \"Raw\" /* Raw */, key, value };\n}\n/**\n * Nests more specific CSS properties into shorthand ones, e.g.\n * `background-position-x` -> `background-position` -> `background`\n */\nfunction nest(snippets) {\n snippets = snippets.slice().sort(snippetsSort);\n const stack = [];\n let prev;\n // For sorted list of CSS properties, create dependency graph where each\n // shorthand property contains its more specific one, e.g.\n // background -> background-position -> background-position-x\n for (const cur of snippets.filter(isProperty)) {\n // Check if current property belongs to one from parent stack.\n // Since `snippets` array is sorted, items are perfectly aligned\n // from shorthands to more specific variants\n while (stack.length) {\n prev = stack[stack.length - 1];\n if (cur.property.startsWith(prev.property)\n && cur.property.charCodeAt(prev.property.length) === 45 /* - */) {\n prev.dependencies.push(cur);\n stack.push(cur);\n break;\n }\n stack.pop();\n }\n if (!stack.length) {\n stack.push(cur);\n }\n }\n return snippets;\n}\n/**\n * A sorting function for array of snippets\n */\nfunction snippetsSort(a, b) {\n if (a.key === b.key) {\n return 0;\n }\n return a.key < b.key ? -1 : 1;\n}\nfunction parseValue(value) {\n return parse$3(value.trim(), opt)[0].value;\n}\nfunction isProperty(snippet) {\n return snippet.type === \"Property\" /* Property */;\n}\nfunction collectKeywords(cssVal, dest) {\n for (const v of cssVal.value) {\n if (v.type === 'Literal') {\n dest[v.value] = v;\n }\n else if (v.type === 'FunctionCall') {\n dest[v.name] = v;\n }\n else if (v.type === 'Field') {\n // Create literal from field, if available\n const value = v.name.trim();\n if (value) {\n dest[value] = { type: 'Literal', value };\n }\n }\n }\n}\n\n/**\n * Calculates how close `str1` matches `str2` using fuzzy match.\n * How matching works:\n * – first characters of both `str1` and `str2` *must* match\n * – `str1` length larger than `str2` length is allowed only when `unmatched` is true\n * – ideal match is when `str1` equals to `str2` (score: 1)\n * – next best match is `str2` starts with `str1` (score: 1 × percent of matched characters)\n * – other scores depend on how close characters of `str1` to the beginning of `str2`\n * @param partialMatch Allow length `str1` to be greater than `str2` length\n */\nfunction scoreMatch(str1, str2, partialMatch = false) {\n str1 = str1.toLowerCase();\n str2 = str2.toLowerCase();\n if (str1 === str2) {\n return 1;\n }\n // Both strings MUST start with the same character\n if (!str1 || !str2 || str1.charCodeAt(0) !== str2.charCodeAt(0)) {\n return 0;\n }\n const str1Len = str1.length;\n const str2Len = str2.length;\n if (!partialMatch && str1Len > str2Len) {\n return 0;\n }\n // Characters from `str1` which are closer to the beginning of a `str2` should\n // have higher score.\n // For example, if `str2` is `abcde`, it’s max score is:\n // 5 + 4 + 3 + 2 + 1 = 15 (sum of character positions in reverse order)\n // Matching `abd` against `abcde` should produce:\n // 5 + 4 + 2 = 11\n // Acronym bonus for match right after `-`. Matching `abd` against `abc-de`\n // should produce:\n // 6 + 5 + 4 (use `d` position in `abd`, not in abc-de`)\n const minLength = Math.min(str1Len, str2Len);\n const maxLength = Math.max(str1Len, str2Len);\n let i = 1;\n let j = 1;\n let score = maxLength;\n let ch1 = 0;\n let ch2 = 0;\n let found = false;\n let acronym = false;\n while (i < str1Len) {\n ch1 = str1.charCodeAt(i);\n found = false;\n acronym = false;\n while (j < str2Len) {\n ch2 = str2.charCodeAt(j);\n if (ch1 === ch2) {\n found = true;\n score += maxLength - (acronym ? i : j);\n break;\n }\n // add acronym bonus for exactly next match after unmatched `-`\n acronym = ch2 === 45 /* - */;\n j++;\n }\n if (!found) {\n if (!partialMatch) {\n return 0;\n }\n break;\n }\n i++;\n }\n const matchRatio = i / maxLength;\n const delta = maxLength - minLength;\n const maxScore = sum(maxLength) - sum(delta);\n return (score * matchRatio) / maxScore;\n}\n/**\n * Calculates sum of first `n` numbers, e.g. 1+2+3+...n\n */\nfunction sum(n) {\n return n * (n + 1) / 2;\n}\n\nfunction color(token, shortHex) {\n if (!token.r && !token.g && !token.b && !token.a) {\n return 'transparent';\n }\n else if (token.a === 1) {\n return asHex(token, shortHex);\n }\n return asRGB(token);\n}\n/**\n * Output given color as hex value\n * @param short Produce short value (e.g. #fff instead of #ffffff), if possible\n */\nfunction asHex(token, short) {\n const fn = (short && isShortHex(token.r) && isShortHex(token.g) && isShortHex(token.b))\n ? toShortHex : toHex;\n return '#' + fn(token.r) + fn(token.g) + fn(token.b);\n}\n/**\n * Output current color as `rgba?(...)` CSS color\n */\nfunction asRGB(token) {\n const values = [token.r, token.g, token.b];\n if (token.a !== 1) {\n values.push(frac(token.a, 8));\n }\n return `${values.length === 3 ? 'rgb' : 'rgba'}(${values.join(', ')})`;\n}\nfunction frac(num, digits = 4) {\n return num.toFixed(digits).replace(/\\.?0+$/, '');\n}\nfunction isShortHex(hex) {\n return !(hex % 17);\n}\nfunction toShortHex(num) {\n return (num >> 4).toString(16);\n}\nfunction toHex(num) {\n return pad(num.toString(16), 2);\n}\nfunction pad(value, len) {\n while (value.length < len) {\n value = '0' + value;\n }\n return value;\n}\n\nfunction css(abbr, config) {\n var _a;\n const out = createOutputStream(config.options);\n const format = config.options['output.format'];\n if (((_a = config.context) === null || _a === void 0 ? void 0 : _a.name) === \"@@section\" /* Section */) {\n // For section context, filter out unmatched snippets\n abbr = abbr.filter(node => node.snippet);\n }\n for (let i = 0; i < abbr.length; i++) {\n if (format && i !== 0) {\n pushNewline(out, true);\n }\n property(abbr[i], out, config);\n }\n return out.value;\n}\n/**\n * Outputs given abbreviation node into output stream\n */\nfunction property(node, out, config) {\n const isJSON = config.options['stylesheet.json'];\n if (node.name) {\n // It’s a CSS property\n const name = isJSON ? toCamelCase(node.name) : node.name;\n pushString(out, name + config.options['stylesheet.between']);\n if (node.value.length) {\n propertyValue(node, out, config);\n }\n else {\n pushField(out, 0, '');\n }\n if (isJSON) {\n // For CSS-in-JS, always finalize property with comma\n // NB: seems like `important` is not available in CSS-in-JS syntaxes\n push(out, ',');\n }\n else {\n outputImportant(node, out, true);\n push(out, config.options['stylesheet.after']);\n }\n }\n else {\n // It’s a regular snippet, output plain tokens without any additional formatting\n for (const cssVal of node.value) {\n for (const v of cssVal.value) {\n outputToken(v, out, config);\n }\n }\n outputImportant(node, out, node.value.length > 0);\n }\n}\nfunction propertyValue(node, out, config) {\n const isJSON = config.options['stylesheet.json'];\n const num = isJSON ? getSingleNumeric(node) : null;\n if (num && (!num.unit || num.unit === 'px')) {\n // For CSS-in-JS, if property contains single numeric value, output it\n // as JS number\n push(out, String(num.value));\n }\n else {\n const quote = getQuote(config);\n isJSON && push(out, quote);\n for (let i = 0; i < node.value.length; i++) {\n if (i !== 0) {\n push(out, ', ');\n }\n outputValue(node.value[i], out, config);\n }\n isJSON && push(out, quote);\n }\n}\nfunction outputImportant(node, out, separator) {\n if (node.important) {\n if (separator) {\n push(out, ' ');\n }\n push(out, '!important');\n }\n}\nfunction outputValue(value, out, config) {\n for (let i = 0, prevEnd = -1; i < value.value.length; i++) {\n const token = value.value[i];\n // Handle edge case: a field is written close to previous token like this: `foo${bar}`.\n // We should not add delimiter here\n if (i !== 0 && (token.type !== 'Field' || token.start !== prevEnd)) {\n push(out, ' ');\n }\n outputToken(token, out, config);\n prevEnd = token['end'];\n }\n}\nfunction outputToken(token, out, config) {\n if (token.type === 'ColorValue') {\n push(out, color(token, config.options['stylesheet.shortHex']));\n }\n else if (token.type === 'Literal') {\n pushString(out, token.value);\n }\n else if (token.type === 'NumberValue') {\n pushString(out, frac(token.value, 4) + token.unit);\n }\n else if (token.type === 'StringValue') {\n const quote = token.quote === 'double' ? '\"' : '\\'';\n pushString(out, quote + token.value + quote);\n }\n else if (token.type === 'Field') {\n pushField(out, token.index, token.name);\n }\n else if (token.type === 'FunctionCall') {\n push(out, token.name + '(');\n for (let i = 0; i < token.arguments.length; i++) {\n if (i) {\n push(out, ', ');\n }\n outputValue(token.arguments[i], out, config);\n }\n push(out, ')');\n }\n}\n/**\n * If value of given property is a single numeric value, returns this token\n */\nfunction getSingleNumeric(node) {\n if (node.value.length === 1) {\n const cssVal = node.value[0];\n if (cssVal.value.length === 1 && cssVal.value[0].type === 'NumberValue') {\n return cssVal.value[0];\n }\n }\n}\n/**\n * Converts kebab-case string to camelCase\n */\nfunction toCamelCase(str) {\n return str.replace(/\\-(\\w)/g, (_, letter) => letter.toUpperCase());\n}\nfunction getQuote(config) {\n return config.options['stylesheet.jsonDoubleQuotes'] ? '\"' : '\\'';\n}\n\nconst gradientName = 'lg';\n/**\n * Parses given Emmet abbreviation into a final abbreviation tree with all\n * required transformations applied\n */\nfunction parse$1(abbr, config) {\n var _a;\n const snippets = ((_a = config.cache) === null || _a === void 0 ? void 0 : _a.stylesheetSnippets) || convertSnippets(config.snippets);\n if (config.cache) {\n config.cache.stylesheetSnippets = snippets;\n }\n if (typeof abbr === 'string') {\n abbr = parse$3(abbr, { value: isValueScope(config) });\n }\n const filteredSnippets = getSnippetsForScope(snippets, config);\n for (const node of abbr) {\n resolveNode(node, filteredSnippets, config);\n }\n return abbr;\n}\n/**\n * Converts given raw snippets into internal snippets representation\n */\nfunction convertSnippets(snippets) {\n const result = [];\n for (const key of Object.keys(snippets)) {\n result.push(createSnippet(key, snippets[key]));\n }\n return nest(result);\n}\n/**\n * Resolves given node: finds matched CSS snippets using fuzzy match and resolves\n * keyword aliases from node value\n */\nfunction resolveNode(node, snippets, config) {\n if (!resolveGradient(node, config)) {\n const score = config.options['stylesheet.fuzzySearchMinScore'];\n if (isValueScope(config)) {\n // Resolve as value of given CSS property\n const propName = config.context.name;\n const snippet = snippets.find(s => s.type === \"Property\" /* Property */ && s.property === propName);\n resolveValueKeywords(node, config, snippet, score);\n node.snippet = snippet;\n }\n else if (node.name) {\n const snippet = findBestMatch(node.name, snippets, score, true);\n node.snippet = snippet;\n if (snippet) {\n if (snippet.type === \"Property\" /* Property */) {\n resolveAsProperty(node, snippet, config);\n }\n else {\n resolveAsSnippet(node, snippet);\n }\n }\n }\n }\n if (node.name || config.context) {\n // Resolve numeric values for CSS properties only\n resolveNumericValue(node, config);\n }\n return node;\n}\n/**\n * Resolves CSS gradient shortcut from given property, if possible\n */\nfunction resolveGradient(node, config) {\n let gradientFn = null;\n const cssVal = node.value.length === 1 ? node.value[0] : null;\n if (cssVal && cssVal.value.length === 1) {\n const v = cssVal.value[0];\n if (v.type === 'FunctionCall' && v.name === gradientName) {\n gradientFn = v;\n }\n }\n if (gradientFn || node.name === gradientName) {\n if (!gradientFn) {\n gradientFn = {\n type: 'FunctionCall',\n name: 'linear-gradient',\n arguments: [cssValue(field(0, ''))]\n };\n }\n else {\n gradientFn = Object.assign(Object.assign({}, gradientFn), { name: 'linear-gradient' });\n }\n if (!config.context) {\n node.name = 'background-image';\n }\n node.value = [cssValue(gradientFn)];\n return true;\n }\n return false;\n}\n/**\n * Resolves given parsed abbreviation node as CSS property\n */\nfunction resolveAsProperty(node, snippet, config) {\n const abbr = node.name;\n // Check for unmatched part of abbreviation\n // For example, in `dib` abbreviation the matched part is `d` and `ib` should\n // be considered as inline value. If unmatched fragment exists, we should check\n // if it matches actual value of snippet. If either explicit value is specified\n // or unmatched fragment did not resolve to to a keyword, we should consider\n // matched snippet as invalid\n const inlineValue = getUnmatchedPart(abbr, snippet.key);\n if (inlineValue) {\n if (node.value.length) {\n // Already have value: unmatched part indicates matched snippet is invalid\n return node;\n }\n const kw = resolveKeyword(inlineValue, config, snippet);\n if (!kw) {\n return node;\n }\n node.value.push(cssValue(kw));\n }\n node.name = snippet.property;\n if (node.value.length) {\n // Replace keyword alias from current abbreviation node with matched keyword\n resolveValueKeywords(node, config, snippet);\n }\n else if (snippet.value.length) {\n const defaultValue = snippet.value[0];\n // https://github.com/emmetio/emmet/issues/558\n // We should auto-select inserted value only if there’s multiple value\n // choice\n node.value = snippet.value.length === 1 || defaultValue.some(hasField)\n ? defaultValue\n : defaultValue.map(n => wrapWithField(n, config));\n }\n return node;\n}\nfunction resolveValueKeywords(node, config, snippet, minScore) {\n for (const cssVal of node.value) {\n const value = [];\n for (const token of cssVal.value) {\n if (token.type === 'Literal') {\n value.push(resolveKeyword(token.value, config, snippet, minScore) || token);\n }\n else if (token.type === 'FunctionCall') {\n // For function calls, we should find matching function call\n // and merge arguments\n const match = resolveKeyword(token.name, config, snippet, minScore);\n if (match && match.type === 'FunctionCall') {\n value.push(Object.assign(Object.assign({}, match), { arguments: token.arguments.concat(match.arguments.slice(token.arguments.length)) }));\n }\n else {\n value.push(token);\n }\n }\n else {\n value.push(token);\n }\n }\n cssVal.value = value;\n }\n}\n/**\n * Resolves given parsed abbreviation node as a snippet: a plain code chunk\n */\nfunction resolveAsSnippet(node, snippet) {\n // When resolving snippets, we have to do the following:\n // 1. Replace field placeholders with actual field tokens.\n // 2. If input values given, put them instead of fields\n let offset = 0;\n let m;\n const reField = /\\$\\{(\\d+)(:[^}]+)?\\}/g;\n const inputValue = node.value[0];\n const outputValue = [];\n while (m = reField.exec(snippet.value)) {\n if (offset !== m.index) {\n outputValue.push(literal(snippet.value.slice(offset, m.index)));\n }\n offset = m.index + m[0].length;\n if (inputValue && inputValue.value.length) {\n outputValue.push(inputValue.value.shift());\n }\n else {\n outputValue.push(field(Number(m[1]), m[2] ? m[2].slice(1) : ''));\n }\n }\n const tail = snippet.value.slice(offset);\n if (tail) {\n outputValue.push(literal(tail));\n }\n node.name = void 0;\n node.value = [cssValue(...outputValue)];\n return node;\n}\n/**\n * Finds best matching item from `items` array\n * @param abbr Abbreviation to match\n * @param items List of items for match\n * @param minScore The minimum score the best matched item should have to be a valid match.\n */\nfunction findBestMatch(abbr, items, minScore = 0, partialMatch = false) {\n let matchedItem = null;\n let maxScore = 0;\n for (const item of items) {\n const score = scoreMatch(abbr, getScoringPart(item), partialMatch);\n if (score === 1) {\n // direct hit, no need to look further\n return item;\n }\n if (score && score >= maxScore) {\n maxScore = score;\n matchedItem = item;\n }\n }\n return maxScore >= minScore ? matchedItem : null;\n}\nfunction getScoringPart(item) {\n return typeof item === 'string' ? item : item.key;\n}\n/**\n * Returns a part of `abbr` that wasn’t directly matched against `str`.\n * For example, if abbreviation `poas` is matched against `position`,\n * the unmatched part will be `as` since `a` wasn’t found in string stream\n */\nfunction getUnmatchedPart(abbr, str) {\n for (let i = 0, lastPos = 0; i < abbr.length; i++) {\n lastPos = str.indexOf(abbr[i], lastPos);\n if (lastPos === -1) {\n return abbr.slice(i);\n }\n lastPos++;\n }\n return '';\n}\n/**\n * Resolves given keyword shorthand into matched snippet keyword or global keyword,\n * if possible\n */\nfunction resolveKeyword(kw, config, snippet, minScore) {\n let ref;\n if (snippet) {\n if (ref = findBestMatch(kw, Object.keys(snippet.keywords), minScore)) {\n return snippet.keywords[ref];\n }\n for (const dep of snippet.dependencies) {\n if (ref = findBestMatch(kw, Object.keys(dep.keywords), minScore)) {\n return dep.keywords[ref];\n }\n }\n }\n if (ref = findBestMatch(kw, config.options['stylesheet.keywords'], minScore)) {\n return literal(ref);\n }\n return null;\n}\n/**\n * Resolves numeric values in given abbreviation node\n */\nfunction resolveNumericValue(node, config) {\n const aliases = config.options['stylesheet.unitAliases'];\n const unitless = config.options['stylesheet.unitless'];\n for (const v of node.value) {\n for (const t of v.value) {\n if (t.type === 'NumberValue') {\n if (t.unit) {\n t.unit = aliases[t.unit] || t.unit;\n }\n else if (t.value !== 0 && !unitless.includes(node.name)) {\n t.unit = t.rawValue.includes('.')\n ? config.options['stylesheet.floatUnit']\n : config.options['stylesheet.intUnit'];\n }\n }\n }\n }\n}\n/**\n * Constructs CSS value token\n */\nfunction cssValue(...args) {\n return {\n type: 'CSSValue',\n value: args\n };\n}\n/**\n * Constructs literal token\n */\nfunction literal(value) {\n return { type: 'Literal', value };\n}\n/**\n * Constructs field token\n */\nfunction field(index, name) {\n return { type: 'Field', index, name };\n}\n/**\n * Check if given value contains fields\n */\nfunction hasField(value) {\n for (const v of value.value) {\n if (v.type === 'Field' || (v.type === 'FunctionCall' && v.arguments.some(hasField))) {\n return true;\n }\n }\n return false;\n}\n/**\n * Wraps tokens of given abbreviation with fields\n */\nfunction wrapWithField(node, config, state = { index: 1 }) {\n let value = [];\n for (const v of node.value) {\n switch (v.type) {\n case 'ColorValue':\n value.push(field(state.index++, color(v, config.options['stylesheet.shortHex'])));\n break;\n case 'Literal':\n value.push(field(state.index++, v.value));\n break;\n case 'NumberValue':\n value.push(field(state.index++, `${v.value}${v.unit}`));\n break;\n case 'StringValue':\n const q = v.quote === 'single' ? '\\'' : '\"';\n value.push(field(state.index++, q + v.value + q));\n break;\n case 'FunctionCall':\n value.push(field(state.index++, v.name), literal('('));\n for (let i = 0, il = v.arguments.length; i < il; i++) {\n value = value.concat(wrapWithField(v.arguments[i], config, state).value);\n if (i !== il - 1) {\n value.push(literal(', '));\n }\n }\n value.push(literal(')'));\n break;\n default:\n value.push(v);\n }\n }\n return Object.assign(Object.assign({}, node), { value });\n}\n/**\n * Check if abbreviation should be expanded in CSS value context\n */\nfunction isValueScope(config) {\n if (config.context) {\n return config.context.name === \"@@value\" /* Value */ || !config.context.name.startsWith('@@');\n }\n return false;\n}\n/**\n * Returns snippets for given scope\n */\nfunction getSnippetsForScope(snippets, config) {\n if (config.context) {\n if (config.context.name === \"@@section\" /* Section */) {\n return snippets.filter(s => s.type === \"Raw\" /* Raw */);\n }\n if (config.context.name === \"@@property\" /* Property */) {\n return snippets.filter(s => s.type === \"Property\" /* Property */);\n }\n }\n return snippets;\n}\n\nvar markupSnippets = {\n\t\"a\": \"a[href]\",\n\t\"a:blank\": \"a[href='http://${0}' target='_blank' rel='noopener noreferrer']\",\n\t\"a:link\": \"a[href='http://${0}']\",\n\t\"a:mail\": \"a[href='mailto:${0}']\",\n\t\"a:tel\": \"a[href='tel:+${0}']\",\n\t\"abbr\": \"abbr[title]\",\n\t\"acr|acronym\": \"acronym[title]\",\n\t\"base\": \"base[href]/\",\n\t\"basefont\": \"basefont/\",\n\t\"br\": \"br/\",\n\t\"frame\": \"frame/\",\n\t\"hr\": \"hr/\",\n\t\"bdo\": \"bdo[dir]\",\n\t\"bdo:r\": \"bdo[dir=rtl]\",\n\t\"bdo:l\": \"bdo[dir=ltr]\",\n\t\"col\": \"col/\",\n\t\"link\": \"link[rel=stylesheet href]/\",\n\t\"link:css\": \"link[href='${1:style}.css']\",\n\t\"link:print\": \"link[href='${1:print}.css' media=print]\",\n\t\"link:favicon\": \"link[rel='shortcut icon' type=image/x-icon href='${1:favicon.ico}']\",\n\t\"link:mf|link:manifest\": \"link[rel='manifest' href='${1:manifest.json}']\",\n\t\"link:touch\": \"link[rel=apple-touch-icon href='${1:favicon.png}']\",\n\t\"link:rss\": \"link[rel=alternate type=application/rss+xml title=RSS href='${1:rss.xml}']\",\n\t\"link:atom\": \"link[rel=alternate type=application/atom+xml title=Atom href='${1:atom.xml}']\",\n\t\"link:im|link:import\": \"link[rel=import href='${1:component}.html']\",\n\t\"meta\": \"meta/\",\n\t\"meta:utf\": \"meta[http-equiv=Content-Type content='text/html;charset=UTF-8']\",\n\t\"meta:vp\": \"meta[name=viewport content='width=${1:device-width}, initial-scale=${2:1.0}']\",\n\t\"meta:compat\": \"meta[http-equiv=X-UA-Compatible content='${1:IE=7}']\",\n\t\"meta:edge\": \"meta:compat[content='${1:ie=edge}']\",\n\t\"meta:redirect\": \"meta[http-equiv=refresh content='0; url=${1:http://example.com}']\",\n\t\"meta:kw\": \"meta[name=keywords content]\",\n\t\"meta:desc\": \"meta[name=description content]\",\n\t\"style\": \"style\",\n\t\"script\": \"script\",\n\t\"script:src\": \"script[src]\",\n\t\"img\": \"img[src alt]/\",\n\t\"img:s|img:srcset\": \"img[srcset src alt]\",\n\t\"img:z|img:sizes\": \"img[sizes srcset src alt]\",\n\t\"picture\": \"picture\",\n\t\"src|source\": \"source/\",\n\t\"src:sc|source:src\": \"source[src type]\",\n\t\"src:s|source:srcset\": \"source[srcset]\",\n\t\"src:t|source:type\": \"source[srcset type='${1:image/}']\",\n\t\"src:z|source:sizes\": \"source[sizes srcset]\",\n\t\"src:m|source:media\": \"source[media='(${1:min-width: })' srcset]\",\n\t\"src:mt|source:media:type\": \"source:media[type='${2:image/}']\",\n\t\"src:mz|source:media:sizes\": \"source:media[sizes srcset]\",\n\t\"src:zt|source:sizes:type\": \"source[sizes srcset type='${1:image/}']\",\n\t\"iframe\": \"iframe[src frameborder=0]\",\n\t\"embed\": \"embed[src type]/\",\n\t\"object\": \"object[data type]\",\n\t\"param\": \"param[name value]/\",\n\t\"map\": \"map[name]\",\n\t\"area\": \"area[shape coords href alt]/\",\n\t\"area:d\": \"area[shape=default]\",\n\t\"area:c\": \"area[shape=circle]\",\n\t\"area:r\": \"area[shape=rect]\",\n\t\"area:p\": \"area[shape=poly]\",\n\t\"form\": \"form[action]\",\n\t\"form:get\": \"form[method=get]\",\n\t\"form:post\": \"form[method=post]\",\n\t\"label\": \"label[for]\",\n\t\"input\": \"input[type=${1:text}]/\",\n\t\"inp\": \"input[name=${1} id=${1}]\",\n\t\"input:h|input:hidden\": \"input[type=hidden name]\",\n\t\"input:t|input:text\": \"inp[type=text]\",\n\t\"input:search\": \"inp[type=search]\",\n\t\"input:email\": \"inp[type=email]\",\n\t\"input:url\": \"inp[type=url]\",\n\t\"input:p|input:password\": \"inp[type=password]\",\n\t\"input:datetime\": \"inp[type=datetime]\",\n\t\"input:date\": \"inp[type=date]\",\n\t\"input:datetime-local\": \"inp[type=datetime-local]\",\n\t\"input:month\": \"inp[type=month]\",\n\t\"input:week\": \"inp[type=week]\",\n\t\"input:time\": \"inp[type=time]\",\n\t\"input:tel\": \"inp[type=tel]\",\n\t\"input:number\": \"inp[type=number]\",\n\t\"input:color\": \"inp[type=color]\",\n\t\"input:c|input:checkbox\": \"inp[type=checkbox]\",\n\t\"input:r|input:radio\": \"inp[type=radio]\",\n\t\"input:range\": \"inp[type=range]\",\n\t\"input:f|input:file\": \"inp[type=file]\",\n\t\"input:s|input:submit\": \"input[type=submit value]\",\n\t\"input:i|input:image\": \"input[type=image src alt]\",\n\t\"input:b|input:btn|input:button\": \"input[type=button value]\",\n\t\"input:reset\": \"input:button[type=reset]\",\n\t\"isindex\": \"isindex/\",\n\t\"select\": \"select[name=${1} id=${1}]\",\n\t\"select:d|select:disabled\": \"select[disabled.]\",\n\t\"opt|option\": \"option[value]\",\n\t\"textarea\": \"textarea[name=${1} id=${1} cols=${2:30} rows=${3:10}]\",\n\t\"marquee\": \"marquee[behavior direction]\",\n\t\"menu:c|menu:context\": \"menu[type=context]\",\n\t\"menu:t|menu:toolbar\": \"menu[type=toolbar]\",\n\t\"video\": \"video[src]\",\n\t\"audio\": \"audio[src]\",\n\t\"html:xml\": \"html[xmlns=http://www.w3.org/1999/xhtml]\",\n\t\"keygen\": \"keygen/\",\n\t\"command\": \"command/\",\n\t\"btn:s|button:s|button:submit\" : \"button[type=submit]\",\n\t\"btn:r|button:r|button:reset\" : \"button[type=reset]\",\n\t\"btn:d|button:d|button:disabled\" : \"button[disabled.]\",\n\t\"fst:d|fset:d|fieldset:d|fieldset:disabled\" : \"fieldset[disabled.]\",\n\n\t\"bq\": \"blockquote\",\n\t\"fig\": \"figure\",\n\t\"figc\": \"figcaption\",\n\t\"pic\": \"picture\",\n\t\"ifr\": \"iframe\",\n\t\"emb\": \"embed\",\n\t\"obj\": \"object\",\n\t\"cap\": \"caption\",\n\t\"colg\": \"colgroup\",\n\t\"fst\": \"fieldset\",\n\t\"btn\": \"button\",\n\t\"optg\": \"optgroup\",\n\t\"tarea\": \"textarea\",\n\t\"leg\": \"legend\",\n\t\"sect\": \"section\",\n\t\"art\": \"article\",\n\t\"hdr\": \"header\",\n\t\"ftr\": \"footer\",\n\t\"adr\": \"address\",\n\t\"dlg\": \"dialog\",\n\t\"str\": \"strong\",\n\t\"prog\": \"progress\",\n\t\"mn\": \"main\",\n\t\"tem\": \"template\",\n\t\"fset\": \"fieldset\",\n\t\"datag\": \"datagrid\",\n\t\"datal\": \"datalist\",\n\t\"kg\": \"keygen\",\n\t\"out\": \"output\",\n\t\"det\": \"details\",\n\t\"sum\": \"summary\",\n\t\"cmd\": \"command\",\n\n\t\"ri:d|ri:dpr\": \"img:s\",\n\t\"ri:v|ri:viewport\": \"img:z\",\n\t\"ri:a|ri:art\": \"pic>src:m+img\",\n\t\"ri:t|ri:type\": \"pic>src:t+img\",\n\n\t\"!!!\": \"{}\",\n\t\"doc\": \"html[lang=${lang}]>(head>meta[charset=${charset}]+meta[http-equiv='X-UA-Compatible'][content='IE=edge']+meta:vp+title{${1:Document}})+body\",\n\t\"!|html:5\": \"!!!+doc\",\n\n\t\"c\": \"{}\",\n\t\"cc:ie\": \"{}\",\n\t\"cc:noie\": \"{${0}}\"\n};\n\nvar stylesheetSnippets = {\n\t\"@f\": \"@font-face {\\n\\tfont-family: ${1};\\n\\tsrc: url(${2});\\n}\",\n\t\"@ff\": \"@font-face {\\n\\tfont-family: '${1:FontName}';\\n\\tsrc: url('${2:FileName}.eot');\\n\\tsrc: url('${2:FileName}.eot?#iefix') format('embedded-opentype'),\\n\\t\\t url('${2:FileName}.woff') format('woff'),\\n\\t\\t url('${2:FileName}.ttf') format('truetype'),\\n\\t\\t url('${2:FileName}.svg#${1:FontName}') format('svg');\\n\\tfont-style: ${3:normal};\\n\\tfont-weight: ${4:normal};\\n}\",\n\t\"@i|@import\": \"@import url(${0});\",\n\t\"@kf\": \"@keyframes ${1:identifier} {\\n\\t${2}\\n}\",\n\t\"@m|@media\": \"@media ${1:screen} {\\n\\t${0}\\n}\",\n\t\"ac\": \"align-content:start|end|flex-start|flex-end|center|space-between|space-around|stretch|space-evenly\",\n\t\"ai\": \"align-items:start|end|flex-start|flex-end|center|baseline|stretch\",\n\t\"anim\": \"animation:${1:name} ${2:duration} ${3:timing-function} ${4:delay} ${5:iteration-count} ${6:direction} ${7:fill-mode}\",\n\t\"animdel\": \"animation-delay:time\",\n\t\"animdir\": \"animation-direction:normal|reverse|alternate|alternate-reverse\",\n\t\"animdur\": \"animation-duration:${1:0}s\",\n\t\"animfm\": \"animation-fill-mode:both|forwards|backwards\",\n\t\"animic\": \"animation-iteration-count:1|infinite\",\n\t\"animn\": \"animation-name\",\n\t\"animps\": \"animation-play-state:running|paused\",\n\t\"animtf\": \"animation-timing-function:linear|ease|ease-in|ease-out|ease-in-out|cubic-bezier(${1:0.1}, ${2:0.7}, ${3:1.0}, ${3:0.1})\",\n\t\"ap\": \"appearance:none\",\n\t\"as\": \"align-self:start|end|auto|flex-start|flex-end|center|baseline|stretch\",\n\t\"b\": \"bottom\",\n\t\"bd\": \"border:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdb\": \"border-bottom:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdbc\": \"border-bottom-color:${1:#000}\",\n\t\"bdbi\": \"border-bottom-image:url(${0})\",\n\t\"bdbk\": \"border-break:close\",\n\t\"bdbli\": \"border-bottom-left-image:url(${0})|continue\",\n\t\"bdblrs\": \"border-bottom-left-radius\",\n\t\"bdbri\": \"border-bottom-right-image:url(${0})|continue\",\n\t\"bdbrrs\": \"border-bottom-right-radius\",\n\t\"bdbs\": \"border-bottom-style\",\n\t\"bdbw\": \"border-bottom-width\",\n\t\"bdc\": \"border-color:${1:#000}\",\n\t\"bdci\": \"border-corner-image:url(${0})|continue\",\n\t\"bdcl\": \"border-collapse:collapse|separate\",\n\t\"bdf\": \"border-fit:repeat|clip|scale|stretch|overwrite|overflow|space\",\n\t\"bdi\": \"border-image:url(${0})\",\n\t\"bdl\": \"border-left:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdlc\": \"border-left-color:${1:#000}\",\n\t\"bdlen\": \"border-length\",\n\t\"bdli\": \"border-left-image:url(${0})\",\n\t\"bdls\": \"border-left-style\",\n\t\"bdlw\": \"border-left-width\",\n\t\"bdr\": \"border-right:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdrc\": \"border-right-color:${1:#000}\",\n\t\"bdri\": \"border-right-image:url(${0})\",\n\t\"bdrs\": \"border-radius\",\n\t\"bdrst\": \"border-right-style\",\n\t\"bdrw\": \"border-right-width\",\n\t\"bds\": \"border-style:none|hidden|dotted|dashed|solid|double|dot-dash|dot-dot-dash|wave|groove|ridge|inset|outset\",\n\t\"bdsp\": \"border-spacing\",\n\t\"bdt\": \"border-top:${1:1px} ${2:solid} ${3:#000}\",\n\t\"bdtc\": \"border-top-color:${1:#000}\",\n\t\"bdti\": \"border-top-image:url(${0})\",\n\t\"bdtli\": \"border-top-left-image:url(${0})|continue\",\n\t\"bdtlrs\": \"border-top-left-radius\",\n\t\"bdtri\": \"border-top-right-image:url(${0})|continue\",\n\t\"bdtrrs\": \"border-top-right-radius\",\n\t\"bdts\": \"border-top-style\",\n\t\"bdtw\": \"border-top-width\",\n\t\"bdw\": \"border-width\",\n\t\"bfv\": \"backface-visibility:hidden|visible\",\n\t\"bg\": \"background:${1:#000}\",\n\t\"bga\": \"background-attachment:fixed|scroll\",\n\t\"bgbk\": \"background-break:bounding-box|each-box|continuous\",\n\t\"bgc\": \"background-color:#${1:fff}\",\n\t\"bgcp\": \"background-clip:padding-box|border-box|content-box|no-clip\",\n\t\"bgi\": \"background-image:url(${0})\",\n\t\"bgo\": \"background-origin:padding-box|border-box|content-box\",\n\t\"bgp\": \"background-position:${1:0} ${2:0}\",\n\t\"bgpx\": \"background-position-x\",\n\t\"bgpy\": \"background-position-y\",\n\t\"bgr\": \"background-repeat:no-repeat|repeat-x|repeat-y|space|round\",\n\t\"bgsz\": \"background-size:contain|cover\",\n\t\"bxsh\": \"box-shadow:${1:inset }${2:hoff} ${3:voff} ${4:blur} ${5:#000}|none\",\n\t\"bxsz\": \"box-sizing:border-box|content-box|border-box\",\n\t\"c\": \"color:${1:#000}\",\n\t\"cr\": \"color:rgb(${1:0}, ${2:0}, ${3:0})\",\n\t\"cra\": \"color:rgba(${1:0}, ${2:0}, ${3:0}, ${4:.5})\",\n\t\"cl\": \"clear:both|left|right|none\",\n\t\"cm\": \"/* ${0} */\",\n\t\"cnt\": \"content:'${0}'|normal|open-quote|no-open-quote|close-quote|no-close-quote|attr(${0})|counter(${0})|counters(${0})\",\n\t\"coi\": \"counter-increment\",\n\t\"colm\": \"columns\",\n\t\"colmc\": \"column-count\",\n\t\"colmf\": \"column-fill\",\n\t\"colmg\": \"column-gap\",\n\t\"colmr\": \"column-rule\",\n\t\"colmrc\": \"column-rule-color\",\n\t\"colmrs\": \"column-rule-style\",\n\t\"colmrw\": \"column-rule-width\",\n\t\"colms\": \"column-span\",\n\t\"colmw\": \"column-width\",\n\t\"cor\": \"counter-reset\",\n\t\"cp\": \"clip:auto|rect(${1:top} ${2:right} ${3:bottom} ${4:left})\",\n\t\"cps\": \"caption-side:top|bottom\",\n\t\"cur\": \"cursor:pointer|auto|default|crosshair|hand|help|move|pointer|text\",\n\t\"d\": \"display:block|none|flex|inline-flex|inline|inline-block|grid|inline-grid|subgrid|list-item|run-in|compact|table|inline-table|table-caption|table-column|table-column-group|table-header-group|table-footer-group|table-row|table-row-group|table-cell|ruby|ruby-base|ruby-base-group|ruby-text|ruby-text-group\",\n\t\"ec\": \"empty-cells:show|hide\",\n\t\"f\": \"font:${1:1em} ${2:sans-serif}\",\n\t\"fd\": \"font-display:auto|block|swap|fallback|optional\",\n\t\"fef\": \"font-effect:none|engrave|emboss|outline\",\n\t\"fem\": \"font-emphasize\",\n\t\"femp\": \"font-emphasize-position:before|after\",\n\t\"fems\": \"font-emphasize-style:none|accent|dot|circle|disc\",\n\t\"ff\": \"font-family:serif|sans-serif|cursive|fantasy|monospace\",\n\t\"fft\": \"font-family:\\\"Times New Roman\\\", Times, Baskerville, Georgia, serif\",\n\t\"ffa\": \"font-family:Arial, \\\"Helvetica Neue\\\", Helvetica, sans-serif\",\n\t\"ffv\": \"font-family:Verdana, Geneva, sans-serif\",\n\t\"fl\": \"float:left|right|none\",\n\t\"fs\": \"font-style:italic|normal|oblique\",\n\t\"fsm\": \"font-smoothing:antialiased|subpixel-antialiased|none\",\n\t\"fst\": \"font-stretch:normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded\",\n\t\"fv\": \"font-variant:normal|small-caps\",\n\t\"fvs\": \"font-variation-settings:normal|inherit|initial|unset\",\n\t\"fw\": \"font-weight:normal|bold|bolder|lighter\",\n\t\"fx\": \"flex\",\n\t\"fxb\": \"flex-basis:fill|max-content|min-content|fit-content|content\",\n\t\"fxd\": \"flex-direction:row|row-reverse|column|column-reverse\",\n\t\"fxf\": \"flex-flow\",\n\t\"fxg\": \"flex-grow\",\n\t\"fxsh\": \"flex-shrink\",\n\t\"fxw\": \"flex-wrap:nowrap|wrap|wrap-reverse\",\n\t\"fsz\": \"font-size\",\n\t\"fsza\": \"font-size-adjust\",\n\t\"gtc\": \"grid-template-columns:repeat()|minmax()\",\n\t\"gtr\": \"grid-template-rows:repeat()|minmax()\",\n\t\"gta\": \"grid-template-areas\",\n\t\"gt\": \"grid-template\",\n\t\"gg\": \"grid-gap\",\n\t\"gcg\": \"grid-column-gap\",\n\t\"grg\": \"grid-row-gap\",\n\t\"gac\": \"grid-auto-columns:auto|minmax()\",\n\t\"gar\": \"grid-auto-rows:auto|minmax()\",\n\t\"gaf\": \"grid-auto-flow:row|column|dense|inherit|initial|unset\",\n\t\"gd\": \"grid\",\n\t\"gc\": \"grid-column\",\n\t\"gcs\": \"grid-column-start\",\n\t\"gce\": \"grid-column-end\",\n\t\"gr\": \"grid-row\",\n\t\"grs\": \"grid-row-start\",\n\t\"gre\": \"grid-row-end\",\n\t\"ga\": \"grid-area\",\n\t\"h\": \"height\",\n\t\"jc\": \"justify-content:start|end|stretch|flex-start|flex-end|center|space-between|space-around|space-evenly\",\n\t\"ji\": \"justify-items:start|end|center|stretch\",\n\t\"js\": \"justify-self:start|end|center|stretch\",\n\t\"l\": \"left\",\n\t\"lg\": \"background-image:linear-gradient(${1})\",\n\t\"lh\": \"line-height\",\n\t\"lis\": \"list-style\",\n\t\"lisi\": \"list-style-image\",\n\t\"lisp\": \"list-style-position:inside|outside\",\n\t\"list\": \"list-style-type:disc|circle|square|decimal|decimal-leading-zero|lower-roman|upper-roman\",\n\t\"lts\": \"letter-spacing:normal\",\n\t\"m\": \"margin\",\n\t\"mah\": \"max-height\",\n\t\"mar\": \"max-resolution\",\n\t\"maw\": \"max-width\",\n\t\"mb\": \"margin-bottom\",\n\t\"mih\": \"min-height\",\n\t\"mir\": \"min-resolution\",\n\t\"miw\": \"min-width\",\n\t\"ml\": \"margin-left\",\n\t\"mr\": \"margin-right\",\n\t\"mt\": \"margin-top\",\n\t\"ol\": \"outline\",\n\t\"olc\": \"outline-color:${1:#000}|invert\",\n\t\"olo\": \"outline-offset\",\n\t\"ols\": \"outline-style:none|dotted|dashed|solid|double|groove|ridge|inset|outset\",\n\t\"olw\": \"outline-width|thin|medium|thick\",\n\t\"op|opa\": \"opacity\",\n\t\"ord\": \"order\",\n\t\"ori\": \"orientation:landscape|portrait\",\n\t\"orp\": \"orphans\",\n\t\"ov\": \"overflow:hidden|visible|hidden|scroll|auto\",\n\t\"ovs\": \"overflow-style:scrollbar|auto|scrollbar|panner|move|marquee\",\n\t\"ovx\": \"overflow-x:hidden|visible|hidden|scroll|auto\",\n\t\"ovy\": \"overflow-y:hidden|visible|hidden|scroll|auto\",\n\t\"p\": \"padding\",\n\t\"pb\": \"padding-bottom\",\n\t\"pgba\": \"page-break-after:auto|always|left|right\",\n\t\"pgbb\": \"page-break-before:auto|always|left|right\",\n\t\"pgbi\": \"page-break-inside:auto|avoid\",\n\t\"pl\": \"padding-left\",\n\t\"pos\": \"position:relative|absolute|relative|fixed|static\",\n\t\"pr\": \"padding-right\",\n\t\"pt\": \"padding-top\",\n\t\"q\": \"quotes\",\n\t\"qen\": \"quotes:'\\\\201C' '\\\\201D' '\\\\2018' '\\\\2019'\",\n\t\"qru\": \"quotes:'\\\\00AB' '\\\\00BB' '\\\\201E' '\\\\201C'\",\n\t\"r\": \"right\",\n\t\"rsz\": \"resize:none|both|horizontal|vertical\",\n\t\"t\": \"top\",\n\t\"ta\": \"text-align:left|center|right|justify\",\n\t\"tal\": \"text-align-last:left|center|right\",\n\t\"tbl\": \"table-layout:fixed\",\n\t\"td\": \"text-decoration:none|underline|overline|line-through\",\n\t\"te\": \"text-emphasis:none|accent|dot|circle|disc|before|after\",\n\t\"th\": \"text-height:auto|font-size|text-size|max-size\",\n\t\"ti\": \"text-indent\",\n\t\"tj\": \"text-justify:auto|inter-word|inter-ideograph|inter-cluster|distribute|kashida|tibetan\",\n\t\"to\": \"text-outline:${1:0} ${2:0} ${3:#000}\",\n\t\"tov\": \"text-overflow:ellipsis|clip\",\n\t\"tr\": \"text-replace\",\n\t\"trf\": \"transform:${1}|skewX(${1:angle})|skewY(${1:angle})|scale(${1:x}, ${2:y})|scaleX(${1:x})|scaleY(${1:y})|scaleZ(${1:z})|scale3d(${1:x}, ${2:y}, ${3:z})|rotate(${1:angle})|rotateX(${1:angle})|rotateY(${1:angle})|rotateZ(${1:angle})|translate(${1:x}, ${2:y})|translateX(${1:x})|translateY(${1:y})|translateZ(${1:z})|translate3d(${1:tx}, ${2:ty}, ${3:tz})\",\n\t\"trfo\": \"transform-origin\",\n\t\"trfs\": \"transform-style:preserve-3d\",\n\t\"trs\": \"transition:${1:prop} ${2:time}\",\n\t\"trsde\": \"transition-delay:${1:time}\",\n\t\"trsdu\": \"transition-duration:${1:time}\",\n\t\"trsp\": \"transition-property:${1:prop}\",\n\t\"trstf\": \"transition-timing-function:${1:fn}\",\n\t\"tsh\": \"text-shadow:${1:hoff} ${2:voff} ${3:blur} ${4:#000}\",\n\t\"tt\": \"text-transform:uppercase|lowercase|capitalize|none\",\n\t\"tw\": \"text-wrap:none|normal|unrestricted|suppress\",\n\t\"us\": \"user-select:none\",\n\t\"v\": \"visibility:hidden|visible|collapse\",\n\t\"va\": \"vertical-align:top|super|text-top|middle|baseline|bottom|text-bottom|sub\",\n\t\"w\": \"width\",\n\t\"whs\": \"white-space:nowrap|pre|pre-wrap|pre-line|normal\",\n\t\"whsc\": \"white-space-collapse:normal|keep-all|loose|break-strict|break-all\",\n\t\"wid\": \"widows\",\n\t\"wm\": \"writing-mode:lr-tb|lr-tb|lr-bt|rl-tb|rl-bt|tb-rl|tb-lr|bt-lr|bt-rl\",\n\t\"wob\": \"word-break:normal|keep-all|break-all\",\n\t\"wos\": \"word-spacing\",\n\t\"wow\": \"word-wrap:none|unrestricted|suppress|break-word|normal\",\n\t\"z\": \"z-index\",\n\t\"zom\": \"zoom:1\"\n};\n\nvar xslSnippets = {\n \"tm|tmatch\": \"xsl:template[match mode]\",\n \"tn|tname\": \"xsl:template[name]\",\n \"call\": \"xsl:call-template[name]\",\n \"ap\": \"xsl:apply-templates[select mode]\",\n \"api\": \"xsl:apply-imports\",\n \"imp\": \"xsl:import[href]\",\n \"inc\": \"xsl:include[href]\",\n \"ch\": \"xsl:choose\",\n \"wh|xsl:when\": \"xsl:when[test]\",\n \"ot\": \"xsl:otherwise\",\n \"if\": \"xsl:if[test]\",\n \"par\": \"xsl:param[name]\",\n \"pare\": \"xsl:param[name select]\",\n \"var\": \"xsl:variable[name]\",\n \"vare\": \"xsl:variable[name select]\",\n \"wp\": \"xsl:with-param[name select]\",\n \"key\": \"xsl:key[name match use]\",\n \"elem\": \"xsl:element[name]\",\n \"attr\": \"xsl:attribute[name]\",\n \"attrs\": \"xsl:attribute-set[name]\",\n \"cp\": \"xsl:copy[select]\",\n \"co\": \"xsl:copy-of[select]\",\n \"val\": \"xsl:value-of[select]\",\n \"for|each\": \"xsl:for-each[select]\",\n \"tex\": \"xsl:text\",\n \"com\": \"xsl:comment\",\n \"msg\": \"xsl:message[terminate=no]\",\n \"fall\": \"xsl:fallback\",\n \"num\": \"xsl:number[value]\",\n \"nam\": \"namespace-alias[stylesheet-prefix result-prefix]\",\n \"pres\": \"xsl:preserve-space[elements]\",\n \"strip\": \"xsl:strip-space[elements]\",\n \"proc\": \"xsl:processing-instruction[name]\",\n \"sort\": \"xsl:sort[select order]\",\n \"choose\": \"xsl:choose>xsl:when+xsl:otherwise\",\n \"xsl\": \"!!!+xsl:stylesheet[version=1.0 xmlns:xsl=http://www.w3.org/1999/XSL/Transform]>{\\n|}\",\n \"!!!\": \"{}\"\n};\n\nvar pugSnippets = {\n\t\"!!!\": \"{doctype html}\"\n};\n\nvar variables = {\n\t\"lang\": \"en\",\n\t\"locale\": \"en-US\",\n\t\"charset\": \"UTF-8\",\n\t\"indentation\": \"\\t\",\n\t\"newline\": \"\\n\"\n};\n\n/**\n * Default syntaxes for abbreviation types\n */\nconst defaultSyntaxes = {\n markup: 'html',\n stylesheet: 'css'\n};\nconst defaultOptions = {\n 'inlineElements': [\n 'a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo',\n 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i',\n 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'object', 'q',\n 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup',\n 'textarea', 'tt', 'u', 'var'\n ],\n 'output.indent': '\\t',\n 'output.baseIndent': '',\n 'output.newline': '\\n',\n 'output.tagCase': '',\n 'output.attributeCase': '',\n 'output.attributeQuotes': 'double',\n 'output.format': true,\n 'output.formatLeafNode': false,\n 'output.formatSkip': ['html'],\n 'output.formatForce': ['body'],\n 'output.inlineBreak': 3,\n 'output.compactBoolean': false,\n 'output.booleanAttributes': [\n 'contenteditable', 'seamless', 'async', 'autofocus',\n 'autoplay', 'checked', 'controls', 'defer', 'disabled', 'formnovalidate',\n 'hidden', 'ismap', 'loop', 'multiple', 'muted', 'novalidate', 'readonly',\n 'required', 'reversed', 'selected', 'typemustmatch'\n ],\n 'output.reverseAttributes': false,\n 'output.selfClosingStyle': 'html',\n 'output.field': (index, placeholder) => placeholder,\n 'output.text': text => text,\n 'markup.href': true,\n 'comment.enabled': false,\n 'comment.trigger': ['id', 'class'],\n 'comment.before': '',\n 'comment.after': '\\n',\n 'bem.enabled': false,\n 'bem.element': '__',\n 'bem.modifier': '_',\n 'jsx.enabled': false,\n 'stylesheet.keywords': ['auto', 'inherit', 'unset', 'none'],\n 'stylesheet.unitless': ['z-index', 'line-height', 'opacity', 'font-weight', 'zoom', 'flex', 'flex-grow', 'flex-shrink'],\n 'stylesheet.shortHex': true,\n 'stylesheet.between': ': ',\n 'stylesheet.after': ';',\n 'stylesheet.intUnit': 'px',\n 'stylesheet.floatUnit': 'em',\n 'stylesheet.unitAliases': { e: 'em', p: '%', x: 'ex', r: 'rem' },\n 'stylesheet.json': false,\n 'stylesheet.jsonDoubleQuotes': false,\n 'stylesheet.fuzzySearchMinScore': 0\n};\nconst defaultConfig = {\n type: 'markup',\n syntax: 'html',\n variables,\n snippets: {},\n options: defaultOptions\n};\n/**\n * Default per-syntax config\n */\nconst syntaxConfig = {\n markup: {\n snippets: parseSnippets(markupSnippets),\n },\n xhtml: {\n options: {\n 'output.selfClosingStyle': 'xhtml'\n }\n },\n xml: {\n options: {\n 'output.selfClosingStyle': 'xml'\n }\n },\n xsl: {\n snippets: parseSnippets(xslSnippets),\n options: {\n 'output.selfClosingStyle': 'xml'\n }\n },\n jsx: {\n options: {\n 'jsx.enabled': true\n }\n },\n pug: {\n snippets: parseSnippets(pugSnippets)\n },\n stylesheet: {\n snippets: parseSnippets(stylesheetSnippets)\n },\n sass: {\n options: {\n 'stylesheet.after': ''\n }\n },\n stylus: {\n options: {\n 'stylesheet.between': ' ',\n 'stylesheet.after': '',\n }\n }\n};\n/**\n * Parses raw snippets definitions with possibly multiple keys into a plan\n * snippet map\n */\nfunction parseSnippets(snippets) {\n const result = {};\n Object.keys(snippets).forEach(k => {\n for (const name of k.split('|')) {\n result[name] = snippets[k];\n }\n });\n return result;\n}\nfunction resolveConfig(config = {}, globals = {}) {\n const type = config.type || 'markup';\n const syntax = config.syntax || defaultSyntaxes[type];\n return Object.assign(Object.assign(Object.assign({}, defaultConfig), config), { type,\n syntax, variables: mergedData(type, syntax, 'variables', config, globals), snippets: mergedData(type, syntax, 'snippets', config, globals), options: mergedData(type, syntax, 'options', config, globals) });\n}\nfunction mergedData(type, syntax, key, config, globals = {}) {\n const typeDefaults = syntaxConfig[type];\n const typeOverride = globals[type];\n const syntaxDefaults = syntaxConfig[syntax];\n const syntaxOverride = globals[syntax];\n return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, defaultConfig[key]), (typeDefaults && typeDefaults[key])), (syntaxDefaults && syntaxDefaults[key])), (typeOverride && typeOverride[key])), (syntaxOverride && syntaxOverride[key])), config[key]);\n}\n\n/**\n * Creates structure for scanning given string in backward direction\n */\nfunction backwardScanner(text, start = 0) {\n return { text, start, pos: text.length };\n}\n/**\n * Check if given scanner position is at start of scanned text\n */\nfunction sol(scanner) {\n return scanner.pos === scanner.start;\n}\n/**\n * “Peeks” character code an current scanner location without advancing it\n */\nfunction peek$1(scanner, offset = 0) {\n return scanner.text.charCodeAt(scanner.pos - 1 + offset);\n}\n/**\n * Returns current character code and moves character location one symbol back\n */\nfunction previous(scanner) {\n if (!sol(scanner)) {\n return scanner.text.charCodeAt(--scanner.pos);\n }\n}\n/**\n * Consumes current character code if it matches given `match` code or function\n */\nfunction consume(scanner, match) {\n if (sol(scanner)) {\n return false;\n }\n const ok = typeof match === 'function'\n ? match(peek$1(scanner))\n : match === peek$1(scanner);\n if (ok) {\n scanner.pos--;\n }\n return !!ok;\n}\nfunction consumeWhile(scanner, match) {\n const start = scanner.pos;\n while (consume(scanner, match)) {\n // empty\n }\n return scanner.pos < start;\n}\n\n/**\n * Check if given character code is a quote\n */\nfunction isQuote(c) {\n return c === 39 /* SingleQuote */ || c === 34 /* DoubleQuote */;\n}\n/**\n * Consumes quoted value, if possible\n * @return Returns `true` is value was consumed\n */\nfunction consumeQuoted(scanner) {\n const start = scanner.pos;\n const quote = previous(scanner);\n if (isQuote(quote)) {\n while (!sol(scanner)) {\n if (previous(scanner) === quote && peek$1(scanner) !== 92 /* Escape */) {\n return true;\n }\n }\n }\n scanner.pos = start;\n return false;\n}\n\nconst bracePairs = {\n [91 /* SquareL */]: 93 /* SquareR */,\n [40 /* RoundL */]: 41 /* RoundR */,\n [123 /* CurlyL */]: 125 /* CurlyR */,\n};\n\n/**\n * Check if given reader’s current position points at the end of HTML tag\n */\nfunction isHtml(scanner) {\n const start = scanner.pos;\n if (!consume(scanner, 62 /* AngleRight */)) {\n return false;\n }\n let ok = false;\n consume(scanner, 47 /* Slash */); // possibly self-closed element\n while (!sol(scanner)) {\n consumeWhile(scanner, isWhiteSpace);\n if (consumeIdent(scanner)) {\n // ate identifier: could be a tag name, boolean attribute or unquoted\n // attribute value\n if (consume(scanner, 47 /* Slash */)) {\n // either closing tag or invalid tag\n ok = consume(scanner, 60 /* AngleLeft */);\n break;\n }\n else if (consume(scanner, 60 /* AngleLeft */)) {\n // opening tag\n ok = true;\n break;\n }\n else if (consume(scanner, isWhiteSpace)) {\n // boolean attribute\n continue;\n }\n else if (consume(scanner, 61 /* Equals */)) {\n // simple unquoted value or invalid attribute\n if (consumeIdent(scanner)) {\n continue;\n }\n break;\n }\n else if (consumeAttributeWithUnquotedValue(scanner)) {\n // identifier was a part of unquoted value\n ok = true;\n break;\n }\n // invalid tag\n break;\n }\n if (consumeAttribute(scanner)) {\n continue;\n }\n break;\n }\n scanner.pos = start;\n return ok;\n}\n/**\n * Consumes HTML attribute from given string.\n * @return `true` if attribute was consumed.\n */\nfunction consumeAttribute(scanner) {\n return consumeAttributeWithQuotedValue(scanner) || consumeAttributeWithUnquotedValue(scanner);\n}\nfunction consumeAttributeWithQuotedValue(scanner) {\n const start = scanner.pos;\n if (consumeQuoted(scanner) && consume(scanner, 61 /* Equals */) && consumeIdent(scanner)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\nfunction consumeAttributeWithUnquotedValue(scanner) {\n const start = scanner.pos;\n const stack = [];\n while (!sol(scanner)) {\n const ch = peek$1(scanner);\n if (isCloseBracket(ch)) {\n stack.push(ch);\n }\n else if (isOpenBracket(ch)) {\n if (stack.pop() !== bracePairs[ch]) {\n // Unexpected open bracket\n break;\n }\n }\n else if (!isUnquotedValue(ch)) {\n break;\n }\n scanner.pos--;\n }\n if (start !== scanner.pos && consume(scanner, 61 /* Equals */) && consumeIdent(scanner)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Consumes HTML identifier from stream\n */\nfunction consumeIdent(scanner) {\n return consumeWhile(scanner, isIdent);\n}\n/**\n * Check if given character code belongs to HTML identifier\n */\nfunction isIdent(ch) {\n return ch === 58 /* Colon */ || ch === 45 /* Dash */ || isAlpha(ch) || isNumber(ch);\n}\n/**\n * Check if given character code is alpha code (letter though A to Z)\n */\nfunction isAlpha(ch) {\n ch &= ~32; // quick hack to convert any char code to uppercase char code\n return ch >= 65 && ch <= 90; // A-Z\n}\n/**\n * Check if given code is a number\n */\nfunction isNumber(ch) {\n return ch > 47 && ch < 58;\n}\n/**\n * Check if given code is a whitespace\n */\nfunction isWhiteSpace(ch) {\n return ch === 32 /* Space */ || ch === 9 /* Tab */;\n}\n/**\n * Check if given code may belong to unquoted attribute value\n */\nfunction isUnquotedValue(ch) {\n return !isNaN(ch) && ch !== 61 /* Equals */ && !isWhiteSpace(ch) && !isQuote(ch);\n}\nfunction isOpenBracket(ch) {\n return ch === 123 /* CurlyL */ || ch === 40 /* RoundL */ || ch === 91 /* SquareL */;\n}\nfunction isCloseBracket(ch) {\n return ch === 125 /* CurlyR */ || ch === 41 /* RoundR */ || ch === 93 /* SquareR */;\n}\n\nconst code = (ch) => ch.charCodeAt(0);\nconst specialChars = '#.*:$-_!@%^+>/'.split('').map(code);\nconst defaultOptions$1 = {\n type: 'markup',\n lookAhead: true,\n prefix: ''\n};\n/**\n * Extracts Emmet abbreviation from given string.\n * The goal of this module is to extract abbreviation from current editor’s line,\n * e.g. like this: `.foo[title=bar|]` -> `.foo[title=bar]`, where\n * `|` is a current caret position.\n * @param line A text line where abbreviation should be expanded\n * @param pos Caret position in line. If not given, uses end of line\n * @param options Extracting options\n */\nfunction extractAbbreviation(line, pos = line.length, options = {}) {\n // make sure `pos` is within line range\n const opt = Object.assign(Object.assign({}, defaultOptions$1), options);\n pos = Math.min(line.length, Math.max(0, pos == null ? line.length : pos));\n if (opt.lookAhead) {\n pos = offsetPastAutoClosed(line, pos, opt);\n }\n let ch;\n const start = getStartOffset(line, pos, opt.prefix || '');\n if (start === -1) {\n return void 0;\n }\n const scanner = backwardScanner(line, start);\n scanner.pos = pos;\n const stack = [];\n while (!sol(scanner)) {\n ch = peek$1(scanner);\n if (stack.includes(125 /* CurlyR */)) {\n if (ch === 125 /* CurlyR */) {\n stack.push(ch);\n scanner.pos--;\n continue;\n }\n if (ch !== 123 /* CurlyL */) {\n scanner.pos--;\n continue;\n }\n }\n if (isCloseBrace(ch, opt.type)) {\n stack.push(ch);\n }\n else if (isOpenBrace(ch, opt.type)) {\n if (stack.pop() !== bracePairs[ch]) {\n // unexpected brace\n break;\n }\n }\n else if (stack.includes(93 /* SquareR */) || stack.includes(125 /* CurlyR */)) {\n // respect all characters inside attribute sets or text nodes\n scanner.pos--;\n continue;\n }\n else if (isHtml(scanner) || !isAbbreviation(ch)) {\n break;\n }\n scanner.pos--;\n }\n if (!stack.length && scanner.pos !== pos) {\n // Found something, remove some invalid symbols from the\n // beginning and return abbreviation\n const abbreviation = line.slice(scanner.pos, pos).replace(/^[*+>^]+/, '');\n return {\n abbreviation,\n location: pos - abbreviation.length,\n start: options.prefix\n ? start - options.prefix.length\n : pos - abbreviation.length,\n end: pos\n };\n }\n}\n/**\n * Returns new `line` index which is right after characters beyound `pos` that\n * editor will likely automatically close, e.g. }, ], and quotes\n */\nfunction offsetPastAutoClosed(line, pos, options) {\n // closing quote is allowed only as a next character\n if (isQuote(line.charCodeAt(pos))) {\n pos++;\n }\n // offset pointer until non-autoclosed character is found\n while (isCloseBrace(line.charCodeAt(pos), options.type)) {\n pos++;\n }\n return pos;\n}\n/**\n * Returns start offset (left limit) in `line` where we should stop looking for\n * abbreviation: it’s nearest to `pos` location of `prefix` token\n */\nfunction getStartOffset(line, pos, prefix) {\n if (!prefix) {\n return 0;\n }\n const scanner = backwardScanner(line);\n const compiledPrefix = prefix.split('').map(code);\n scanner.pos = pos;\n let result;\n while (!sol(scanner)) {\n if (consumePair(scanner, 93 /* SquareR */, 91 /* SquareL */) || consumePair(scanner, 125 /* CurlyR */, 123 /* CurlyL */)) {\n continue;\n }\n result = scanner.pos;\n if (consumeArray(scanner, compiledPrefix)) {\n return result;\n }\n scanner.pos--;\n }\n return -1;\n}\n/**\n * Consumes full character pair, if possible\n */\nfunction consumePair(scanner, close, open) {\n const start = scanner.pos;\n if (consume(scanner, close)) {\n while (!sol(scanner)) {\n if (consume(scanner, open)) {\n return true;\n }\n scanner.pos--;\n }\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Consumes all character codes from given array, right-to-left, if possible\n */\nfunction consumeArray(scanner, arr) {\n const start = scanner.pos;\n let consumed = false;\n for (let i = arr.length - 1; i >= 0 && !sol(scanner); i--) {\n if (!consume(scanner, arr[i])) {\n break;\n }\n consumed = i === 0;\n }\n if (!consumed) {\n scanner.pos = start;\n }\n return consumed;\n}\nfunction isAbbreviation(ch) {\n return (ch > 64 && ch < 91) // uppercase letter\n || (ch > 96 && ch < 123) // lowercase letter\n || (ch > 47 && ch < 58) // number\n || specialChars.includes(ch); // special character\n}\nfunction isOpenBrace(ch, syntax) {\n return ch === 40 /* RoundL */ || (syntax === 'markup' && (ch === 91 /* SquareL */ || ch === 123 /* CurlyL */));\n}\nfunction isCloseBrace(ch, syntax) {\n return ch === 41 /* RoundR */ || (syntax === 'markup' && (ch === 93 /* SquareR */ || ch === 125 /* CurlyR */));\n}\n\nfunction expandAbbreviation(abbr, config) {\n const resolvedConfig = resolveConfig(config);\n return resolvedConfig.type === 'stylesheet'\n ? stylesheet(abbr, resolvedConfig)\n : markup(abbr, resolvedConfig);\n}\n/**\n * Expands given *markup* abbreviation (e.g. regular Emmet abbreviation that\n * produces structured output like HTML) and outputs it according to options\n * provided in config\n */\nfunction markup(abbr, config) {\n return stringify(parse(abbr, config), config);\n}\n/**\n * Expands given *stylesheet* abbreviation (a special Emmet abbreviation designed for\n * stylesheet languages like CSS, SASS etc.) and outputs it according to options\n * provided in config\n */\nfunction stylesheet(abbr, config) {\n return css(parse$1(abbr, config), config);\n}\n\nexport default expandAbbreviation;\nexport { extractAbbreviation as extract, markup, parse as parseMarkup, parse$1 as parseStylesheet, convertSnippets as parseStylesheetSnippets, resolveConfig, stringify as stringifyMarkup, css as stringifyStylesheet, stylesheet };\n//# sourceMappingURL=emmet.es.js.map\n","import Scanner, { isSpace, isQuote } from '@emmetio/scanner';\n\n/**\n * Performs fast scan of given stylesheet (CSS, LESS, SCSS) source code and runs\n * callback for each token and its range found. The goal of this parser is to quickly\n * determine document structure: selector, property, value and block end.\n * It doesn’t provide detailed info about CSS atoms like compound selectors,\n * operators, quoted string etc. to reduce memory allocations: this data can be\n * parsed later on demand.\n */\nfunction scan(source, callback) {\n const scanner = new Scanner(source);\n const state = {\n start: -1,\n end: -1,\n propertyStart: -1,\n propertyEnd: -1,\n propertyDelimiter: -1,\n expression: 0,\n };\n let blockEnd;\n const notify = (type, delimiter = scanner.start, start = state.start, end = state.end) => {\n return callback(type, start, end, delimiter) === false;\n };\n while (!scanner.eof()) {\n if (comment(scanner) || whitespace(scanner)) {\n continue;\n }\n scanner.start = scanner.pos;\n if ((blockEnd = scanner.eat(125 /* RightCurly */)) || scanner.eat(59 /* Semicolon */)) {\n // Block or property end\n if (state.propertyStart !== -1) {\n // We have pending property\n if (notify(\"propertyName\" /* PropertyName */, state.propertyDelimiter, state.propertyStart, state.propertyEnd)) {\n return;\n }\n if (state.start === -1) {\n // Explicit property value state: emit empty value\n state.start = state.end = scanner.start;\n }\n if (notify(\"propertyValue\" /* PropertyValue */)) {\n return;\n }\n }\n else if (state.start !== -1 && notify(\"propertyName\" /* PropertyName */)) {\n // Flush consumed token\n return;\n }\n if (blockEnd) {\n state.start = scanner.start;\n state.end = scanner.pos;\n if (notify(\"blockEnd\" /* BlockEnd */)) {\n return;\n }\n }\n reset(state);\n }\n else if (scanner.eat(123 /* LeftCurly */)) {\n // Block start\n if (state.start === -1 && state.propertyStart === -1) {\n // No consumed selector, emit empty value as selector start\n state.start = state.end = scanner.pos;\n }\n if (state.propertyStart !== -1) {\n // Now we know that value that looks like property name-value pair\n // was actually a selector\n state.start = state.propertyStart;\n }\n if (notify(\"selector\" /* Selector */)) {\n return;\n }\n reset(state);\n }\n else if (scanner.eat(58 /* Colon */) && !isKnownSelectorColon(scanner, state)) {\n // Colon could be one of the following:\n // — property delimiter: `foo: bar`, must be in block context\n // — variable delimiter: `$foo: bar`, could be anywhere\n // — pseudo-selector: `a:hover`, could be anywhere (for LESS and SCSS)\n // — media query expression: `min-width: 100px`, must be inside expression context\n // Since I can’t easily detect `:` meaning for sure, we’ll update state\n // to accumulate possible property name-value pair or selector\n if (state.propertyStart === -1) {\n state.propertyStart = state.start;\n }\n state.propertyEnd = state.end;\n state.propertyDelimiter = scanner.pos - 1;\n state.start = state.end = -1;\n }\n else {\n if (state.start === -1) {\n state.start = scanner.pos;\n }\n if (scanner.eat(40 /* LeftRound */)) {\n state.expression++;\n }\n else if (scanner.eat(41 /* RightRound */)) {\n state.expression--;\n }\n else if (!literal(scanner)) {\n scanner.pos++;\n }\n state.end = scanner.pos;\n }\n }\n if (state.propertyStart !== -1) {\n // Pending property name\n if (notify(\"propertyName\" /* PropertyName */, state.propertyDelimiter, state.propertyStart, state.propertyEnd)) {\n return;\n }\n }\n if (state.start !== -1) {\n // There’s pending token in state\n notify(state.propertyStart !== -1 ? \"propertyValue\" /* PropertyValue */ : \"propertyName\" /* PropertyName */, -1);\n }\n}\nfunction whitespace(scanner) {\n return scanner.eatWhile(isSpace);\n}\n/**\n * Consumes CSS comments from scanner: `/* * /`\n * It’s possible that comment may not have closing part\n */\nfunction comment(scanner) {\n const start = scanner.pos;\n if (scanner.eat(47 /* Slash */) && scanner.eat(42 /* Asterisk */)) {\n scanner.start = start;\n while (!scanner.eof()) {\n if (scanner.eat(42 /* Asterisk */)) {\n if (scanner.eat(47 /* Slash */)) {\n return true;\n }\n continue;\n }\n scanner.pos++;\n }\n return true;\n }\n else {\n scanner.pos = start;\n }\n return false;\n}\n/**\n * Consumes single- or double-quoted string literal\n */\nfunction literal(scanner) {\n const ch = scanner.peek();\n if (isQuote(ch)) {\n scanner.start = scanner.pos++;\n while (!scanner.eof()) {\n if (scanner.eat(ch) || scanner.eat(10 /* LF */) || scanner.eat(13 /* CR */)) {\n break;\n }\n // Skip escape character, if any\n scanner.eat(92 /* Backslash */);\n scanner.pos++;\n }\n // Do not throw if string is incomplete\n return true;\n }\n}\nfunction reset(state) {\n state.start = state.end = state.propertyStart = state.propertyEnd = state.propertyDelimiter = -1;\n}\n/**\n * Check if current state is a known selector context for `:` delimiter\n */\nfunction isKnownSelectorColon(scanner, state) {\n // Either inside expression like `(min-width: 10px)` or pseudo-element `::before`\n return state.expression || scanner.eatWhile(58 /* Colon */);\n}\n\n// NB: no `Minus` operator, it must be handled differently\nconst operators = [\n 43 /* Plus */, 47 /* Division */, 42 /* Multiplication */,\n 44 /* Comma */\n];\n/**\n * Splits given CSS value into token list\n */\nfunction splitValue(value, offset = 0) {\n let start = -1;\n let expression = 0;\n let pos = 0;\n const result = [];\n const scanner = new Scanner(value);\n while (!scanner.eof()) {\n pos = scanner.pos;\n if (scanner.eat(isSpace) || scanner.eat(isOperator) || isMinusOperator(scanner)) {\n // Use space as value delimiter but only if not in expression context,\n // e.g. `1 2` are distinct values but `(1 2)` not\n if (!expression && start !== -1) {\n result.push([offset + start, offset + pos]);\n start = -1;\n }\n scanner.eatWhile(isSpace);\n }\n else {\n if (start === -1) {\n start = scanner.pos;\n }\n if (scanner.eat(40 /* LeftRound */)) {\n expression++;\n }\n else if (scanner.eat(41 /* RightRound */)) {\n expression--;\n }\n else if (!literal(scanner)) {\n scanner.pos++;\n }\n }\n }\n if (start !== -1 && start !== scanner.pos) {\n result.push([offset + start, offset + scanner.pos]);\n }\n return result;\n}\nfunction isOperator(ch) {\n return operators.includes(ch);\n}\n/**\n * Check if current scanner state is at minus operator\n */\nfunction isMinusOperator(scanner) {\n // Minus operator is tricky since CSS supports dashes in keyword names like\n // `no-repeat`\n const start = scanner.pos;\n if (scanner.eat(45 /* Minus */) && scanner.eat(isSpace)) {\n return true;\n }\n scanner.pos = start;\n return false;\n}\n\nfunction match(source, pos) {\n const pool = [];\n const stack = [];\n let result = null;\n let pendingProperty = null;\n const releasePending = () => {\n if (pendingProperty) {\n releaseRange(pool, pendingProperty);\n pendingProperty = null;\n }\n };\n scan(source, (type, start, end, delimiter) => {\n if (type === \"selector\" /* Selector */) {\n releasePending();\n stack.push(allocRange(pool, start, end, delimiter));\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n releasePending();\n const parent = stack.pop();\n if (parent && parent[0] < pos && pos < end) {\n result = {\n type: 'selector',\n start: parent[0],\n end,\n bodyStart: parent[2] + 1,\n bodyEnd: start\n };\n return false;\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n releasePending();\n pendingProperty = allocRange(pool, start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (pendingProperty && pendingProperty[0] < pos && pos < end) {\n result = {\n type: 'property',\n start: pendingProperty[0],\n end: delimiter + 1,\n bodyStart: start,\n bodyEnd: end\n };\n return false;\n }\n releasePending();\n }\n });\n return result;\n}\n/**\n * Returns balanced CSS model: a list of all ranges that could possibly match\n * given location when moving in outward direction\n */\nfunction balancedOutward(source, pos) {\n const pool = [];\n const stack = [];\n const result = [];\n let property = null;\n scan(source, (type, start, end, delimiter) => {\n if (type === \"selector\" /* Selector */) {\n stack.push(allocRange(pool, start, end, delimiter));\n }\n else if (type === \"blockEnd\" /* BlockEnd */) {\n const left = stack.pop();\n if (left && left[0] < pos && end > pos) {\n // Matching section found\n const inner = innerRange(source, left[2] + 1, start);\n inner && push(result, inner);\n push(result, [left[0], end]);\n }\n left && releaseRange(pool, left);\n if (!stack.length) {\n return false;\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n property && releaseRange(pool, property);\n property = allocRange(pool, start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (property && property[0] < pos && Math.max(delimiter, end) > pos) {\n // Push full token and value range\n push(result, [start, end]);\n push(result, [property[0], delimiter !== -1 ? delimiter + 1 : end]);\n }\n }\n if (type !== \"propertyName\" /* PropertyName */ && property) {\n releaseRange(pool, property);\n property = null;\n }\n });\n return result;\n}\n/**\n * Returns balanced CSS selectors: a list of all ranges that could possibly match\n * given location when moving in inward direction\n */\nfunction balancedInward(source, pos) {\n // Collecting ranges for inward balancing is a bit trickier: we have to store\n // first child of every matched selector until we find the one that matches given\n // location\n const pool = [];\n const stack = [];\n const result = [];\n let pendingProperty = null;\n const alloc = (start, end, delimiter) => {\n if (pool.length) {\n const range = pool.pop();\n range.start = start;\n range.end = end;\n range.delimiter = delimiter;\n return range;\n }\n return { start, end, delimiter, firstChild: null };\n };\n const release = (range) => {\n range.firstChild = null;\n pool.push(range);\n };\n const releasePending = () => {\n if (pendingProperty) {\n release(pendingProperty);\n pendingProperty = null;\n }\n };\n /**\n * Pushes given inward range as a first child of current selector only if it’s\n * not set yet\n */\n const pushChild = (start, end, delimiter) => {\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n parent.firstChild = alloc(start, end, delimiter);\n }\n };\n scan(source, (type, start, end, delimiter) => {\n if (type === \"blockEnd\" /* BlockEnd */) {\n releasePending();\n let range = stack.pop();\n if (!range) {\n // Some sort of lone closing brace, ignore it\n return;\n }\n if (range.start <= pos && pos <= end) {\n // Matching selector found: add it and its inner range into result\n let inner = innerRange(source, range.delimiter + 1, start);\n push(result, [range.start, end]);\n inner && push(result, inner);\n while (range.firstChild) {\n const child = range.firstChild;\n inner = innerRange(source, child.delimiter + 1, child.end - 1);\n push(result, [child.start, child.end]);\n inner && push(result, inner);\n range = child;\n }\n return false;\n }\n else {\n const parent = last(stack);\n if (parent && !parent.firstChild) {\n // No first child in parent node: store current selector\n range.end = end;\n parent.firstChild = range;\n }\n else {\n release(range);\n }\n }\n }\n else if (type === \"propertyName\" /* PropertyName */) {\n releasePending();\n pendingProperty = alloc(start, end, delimiter);\n pushChild(start, end, delimiter);\n }\n else if (type === \"propertyValue\" /* PropertyValue */) {\n if (pendingProperty) {\n if (pendingProperty.start <= pos && end >= pos) {\n // Direct hit into property, no need to look further\n push(result, [pendingProperty.start, delimiter + 1]);\n push(result, [start, end]);\n releasePending();\n return false;\n }\n const parent = last(stack);\n if (parent && parent.firstChild && parent.firstChild.start === pendingProperty.start) {\n // First child is an expected property name, update its range\n // to include property value\n parent.firstChild.end = delimiter !== -1 ? delimiter + 1 : end;\n }\n releasePending();\n }\n }\n else {\n // Selector start\n stack.push(alloc(start, end, delimiter));\n releasePending();\n }\n });\n stack.length = pool.length = 0;\n return result;\n}\n/**\n * Returns inner range for given selector bounds: narrows it to first non-empty\n * region. If resulting region is empty, returns `null`\n */\nfunction innerRange(source, start, end) {\n while (start < end && isSpace(source.charCodeAt(start))) {\n start++;\n }\n while (end > start && isSpace(source.charCodeAt(end - 1))) {\n end--;\n }\n return start !== end ? [start, end] : null;\n}\nfunction allocRange(pool, start, end, delimiter) {\n if (pool.length) {\n const range = pool.pop();\n range[0] = start;\n range[1] = end;\n range[2] = delimiter;\n return range;\n }\n return [start, end, delimiter];\n}\nfunction releaseRange(pool, range) {\n range && pool.push(range);\n return null;\n}\nfunction push(ranges, range) {\n const prev = ranges.length ? ranges[ranges.length - 1] : null;\n if ((!prev || prev[0] !== range[0] || prev[1] !== range[1]) && range[0] !== range[1]) {\n ranges.push(range);\n }\n}\nfunction last(arr) {\n return arr.length ? arr[arr.length - 1] : null;\n}\n\nexport default match;\nexport { balancedInward, balancedOutward, scan, splitValue };\n//# sourceMappingURL=css-matcher.es.js.map\n","import Scanner, { isWhiteSpace, isNumber, isSpace } from '@emmetio/scanner';\n\nconst nullary = token(\"null\" /* Null */, 0);\n/**\n * Parses given expression in forward direction\n */\nfunction parse(expr) {\n const scanner = typeof expr === 'string' ? new Scanner(expr) : expr;\n let ch;\n let priority = 0;\n let expected = (1 /* Primary */ | 4 /* LParen */ | 16 /* Sign */);\n const tokens = [];\n while (!scanner.eof()) {\n scanner.eatWhile(isWhiteSpace);\n scanner.start = scanner.pos;\n if (consumeNumber(scanner)) {\n if ((expected & 1 /* Primary */) === 0) {\n error('Unexpected number', scanner);\n }\n tokens.push(number(scanner.current()));\n expected = (2 /* Operator */ | 8 /* RParen */);\n }\n else if (isOperator(scanner.peek())) {\n ch = scanner.next();\n if (isSign(ch) && (expected & 16 /* Sign */)) {\n if (isNegativeSign(ch)) {\n tokens.push(op1(ch, priority));\n }\n expected = (1 /* Primary */ | 4 /* LParen */ | 16 /* Sign */);\n }\n else {\n if ((expected & 2 /* Operator */) === 0) {\n error('Unexpected operator', scanner);\n }\n tokens.push(op2(ch, priority));\n expected = (1 /* Primary */ | 4 /* LParen */ | 16 /* Sign */);\n }\n }\n else if (scanner.eat(40 /* LeftParenthesis */)) {\n if ((expected & 4 /* LParen */) === 0) {\n error('Unexpected \"(\"', scanner);\n }\n priority += 10;\n expected = (1 /* Primary */ | 4 /* LParen */ | 16 /* Sign */ | 32 /* NullaryCall */);\n }\n else if (scanner.eat(41 /* RightParenthesis */)) {\n priority -= 10;\n if (expected & 32 /* NullaryCall */) {\n tokens.push(nullary);\n }\n else if ((expected & 8 /* RParen */) === 0) {\n error('Unexpected \")\"', scanner);\n }\n expected = (2 /* Operator */ | 8 /* RParen */ | 4 /* LParen */);\n }\n else {\n error('Unknown character', scanner);\n }\n }\n if (priority < 0 || priority >= 10) {\n error('Unmatched \"()\"', scanner);\n }\n const result = orderTokens(tokens);\n if (result === null) {\n error('Parity', scanner);\n }\n return result;\n}\n/**\n * Consumes number from given stream\n * @return Returns `true` if number was consumed\n */\nfunction consumeNumber(scanner) {\n const start = scanner.pos;\n if (scanner.eat(46 /* Dot */) && scanner.eatWhile(isNumber)) {\n // short decimal notation: .025\n return true;\n }\n if (scanner.eatWhile(isNumber) && (!scanner.eat(46 /* Dot */) || scanner.eatWhile(isNumber))) {\n // either integer or decimal: 10, 10.25\n return true;\n }\n scanner.pos = start;\n return false;\n}\n/**\n * Orders parsed tokens (operands and operators) in given array so that they are\n * laid off in order of execution\n */\nfunction orderTokens(tokens) {\n const operators = [];\n const operands = [];\n let nOperators = 0;\n for (let i = 0; i < tokens.length; i++) {\n const t = tokens[i];\n if (t.type === \"num\" /* Number */) {\n operands.push(t);\n }\n else {\n nOperators += t.type === \"op1\" /* Op1 */ ? 1 : 2;\n while (operators.length) {\n if (t.priority <= operators[operators.length - 1].priority) {\n operands.push(operators.pop());\n }\n else {\n break;\n }\n }\n operators.push(t);\n }\n }\n return nOperators + 1 === operands.length + operators.length\n ? operands.concat(operators.reverse())\n : null /* parity */;\n}\n/**\n * Number token factory\n */\nfunction number(value, priority) {\n return token(\"num\" /* Number */, parseFloat(value), priority);\n}\n/**\n * Unary operator factory\n * @param value Operator character code\n * @param priority Operator execution priority\n */\nfunction op1(value, priority = 0) {\n if (value === 45 /* Minus */) {\n priority += 2;\n }\n return token(\"op1\" /* Op1 */, value, priority);\n}\n/**\n * Binary operator factory\n * @param value Operator character code\n * @param priority Operator execution priority\n */\nfunction op2(value, priority = 0) {\n if (value === 42 /* Multiply */) {\n priority += 1;\n }\n else if (value === 47 /* Divide */ || value === 92 /* IntDivide */) {\n priority += 2;\n }\n return token(\"op2\" /* Op2 */, value, priority);\n}\nfunction error(name, scanner) {\n if (scanner) {\n name += ` at column ${scanner.pos} of expression`;\n }\n throw new Error(name);\n}\nfunction isSign(ch) {\n return isPositiveSign(ch) || isNegativeSign(ch);\n}\nfunction isPositiveSign(ch) {\n return ch === 43 /* Plus */;\n}\nfunction isNegativeSign(ch) {\n return ch === 45 /* Minus */;\n}\nfunction isOperator(ch) {\n return ch === 43 /* Plus */ || ch === 45 /* Minus */ || ch === 42 /* Multiply */\n || ch === 47 /* Divide */ || ch === 92 /* IntDivide */;\n}\nfunction token(type, value, priority = 0) {\n return { type, value, priority };\n}\n\nconst defaultOptions = {\n lookAhead: true,\n whitespace: true\n};\nfunction extract(text, pos = text.length, options) {\n const opt = Object.assign(Object.assign({}, defaultOptions), options);\n const scanner = { text, pos };\n let ch;\n if (opt.lookAhead && cur(scanner) === 41 /* RightParenthesis */) {\n // Basically, we should consume right parenthesis only with optional whitespace\n scanner.pos++;\n const len = text.length;\n while (scanner.pos < len) {\n ch = cur(scanner);\n if (ch !== 41 /* RightParenthesis */ && !(opt.whitespace && isSpace(ch))) {\n break;\n }\n scanner.pos++;\n }\n }\n const end = scanner.pos;\n let braces = 0;\n while (scanner.pos >= 0) {\n if (number$1(scanner)) {\n continue;\n }\n ch = prev(scanner);\n if (ch === 41 /* RightParenthesis */) {\n braces++;\n }\n else if (ch === 40 /* LeftParenthesis */) {\n if (!braces) {\n break;\n }\n braces--;\n }\n else if (!((opt.whitespace && isSpace(ch)) || isSign(ch) || isOperator(ch))) {\n break;\n }\n scanner.pos--;\n }\n if (scanner.pos !== end && !braces) {\n // Trim whitespace\n while (isSpace(cur(scanner))) {\n scanner.pos++;\n }\n return [scanner.pos, end];\n }\n return null;\n}\n/**\n * Backward-consumes number from given scanner, if possible\n */\nfunction number$1(scanner) {\n if (isNumber(prev(scanner))) {\n scanner.pos--;\n let dot = false;\n let ch;\n while (scanner.pos >= 0) {\n ch = prev(scanner);\n if (ch === 46 /* . */) {\n if (dot) {\n // Decimal delimiter already consumed, abort\n break;\n }\n dot = true;\n }\n else if (!isNumber(ch)) {\n break;\n }\n scanner.pos--;\n }\n return true;\n }\n return false;\n}\nfunction prev(scanner) {\n return scanner.text.charCodeAt(scanner.pos - 1);\n}\nfunction cur(scanner) {\n return scanner.text.charCodeAt(scanner.pos);\n}\n\nconst ops1 = {\n [45 /* Minus */]: num => -num\n};\nconst ops2 = {\n [43 /* Plus */]: (a, b) => a + b,\n [45 /* Minus */]: (a, b) => a - b,\n [42 /* Multiply */]: (a, b) => a * b,\n [47 /* Divide */]: (a, b) => a / b,\n [92 /* IntDivide */]: (a, b) => Math.floor(a / b)\n};\n/**\n * Evaluates given math expression\n * @param expr Expression to evaluate\n */\nfunction evaluate(expr) {\n if (!Array.isArray(expr)) {\n expr = parse(expr);\n }\n if (!expr || !expr.length) {\n return null;\n }\n const nStack = [];\n let n1;\n let n2;\n let f;\n for (let i = 0, il = expr.length; i < il; i++) {\n const token = expr[i];\n if (token.type === \"num\" /* Number */) {\n nStack.push(token.value);\n }\n else if (token.type === \"op2\" /* Op2 */) {\n n2 = nStack.pop();\n n1 = nStack.pop();\n f = ops2[token.value];\n nStack.push(f(n1, n2));\n }\n else if (token.type === \"op1\" /* Op1 */) {\n n1 = nStack.pop();\n f = ops1[token.value];\n nStack.push(f(n1));\n }\n else {\n throw new Error('Invalid expression');\n }\n }\n if (nStack.length > 1) {\n throw new Error('Invalid Expression (parity)');\n }\n return nStack[0];\n}\n\nexport default evaluate;\nexport { extract, parse };\n//# sourceMappingURL=math.es.js.map\n","import { Options } from 'emmet';\nimport getEmmetConfig from './config';\nimport { tabStopStart, tabStopEnd } from './utils';\nimport { isHTML, docSyntax } from './syntax';\n\nexport default function getOutputOptions(editor: CodeMirror.Editor, pos?: number, inline?: boolean): Partial