{"version":3,"file":"index.cjs","sources":["../../src/index.ts"],"sourcesContent":["/**\n * query-selector-shadow-dom-modern\n *\n * Drop-in replacement for https://www.npmjs.com/package/query-selector-shadow-dom\n * with the same public API:\n *\n *   - querySelectorDeep(selector, root?, allElements?)\n *   - querySelectorAllDeep(selector, root?, allElements?)\n *   - collectAllElementsDeep(selector?, root?, cachedElements?)\n *\n * but faster and safer:\n *   - Native `querySelector(All)` does the heavy lifting whenever possible\n *     (whole-selector fast path when no shadow roots are involved, and a\n *     per-root pre-filter on the right-most compound selector otherwise).\n *   - Selector parsing is memoized (strings are immutable — safe to cache).\n *   - No DOM caching: results are always computed from the live tree, so\n *     dynamic pages never see stale data.\n *   - Full combinator support across shadow boundaries: ` `, `>`, `+`, `~`.\n *   - Cross-realm safe (iframe documents): no `instanceof` on DOM classes.\n *\n * One upstream bug is fixed: the original re-tests a `>` group at every\n * ancestor, which silently turns the child combinator into a descendant\n * combinator. Here `a > b` means \"a is b's composed parent\", exactly like a\n * native `querySelector` — just extended across shadow boundaries.\n */\n\nexport type QueryableNode = Document | DocumentFragment | Element;\n\nconst ELEMENT_NODE = 1;\nconst DOCUMENT_FRAGMENT_NODE = 11;\n\n/** Cross-realm-safe Element check (`instanceof` fails across frames). */\nfunction isElementNode(node: unknown): node is Element {\n    return !!node && (node as Node).nodeType === ELEMENT_NODE;\n}\n\n/** Cross-realm-safe ShadowRoot check. */\nfunction isHostedFragment(node: unknown): node is ShadowRoot {\n    return (\n        !!node &&\n        (node as Node).nodeType === DOCUMENT_FRAGMENT_NODE &&\n        !!(node as ShadowRoot).host\n    );\n}\n\n/**\n * `el.matches()` that never throws (context-dependent pseudo-classes etc.).\n * When `state` is provided, a rejected selector is recorded so the caller can\n * re-validate and throw exactly like the original library does.\n */\nfunction matchesSelector(\n    el: Element,\n    compound: string,\n    state?: { invalid: boolean },\n): boolean {\n    try {\n        return el.matches(compound);\n    } catch {\n        if (state) state.invalid = true;\n        return false;\n    }\n}\n\n/**\n * Parent in the composed (flat-ish) tree: crosses shadow boundaries towards\n * the host, and stops at the boundary the search was scoped to.\n * Matches the original library's findParentOrHost semantics.\n */\nfunction composedParent(el: Element, boundary: QueryableNode): Element | null {\n    if (el === boundary) return null;\n    const parent = el.parentElement;\n    // The search is scoped to `boundary`: the original library stops there and\n    // never matches the boundary element itself from the inside.\n    if (parent === boundary) return null;\n    if (parent) return parent;\n    const rootNode = el.getRootNode();\n    if (rootNode === el || rootNode === boundary) return null;\n    if (isHostedFragment(rootNode)) return rootNode.host;\n    return null;\n}\n\n/**\n * The right-most compound of the last group — this is the compound the original\n * library pre-filters candidates with (note that `+` / `~` stay part of it).\n */\nfunction rightMostCompound(groups: string[][]): string {\n    const last = groups[groups.length - 1];\n    return last[last.length - 1];\n}\n\n/**\n * Regroup tokenized compounds the way the original library does:\n *   - `>` keeps compounds in the same group (\"a > b\" → [\"a\", \"b\"])\n *   - whitespace starts a new group (\"a b\" → [\"a\"], [\"b\"])\n *   - `+` / `~` stay *inside* a compound and are resolved by native `matches()`\n */\nfunction buildGroups(tokens: string[]): string[][] {\n    const groups: string[][] = [];\n    let group: string[] = [];\n    let current = '';\n    const flushCompound = () => {\n        if (current) {\n            group.push(current);\n            current = '';\n        }\n    };\n\n    for (let i = 0; i < tokens.length; i++) {\n        const token = tokens[i];\n        if (token === ' ') {\n            flushCompound();\n            if (group.length) groups.push(group);\n            group = [];\n        } else if (token === '>') {\n            flushCompound();\n        } else if (token === '+' || token === '~') {\n            current += token + (tokens[++i] ?? '');\n        } else {\n            current = token;\n        }\n    }\n    flushCompound();\n    if (group.length) groups.push(group);\n    return groups;\n}\n\n/**\n * Verify that `el` (already known to match the right-most compound) satisfies\n * the whole selector path.\n *\n * A group is a chain of `>`-separated compounds that must match contiguous\n * composed ancestors; groups are separated from each other by a descendant\n * combinator, so each one is searched for at the current anchor and above it.\n * That is what a native `querySelector` would return on the flattened tree.\n *\n * The original library instead climbs the composed tree and re-tests the whole\n * group at every level, which is where its `a > b` degrades into `a b`.\n */\nfunction matchesComposedPath(el: Element, groups: string[][], boundary: QueryableNode): boolean {\n    let anchor = matchGroupAt(el, groups[groups.length - 1], boundary);\n    if (!anchor) return false;\n\n    // Groups to the left are joined by a descendant combinator → climb until\n    // one of them matches.\n    let walker = composedParent(anchor, boundary);\n    for (let g = groups.length - 2; g >= 0; g--) {\n        let hit: Element | null = null;\n        let node: Element | null = walker;\n        while (node) {\n            hit = matchGroupAt(node, groups[g], boundary);\n            if (hit) break;\n            node = composedParent(node, boundary);\n        }\n        if (!hit) return false;\n        walker = composedParent(hit, boundary);\n    }\n    return true;\n}\n\n/**\n * Match a `>`-separated run of compounds with its right-most compound anchored\n * at `node`. Returns the element the left-most compound matched (the anchor for\n * whatever sits further to the left), or null when the chain breaks.\n */\nfunction matchGroupAt(\n    node: Element,\n    group: string[],\n    boundary: QueryableNode,\n): Element | null {\n    let walker: Element | null = node;\n    for (let k = group.length - 1; k >= 0; k--) {\n        if (!walker || !matchesSelector(walker, group[k])) return null;\n        if (k > 0) walker = composedParent(walker, boundary);\n    }\n    return walker;\n}\n\n\n/**\n * All queryable roots below (and including) `root`: the root itself plus every\n * open shadow root found underneath, in discovery order. Computed fresh on\n * every call — never cached, so dynamic DOMs are always correct.\n */\ninterface TreeScan {\n    /** The root itself plus every open shadow root underneath. */\n    roots: QueryableNode[];\n    /** All elements in the original library's composed pre-order (when requested). */\n    elements: Element[];\n}\n\n/**\n * One walk of the tree that collects both the queryable roots and — when the\n * caller needs result ordering — every element in composed pre-order. Doing it\n * in a single pass is what keeps `querySelectorAllDeep` from paying for two\n * full traversals. Computed fresh on every call, never cached, so dynamic DOMs\n * are always correct.\n */\nfunction collectTree(root: QueryableNode, withElements: boolean): TreeScan {\n    const roots: QueryableNode[] = [root];\n    const elements: Element[] = [];\n\n    const walk = (scope: QueryableNode) => {\n        const all = scope.querySelectorAll('*');\n        for (let i = 0; i < all.length; i++) {\n            const el = all[i];\n            if (withElements) elements.push(el);\n            const shadowRoot = el.shadowRoot;\n            if (shadowRoot) {\n                roots.push(shadowRoot);\n                walk(shadowRoot);\n            }\n        }\n    };\n\n    if (isElementNode(root) && root.shadowRoot) {\n        roots.push(root.shadowRoot);\n        walk(root.shadowRoot);\n    }\n    walk(root);\n    return { roots, elements };\n}\n\n/**\n * Collect every element under `root` in the original library's order\n * (composed tree pre-order: a host's shadow content comes immediately after\n * the host element). One native `querySelectorAll('*')` per root — the\n * browser does the walking.\n */\nfunction collectAllElements(\n    root: QueryableNode,\n    filter?: string,\n    state?: { invalid: boolean },\n): Element[] {\n    const out: Element[] = [];\n    // A root element's own shadow content is listed first (original behavior).\n    const ownShadow = (root as Element).shadowRoot;\n    if (ownShadow) collectList(ownShadow.querySelectorAll('*'), out, filter, state);\n    collectList(root.querySelectorAll('*'), out, filter, state);\n    return out;\n}\n\nfunction collectList(\n    list: NodeListOf<Element>,\n    out: Element[],\n    filter?: string,\n    state?: { invalid: boolean },\n): void {\n    if (filter) {\n        for (let i = 0; i < list.length; i++) {\n            const el = list[i];\n            if (matchesSelector(el, filter, state)) out.push(el);\n            const shadowRoot = el.shadowRoot;\n            if (shadowRoot) collectList(shadowRoot.querySelectorAll('*'), out, filter, state);\n        }\n        return;\n    }\n    for (let i = 0; i < list.length; i++) {\n        const el = list[i];\n        out.push(el);\n        const shadowRoot = el.shadowRoot;\n        if (shadowRoot) collectList(shadowRoot.querySelectorAll('*'), out, filter, state);\n    }\n}\n\n/**\n * Generator variant of the same traversal, for callers that can stop early.\n */\nfunction* iterateDeep(root: QueryableNode): Generator<Element, void, undefined> {\n    const stack: Element[] = [];\n    const pushChildren = (scope: QueryableNode) => {\n        const kids = scope.children;\n        for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);\n    };\n\n    if (isElementNode(root)) {\n        pushChildren(root);\n        if (root.shadowRoot) pushChildren(root.shadowRoot);\n    } else {\n        pushChildren(root);\n    }\n\n    while (stack.length > 0) {\n        const el = stack.pop()!;\n        yield el;\n        pushChildren(el);\n        if (el.shadowRoot) pushChildren(el.shadowRoot);\n    }\n}\n\n/** One comma-separated selector part: the raw text plus its [compound, combinator, ...] tokens. */\ninterface SelectorPart {\n    raw: string;\n    tokens: string[];\n    /** Compounds regrouped the way the original library matches them. */\n    groups: string[][];\n}\n\ninterface ParsedSelector {\n    parts: SelectorPart[];\n    /** Comment-free, trimmed equivalent of the input — used for native queries. */\n    normalized: string;\n}\n\nconst PARSE_CACHE_LIMIT = 512;\nconst parseCache = new Map<string, ParsedSelector>();\n\n/** Split into comma-separated parts, each tokenized as [compound, combinator, ...]. Memoized. */\nfunction parseSelector(selector: string): ParsedSelector {\n    const cached = parseCache.get(selector);\n    if (cached) return cached;\n\n    const parts: SelectorPart[] = [];\n    for (const part of splitByComma(selector)) {\n        const tokens = tokenizePath(part);\n        if (tokens.length > 0) parts.push({ raw: part, tokens, groups: buildGroups(tokens) });\n    }\n    const parsed: ParsedSelector = {\n        parts,\n        normalized: parts.map((p) => p.raw).join(', '),\n    };\n\n    if (parseCache.size >= PARSE_CACHE_LIMIT) parseCache.clear();\n    parseCache.set(selector, parsed);\n    return parsed;\n}\n\n/**\n * Candidates for one tokenized selector part: elements matching the\n * right-most compound, natively pre-filtered inside each root.\n * Returns the candidates either as a single ordered list (when only one root\n * produced hits) or as a Set plus a flag that a composed-order walk is needed.\n */\nfunction collectCandidates<T extends Element>(\n    roots: QueryableNode[],\n    rightMostCompound: string,\n): { list: T[] | null; set: Set<T> | null; rootsWithHits: number; invalid: boolean } {\n    let list: T[] | null = null;\n    let set: Set<T> | null = null;\n    let rootsWithHits = 0;\n    let invalid = false;\n\n    for (const root of roots) {\n        let found: NodeListOf<T>;\n        try {\n            found = root.querySelectorAll<T>(rightMostCompound);\n        } catch {\n            invalid = true; // selector rejected by the engine — re-checked before returning\n            continue;\n        }\n        if (found.length === 0) continue;\n        rootsWithHits++;\n        if (!list) {\n            list = Array.from(found);\n        } else {\n            if (!set) set = new Set(list);\n            for (let i = 0; i < found.length; i++) set.add(found[i]);\n        }\n    }\n    return { list, set, rootsWithHits, invalid };\n}\n\n/**\n * The original library always runs a native `root.querySelector(selector)`\n * first, so an invalid selector throws a SyntaxError instead of silently\n * returning \"not found\". We only pay for that check on the rare paths where\n * the selector looks suspicious (nothing parsed, or rejected by the engine),\n * which keeps the happy path fast while staying behaviour-compatible.\n */\nfunction assertValidSelector(root: QueryableNode, selector: string): void {\n    root.querySelector(selector);\n}\n\n/**\n * Same idea for the filter of `collectAllElementsDeep`: the original throws\n * from `Element.matches()`, so re-run a native match to reproduce it.\n */\nfunction assertValidFilter(root: QueryableNode, filter: string): void {\n    const probe = root.querySelector('*');\n    if (probe) probe.matches(filter);\n}\n\n/**\n * Finds the first matching element on the page, piercing any number of nested\n * shadow roots. Same signature and semantics as the original library.\n */\nexport function querySelectorDeep<T extends Element = HTMLElement>(\n    selector: string,\n    root: QueryableNode = document,\n    allElements: Element[] | null = null,\n): T | null {\n    if (selector == null) return null;\n\n    const { parts, normalized } = parseSelector(selector);\n\n    // Native fast path — identical to the original library: a plain\n    // light-DOM match always wins, no matter what lives in shadow roots.\n    // (Also makes invalid selectors throw exactly like the original.)\n    const lightElement = root.querySelector<T>(normalized);\n    if (lightElement) return lightElement;\n\n    if (parts.length === 0) {\n        assertValidSelector(root, normalized);\n        return null;\n    }\n\n    // Caller-supplied element list (original API's third argument).\n    if (allElements) {\n        let invalid = false;\n        const match = (el: Element, compound: string): boolean => {\n            try {\n                return el.matches(compound);\n            } catch {\n                invalid = true;\n                return false;\n            }\n        };\n        for (const part of parts) {\n            const last = rightMostCompound(part.groups);\n            const single = part.groups.length === 1 && part.groups[0].length === 1;\n            for (const el of allElements) {\n                if (match(el, last) && (single || matchesComposedPath(el, part.groups, root))) {\n                    return el as T;\n                }\n            }\n        }\n        if (invalid) assertValidSelector(root, normalized);\n        return null;\n    }\n\n    const { roots, elements } = collectTree(root, true);\n    // Without shadow roots the native query above is authoritative: `>` is\n    // matched exactly the way the engine matches it (see matchesComposedPath),\n    // so there is nothing left to find.\n    if (roots.length === 1) return null;\n\n    // Few roots + many elements → let the browser pre-filter with one native\n    // query per root. Many tiny roots → a single scan in composed order is\n    // cheaper than the per-query overhead (and it can stop at the first hit).\n    const nativePerRoot = roots.length * 4 <= elements.length;\n    const state = { invalid: false };\n\n    for (const part of parts) {\n        const last = rightMostCompound(part.groups);\n        const single = part.groups.length === 1 && part.groups[0].length === 1;\n\n        if (!nativePerRoot) {\n            if (elements.length === 0) {\n                assertValidSelector(root, normalized);\n                continue;\n            }\n            for (let i = 0; i < elements.length; i++) {\n                const el = elements[i] as T;\n                if (!matchesSelector(el, last, state)) continue;\n                if (single || matchesComposedPath(el, part.groups, root)) return el;\n            }\n            continue;\n        }\n\n        const { list, set, rootsWithHits, invalid } = collectCandidates<T>(roots, last);\n        if (invalid) state.invalid = true;\n        if (!list) continue;\n\n        const verified = (el: T): boolean =>\n            single || matchesComposedPath(el, part.groups, root);\n\n        if (rootsWithHits === 1) {\n            // All candidates live in a single root → that root's native order is composed order.\n            for (const el of list) {\n                if (verified(el)) return el;\n            }\n        } else {\n            const candidates = set ?? new Set(list);\n            for (const el of iterateDeep(root)) {\n                if (candidates.has(el as T) && verified(el as T)) return el as T;\n            }\n        }\n    }\n    if (state.invalid) assertValidSelector(root, normalized);\n    return null;\n}\n\n/**\n * Finds all matching elements on the page, piercing any number of nested\n * shadow roots. Same signature and semantics as the original library\n * (results are additionally de-duplicated).\n */\nexport function querySelectorAllDeep<T extends Element = HTMLElement>(\n    selector: string,\n    root: QueryableNode = document,\n    allElements: Element[] | null = null,\n): T[] {\n    if (selector == null) return [];\n\n    const { parts, normalized } = parseSelector(selector);\n    if (parts.length === 0) {\n        assertValidSelector(root, normalized);\n        return [];\n    }\n\n    // Caller-supplied element list (original API's third argument).\n    if (allElements) {\n        const out: T[] = [];\n        const seen = new Set<Element>();\n        let invalid = false;\n        const match = (el: Element, compound: string): boolean => {\n            try {\n                return el.matches(compound);\n            } catch {\n                invalid = true;\n                return false;\n            }\n        };\n        for (const part of parts) {\n            const last = rightMostCompound(part.groups);\n            const single = part.groups.length === 1 && part.groups[0].length === 1;\n            for (const el of allElements) {\n                if (seen.has(el) || !match(el, last)) continue;\n                if (single || matchesComposedPath(el, part.groups, root)) {\n                    seen.add(el);\n                    out.push(el as T);\n                }\n            }\n        }\n        if (invalid) assertValidSelector(root, normalized);\n        return out;\n    }\n\n    const { roots, elements } = collectTree(root, true);\n\n    // No shadow roots below `root` → hand everything to the browser, one comma\n    // part at a time so results keep the original's per-part grouping (and an\n    // invalid part still throws). Only safe for non-element roots: the original\n    // never matches the boundary element itself, while a native query on an\n    // element root does (e.g. `querySelectorAllDeep('div > span', divRoot)`).\n    if (roots.length === 1 && !isElementNode(root)) {\n        const out: T[] = [];\n        const seen = new Set<T>();\n        for (const part of parts) {\n            for (const el of root.querySelectorAll<T>(part.raw)) {\n                if (seen.has(el)) continue;\n                seen.add(el);\n                out.push(el);\n            }\n        }\n        return out;\n    }\n\n    const results: T[] = [];\n    const seen = new Set<T>();\n    const state = { invalid: false };\n    // Two ways to find the candidates for a comma part:\n    //   - one native query per root: cheap when there are few roots and many\n    //     elements (the browser does the filtering);\n    //   - a single JS pass over the composed element list: cheaper when there\n    //     are many tiny roots, where per-query overhead would dominate.\n    const nativePerRoot = roots.length * 4 <= elements.length;\n\n    for (const part of parts) {\n        const last = rightMostCompound(part.groups);\n        const single = part.groups.length === 1 && part.groups[0].length === 1;\n\n        if (!nativePerRoot) {\n            if (elements.length === 0) {\n                // Nothing to match against, so an invalid selector would slip\n                // through unnoticed — validate it the way the original does.\n                assertValidSelector(root, normalized);\n                continue;\n            }\n            for (let i = 0; i < elements.length; i++) {\n                const el = elements[i] as T;\n                if (seen.has(el) || !matchesSelector(el, last, state)) continue;\n                if (single || matchesComposedPath(el, part.groups, root)) {\n                    seen.add(el);\n                    results.push(el);\n                }\n            }\n            continue;\n        }\n\n        const { list, set, rootsWithHits, invalid } = collectCandidates<T>(roots, last);\n        if (invalid) state.invalid = true;\n        if (!list) continue;\n\n        if (rootsWithHits === 1) {\n            // All candidates live in a single root → that root's native order is composed order.\n            for (const el of list) {\n                if (seen.has(el)) continue;\n                if (single || matchesComposedPath(el, part.groups, root)) {\n                    seen.add(el);\n                    results.push(el);\n                }\n            }\n        } else {\n            // Candidates spread across roots → merge in composed tree order.\n            const candidates = set ?? new Set(list);\n            for (let i = 0; i < elements.length; i++) {\n                const el = elements[i] as T;\n                if (!candidates.has(el) || seen.has(el)) continue;\n                if (single || matchesComposedPath(el, part.groups, root)) {\n                    seen.add(el);\n                    results.push(el);\n                }\n            }\n        }\n    }\n    if (state.invalid) assertValidSelector(root, normalized);\n    return results;\n}\n\n/**\n * Finds all elements on the page, inclusive of those within shadow roots.\n * Optionally filtered by a CSS selector.\n * Same signature and semantics as the original library.\n */\nexport function collectAllElementsDeep<T extends Element = HTMLElement>(\n    selector: string | null = null,\n    root: QueryableNode = document,\n    cachedElements: Element[] | null = null,\n): T[] {\n    // The original only checks `selector ? ... : ...` (it never trims here), so\n    // an empty string means \"no filter\" while a blank one is handed to\n    // `matches()` and throws — bug-for-bug compatible.\n    const filter = selector ? selector : undefined;\n\n    if (cachedElements) {\n        const all = cachedElements as T[];\n        if (!filter) return all;\n        let invalid = false;\n        const out = all.filter((el) => {\n            try {\n                return el.matches(filter);\n            } catch {\n                invalid = true;\n                return false;\n            }\n        });\n        if (invalid) assertValidFilter(cachedElements[0], filter);\n        return out;\n    }\n\n    // Single pass: elements are filtered while the tree is being walked.\n    const state = { invalid: false };\n    const out = collectAllElements(root, filter, state) as T[];\n    if (state.invalid && filter) assertValidFilter(root, filter);\n    return out;\n}\n\n/**\n * Split a selector list on top-level commas (ignores commas inside quotes,\n * attribute brackets and pseudo-class parentheses).\n */\nexport function splitByComma(selector: string): string[] {\n    if (!selector || !selector.trim()) return [];\n\n    const results: string[] = [];\n    let current = '';\n    let parenDepth = 0;\n    let bracketDepth = 0;\n    let inSingleQuote = false;\n    let inDoubleQuote = false;\n    let escaped = false;\n\n    for (let i = 0; i < selector.length; i++) {\n        const char = selector[i];\n\n        if (escaped) {\n            current += char;\n            escaped = false;\n            continue;\n        }\n\n        if (char === '\\\\') {\n            escaped = true;\n            current += char;\n            continue;\n        }\n\n        if (char === \"'\" && !inDoubleQuote) {\n            inSingleQuote = !inSingleQuote;\n            current += char;\n            continue;\n        }\n\n        if (char === '\"' && !inSingleQuote) {\n            inDoubleQuote = !inDoubleQuote;\n            current += char;\n            continue;\n        }\n\n        if (!inSingleQuote && !inDoubleQuote) {\n            // CSS comments are stripped by the original library's normalizer —\n            // replace them with a space so commas inside a comment never split\n            // a part and the raw part stays valid for native queries.\n            if (char === '/' && selector[i + 1] === '*') {\n                const end = selector.indexOf('*/', i + 2);\n                i = end === -1 ? selector.length : end + 1;\n                current += ' ';\n                continue;\n            }\n            if (char === '(') parenDepth++;\n            else if (char === ')') parenDepth = Math.max(0, parenDepth - 1);\n            else if (char === '[') bracketDepth++;\n            else if (char === ']') bracketDepth = Math.max(0, bracketDepth - 1);\n            else if (char === ',' && parenDepth === 0 && bracketDepth === 0) {\n                results.push(current.trim());\n                current = '';\n                continue;\n            }\n        }\n\n        current += char;\n    }\n\n    if (current.trim()) {\n        results.push(current.trim());\n    }\n\n    return results;\n}\n\n/**\n * Tokenize a CSS selector into compounds and combinators:\n * 'div > p span' → ['div', '>', 'p', ' ', 'span'].\n */\nexport function tokenizePath(selector: string): string[] {\n    if (!selector || !selector.trim()) return [];\n\n    const tokens: string[] = [];\n    let current = '';\n    let parenDepth = 0;\n    let bracketDepth = 0;\n    let inSingleQuote = false;\n    let inDoubleQuote = false;\n    let escaped = false;\n\n    const pushCurrent = () => {\n        const trimmed = current.trim();\n        if (trimmed) {\n            tokens.push(trimmed);\n        }\n        current = '';\n    };\n\n    // Emit the implicit descendant combinator when two compounds are separated\n    // by whitespace and/or a CSS comment (the original library normalizes\n    // comments to whitespace before parsing).\n    const pushDescendantIfNeeded = (nextIndex: number) => {\n        let nextChar = '';\n        for (let j = nextIndex; j < selector.length; j++) {\n            if (!/\\s/.test(selector[j])) {\n                nextChar = selector[j];\n                break;\n            }\n        }\n        const lastToken = tokens[tokens.length - 1];\n        const isLastCombinator =\n            lastToken === ' ' || lastToken === '>' || lastToken === '+' || lastToken === '~';\n        if (\n            tokens.length > 0 &&\n            !isLastCombinator &&\n            nextChar &&\n            nextChar !== '>' &&\n            nextChar !== '+' &&\n            nextChar !== '~'\n        ) {\n            tokens.push(' ');\n        }\n    };\n\n    for (let i = 0; i < selector.length; i++) {\n        const char = selector[i];\n\n        if (escaped) {\n            current += char;\n            escaped = false;\n            continue;\n        }\n\n        if (char === '\\\\') {\n            escaped = true;\n            current += char;\n            continue;\n        }\n\n        if (char === \"'\" && !inDoubleQuote) {\n            inSingleQuote = !inSingleQuote;\n            current += char;\n            continue;\n        }\n\n        if (char === '\"' && !inSingleQuote) {\n            inDoubleQuote = !inDoubleQuote;\n            current += char;\n            continue;\n        }\n\n        if (!inSingleQuote && !inDoubleQuote) {\n            // A CSS comment acts as whitespace (original: normalizeSelector).\n            if (char === '/' && selector[i + 1] === '*') {\n                pushCurrent();\n                const end = selector.indexOf('*/', i + 2);\n                i = end === -1 ? selector.length : end + 1;\n                pushDescendantIfNeeded(i + 1);\n                continue;\n            }\n\n            if (char === '(') parenDepth++;\n            else if (char === ')') parenDepth = Math.max(0, parenDepth - 1);\n            else if (char === '[') bracketDepth++;\n            else if (char === ']') bracketDepth = Math.max(0, bracketDepth - 1);\n\n            if (parenDepth === 0 && bracketDepth === 0) {\n                if (char === '>' || char === '+' || char === '~') {\n                    pushCurrent();\n                    tokens.push(char);\n                    continue;\n                }\n\n                if (/\\s/.test(char)) {\n                    pushCurrent();\n                    while (i + 1 < selector.length && /\\s/.test(selector[i + 1])) {\n                        i++;\n                    }\n                    pushDescendantIfNeeded(i + 1);\n                    continue;\n                }\n            }\n        }\n\n        current += char;\n    }\n\n    pushCurrent();\n\n    return tokens;\n}\n"],"names":[],"mappings":"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"}