{"version":3,"file":"selderee-c33c36f6.js","sources":["../../node_modules/selderee/lib/selderee.mjs"],"sourcesContent":["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\nconst treeify = (nodes) => '▽\\n' + treeifyArray(nodes, thinLines);\nconst thinLines = [['├─', '│ '], ['└─', '  ']];\nconst heavyLines = [['┠─', '┃ '], ['┖─', '  ']];\nconst doubleLines = [['╟─', '║ '], ['╙─', '  ']];\nfunction treeifyArray(nodes, tpl = heavyLines) {\n    return prefixItems(tpl, nodes.map(n => treeifyNode(n)));\n}\nfunction treeifyNode(node) {\n    switch (node.type) {\n        case 'terminal': {\n            const vctr = node.valueContainer;\n            return `◁ #${vctr.index} ${JSON.stringify(vctr.specificity)} ${vctr.value}`;\n        }\n        case 'tagName':\n            return `◻ Tag name\\n${treeifyArray(node.variants, doubleLines)}`;\n        case 'attrValue':\n            return `▣ Attr value: ${node.name}\\n${treeifyArray(node.matchers, doubleLines)}`;\n        case 'attrPresence':\n            return `◨ Attr presence: ${node.name}\\n${treeifyArray(node.cont)}`;\n        case 'pushElement':\n            return `◉ Push element: ${node.combinator}\\n${treeifyArray(node.cont, thinLines)}`;\n        case 'popElement':\n            return `◌ Pop element\\n${treeifyArray(node.cont, thinLines)}`;\n        case 'variant':\n            return `◇ = ${node.value}\\n${treeifyArray(node.cont)}`;\n        case 'matcher':\n            return `◈ ${node.matcher} \"${node.value}\"${node.modifier || ''}\\n${treeifyArray(node.cont)}`;\n    }\n}\nfunction prefixItems(tpl, items) {\n    return items\n        .map((item, i, { length }) => prefixItem(tpl, item, i === length - 1))\n        .join('\\n');\n}\nfunction prefixItem(tpl, item, tail = true) {\n    const tpl1 = tpl[tail ? 1 : 0];\n    return tpl1[0] + item.split('\\n').join('\\n' + tpl1[1]);\n}\n\nvar TreeifyBuilder = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    treeify: treeify\n});\n\nclass DecisionTree {\n    constructor(input) {\n        this.branches = weave(toAstTerminalPairs(input));\n    }\n    build(builder) {\n        return builder(this.branches);\n    }\n}\nfunction toAstTerminalPairs(array) {\n    const len = array.length;\n    const results = new Array(len);\n    for (let i = 0; i < len; i++) {\n        const [selectorString, val] = array[i];\n        const ast = preprocess(parseley.parse1(selectorString));\n        results[i] = {\n            ast: ast,\n            terminal: {\n                type: 'terminal',\n                valueContainer: { index: i, value: val, specificity: ast.specificity }\n            }\n        };\n    }\n    return results;\n}\nfunction preprocess(ast) {\n    reduceSelectorVariants(ast);\n    parseley.normalize(ast);\n    return ast;\n}\nfunction reduceSelectorVariants(ast) {\n    const newList = [];\n    ast.list.forEach(sel => {\n        switch (sel.type) {\n            case 'class':\n                newList.push({\n                    matcher: '~=',\n                    modifier: null,\n                    name: 'class',\n                    namespace: null,\n                    specificity: sel.specificity,\n                    type: 'attrValue',\n                    value: sel.name,\n                });\n                break;\n            case 'id':\n                newList.push({\n                    matcher: '=',\n                    modifier: null,\n                    name: 'id',\n                    namespace: null,\n                    specificity: sel.specificity,\n                    type: 'attrValue',\n                    value: sel.name,\n                });\n                break;\n            case 'combinator':\n                reduceSelectorVariants(sel.left);\n                newList.push(sel);\n                break;\n            case 'universal':\n                break;\n            default:\n                newList.push(sel);\n                break;\n        }\n    });\n    ast.list = newList;\n}\nfunction weave(items) {\n    const branches = [];\n    while (items.length) {\n        const topKind = findTopKey(items, (sel) => true, getSelectorKind);\n        const { matches, nonmatches, empty } = breakByKind(items, topKind);\n        items = nonmatches;\n        if (matches.length) {\n            branches.push(branchOfKind(topKind, matches));\n        }\n        if (empty.length) {\n            branches.push(...terminate(empty));\n        }\n    }\n    return branches;\n}\nfunction terminate(items) {\n    const results = [];\n    for (const item of items) {\n        const terminal = item.terminal;\n        if (terminal.type === 'terminal') {\n            results.push(terminal);\n        }\n        else {\n            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');\n            matches.forEach((node) => results.push(node));\n            if (rest.length) {\n                terminal.cont = rest;\n                results.push(terminal);\n            }\n        }\n    }\n    return results;\n}\nfunction breakByKind(items, selectedKind) {\n    const matches = [];\n    const nonmatches = [];\n    const empty = [];\n    for (const item of items) {\n        const simpsels = item.ast.list;\n        if (simpsels.length) {\n            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);\n            (isMatch ? matches : nonmatches).push(item);\n        }\n        else {\n            empty.push(item);\n        }\n    }\n    return { matches, nonmatches, empty };\n}\nfunction getSelectorKind(sel) {\n    switch (sel.type) {\n        case 'attrPresence':\n            return `attrPresence ${sel.name}`;\n        case 'attrValue':\n            return `attrValue ${sel.name}`;\n        case 'combinator':\n            return `combinator ${sel.combinator}`;\n        default:\n            return sel.type;\n    }\n}\nfunction branchOfKind(kind, items) {\n    if (kind === 'tag') {\n        return tagNameBranch(items);\n    }\n    if (kind.startsWith('attrValue ')) {\n        return attrValueBranch(kind.substring(10), items);\n    }\n    if (kind.startsWith('attrPresence ')) {\n        return attrPresenceBranch(kind.substring(13), items);\n    }\n    if (kind === 'combinator >') {\n        return combinatorBranch('>', items);\n    }\n    if (kind === 'combinator +') {\n        return combinatorBranch('+', items);\n    }\n    throw new Error(`Unsupported selector kind: ${kind}`);\n}\nfunction tagNameBranch(items) {\n    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);\n    const variants = Object.entries(groups).map(([name, group]) => ({\n        type: 'variant',\n        value: name,\n        cont: weave(group.items)\n    }));\n    return {\n        type: 'tagName',\n        variants: variants\n    };\n}\nfunction attrPresenceBranch(name, items) {\n    for (const item of items) {\n        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));\n    }\n    return {\n        type: 'attrPresence',\n        name: name,\n        cont: weave(items)\n    };\n}\nfunction attrValueBranch(name, items) {\n    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);\n    const matchers = [];\n    for (const group of Object.values(groups)) {\n        const sel = group.oneSimpleSelector;\n        const predicate = getAttrPredicate(sel);\n        const continuation = weave(group.items);\n        matchers.push({\n            type: 'matcher',\n            matcher: sel.matcher,\n            modifier: sel.modifier,\n            value: sel.value,\n            predicate: predicate,\n            cont: continuation\n        });\n    }\n    return {\n        type: 'attrValue',\n        name: name,\n        matchers: matchers\n    };\n}\nfunction getAttrPredicate(sel) {\n    if (sel.modifier === 'i') {\n        const expected = sel.value.toLowerCase();\n        switch (sel.matcher) {\n            case '=':\n                return (actual) => expected === actual.toLowerCase();\n            case '~=':\n                return (actual) => actual.toLowerCase().split(/[ \\t]+/).includes(expected);\n            case '^=':\n                return (actual) => actual.toLowerCase().startsWith(expected);\n            case '$=':\n                return (actual) => actual.toLowerCase().endsWith(expected);\n            case '*=':\n                return (actual) => actual.toLowerCase().includes(expected);\n            case '|=':\n                return (actual) => {\n                    const lower = actual.toLowerCase();\n                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');\n                };\n        }\n    }\n    else {\n        const expected = sel.value;\n        switch (sel.matcher) {\n            case '=':\n                return (actual) => expected === actual;\n            case '~=':\n                return (actual) => actual.split(/[ \\t]+/).includes(expected);\n            case '^=':\n                return (actual) => actual.startsWith(expected);\n            case '$=':\n                return (actual) => actual.endsWith(expected);\n            case '*=':\n                return (actual) => actual.includes(expected);\n            case '|=':\n                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');\n        }\n    }\n}\nfunction combinatorBranch(combinator, items) {\n    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => parseley.serialize(x.left));\n    const leftItems = [];\n    for (const group of Object.values(groups)) {\n        const rightCont = weave(group.items);\n        const leftAst = group.oneSimpleSelector.left;\n        leftItems.push({\n            ast: leftAst,\n            terminal: { type: 'popElement', cont: rightCont }\n        });\n    }\n    return {\n        type: 'pushElement',\n        combinator: combinator,\n        cont: weave(leftItems)\n    };\n}\nfunction spliceAndGroup(items, predicate, keyCallback) {\n    const groups = {};\n    while (items.length) {\n        const bestKey = findTopKey(items, predicate, keyCallback);\n        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;\n        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);\n        const { matches, rest } = partition1(items, hasBestKeyPredicate);\n        let oneSimpleSelector = null;\n        for (const item of matches) {\n            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);\n            if (!oneSimpleSelector) {\n                oneSimpleSelector = splicedNode;\n            }\n        }\n        if (oneSimpleSelector == null) {\n            throw new Error('No simple selector is found.');\n        }\n        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };\n        items = rest;\n    }\n    return groups;\n}\nfunction spliceSimpleSelector(item, predicate) {\n    const simpsels = item.ast.list;\n    const matches = new Array(simpsels.length);\n    let firstIndex = -1;\n    for (let i = simpsels.length; i-- > 0;) {\n        if (predicate(simpsels[i])) {\n            matches[i] = true;\n            firstIndex = i;\n        }\n    }\n    if (firstIndex == -1) {\n        throw new Error(`Couldn't find the required simple selector.`);\n    }\n    const result = simpsels[firstIndex];\n    item.ast.list = simpsels.filter((sel, i) => !matches[i]);\n    return result;\n}\nfunction findTopKey(items, predicate, keyCallback) {\n    const candidates = {};\n    for (const item of items) {\n        const candidates1 = {};\n        for (const node of item.ast.list.filter(predicate)) {\n            candidates1[keyCallback(node)] = true;\n        }\n        for (const key of Object.keys(candidates1)) {\n            if (candidates[key]) {\n                candidates[key]++;\n            }\n            else {\n                candidates[key] = 1;\n            }\n        }\n    }\n    let topKind = '';\n    let topCounter = 0;\n    for (const entry of Object.entries(candidates)) {\n        if (entry[1] > topCounter) {\n            topKind = entry[0];\n            topCounter = entry[1];\n        }\n    }\n    return topKind;\n}\nfunction partition(src, predicate) {\n    const matches = [];\n    const rest = [];\n    for (const x of src) {\n        if (predicate(x)) {\n            matches.push(x);\n        }\n        else {\n            rest.push(x);\n        }\n    }\n    return { matches, rest };\n}\nfunction partition1(src, predicate) {\n    const matches = [];\n    const rest = [];\n    for (const x of src) {\n        if (predicate(x)) {\n            matches.push(x);\n        }\n        else {\n            rest.push(x);\n        }\n    }\n    return { matches, rest };\n}\n\nclass Picker {\n    constructor(f) {\n        this.f = f;\n    }\n    pickAll(el) {\n        return this.f(el);\n    }\n    pick1(el, preferFirst = false) {\n        const results = this.f(el);\n        const len = results.length;\n        if (len === 0) {\n            return null;\n        }\n        if (len === 1) {\n            return results[0].value;\n        }\n        const comparator = (preferFirst)\n            ? comparatorPreferFirst\n            : comparatorPreferLast;\n        let result = results[0];\n        for (let i = 1; i < len; i++) {\n            const next = results[i];\n            if (comparator(result, next)) {\n                result = next;\n            }\n        }\n        return result.value;\n    }\n}\nfunction comparatorPreferFirst(acc, next) {\n    const diff = compareSpecificity(next.specificity, acc.specificity);\n    return diff > 0 || (diff === 0 && next.index < acc.index);\n}\nfunction comparatorPreferLast(acc, next) {\n    const diff = compareSpecificity(next.specificity, acc.specificity);\n    return diff > 0 || (diff === 0 && next.index > acc.index);\n}\n\nexport { Ast, DecisionTree, Picker, TreeifyBuilder as Treeify, Types };\n"],"names":["DecisionTree","input","weave","toAstTerminalPairs","builder","array","len","results","i","selectorString","val","ast","preprocess","parseley.parse1","reduceSelectorVariants","parseley.normalize","newList","sel","items","branches","topKind","findTopKey","getSelectorKind","matches","nonmatches","empty","breakByKind","branchOfKind","terminate","item","terminal","rest","partition","node","selectedKind","simpsels","kind","tagNameBranch","attrValueBranch","attrPresenceBranch","combinatorBranch","groups","spliceAndGroup","x","name","group","spliceSimpleSelector","matchers","predicate","getAttrPredicate","continuation","expected","actual","lower","combinator","parseley.serialize","leftItems","rightCont","leftAst","keyCallback","bestKey","bestKeyPredicate","hasBestKeyPredicate","partition1","oneSimpleSelector","splicedNode","firstIndex","result","candidates","candidates1","key","topCounter","entry","src","Picker","f","el","preferFirst","comparator","comparatorPreferFirst","comparatorPreferLast","next","acc","diff","compareSpecificity"],"mappings":"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","x_google_ignoreList":[0]}