{"version":3,"file":"parseley-4704b79d.js","sources":["../../node_modules/parseley/lib/parseley.mjs"],"sourcesContent":["import { createLexer } from 'leac';\nimport * as p from 'peberminta';\n\nvar ast = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\nconst ws = `(?:[ \\\\t\\\\r\\\\n\\\\f]*)`;\nconst nl = `(?:\\\\n|\\\\r\\\\n|\\\\r|\\\\f)`;\nconst nonascii = `[^\\\\x00-\\\\x7F]`;\nconst unicode = `(?:\\\\\\\\[0-9a-f]{1,6}(?:\\\\r\\\\n|[ \\\\n\\\\r\\\\t\\\\f])?)`;\nconst escape = `(?:\\\\\\\\[^\\\\n\\\\r\\\\f0-9a-f])`;\nconst nmstart = `(?:[_a-z]|${nonascii}|${unicode}|${escape})`;\nconst nmchar = `(?:[_a-z0-9-]|${nonascii}|${unicode}|${escape})`;\nconst name = `(?:${nmchar}+)`;\nconst ident = `(?:[-]?${nmstart}${nmchar}*)`;\nconst string1 = `'([^\\\\n\\\\r\\\\f\\\\\\\\']|\\\\\\\\${nl}|${nonascii}|${unicode}|${escape})*'`;\nconst string2 = `\"([^\\\\n\\\\r\\\\f\\\\\\\\\"]|\\\\\\\\${nl}|${nonascii}|${unicode}|${escape})*\"`;\nconst lexSelector = createLexer([\n    { name: 'ws', regex: new RegExp(ws) },\n    { name: 'hash', regex: new RegExp(`#${name}`, 'i') },\n    { name: 'ident', regex: new RegExp(ident, 'i') },\n    { name: 'str1', regex: new RegExp(string1, 'i') },\n    { name: 'str2', regex: new RegExp(string2, 'i') },\n    { name: '*' },\n    { name: '.' },\n    { name: ',' },\n    { name: '[' },\n    { name: ']' },\n    { name: '=' },\n    { name: '>' },\n    { name: '|' },\n    { name: '+' },\n    { name: '~' },\n    { name: '^' },\n    { name: '$' },\n]);\nconst lexEscapedString = createLexer([\n    { name: 'unicode', regex: new RegExp(unicode, 'i') },\n    { name: 'escape', regex: new RegExp(escape, 'i') },\n    { name: 'any', regex: new RegExp('[\\\\s\\\\S]', 'i') }\n]);\nfunction sumSpec([a0, a1, a2], [b0, b1, b2]) {\n    return [a0 + b0, a1 + b1, a2 + b2];\n}\nfunction sumAllSpec(ss) {\n    return ss.reduce(sumSpec, [0, 0, 0]);\n}\nconst unicodeEscapedSequence_ = p.token((t) => t.name === 'unicode' ? String.fromCodePoint(parseInt(t.text.slice(1), 16)) : undefined);\nconst escapedSequence_ = p.token((t) => t.name === 'escape' ? t.text.slice(1) : undefined);\nconst anyChar_ = p.token((t) => t.name === 'any' ? t.text : undefined);\nconst escapedString_ = p.map(p.many(p.or(unicodeEscapedSequence_, escapedSequence_, anyChar_)), (cs) => cs.join(''));\nfunction unescape(escapedString) {\n    const lexerResult = lexEscapedString(escapedString);\n    const result = escapedString_({ tokens: lexerResult.tokens, options: undefined }, 0);\n    return result.value;\n}\nfunction literal(name) {\n    return p.token((t) => t.name === name ? true : undefined);\n}\nconst whitespace_ = p.token((t) => t.name === 'ws' ? null : undefined);\nconst optionalWhitespace_ = p.option(whitespace_, null);\nfunction optionallySpaced(parser) {\n    return p.middle(optionalWhitespace_, parser, optionalWhitespace_);\n}\nconst identifier_ = p.token((t) => t.name === 'ident' ? unescape(t.text) : undefined);\nconst hashId_ = p.token((t) => t.name === 'hash' ? unescape(t.text.slice(1)) : undefined);\nconst string_ = p.token((t) => t.name.startsWith('str') ? unescape(t.text.slice(1, -1)) : undefined);\nconst namespace_ = p.left(p.option(identifier_, ''), literal('|'));\nconst qualifiedName_ = p.eitherOr(p.ab(namespace_, identifier_, (ns, name) => ({ name: name, namespace: ns })), p.map(identifier_, (name) => ({ name: name, namespace: null })));\nconst uniSelector_ = p.eitherOr(p.ab(namespace_, literal('*'), (ns) => ({ type: 'universal', namespace: ns, specificity: [0, 0, 0] })), p.map(literal('*'), () => ({ type: 'universal', namespace: null, specificity: [0, 0, 0] })));\nconst tagSelector_ = p.map(qualifiedName_, ({ name, namespace }) => ({\n    type: 'tag',\n    name: name,\n    namespace: namespace,\n    specificity: [0, 0, 1]\n}));\nconst classSelector_ = p.ab(literal('.'), identifier_, (fullstop, name) => ({\n    type: 'class',\n    name: name,\n    specificity: [0, 1, 0]\n}));\nconst idSelector_ = p.map(hashId_, (name) => ({\n    type: 'id',\n    name: name,\n    specificity: [1, 0, 0]\n}));\nconst attrModifier_ = p.token((t) => {\n    if (t.name === 'ident') {\n        if (t.text === 'i' || t.text === 'I') {\n            return 'i';\n        }\n        if (t.text === 's' || t.text === 'S') {\n            return 's';\n        }\n    }\n    return undefined;\n});\nconst attrValue_ = p.eitherOr(p.ab(string_, p.option(p.right(optionalWhitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })), p.ab(identifier_, p.option(p.right(whitespace_, attrModifier_), null), (v, mod) => ({ value: v, modifier: mod })));\nconst attrMatcher_ = p.choice(p.map(literal('='), () => '='), p.ab(literal('~'), literal('='), () => '~='), p.ab(literal('|'), literal('='), () => '|='), p.ab(literal('^'), literal('='), () => '^='), p.ab(literal('$'), literal('='), () => '$='), p.ab(literal('*'), literal('='), () => '*='));\nconst attrPresenceSelector_ = p.abc(literal('['), optionallySpaced(qualifiedName_), literal(']'), (lbr, { name, namespace }) => ({\n    type: 'attrPresence',\n    name: name,\n    namespace: namespace,\n    specificity: [0, 1, 0]\n}));\nconst attrValueSelector_ = p.middle(literal('['), p.abc(optionallySpaced(qualifiedName_), attrMatcher_, optionallySpaced(attrValue_), ({ name, namespace }, matcher, { value, modifier }) => ({\n    type: 'attrValue',\n    name: name,\n    namespace: namespace,\n    matcher: matcher,\n    value: value,\n    modifier: modifier,\n    specificity: [0, 1, 0]\n})), literal(']'));\nconst attrSelector_ = p.eitherOr(attrPresenceSelector_, attrValueSelector_);\nconst typeSelector_ = p.eitherOr(uniSelector_, tagSelector_);\nconst subclassSelector_ = p.choice(idSelector_, classSelector_, attrSelector_);\nconst compoundSelector_ = p.map(p.eitherOr(p.flatten(typeSelector_, p.many(subclassSelector_)), p.many1(subclassSelector_)), (ss) => {\n    return {\n        type: 'compound',\n        list: ss,\n        specificity: sumAllSpec(ss.map(s => s.specificity))\n    };\n});\nconst combinator_ = p.choice(p.map(literal('>'), () => '>'), p.map(literal('+'), () => '+'), p.map(literal('~'), () => '~'), p.ab(literal('|'), literal('|'), () => '||'));\nconst combinatorSeparator_ = p.eitherOr(optionallySpaced(combinator_), p.map(whitespace_, () => ' '));\nconst complexSelector_ = p.leftAssoc2(compoundSelector_, p.map(combinatorSeparator_, (c) => (left, right) => ({\n    type: 'compound',\n    list: [...right.list, { type: 'combinator', combinator: c, left: left, specificity: left.specificity }],\n    specificity: sumSpec(left.specificity, right.specificity)\n})), compoundSelector_);\nconst listSelector_ = p.leftAssoc2(p.map(complexSelector_, (s) => ({ type: 'list', list: [s] })), p.map(optionallySpaced(literal(',')), () => (acc, next) => ({ type: 'list', list: [...acc.list, next] })), complexSelector_);\nfunction parse_(parser, str) {\n    if (!(typeof str === 'string' || str instanceof String)) {\n        throw new Error('Expected a selector string. Actual input is not a string!');\n    }\n    const lexerResult = lexSelector(str);\n    if (!lexerResult.complete) {\n        throw new Error(`The input \"${str}\" was only partially tokenized, stopped at offset ${lexerResult.offset}!\\n` +\n            prettyPrintPosition(str, lexerResult.offset));\n    }\n    const result = optionallySpaced(parser)({ tokens: lexerResult.tokens, options: undefined }, 0);\n    if (!result.matched) {\n        throw new Error(`No match for \"${str}\" input!`);\n    }\n    if (result.position < lexerResult.tokens.length) {\n        const token = lexerResult.tokens[result.position];\n        throw new Error(`The input \"${str}\" was only partially parsed, stopped at offset ${token.offset}!\\n` +\n            prettyPrintPosition(str, token.offset, token.len));\n    }\n    return result.value;\n}\nfunction prettyPrintPosition(str, offset, len = 1) {\n    return `${str.replace(/(\\t)|(\\r)|(\\n)/g, (m, t, r) => t ? '\\u2409' : r ? '\\u240d' : '\\u240a')}\\n${''.padEnd(offset)}${'^'.repeat(len)}`;\n}\nfunction parse(str) {\n    return parse_(listSelector_, str);\n}\nfunction parse1(str) {\n    return parse_(complexSelector_, str);\n}\n\nfunction serialize(selector) {\n    if (!selector.type) {\n        throw new Error('This is not an AST node.');\n    }\n    switch (selector.type) {\n        case 'universal':\n            return _serNs(selector.namespace) + '*';\n        case 'tag':\n            return _serNs(selector.namespace) + _serIdent(selector.name);\n        case 'class':\n            return '.' + _serIdent(selector.name);\n        case 'id':\n            return '#' + _serIdent(selector.name);\n        case 'attrPresence':\n            return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}]`;\n        case 'attrValue':\n            return `[${_serNs(selector.namespace)}${_serIdent(selector.name)}${selector.matcher}\"${_serStr(selector.value)}\"${(selector.modifier ? selector.modifier : '')}]`;\n        case 'combinator':\n            return serialize(selector.left) + selector.combinator;\n        case 'compound':\n            return selector.list.reduce((acc, node) => {\n                if (node.type === 'combinator') {\n                    return serialize(node) + acc;\n                }\n                else {\n                    return acc + serialize(node);\n                }\n            }, '');\n        case 'list':\n            return selector.list.map(serialize).join(',');\n    }\n}\nfunction _serNs(ns) {\n    return (ns || ns === '')\n        ? _serIdent(ns) + '|'\n        : '';\n}\nfunction _codePoint(char) {\n    return `\\\\${char.codePointAt(0).toString(16)} `;\n}\nfunction _serIdent(str) {\n    return str.replace(\n    /(^[0-9])|(^-[0-9])|(^-$)|([-0-9a-zA-Z_]|[^\\x00-\\x7F])|(\\x00)|([\\x01-\\x1f]|\\x7f)|([\\s\\S])/g, (m, d1, d2, hy, safe, nl, ctrl, other) => d1 ? _codePoint(d1) :\n        d2 ? '-' + _codePoint(d2.slice(1)) :\n            hy ? '\\\\-' :\n                safe ? safe :\n                    nl ? '\\ufffd' :\n                        ctrl ? _codePoint(ctrl) :\n                            '\\\\' + other);\n}\nfunction _serStr(str) {\n    return str.replace(\n    /(\")|(\\\\)|(\\x00)|([\\x01-\\x1f]|\\x7f)/g, (m, dq, bs, nl, ctrl) => dq ? '\\\\\"' :\n        bs ? '\\\\\\\\' :\n            nl ? '\\ufffd' :\n                _codePoint(ctrl));\n}\nfunction normalize(selector) {\n    if (!selector.type) {\n        throw new Error('This is not an AST node.');\n    }\n    switch (selector.type) {\n        case 'compound': {\n            selector.list.forEach(normalize);\n            selector.list.sort((a, b) => _compareArrays(_getSelectorPriority(a), _getSelectorPriority(b)));\n            break;\n        }\n        case 'combinator': {\n            normalize(selector.left);\n            break;\n        }\n        case 'list': {\n            selector.list.forEach(normalize);\n            selector.list.sort((a, b) => (serialize(a) < serialize(b)) ? -1 : 1);\n            break;\n        }\n    }\n    return selector;\n}\nfunction _getSelectorPriority(selector) {\n    switch (selector.type) {\n        case 'universal':\n            return [1];\n        case 'tag':\n            return [1];\n        case 'id':\n            return [2];\n        case 'class':\n            return [3, selector.name];\n        case 'attrPresence':\n            return [4, serialize(selector)];\n        case 'attrValue':\n            return [5, serialize(selector)];\n        case 'combinator':\n            return [15, serialize(selector)];\n    }\n}\nfunction compareSelectors(a, b) {\n    return _compareArrays(a.specificity, b.specificity);\n}\nfunction compareSpecificity(a, b) {\n    return _compareArrays(a, b);\n}\nfunction _compareArrays(a, b) {\n    if (!Array.isArray(a) || !Array.isArray(b)) {\n        throw new Error('Arguments must be arrays.');\n    }\n    const shorter = (a.length < b.length) ? a.length : b.length;\n    for (let i = 0; i < shorter; i++) {\n        if (a[i] === b[i]) {\n            continue;\n        }\n        return (a[i] < b[i]) ? -1 : 1;\n    }\n    return a.length - b.length;\n}\n\nexport { ast as Ast, compareSelectors, compareSpecificity, normalize, parse, parse1, serialize };\n"],"names":["ws","nl","nonascii","unicode","escape","nmstart","nmchar","name","ident","string1","string2","lexSelector","createLexer","lexEscapedString","sumSpec","a0","a1","a2","b0","b1","b2","sumAllSpec","ss","unicodeEscapedSequence_","p.token","t","escapedSequence_","anyChar_","escapedString_","p.map","p.many","p.or","cs","unescape","escapedString","lexerResult","literal","whitespace_","optionalWhitespace_","p.option","optionallySpaced","parser","p.middle","identifier_","hashId_","string_","namespace_","p.left","qualifiedName_","p.eitherOr","p.ab","ns","uniSelector_","tagSelector_","namespace","classSelector_","fullstop","idSelector_","attrModifier_","attrValue_","p.right","v","mod","attrMatcher_","p.choice","attrPresenceSelector_","p.abc","lbr","attrValueSelector_","matcher","value","modifier","attrSelector_","typeSelector_","subclassSelector_","compoundSelector_","p.flatten","p.many1","s","combinator_","combinatorSeparator_","complexSelector_","p.leftAssoc2","c","left","right","parse_","str","prettyPrintPosition","result","token","offset","len","m","r","parse1","serialize","selector","_serNs","_serIdent","_serStr","acc","node","_codePoint","char","d1","d2","hy","safe","ctrl","other","dq","bs","normalize","a","b","_compareArrays","_getSelectorPriority","compareSpecificity","shorter","i"],"mappings":"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","x_google_ignoreList":[0]}