{"version":3,"sources":["webpack:///./node_modules/@selderee/plugin-htmlparser2/lib/hp2-builder.mjs","webpack:///./node_modules/selderee/lib/selderee.cjs","webpack:///./node_modules/selderee/lib/selderee.mjs"],"names":["hp2Builder","nodes","handleArray","matchers","map","handleNode","el","tail","flatMap","m","node","type","result","valueContainer","handleTagName","handleAttrValueName","handleAttrPresenceName","handlePushElementNode","handlePopElementNode","variants","variant","value","cont","continuation","name","attrName","Object","prototype","hasOwnProperty","call","attribs","callbacks","matcher","predicate","push","attr","cb","leftElementGetter","combinator","getPrecedingElement","getParentElement","next","prev","parent","items","mapper","concat","amap","len","length","res","Array","i","defineProperty","exports","parseley","_interopNamespace","e","__esModule","n","create","keys","forEach","k","d","getOwnPropertyDescriptor","get","enumerable","freeze","parseley__namespace","Ast","__proto__","Types","treeify","treeifyArray","thinLines","heavyLines","doubleLines","tpl","prefixItems","treeifyNode","vctr","index","JSON","stringify","specificity","modifier","item","prefixItem","join","tpl1","split","TreeifyBuilder","DecisionTree","input","this","branches","weave","toAstTerminalPairs","builder","array","results","selectorString","val","ast","preprocess","parse1","terminal","reduceSelectorVariants","normalize","newList","list","sel","namespace","left","topKind","findTopKey","getSelectorKind","matches","nonmatches","empty","breakByKind","branchOfKind","terminate","rest","partition","selectedKind","simpsels","isMatch","some","kind","tagNameBranch","startsWith","attrValueBranch","substring","attrPresenceBranch","combinatorBranch","Error","groups","spliceAndGroup","x","entries","group","spliceSimpleSelector","values","oneSimpleSelector","getAttrPredicate","expected","toLowerCase","actual","includes","endsWith","lower","serialize","leftItems","rightCont","leftAst","keyCallback","bestKey","bestKeyPredicate","hasBestKeyPredicate","partition1","splicedNode","firstIndex","filter","candidates","candidates1","key","topCounter","entry","src","Picker","f","preferFirst","comparator","comparatorPreferFirst","comparatorPreferLast","acc","diff","compareSpecificity","Treeify"],"mappings":"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","file":"js/npm.selderee.db0d67a6.js","sourcesContent":["import { isTag } from 'domhandler';\nimport { Picker } from 'selderee';\n\n/**\r\n * A {@link BuilderFunction} implementation.\r\n *\r\n * Creates a function (in a {@link Picker} wrapper) that can run\r\n * the decision tree against `htmlparser2` `Element` nodes.\r\n *\r\n * @typeParam V - the type of values associated with selectors.\r\n *\r\n * @param nodes - nodes ({@link DecisionTreeNode})\r\n * from the root level of the decision tree.\r\n *\r\n * @returns a {@link Picker} object.\r\n */\r\nfunction hp2Builder(nodes) {\r\n    return new Picker(handleArray(nodes));\r\n}\r\n// ==============================================\r\nfunction handleArray(nodes) {\r\n    const matchers = nodes.map(handleNode);\r\n    return (el, ...tail) => flatMap(matchers, m => m(el, ...tail));\r\n}\r\nfunction handleNode(node) {\r\n    switch (node.type) {\r\n        case 'terminal': {\r\n            const result = [node.valueContainer];\r\n            return (el, ...tail) => result;\r\n        }\r\n        case 'tagName':\r\n            return handleTagName(node);\r\n        case 'attrValue':\r\n            return handleAttrValueName(node);\r\n        case 'attrPresence':\r\n            return handleAttrPresenceName(node);\r\n        case 'pushElement':\r\n            return handlePushElementNode(node);\r\n        case 'popElement':\r\n            return handlePopElementNode(node);\r\n    }\r\n}\r\nfunction handleTagName(node) {\r\n    const variants = {};\r\n    for (const variant of node.variants) {\r\n        variants[variant.value] = handleArray(variant.cont);\r\n    }\r\n    return (el, ...tail) => {\r\n        const continuation = variants[el.name];\r\n        return (continuation) ? continuation(el, ...tail) : [];\r\n    };\r\n}\r\nfunction handleAttrPresenceName(node) {\r\n    const attrName = node.name;\r\n    const continuation = handleArray(node.cont);\r\n    return (el, ...tail) => (Object.prototype.hasOwnProperty.call(el.attribs, attrName))\r\n        ? continuation(el, ...tail)\r\n        : [];\r\n}\r\nfunction handleAttrValueName(node) {\r\n    const callbacks = [];\r\n    for (const matcher of node.matchers) {\r\n        const predicate = matcher.predicate;\r\n        const continuation = handleArray(matcher.cont);\r\n        callbacks.push((attr, el, ...tail) => (predicate(attr) ? continuation(el, ...tail) : []));\r\n    }\r\n    const attrName = node.name;\r\n    return (el, ...tail) => {\r\n        const attr = el.attribs[attrName];\r\n        return (attr || attr === '')\r\n            ? flatMap(callbacks, cb => cb(attr, el, ...tail))\r\n            : [];\r\n    };\r\n}\r\nfunction handlePushElementNode(node) {\r\n    const continuation = handleArray(node.cont);\r\n    const leftElementGetter = (node.combinator === '+')\r\n        ? getPrecedingElement\r\n        : getParentElement;\r\n    return (el, ...tail) => {\r\n        const next = leftElementGetter(el);\r\n        if (next === null) {\r\n            return [];\r\n        }\r\n        return continuation(next, el, ...tail);\r\n    };\r\n}\r\nconst getPrecedingElement = (el) => {\r\n    const prev = el.prev;\r\n    if (prev === null) {\r\n        return null;\r\n    }\r\n    return (isTag(prev)) ? prev : getPrecedingElement(prev);\r\n};\r\nconst getParentElement = (el) => {\r\n    const parent = el.parent;\r\n    return (parent && isTag(parent)) ? parent : null;\r\n};\r\nfunction handlePopElementNode(node) {\r\n    const continuation = handleArray(node.cont);\r\n    return (el, next, ...tail) => continuation(next, ...tail);\r\n}\r\n// Can be removed after transition to Node 12.\r\nfunction flatMap(items, mapper) {\r\n    return [].concat(...amap(items, mapper));\r\n}\r\nfunction amap(items, mapper) {\r\n    const len = items.length;\r\n    const res = new Array(len);\r\n    for (let i = 0; i < len; i++) {\r\n        res[i] = mapper(items[i]);\r\n    }\r\n    return res;\r\n}\n\nexport { hp2Builder };\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar parseley = require('parseley');\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        Object.keys(e).forEach(function (k) {\n            if (k !== 'default') {\n                var d = Object.getOwnPropertyDescriptor(e, k);\n                Object.defineProperty(n, k, d.get ? d : {\n                    enumerable: true,\n                    get: function () {\n                        return e[k];\n                    }\n                });\n            }\n        });\n    }\n    n['default'] = e;\n    return Object.freeze(n);\n}\n\nvar parseley__namespace = /*#__PURE__*/_interopNamespace(parseley);\n\nvar Ast = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\nvar Types = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\n/**\r\n * A {@link BuilderFunction} implementation.\r\n *\r\n * Produces a string representation of the tree\r\n * for testing and debug purposes.\r\n *\r\n * Only accepts `string` as the associated value type.\r\n * Map your input collection before creating a {@link DecisionTree}\r\n * if you want to use it with a different type -\r\n * the decision on how to stringify the value is up to you.\r\n *\r\n * @param nodes - nodes from the root level of the decision tree.\r\n * @returns the string representation of the tree.\r\n */\r\nconst treeify = (nodes) => '▽\\n' + treeifyArray(nodes, thinLines);\r\nconst thinLines = [['├─', '│ '], ['└─', '  ']];\r\nconst heavyLines = [['┠─', '┃ '], ['┖─', '  ']];\r\nconst doubleLines = [['╟─', '║ '], ['╙─', '  ']];\r\nfunction treeifyArray(nodes, tpl = heavyLines) {\r\n    return prefixItems(tpl, nodes.map(n => treeifyNode(n)));\r\n}\r\nfunction treeifyNode(node) {\r\n    switch (node.type) {\r\n        case 'terminal': {\r\n            const vctr = node.valueContainer;\r\n            return `◁ #${vctr.index} ${JSON.stringify(vctr.specificity)} ${vctr.value}`;\r\n        }\r\n        case 'tagName':\r\n            return `◻ Tag name\\n${treeifyArray(node.variants, doubleLines)}`;\r\n        case 'attrValue':\r\n            return `▣ Attr value: ${node.name}\\n${treeifyArray(node.matchers, doubleLines)}`;\r\n        case 'attrPresence':\r\n            return `◨ Attr presence: ${node.name}\\n${treeifyArray(node.cont)}`;\r\n        case 'pushElement':\r\n            return `◉ Push element: ${node.combinator}\\n${treeifyArray(node.cont, thinLines)}`;\r\n        case 'popElement':\r\n            return `◌ Pop element\\n${treeifyArray(node.cont, thinLines)}`;\r\n        case 'variant':\r\n            return `◇ = ${node.value}\\n${treeifyArray(node.cont)}`;\r\n        case 'matcher':\r\n            return `◈ ${node.matcher} \"${node.value}\"${node.modifier || ''}\\n${treeifyArray(node.cont)}`;\r\n    }\r\n}\r\nfunction prefixItems(tpl, items) {\r\n    return items\r\n        .map((item, i, { length }) => prefixItem(tpl, item, i === length - 1))\r\n        .join('\\n');\r\n}\r\nfunction prefixItem(tpl, item, tail = true) {\r\n    const tpl1 = tpl[tail ? 1 : 0];\r\n    return tpl1[0] + item.split('\\n').join('\\n' + tpl1[1]);\r\n}\n\nvar TreeifyBuilder = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    treeify: treeify\n});\n\n/**\r\n * CSS selectors decision tree.\r\n * Data structure that weaves similar selectors together\r\n * in order to minimize the number of checks required\r\n * to find the ones matching a given HTML element.\r\n *\r\n * Converted into a functioning implementation via plugins\r\n * tailored for specific DOM ASTs.\r\n *\r\n * @typeParam V - the type of values associated with selectors.\r\n */\r\nclass DecisionTree {\r\n    /**\r\n     * Create new DecisionTree object.\r\n     *\r\n     * @param input - an array containing all selectors\r\n     * paired with associated values.\r\n     *\r\n     * @typeParam V - the type of values associated with selectors.\r\n     */\r\n    constructor(input) {\r\n        this.branches = weave(toAstTerminalPairs(input));\r\n    }\r\n    /**\r\n     * Turn this decision tree into a usable form.\r\n     *\r\n     * @typeParam R - return type defined by the builder function.\r\n     *\r\n     * @param builder - the builder function.\r\n     *\r\n     * @returns the decision tree in a form ready for use.\r\n     */\r\n    build(builder) {\r\n        return builder(this.branches);\r\n    }\r\n}\r\nfunction toAstTerminalPairs(array) {\r\n    const len = array.length;\r\n    const results = new Array(len);\r\n    for (let i = 0; i < len; i++) {\r\n        const [selectorString, val] = array[i];\r\n        const ast = preprocess(parseley__namespace.parse1(selectorString));\r\n        results[i] = {\r\n            ast: ast,\r\n            terminal: {\r\n                type: 'terminal',\r\n                valueContainer: { index: i, value: val, specificity: ast.specificity }\r\n            }\r\n        };\r\n    }\r\n    return results;\r\n}\r\nfunction preprocess(ast) {\r\n    reduceSelectorVariants(ast);\r\n    parseley__namespace.normalize(ast);\r\n    return ast;\r\n}\r\nfunction reduceSelectorVariants(ast) {\r\n    const newList = [];\r\n    ast.list.forEach(sel => {\r\n        switch (sel.type) {\r\n            case 'class':\r\n                newList.push({\r\n                    matcher: '~=',\r\n                    modifier: null,\r\n                    name: 'class',\r\n                    namespace: null,\r\n                    specificity: sel.specificity,\r\n                    type: 'attrValue',\r\n                    value: sel.name,\r\n                });\r\n                break;\r\n            case 'id':\r\n                newList.push({\r\n                    matcher: '=',\r\n                    modifier: null,\r\n                    name: 'id',\r\n                    namespace: null,\r\n                    specificity: sel.specificity,\r\n                    type: 'attrValue',\r\n                    value: sel.name,\r\n                });\r\n                break;\r\n            case 'combinator':\r\n                reduceSelectorVariants(sel.left);\r\n                newList.push(sel);\r\n                break;\r\n            case 'universal':\r\n                // skip it\r\n                break;\r\n            default:\r\n                newList.push(sel);\r\n                break;\r\n        }\r\n    });\r\n    ast.list = newList;\r\n}\r\nfunction weave(items) {\r\n    const branches = [];\r\n    while (items.length) {\r\n        const topKind = findTopKey(items, (sel) => true, getSelectorKind);\r\n        const { matches, nonmatches, empty } = breakByKind(items, topKind);\r\n        items = nonmatches;\r\n        if (matches.length) {\r\n            branches.push(branchOfKind(topKind, matches));\r\n        }\r\n        if (empty.length) {\r\n            branches.push(...terminate(empty));\r\n        }\r\n    }\r\n    return branches;\r\n}\r\nfunction terminate(items) {\r\n    const results = [];\r\n    for (const item of items) {\r\n        const terminal = item.terminal;\r\n        if (terminal.type === 'terminal') {\r\n            results.push(terminal);\r\n        }\r\n        else { // popElement - lift contained terminals\r\n            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');\r\n            matches.forEach((node) => results.push(node));\r\n            if (rest.length) {\r\n                terminal.cont = rest;\r\n                results.push(terminal);\r\n            }\r\n        }\r\n    }\r\n    return results;\r\n}\r\nfunction breakByKind(items, selectedKind) {\r\n    const matches = [];\r\n    const nonmatches = [];\r\n    const empty = [];\r\n    for (const item of items) {\r\n        const simpsels = item.ast.list;\r\n        if (simpsels.length) {\r\n            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);\r\n            (isMatch ? matches : nonmatches).push(item);\r\n        }\r\n        else {\r\n            empty.push(item);\r\n        }\r\n    }\r\n    return { matches, nonmatches, empty };\r\n}\r\nfunction getSelectorKind(sel) {\r\n    switch (sel.type) {\r\n        case 'attrPresence':\r\n            return `attrPresence ${sel.name}`;\r\n        case 'attrValue':\r\n            return `attrValue ${sel.name}`;\r\n        case 'combinator':\r\n            return `combinator ${sel.combinator}`;\r\n        default:\r\n            return sel.type;\r\n    }\r\n}\r\nfunction branchOfKind(kind, items) {\r\n    if (kind === 'tag') {\r\n        return tagNameBranch(items);\r\n    }\r\n    if (kind.startsWith('attrValue ')) {\r\n        return attrValueBranch(kind.substring(10), items);\r\n    }\r\n    if (kind.startsWith('attrPresence ')) {\r\n        return attrPresenceBranch(kind.substring(13), items);\r\n    }\r\n    if (kind === 'combinator >') {\r\n        return combinatorBranch('>', items);\r\n    }\r\n    if (kind === 'combinator +') {\r\n        return combinatorBranch('+', items);\r\n    }\r\n    throw new Error(`Unsupported selector kind: ${kind}`);\r\n}\r\nfunction tagNameBranch(items) {\r\n    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);\r\n    const variants = Object.entries(groups).map(([name, group]) => ({\r\n        type: 'variant',\r\n        value: name,\r\n        cont: weave(group.items)\r\n    }));\r\n    return {\r\n        type: 'tagName',\r\n        variants: variants\r\n    };\r\n}\r\nfunction attrPresenceBranch(name, items) {\r\n    for (const item of items) {\r\n        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));\r\n    }\r\n    return {\r\n        type: 'attrPresence',\r\n        name: name,\r\n        cont: weave(items)\r\n    };\r\n}\r\nfunction attrValueBranch(name, items) {\r\n    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);\r\n    const matchers = [];\r\n    for (const group of Object.values(groups)) {\r\n        const sel = group.oneSimpleSelector;\r\n        const predicate = getAttrPredicate(sel);\r\n        const continuation = weave(group.items);\r\n        matchers.push({\r\n            type: 'matcher',\r\n            matcher: sel.matcher,\r\n            modifier: sel.modifier,\r\n            value: sel.value,\r\n            predicate: predicate,\r\n            cont: continuation\r\n        });\r\n    }\r\n    return {\r\n        type: 'attrValue',\r\n        name: name,\r\n        matchers: matchers\r\n    };\r\n}\r\nfunction getAttrPredicate(sel) {\r\n    if (sel.modifier === 'i') {\r\n        const expected = sel.value.toLowerCase();\r\n        switch (sel.matcher) {\r\n            case '=':\r\n                return (actual) => expected === actual.toLowerCase();\r\n            case '~=':\r\n                return (actual) => actual.toLowerCase().split(/[ \\t]+/).includes(expected);\r\n            case '^=':\r\n                return (actual) => actual.toLowerCase().startsWith(expected);\r\n            case '$=':\r\n                return (actual) => actual.toLowerCase().endsWith(expected);\r\n            case '*=':\r\n                return (actual) => actual.toLowerCase().includes(expected);\r\n            case '|=':\r\n                return (actual) => {\r\n                    const lower = actual.toLowerCase();\r\n                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');\r\n                };\r\n        }\r\n    }\r\n    else {\r\n        const expected = sel.value;\r\n        switch (sel.matcher) {\r\n            case '=':\r\n                return (actual) => expected === actual;\r\n            case '~=':\r\n                return (actual) => actual.split(/[ \\t]+/).includes(expected);\r\n            case '^=':\r\n                return (actual) => actual.startsWith(expected);\r\n            case '$=':\r\n                return (actual) => actual.endsWith(expected);\r\n            case '*=':\r\n                return (actual) => actual.includes(expected);\r\n            case '|=':\r\n                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');\r\n        }\r\n    }\r\n}\r\nfunction combinatorBranch(combinator, items) {\r\n    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => parseley__namespace.serialize(x.left));\r\n    const leftItems = [];\r\n    for (const group of Object.values(groups)) {\r\n        const rightCont = weave(group.items);\r\n        const leftAst = group.oneSimpleSelector.left;\r\n        leftItems.push({\r\n            ast: leftAst,\r\n            terminal: { type: 'popElement', cont: rightCont }\r\n        });\r\n    }\r\n    return {\r\n        type: 'pushElement',\r\n        combinator: combinator,\r\n        cont: weave(leftItems)\r\n    };\r\n}\r\nfunction spliceAndGroup(items, predicate, keyCallback) {\r\n    const groups = {};\r\n    while (items.length) {\r\n        const bestKey = findTopKey(items, predicate, keyCallback);\r\n        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;\r\n        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);\r\n        const { matches, rest } = partition1(items, hasBestKeyPredicate);\r\n        let oneSimpleSelector = null;\r\n        for (const item of matches) {\r\n            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);\r\n            if (!oneSimpleSelector) {\r\n                oneSimpleSelector = splicedNode;\r\n            }\r\n        }\r\n        if (oneSimpleSelector == null) {\r\n            throw new Error('No simple selector is found.');\r\n        }\r\n        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };\r\n        items = rest;\r\n    }\r\n    return groups;\r\n}\r\nfunction spliceSimpleSelector(item, predicate) {\r\n    const simpsels = item.ast.list;\r\n    const matches = new Array(simpsels.length);\r\n    let firstIndex = -1;\r\n    for (let i = simpsels.length; i-- > 0;) {\r\n        if (predicate(simpsels[i])) {\r\n            matches[i] = true;\r\n            firstIndex = i;\r\n        }\r\n    }\r\n    if (firstIndex == -1) {\r\n        throw new Error(`Couldn't find the required simple selector.`);\r\n    }\r\n    const result = simpsels[firstIndex];\r\n    item.ast.list = simpsels.filter((sel, i) => !matches[i]);\r\n    return result;\r\n}\r\nfunction findTopKey(items, predicate, keyCallback) {\r\n    const candidates = {};\r\n    for (const item of items) {\r\n        const candidates1 = {};\r\n        for (const node of item.ast.list.filter(predicate)) {\r\n            candidates1[keyCallback(node)] = true;\r\n        }\r\n        for (const key of Object.keys(candidates1)) {\r\n            if (candidates[key]) {\r\n                candidates[key]++;\r\n            }\r\n            else {\r\n                candidates[key] = 1;\r\n            }\r\n        }\r\n    }\r\n    let topKind = '';\r\n    let topCounter = 0;\r\n    for (const entry of Object.entries(candidates)) {\r\n        if (entry[1] > topCounter) {\r\n            topKind = entry[0];\r\n            topCounter = entry[1];\r\n        }\r\n    }\r\n    return topKind;\r\n}\r\nfunction partition(src, predicate) {\r\n    const matches = [];\r\n    const rest = [];\r\n    for (const x of src) {\r\n        if (predicate(x)) {\r\n            matches.push(x);\r\n        }\r\n        else {\r\n            rest.push(x);\r\n        }\r\n    }\r\n    return { matches, rest };\r\n}\r\nfunction partition1(src, predicate) {\r\n    const matches = [];\r\n    const rest = [];\r\n    for (const x of src) {\r\n        if (predicate(x)) {\r\n            matches.push(x);\r\n        }\r\n        else {\r\n            rest.push(x);\r\n        }\r\n    }\r\n    return { matches, rest };\r\n}\n\n/**\r\n * Simple wrapper around the matcher function.\r\n * Recommended return type for builder plugins.\r\n *\r\n * @typeParam L - the type of HTML Element in the targeted DOM AST.\r\n * @typeParam V - the type of associated values.\r\n */\r\nclass Picker {\r\n    /**\r\n     * Create new Picker object.\r\n     *\r\n     * @typeParam L - the type of HTML Element in the targeted DOM AST.\r\n     * @typeParam V - the type of associated values.\r\n     *\r\n     * @param f - the function that matches an element\r\n     * and returns all associated values.\r\n     */\r\n    constructor(f) {\r\n        this.f = f;\r\n    }\r\n    /**\r\n     * Run the selectors decision tree against one HTML Element\r\n     * and return all matched associated values\r\n     * along with selector specificities.\r\n     *\r\n     * Client code then decides how to further process them\r\n     * (sort, filter, etc).\r\n     *\r\n     * @param el - an HTML Element.\r\n     *\r\n     * @returns all associated values along with\r\n     * selector specificities for all matched selectors.\r\n     */\r\n    pickAll(el) {\r\n        return this.f(el);\r\n    }\r\n    /**\r\n     * Run the selectors decision tree against one HTML Element\r\n     * and choose the value from the most specific mached selector.\r\n     *\r\n     * @param el - an HTML Element.\r\n     *\r\n     * @param preferFirst - option to define which value to choose\r\n     * when there are multiple matches with equal specificity.\r\n     *\r\n     * @returns the value from the most specific mached selector\r\n     * or `null` if nothing matched.\r\n     */\r\n    pick1(el, preferFirst = false) {\r\n        const results = this.f(el);\r\n        const len = results.length;\r\n        if (len === 0) {\r\n            return null;\r\n        }\r\n        if (len === 1) {\r\n            return results[0].value;\r\n        }\r\n        const comparator = (preferFirst)\r\n            ? comparatorPreferFirst\r\n            : comparatorPreferLast;\r\n        let result = results[0];\r\n        for (let i = 1; i < len; i++) {\r\n            const next = results[i];\r\n            if (comparator(result, next)) {\r\n                result = next;\r\n            }\r\n        }\r\n        return result.value;\r\n    }\r\n}\r\nfunction comparatorPreferFirst(acc, next) {\r\n    const diff = parseley.compareSpecificity(next.specificity, acc.specificity);\r\n    return diff > 0 || (diff === 0 && next.index < acc.index);\r\n}\r\nfunction comparatorPreferLast(acc, next) {\r\n    const diff = parseley.compareSpecificity(next.specificity, acc.specificity);\r\n    return diff > 0 || (diff === 0 && next.index > acc.index);\r\n}\n\nexports.Ast = Ast;\nexports.DecisionTree = DecisionTree;\nexports.Picker = Picker;\nexports.Treeify = TreeifyBuilder;\nexports.Types = Types;\n","import * as parseley from 'parseley';\nimport { compareSpecificity } from 'parseley';\n\nvar Ast = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\nvar Types = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\n/**\r\n * A {@link BuilderFunction} implementation.\r\n *\r\n * Produces a string representation of the tree\r\n * for testing and debug purposes.\r\n *\r\n * Only accepts `string` as the associated value type.\r\n * Map your input collection before creating a {@link DecisionTree}\r\n * if you want to use it with a different type -\r\n * the decision on how to stringify the value is up to you.\r\n *\r\n * @param nodes - nodes from the root level of the decision tree.\r\n * @returns the string representation of the tree.\r\n */\r\nconst treeify = (nodes) => '▽\\n' + treeifyArray(nodes, thinLines);\r\nconst thinLines = [['├─', '│ '], ['└─', '  ']];\r\nconst heavyLines = [['┠─', '┃ '], ['┖─', '  ']];\r\nconst doubleLines = [['╟─', '║ '], ['╙─', '  ']];\r\nfunction treeifyArray(nodes, tpl = heavyLines) {\r\n    return prefixItems(tpl, nodes.map(n => treeifyNode(n)));\r\n}\r\nfunction treeifyNode(node) {\r\n    switch (node.type) {\r\n        case 'terminal': {\r\n            const vctr = node.valueContainer;\r\n            return `◁ #${vctr.index} ${JSON.stringify(vctr.specificity)} ${vctr.value}`;\r\n        }\r\n        case 'tagName':\r\n            return `◻ Tag name\\n${treeifyArray(node.variants, doubleLines)}`;\r\n        case 'attrValue':\r\n            return `▣ Attr value: ${node.name}\\n${treeifyArray(node.matchers, doubleLines)}`;\r\n        case 'attrPresence':\r\n            return `◨ Attr presence: ${node.name}\\n${treeifyArray(node.cont)}`;\r\n        case 'pushElement':\r\n            return `◉ Push element: ${node.combinator}\\n${treeifyArray(node.cont, thinLines)}`;\r\n        case 'popElement':\r\n            return `◌ Pop element\\n${treeifyArray(node.cont, thinLines)}`;\r\n        case 'variant':\r\n            return `◇ = ${node.value}\\n${treeifyArray(node.cont)}`;\r\n        case 'matcher':\r\n            return `◈ ${node.matcher} \"${node.value}\"${node.modifier || ''}\\n${treeifyArray(node.cont)}`;\r\n    }\r\n}\r\nfunction prefixItems(tpl, items) {\r\n    return items\r\n        .map((item, i, { length }) => prefixItem(tpl, item, i === length - 1))\r\n        .join('\\n');\r\n}\r\nfunction prefixItem(tpl, item, tail = true) {\r\n    const tpl1 = tpl[tail ? 1 : 0];\r\n    return tpl1[0] + item.split('\\n').join('\\n' + tpl1[1]);\r\n}\n\nvar TreeifyBuilder = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    treeify: treeify\n});\n\n/**\r\n * CSS selectors decision tree.\r\n * Data structure that weaves similar selectors together\r\n * in order to minimize the number of checks required\r\n * to find the ones matching a given HTML element.\r\n *\r\n * Converted into a functioning implementation via plugins\r\n * tailored for specific DOM ASTs.\r\n *\r\n * @typeParam V - the type of values associated with selectors.\r\n */\r\nclass DecisionTree {\r\n    /**\r\n     * Create new DecisionTree object.\r\n     *\r\n     * @param input - an array containing all selectors\r\n     * paired with associated values.\r\n     *\r\n     * @typeParam V - the type of values associated with selectors.\r\n     */\r\n    constructor(input) {\r\n        this.branches = weave(toAstTerminalPairs(input));\r\n    }\r\n    /**\r\n     * Turn this decision tree into a usable form.\r\n     *\r\n     * @typeParam R - return type defined by the builder function.\r\n     *\r\n     * @param builder - the builder function.\r\n     *\r\n     * @returns the decision tree in a form ready for use.\r\n     */\r\n    build(builder) {\r\n        return builder(this.branches);\r\n    }\r\n}\r\nfunction toAstTerminalPairs(array) {\r\n    const len = array.length;\r\n    const results = new Array(len);\r\n    for (let i = 0; i < len; i++) {\r\n        const [selectorString, val] = array[i];\r\n        const ast = preprocess(parseley.parse1(selectorString));\r\n        results[i] = {\r\n            ast: ast,\r\n            terminal: {\r\n                type: 'terminal',\r\n                valueContainer: { index: i, value: val, specificity: ast.specificity }\r\n            }\r\n        };\r\n    }\r\n    return results;\r\n}\r\nfunction preprocess(ast) {\r\n    reduceSelectorVariants(ast);\r\n    parseley.normalize(ast);\r\n    return ast;\r\n}\r\nfunction reduceSelectorVariants(ast) {\r\n    const newList = [];\r\n    ast.list.forEach(sel => {\r\n        switch (sel.type) {\r\n            case 'class':\r\n                newList.push({\r\n                    matcher: '~=',\r\n                    modifier: null,\r\n                    name: 'class',\r\n                    namespace: null,\r\n                    specificity: sel.specificity,\r\n                    type: 'attrValue',\r\n                    value: sel.name,\r\n                });\r\n                break;\r\n            case 'id':\r\n                newList.push({\r\n                    matcher: '=',\r\n                    modifier: null,\r\n                    name: 'id',\r\n                    namespace: null,\r\n                    specificity: sel.specificity,\r\n                    type: 'attrValue',\r\n                    value: sel.name,\r\n                });\r\n                break;\r\n            case 'combinator':\r\n                reduceSelectorVariants(sel.left);\r\n                newList.push(sel);\r\n                break;\r\n            case 'universal':\r\n                // skip it\r\n                break;\r\n            default:\r\n                newList.push(sel);\r\n                break;\r\n        }\r\n    });\r\n    ast.list = newList;\r\n}\r\nfunction weave(items) {\r\n    const branches = [];\r\n    while (items.length) {\r\n        const topKind = findTopKey(items, (sel) => true, getSelectorKind);\r\n        const { matches, nonmatches, empty } = breakByKind(items, topKind);\r\n        items = nonmatches;\r\n        if (matches.length) {\r\n            branches.push(branchOfKind(topKind, matches));\r\n        }\r\n        if (empty.length) {\r\n            branches.push(...terminate(empty));\r\n        }\r\n    }\r\n    return branches;\r\n}\r\nfunction terminate(items) {\r\n    const results = [];\r\n    for (const item of items) {\r\n        const terminal = item.terminal;\r\n        if (terminal.type === 'terminal') {\r\n            results.push(terminal);\r\n        }\r\n        else { // popElement - lift contained terminals\r\n            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');\r\n            matches.forEach((node) => results.push(node));\r\n            if (rest.length) {\r\n                terminal.cont = rest;\r\n                results.push(terminal);\r\n            }\r\n        }\r\n    }\r\n    return results;\r\n}\r\nfunction breakByKind(items, selectedKind) {\r\n    const matches = [];\r\n    const nonmatches = [];\r\n    const empty = [];\r\n    for (const item of items) {\r\n        const simpsels = item.ast.list;\r\n        if (simpsels.length) {\r\n            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);\r\n            (isMatch ? matches : nonmatches).push(item);\r\n        }\r\n        else {\r\n            empty.push(item);\r\n        }\r\n    }\r\n    return { matches, nonmatches, empty };\r\n}\r\nfunction getSelectorKind(sel) {\r\n    switch (sel.type) {\r\n        case 'attrPresence':\r\n            return `attrPresence ${sel.name}`;\r\n        case 'attrValue':\r\n            return `attrValue ${sel.name}`;\r\n        case 'combinator':\r\n            return `combinator ${sel.combinator}`;\r\n        default:\r\n            return sel.type;\r\n    }\r\n}\r\nfunction branchOfKind(kind, items) {\r\n    if (kind === 'tag') {\r\n        return tagNameBranch(items);\r\n    }\r\n    if (kind.startsWith('attrValue ')) {\r\n        return attrValueBranch(kind.substring(10), items);\r\n    }\r\n    if (kind.startsWith('attrPresence ')) {\r\n        return attrPresenceBranch(kind.substring(13), items);\r\n    }\r\n    if (kind === 'combinator >') {\r\n        return combinatorBranch('>', items);\r\n    }\r\n    if (kind === 'combinator +') {\r\n        return combinatorBranch('+', items);\r\n    }\r\n    throw new Error(`Unsupported selector kind: ${kind}`);\r\n}\r\nfunction tagNameBranch(items) {\r\n    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);\r\n    const variants = Object.entries(groups).map(([name, group]) => ({\r\n        type: 'variant',\r\n        value: name,\r\n        cont: weave(group.items)\r\n    }));\r\n    return {\r\n        type: 'tagName',\r\n        variants: variants\r\n    };\r\n}\r\nfunction attrPresenceBranch(name, items) {\r\n    for (const item of items) {\r\n        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));\r\n    }\r\n    return {\r\n        type: 'attrPresence',\r\n        name: name,\r\n        cont: weave(items)\r\n    };\r\n}\r\nfunction attrValueBranch(name, items) {\r\n    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);\r\n    const matchers = [];\r\n    for (const group of Object.values(groups)) {\r\n        const sel = group.oneSimpleSelector;\r\n        const predicate = getAttrPredicate(sel);\r\n        const continuation = weave(group.items);\r\n        matchers.push({\r\n            type: 'matcher',\r\n            matcher: sel.matcher,\r\n            modifier: sel.modifier,\r\n            value: sel.value,\r\n            predicate: predicate,\r\n            cont: continuation\r\n        });\r\n    }\r\n    return {\r\n        type: 'attrValue',\r\n        name: name,\r\n        matchers: matchers\r\n    };\r\n}\r\nfunction getAttrPredicate(sel) {\r\n    if (sel.modifier === 'i') {\r\n        const expected = sel.value.toLowerCase();\r\n        switch (sel.matcher) {\r\n            case '=':\r\n                return (actual) => expected === actual.toLowerCase();\r\n            case '~=':\r\n                return (actual) => actual.toLowerCase().split(/[ \\t]+/).includes(expected);\r\n            case '^=':\r\n                return (actual) => actual.toLowerCase().startsWith(expected);\r\n            case '$=':\r\n                return (actual) => actual.toLowerCase().endsWith(expected);\r\n            case '*=':\r\n                return (actual) => actual.toLowerCase().includes(expected);\r\n            case '|=':\r\n                return (actual) => {\r\n                    const lower = actual.toLowerCase();\r\n                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');\r\n                };\r\n        }\r\n    }\r\n    else {\r\n        const expected = sel.value;\r\n        switch (sel.matcher) {\r\n            case '=':\r\n                return (actual) => expected === actual;\r\n            case '~=':\r\n                return (actual) => actual.split(/[ \\t]+/).includes(expected);\r\n            case '^=':\r\n                return (actual) => actual.startsWith(expected);\r\n            case '$=':\r\n                return (actual) => actual.endsWith(expected);\r\n            case '*=':\r\n                return (actual) => actual.includes(expected);\r\n            case '|=':\r\n                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');\r\n        }\r\n    }\r\n}\r\nfunction combinatorBranch(combinator, items) {\r\n    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => parseley.serialize(x.left));\r\n    const leftItems = [];\r\n    for (const group of Object.values(groups)) {\r\n        const rightCont = weave(group.items);\r\n        const leftAst = group.oneSimpleSelector.left;\r\n        leftItems.push({\r\n            ast: leftAst,\r\n            terminal: { type: 'popElement', cont: rightCont }\r\n        });\r\n    }\r\n    return {\r\n        type: 'pushElement',\r\n        combinator: combinator,\r\n        cont: weave(leftItems)\r\n    };\r\n}\r\nfunction spliceAndGroup(items, predicate, keyCallback) {\r\n    const groups = {};\r\n    while (items.length) {\r\n        const bestKey = findTopKey(items, predicate, keyCallback);\r\n        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;\r\n        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);\r\n        const { matches, rest } = partition1(items, hasBestKeyPredicate);\r\n        let oneSimpleSelector = null;\r\n        for (const item of matches) {\r\n            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);\r\n            if (!oneSimpleSelector) {\r\n                oneSimpleSelector = splicedNode;\r\n            }\r\n        }\r\n        if (oneSimpleSelector == null) {\r\n            throw new Error('No simple selector is found.');\r\n        }\r\n        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };\r\n        items = rest;\r\n    }\r\n    return groups;\r\n}\r\nfunction spliceSimpleSelector(item, predicate) {\r\n    const simpsels = item.ast.list;\r\n    const matches = new Array(simpsels.length);\r\n    let firstIndex = -1;\r\n    for (let i = simpsels.length; i-- > 0;) {\r\n        if (predicate(simpsels[i])) {\r\n            matches[i] = true;\r\n            firstIndex = i;\r\n        }\r\n    }\r\n    if (firstIndex == -1) {\r\n        throw new Error(`Couldn't find the required simple selector.`);\r\n    }\r\n    const result = simpsels[firstIndex];\r\n    item.ast.list = simpsels.filter((sel, i) => !matches[i]);\r\n    return result;\r\n}\r\nfunction findTopKey(items, predicate, keyCallback) {\r\n    const candidates = {};\r\n    for (const item of items) {\r\n        const candidates1 = {};\r\n        for (const node of item.ast.list.filter(predicate)) {\r\n            candidates1[keyCallback(node)] = true;\r\n        }\r\n        for (const key of Object.keys(candidates1)) {\r\n            if (candidates[key]) {\r\n                candidates[key]++;\r\n            }\r\n            else {\r\n                candidates[key] = 1;\r\n            }\r\n        }\r\n    }\r\n    let topKind = '';\r\n    let topCounter = 0;\r\n    for (const entry of Object.entries(candidates)) {\r\n        if (entry[1] > topCounter) {\r\n            topKind = entry[0];\r\n            topCounter = entry[1];\r\n        }\r\n    }\r\n    return topKind;\r\n}\r\nfunction partition(src, predicate) {\r\n    const matches = [];\r\n    const rest = [];\r\n    for (const x of src) {\r\n        if (predicate(x)) {\r\n            matches.push(x);\r\n        }\r\n        else {\r\n            rest.push(x);\r\n        }\r\n    }\r\n    return { matches, rest };\r\n}\r\nfunction partition1(src, predicate) {\r\n    const matches = [];\r\n    const rest = [];\r\n    for (const x of src) {\r\n        if (predicate(x)) {\r\n            matches.push(x);\r\n        }\r\n        else {\r\n            rest.push(x);\r\n        }\r\n    }\r\n    return { matches, rest };\r\n}\n\n/**\r\n * Simple wrapper around the matcher function.\r\n * Recommended return type for builder plugins.\r\n *\r\n * @typeParam L - the type of HTML Element in the targeted DOM AST.\r\n * @typeParam V - the type of associated values.\r\n */\r\nclass Picker {\r\n    /**\r\n     * Create new Picker object.\r\n     *\r\n     * @typeParam L - the type of HTML Element in the targeted DOM AST.\r\n     * @typeParam V - the type of associated values.\r\n     *\r\n     * @param f - the function that matches an element\r\n     * and returns all associated values.\r\n     */\r\n    constructor(f) {\r\n        this.f = f;\r\n    }\r\n    /**\r\n     * Run the selectors decision tree against one HTML Element\r\n     * and return all matched associated values\r\n     * along with selector specificities.\r\n     *\r\n     * Client code then decides how to further process them\r\n     * (sort, filter, etc).\r\n     *\r\n     * @param el - an HTML Element.\r\n     *\r\n     * @returns all associated values along with\r\n     * selector specificities for all matched selectors.\r\n     */\r\n    pickAll(el) {\r\n        return this.f(el);\r\n    }\r\n    /**\r\n     * Run the selectors decision tree against one HTML Element\r\n     * and choose the value from the most specific mached selector.\r\n     *\r\n     * @param el - an HTML Element.\r\n     *\r\n     * @param preferFirst - option to define which value to choose\r\n     * when there are multiple matches with equal specificity.\r\n     *\r\n     * @returns the value from the most specific mached selector\r\n     * or `null` if nothing matched.\r\n     */\r\n    pick1(el, preferFirst = false) {\r\n        const results = this.f(el);\r\n        const len = results.length;\r\n        if (len === 0) {\r\n            return null;\r\n        }\r\n        if (len === 1) {\r\n            return results[0].value;\r\n        }\r\n        const comparator = (preferFirst)\r\n            ? comparatorPreferFirst\r\n            : comparatorPreferLast;\r\n        let result = results[0];\r\n        for (let i = 1; i < len; i++) {\r\n            const next = results[i];\r\n            if (comparator(result, next)) {\r\n                result = next;\r\n            }\r\n        }\r\n        return result.value;\r\n    }\r\n}\r\nfunction comparatorPreferFirst(acc, next) {\r\n    const diff = compareSpecificity(next.specificity, acc.specificity);\r\n    return diff > 0 || (diff === 0 && next.index < acc.index);\r\n}\r\nfunction comparatorPreferLast(acc, next) {\r\n    const diff = compareSpecificity(next.specificity, acc.specificity);\r\n    return diff > 0 || (diff === 0 && next.index > acc.index);\r\n}\n\nexport { Ast, DecisionTree, Picker, TreeifyBuilder as Treeify, Types };\n"],"sourceRoot":""}