@vc-shell/framework 1.1.45 → 1.1.47

package/dist/vendor-css-select-DRIZ9kfZ.js

@@ -1,966 +0,0 @@
-import { D as DomUtils } from './vendor-domutils-Bc-Opz-v.js';
-import { a as boolbase } from './vendor-boolbase-Cp9L0GAZ.js';
-import { S as SelectorType, A as AttributeAction, p as parse } from './vendor-css-what-DuPJ1HEF.js';
-import { n as nthCheck } from './vendor-nth-check-Bx8TxtJt.js';
-
-const procedure = new Map([
-    [SelectorType.Universal, 50],
-    [SelectorType.Tag, 30],
-    [SelectorType.Attribute, 1],
-    [SelectorType.Pseudo, 0],
-]);
-function isTraversal(token) {
-    return !procedure.has(token.type);
-}
-const attributes = new Map([
-    [AttributeAction.Exists, 10],
-    [AttributeAction.Equals, 8],
-    [AttributeAction.Not, 7],
-    [AttributeAction.Start, 6],
-    [AttributeAction.End, 6],
-    [AttributeAction.Any, 5],
-]);
-/**
- * Sort the parts of the passed selector,
- * as there is potential for optimization
- * (some types of selectors are faster than others)
- *
- * @param arr Selector to sort
- */
-function sortByProcedure(arr) {
-    const procs = arr.map(getProcedure);
-    for (let i = 1; i < arr.length; i++) {
-        const procNew = procs[i];
-        if (procNew < 0)
-            continue;
-        for (let j = i - 1; j >= 0 && procNew < procs[j]; j--) {
-            const token = arr[j + 1];
-            arr[j + 1] = arr[j];
-            arr[j] = token;
-            procs[j + 1] = procs[j];
-            procs[j] = procNew;
-        }
-    }
-}
-function getProcedure(token) {
-    var _a, _b;
-    let proc = (_a = procedure.get(token.type)) !== null && _a !== void 0 ? _a : -1;
-    if (token.type === SelectorType.Attribute) {
-        proc = (_b = attributes.get(token.action)) !== null && _b !== void 0 ? _b : 4;
-        if (token.action === AttributeAction.Equals && token.name === "id") {
-            // Prefer ID selectors (eg. #ID)
-            proc = 9;
-        }
-        if (token.ignoreCase) {
-            /*
-             * IgnoreCase adds some overhead, prefer "normal" token
-             * this is a binary operation, to ensure it's still an int
-             */
-            proc >>= 1;
-        }
-    }
-    else if (token.type === SelectorType.Pseudo) {
-        if (!token.data) {
-            proc = 3;
-        }
-        else if (token.name === "has" || token.name === "contains") {
-            proc = 0; // Expensive in any case
-        }
-        else if (Array.isArray(token.data)) {
-            // Eg. :matches, :not
-            proc = Math.min(...token.data.map((d) => Math.min(...d.map(getProcedure))));
-            // If we have traversals, try to avoid executing this selector
-            if (proc < 0) {
-                proc = 0;
-            }
-        }
-        else {
-            proc = 2;
-        }
-    }
-    return proc;
-}
-
-/**
- * All reserved characters in a regex, used for escaping.
- *
- * Taken from XRegExp, (c) 2007-2020 Steven Levithan under the MIT license
- * https://github.com/slevithan/xregexp/blob/95eeebeb8fac8754d54eafe2b4743661ac1cf028/src/xregexp.js#L794
- */
-const reChars = /[-[\]{}()*+?.,\\^$|#\s]/g;
-function escapeRegex(value) {
-    return value.replace(reChars, "\\$&");
-}
-/**
- * Attributes that are case-insensitive in HTML.
- *
- * @private
- * @see https://html.spec.whatwg.org/multipage/semantics-other.html#case-sensitivity-of-selectors
- */
-const caseInsensitiveAttributes = new Set([
-    "accept",
-    "accept-charset",
-    "align",
-    "alink",
-    "axis",
-    "bgcolor",
-    "charset",
-    "checked",
-    "clear",
-    "codetype",
-    "color",
-    "compact",
-    "declare",
-    "defer",
-    "dir",
-    "direction",
-    "disabled",
-    "enctype",
-    "face",
-    "frame",
-    "hreflang",
-    "http-equiv",
-    "lang",
-    "language",
-    "link",
-    "media",
-    "method",
-    "multiple",
-    "nohref",
-    "noresize",
-    "noshade",
-    "nowrap",
-    "readonly",
-    "rel",
-    "rev",
-    "rules",
-    "scope",
-    "scrolling",
-    "selected",
-    "shape",
-    "target",
-    "text",
-    "type",
-    "valign",
-    "valuetype",
-    "vlink",
-]);
-function shouldIgnoreCase(selector, options) {
-    return typeof selector.ignoreCase === "boolean"
-        ? selector.ignoreCase
-        : selector.ignoreCase === "quirks"
-            ? !!options.quirksMode
-            : !options.xmlMode && caseInsensitiveAttributes.has(selector.name);
-}
-/**
- * Attribute selectors
- */
-const attributeRules = {
-    equals(next, data, options) {
-        const { adapter } = options;
-        const { name } = data;
-        let { value } = data;
-        if (shouldIgnoreCase(data, options)) {
-            value = value.toLowerCase();
-            return (elem) => {
-                const attr = adapter.getAttributeValue(elem, name);
-                return (attr != null &&
-                    attr.length === value.length &&
-                    attr.toLowerCase() === value &&
-                    next(elem));
-            };
-        }
-        return (elem) => adapter.getAttributeValue(elem, name) === value && next(elem);
-    },
-    hyphen(next, data, options) {
-        const { adapter } = options;
-        const { name } = data;
-        let { value } = data;
-        const len = value.length;
-        if (shouldIgnoreCase(data, options)) {
-            value = value.toLowerCase();
-            return function hyphenIC(elem) {
-                const attr = adapter.getAttributeValue(elem, name);
-                return (attr != null &&
-                    (attr.length === len || attr.charAt(len) === "-") &&
-                    attr.substr(0, len).toLowerCase() === value &&
-                    next(elem));
-            };
-        }
-        return function hyphen(elem) {
-            const attr = adapter.getAttributeValue(elem, name);
-            return (attr != null &&
-                (attr.length === len || attr.charAt(len) === "-") &&
-                attr.substr(0, len) === value &&
-                next(elem));
-        };
-    },
-    element(next, data, options) {
-        const { adapter } = options;
-        const { name, value } = data;
-        if (/\s/.test(value)) {
-            return boolbase.falseFunc;
-        }
-        const regex = new RegExp(`(?:^|\\s)${escapeRegex(value)}(?:$|\\s)`, shouldIgnoreCase(data, options) ? "i" : "");
-        return function element(elem) {
-            const attr = adapter.getAttributeValue(elem, name);
-            return (attr != null &&
-                attr.length >= value.length &&
-                regex.test(attr) &&
-                next(elem));
-        };
-    },
-    exists(next, { name }, { adapter }) {
-        return (elem) => adapter.hasAttrib(elem, name) && next(elem);
-    },
-    start(next, data, options) {
-        const { adapter } = options;
-        const { name } = data;
-        let { value } = data;
-        const len = value.length;
-        if (len === 0) {
-            return boolbase.falseFunc;
-        }
-        if (shouldIgnoreCase(data, options)) {
-            value = value.toLowerCase();
-            return (elem) => {
-                const attr = adapter.getAttributeValue(elem, name);
-                return (attr != null &&
-                    attr.length >= len &&
-                    attr.substr(0, len).toLowerCase() === value &&
-                    next(elem));
-            };
-        }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.startsWith(value)) &&
-                next(elem);
-        };
-    },
-    end(next, data, options) {
-        const { adapter } = options;
-        const { name } = data;
-        let { value } = data;
-        const len = -value.length;
-        if (len === 0) {
-            return boolbase.falseFunc;
-        }
-        if (shouldIgnoreCase(data, options)) {
-            value = value.toLowerCase();
-            return (elem) => {
-                var _a;
-                return ((_a = adapter
-                    .getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(len).toLowerCase()) === value && next(elem);
-            };
-        }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.endsWith(value)) &&
-                next(elem);
-        };
-    },
-    any(next, data, options) {
-        const { adapter } = options;
-        const { name, value } = data;
-        if (value === "") {
-            return boolbase.falseFunc;
-        }
-        if (shouldIgnoreCase(data, options)) {
-            const regex = new RegExp(escapeRegex(value), "i");
-            return function anyIC(elem) {
-                const attr = adapter.getAttributeValue(elem, name);
-                return (attr != null &&
-                    attr.length >= value.length &&
-                    regex.test(attr) &&
-                    next(elem));
-            };
-        }
-        return (elem) => {
-            var _a;
-            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.includes(value)) &&
-                next(elem);
-        };
-    },
-    not(next, data, options) {
-        const { adapter } = options;
-        const { name } = data;
-        let { value } = data;
-        if (value === "") {
-            return (elem) => !!adapter.getAttributeValue(elem, name) && next(elem);
-        }
-        else if (shouldIgnoreCase(data, options)) {
-            value = value.toLowerCase();
-            return (elem) => {
-                const attr = adapter.getAttributeValue(elem, name);
-                return ((attr == null ||
-                    attr.length !== value.length ||
-                    attr.toLowerCase() !== value) &&
-                    next(elem));
-            };
-        }
-        return (elem) => adapter.getAttributeValue(elem, name) !== value && next(elem);
-    },
-};
-
-function getChildFunc(next, adapter) {
-    return (elem) => {
-        const parent = adapter.getParent(elem);
-        return parent != null && adapter.isTag(parent) && next(elem);
-    };
-}
-const filters = {
-    contains(next, text, { adapter }) {
-        return function contains(elem) {
-            return next(elem) && adapter.getText(elem).includes(text);
-        };
-    },
-    icontains(next, text, { adapter }) {
-        const itext = text.toLowerCase();
-        return function icontains(elem) {
-            return (next(elem) &&
-                adapter.getText(elem).toLowerCase().includes(itext));
-        };
-    },
-    // Location specific methods
-    "nth-child"(next, rule, { adapter, equals }) {
-        const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
-        return function nthChild(elem) {
-            const siblings = adapter.getSiblings(elem);
-            let pos = 0;
-            for (let i = 0; i < siblings.length; i++) {
-                if (equals(elem, siblings[i]))
-                    break;
-                if (adapter.isTag(siblings[i])) {
-                    pos++;
-                }
-            }
-            return func(pos) && next(elem);
-        };
-    },
-    "nth-last-child"(next, rule, { adapter, equals }) {
-        const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
-        return function nthLastChild(elem) {
-            const siblings = adapter.getSiblings(elem);
-            let pos = 0;
-            for (let i = siblings.length - 1; i >= 0; i--) {
-                if (equals(elem, siblings[i]))
-                    break;
-                if (adapter.isTag(siblings[i])) {
-                    pos++;
-                }
-            }
-            return func(pos) && next(elem);
-        };
-    },
-    "nth-of-type"(next, rule, { adapter, equals }) {
-        const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
-        return function nthOfType(elem) {
-            const siblings = adapter.getSiblings(elem);
-            let pos = 0;
-            for (let i = 0; i < siblings.length; i++) {
-                const currentSibling = siblings[i];
-                if (equals(elem, currentSibling))
-                    break;
-                if (adapter.isTag(currentSibling) &&
-                    adapter.getName(currentSibling) === adapter.getName(elem)) {
-                    pos++;
-                }
-            }
-            return func(pos) && next(elem);
-        };
-    },
-    "nth-last-of-type"(next, rule, { adapter, equals }) {
-        const func = nthCheck(rule);
-        if (func === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        if (func === boolbase.trueFunc)
-            return getChildFunc(next, adapter);
-        return function nthLastOfType(elem) {
-            const siblings = adapter.getSiblings(elem);
-            let pos = 0;
-            for (let i = siblings.length - 1; i >= 0; i--) {
-                const currentSibling = siblings[i];
-                if (equals(elem, currentSibling))
-                    break;
-                if (adapter.isTag(currentSibling) &&
-                    adapter.getName(currentSibling) === adapter.getName(elem)) {
-                    pos++;
-                }
-            }
-            return func(pos) && next(elem);
-        };
-    },
-    // TODO determine the actual root element
-    root(next, _rule, { adapter }) {
-        return (elem) => {
-            const parent = adapter.getParent(elem);
-            return (parent == null || !adapter.isTag(parent)) && next(elem);
-        };
-    },
-    scope(next, rule, options, context) {
-        const { equals } = options;
-        if (!context || context.length === 0) {
-            // Equivalent to :root
-            return filters["root"](next, rule, options);
-        }
-        if (context.length === 1) {
-            // NOTE: can't be unpacked, as :has uses this for side-effects
-            return (elem) => equals(context[0], elem) && next(elem);
-        }
-        return (elem) => context.includes(elem) && next(elem);
-    },
-    hover: dynamicStatePseudo("isHovered"),
-    visited: dynamicStatePseudo("isVisited"),
-    active: dynamicStatePseudo("isActive"),
-};
-/**
- * Dynamic state pseudos. These depend on optional Adapter methods.
- *
- * @param name The name of the adapter method to call.
- * @returns Pseudo for the `filters` object.
- */
-function dynamicStatePseudo(name) {
-    return function dynamicPseudo(next, _rule, { adapter }) {
-        const func = adapter[name];
-        if (typeof func !== "function") {
-            return boolbase.falseFunc;
-        }
-        return function active(elem) {
-            return func(elem) && next(elem);
-        };
-    };
-}
-
-// While filters are precompiled, pseudos get called when they are needed
-const pseudos = {
-    empty(elem, { adapter }) {
-        return !adapter.getChildren(elem).some((elem) => 
-        // FIXME: `getText` call is potentially expensive.
-        adapter.isTag(elem) || adapter.getText(elem) !== "");
-    },
-    "first-child"(elem, { adapter, equals }) {
-        if (adapter.prevElementSibling) {
-            return adapter.prevElementSibling(elem) == null;
-        }
-        const firstChild = adapter
-            .getSiblings(elem)
-            .find((elem) => adapter.isTag(elem));
-        return firstChild != null && equals(elem, firstChild);
-    },
-    "last-child"(elem, { adapter, equals }) {
-        const siblings = adapter.getSiblings(elem);
-        for (let i = siblings.length - 1; i >= 0; i--) {
-            if (equals(elem, siblings[i]))
-                return true;
-            if (adapter.isTag(siblings[i]))
-                break;
-        }
-        return false;
-    },
-    "first-of-type"(elem, { adapter, equals }) {
-        const siblings = adapter.getSiblings(elem);
-        const elemName = adapter.getName(elem);
-        for (let i = 0; i < siblings.length; i++) {
-            const currentSibling = siblings[i];
-            if (equals(elem, currentSibling))
-                return true;
-            if (adapter.isTag(currentSibling) &&
-                adapter.getName(currentSibling) === elemName) {
-                break;
-            }
-        }
-        return false;
-    },
-    "last-of-type"(elem, { adapter, equals }) {
-        const siblings = adapter.getSiblings(elem);
-        const elemName = adapter.getName(elem);
-        for (let i = siblings.length - 1; i >= 0; i--) {
-            const currentSibling = siblings[i];
-            if (equals(elem, currentSibling))
-                return true;
-            if (adapter.isTag(currentSibling) &&
-                adapter.getName(currentSibling) === elemName) {
-                break;
-            }
-        }
-        return false;
-    },
-    "only-of-type"(elem, { adapter, equals }) {
-        const elemName = adapter.getName(elem);
-        return adapter
-            .getSiblings(elem)
-            .every((sibling) => equals(elem, sibling) ||
-            !adapter.isTag(sibling) ||
-            adapter.getName(sibling) !== elemName);
-    },
-    "only-child"(elem, { adapter, equals }) {
-        return adapter
-            .getSiblings(elem)
-            .every((sibling) => equals(elem, sibling) || !adapter.isTag(sibling));
-    },
-};
-function verifyPseudoArgs(func, name, subselect, argIndex) {
-    if (subselect === null) {
-        if (func.length > argIndex) {
-            throw new Error(`Pseudo-class :${name} requires an argument`);
-        }
-    }
-    else if (func.length === argIndex) {
-        throw new Error(`Pseudo-class :${name} doesn't have any arguments`);
-    }
-}
-
-/**
- * Aliases are pseudos that are expressed as selectors.
- */
-const aliases = {
-    // Links
-    "any-link": ":is(a, area, link)[href]",
-    link: ":any-link:not(:visited)",
-    // Forms
-    // https://html.spec.whatwg.org/multipage/scripting.html#disabled-elements
-    disabled: `:is(
-        :is(button, input, select, textarea, optgroup, option)[disabled],
-        optgroup[disabled] > option,
-        fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)
-    )`,
-    enabled: ":not(:disabled)",
-    checked: ":is(:is(input[type=radio], input[type=checkbox])[checked], option:selected)",
-    required: ":is(input, select, textarea)[required]",
-    optional: ":is(input, select, textarea):not([required])",
-    // JQuery extensions
-    // https://html.spec.whatwg.org/multipage/form-elements.html#concept-option-selectedness
-    selected: "option:is([selected], select:not([multiple]):not(:has(> option[selected])) > :first-of-type)",
-    checkbox: "[type=checkbox]",
-    file: "[type=file]",
-    password: "[type=password]",
-    radio: "[type=radio]",
-    reset: "[type=reset]",
-    image: "[type=image]",
-    submit: "[type=submit]",
-    parent: ":not(:empty)",
-    header: ":is(h1, h2, h3, h4, h5, h6)",
-    button: ":is(button, input[type=button])",
-    input: ":is(input, textarea, select, button)",
-    text: "input:is(:not([type!='']), [type=text])",
-};
-
-/** Used as a placeholder for :has. Will be replaced with the actual element. */
-const PLACEHOLDER_ELEMENT = {};
-function ensureIsTag(next, adapter) {
-    if (next === boolbase.falseFunc)
-        return boolbase.falseFunc;
-    return (elem) => adapter.isTag(elem) && next(elem);
-}
-function getNextSiblings(elem, adapter) {
-    const siblings = adapter.getSiblings(elem);
-    if (siblings.length <= 1)
-        return [];
-    const elemIndex = siblings.indexOf(elem);
-    if (elemIndex < 0 || elemIndex === siblings.length - 1)
-        return [];
-    return siblings.slice(elemIndex + 1).filter(adapter.isTag);
-}
-function copyOptions(options) {
-    // Not copied: context, rootFunc
-    return {
-        xmlMode: !!options.xmlMode,
-        lowerCaseAttributeNames: !!options.lowerCaseAttributeNames,
-        lowerCaseTags: !!options.lowerCaseTags,
-        quirksMode: !!options.quirksMode,
-        cacheResults: !!options.cacheResults,
-        pseudos: options.pseudos,
-        adapter: options.adapter,
-        equals: options.equals,
-    };
-}
-const is = (next, token, options, context, compileToken) => {
-    const func = compileToken(token, copyOptions(options), context);
-    return func === boolbase.trueFunc
-        ? next
-        : func === boolbase.falseFunc
-            ? boolbase.falseFunc
-            : (elem) => func(elem) && next(elem);
-};
-/*
- * :not, :has, :is, :matches and :where have to compile selectors
- * doing this in src/pseudos.ts would lead to circular dependencies,
- * so we add them here
- */
-const subselects = {
-    is,
-    /**
-     * `:matches` and `:where` are aliases for `:is`.
-     */
-    matches: is,
-    where: is,
-    not(next, token, options, context, compileToken) {
-        const func = compileToken(token, copyOptions(options), context);
-        return func === boolbase.falseFunc
-            ? next
-            : func === boolbase.trueFunc
-                ? boolbase.falseFunc
-                : (elem) => !func(elem) && next(elem);
-    },
-    has(next, subselect, options, _context, compileToken) {
-        const { adapter } = options;
-        const opts = copyOptions(options);
-        opts.relativeSelector = true;
-        const context = subselect.some((s) => s.some(isTraversal))
-            ? // Used as a placeholder. Will be replaced with the actual element.
-                [PLACEHOLDER_ELEMENT]
-            : undefined;
-        const compiled = compileToken(subselect, opts, context);
-        if (compiled === boolbase.falseFunc)
-            return boolbase.falseFunc;
-        const hasElement = ensureIsTag(compiled, adapter);
-        // If `compiled` is `trueFunc`, we can skip this.
-        if (context && compiled !== boolbase.trueFunc) {
-            /*
-             * `shouldTestNextSiblings` will only be true if the query starts with
-             * a traversal (sibling or adjacent). That means we will always have a context.
-             */
-            const { shouldTestNextSiblings = false } = compiled;
-            return (elem) => {
-                if (!next(elem))
-                    return false;
-                context[0] = elem;
-                const childs = adapter.getChildren(elem);
-                const nextElements = shouldTestNextSiblings
-                    ? [...childs, ...getNextSiblings(elem, adapter)]
-                    : childs;
-                return adapter.existsOne(hasElement, nextElements);
-            };
-        }
-        return (elem) => next(elem) &&
-            adapter.existsOne(hasElement, adapter.getChildren(elem));
-    },
-};
-
-function compilePseudoSelector(next, selector, options, context, compileToken) {
-    var _a;
-    const { name, data } = selector;
-    if (Array.isArray(data)) {
-        if (!(name in subselects)) {
-            throw new Error(`Unknown pseudo-class :${name}(${data})`);
-        }
-        return subselects[name](next, data, options, context, compileToken);
-    }
-    const userPseudo = (_a = options.pseudos) === null || _a === void 0 ? void 0 : _a[name];
-    const stringPseudo = typeof userPseudo === "string" ? userPseudo : aliases[name];
-    if (typeof stringPseudo === "string") {
-        if (data != null) {
-            throw new Error(`Pseudo ${name} doesn't have any arguments`);
-        }
-        // The alias has to be parsed here, to make sure options are respected.
-        const alias = parse(stringPseudo);
-        return subselects["is"](next, alias, options, context, compileToken);
-    }
-    if (typeof userPseudo === "function") {
-        verifyPseudoArgs(userPseudo, name, data, 1);
-        return (elem) => userPseudo(elem, data) && next(elem);
-    }
-    if (name in filters) {
-        return filters[name](next, data, options, context);
-    }
-    if (name in pseudos) {
-        const pseudo = pseudos[name];
-        verifyPseudoArgs(pseudo, name, data, 2);
-        return (elem) => pseudo(elem, options, data) && next(elem);
-    }
-    throw new Error(`Unknown pseudo-class :${name}`);
-}
-
-function getElementParent(node, adapter) {
-    const parent = adapter.getParent(node);
-    if (parent && adapter.isTag(parent)) {
-        return parent;
-    }
-    return null;
-}
-/*
- * All available rules
- */
-function compileGeneralSelector(next, selector, options, context, compileToken) {
-    const { adapter, equals } = options;
-    switch (selector.type) {
-        case SelectorType.PseudoElement: {
-            throw new Error("Pseudo-elements are not supported by css-select");
-        }
-        case SelectorType.ColumnCombinator: {
-            throw new Error("Column combinators are not yet supported by css-select");
-        }
-        case SelectorType.Attribute: {
-            if (selector.namespace != null) {
-                throw new Error("Namespaced attributes are not yet supported by css-select");
-            }
-            if (!options.xmlMode || options.lowerCaseAttributeNames) {
-                selector.name = selector.name.toLowerCase();
-            }
-            return attributeRules[selector.action](next, selector, options);
-        }
-        case SelectorType.Pseudo: {
-            return compilePseudoSelector(next, selector, options, context, compileToken);
-        }
-        // Tags
-        case SelectorType.Tag: {
-            if (selector.namespace != null) {
-                throw new Error("Namespaced tag names are not yet supported by css-select");
-            }
-            let { name } = selector;
-            if (!options.xmlMode || options.lowerCaseTags) {
-                name = name.toLowerCase();
-            }
-            return function tag(elem) {
-                return adapter.getName(elem) === name && next(elem);
-            };
-        }
-        // Traversal
-        case SelectorType.Descendant: {
-            if (options.cacheResults === false ||
-                typeof WeakSet === "undefined") {
-                return function descendant(elem) {
-                    let current = elem;
-                    while ((current = getElementParent(current, adapter))) {
-                        if (next(current)) {
-                            return true;
-                        }
-                    }
-                    return false;
-                };
-            }
-            // @ts-expect-error `ElementNode` is not extending object
-            const isFalseCache = new WeakSet();
-            return function cachedDescendant(elem) {
-                let current = elem;
-                while ((current = getElementParent(current, adapter))) {
-                    if (!isFalseCache.has(current)) {
-                        if (adapter.isTag(current) && next(current)) {
-                            return true;
-                        }
-                        isFalseCache.add(current);
-                    }
-                }
-                return false;
-            };
-        }
-        case "_flexibleDescendant": {
-            // Include element itself, only used while querying an array
-            return function flexibleDescendant(elem) {
-                let current = elem;
-                do {
-                    if (next(current))
-                        return true;
-                } while ((current = getElementParent(current, adapter)));
-                return false;
-            };
-        }
-        case SelectorType.Parent: {
-            return function parent(elem) {
-                return adapter
-                    .getChildren(elem)
-                    .some((elem) => adapter.isTag(elem) && next(elem));
-            };
-        }
-        case SelectorType.Child: {
-            return function child(elem) {
-                const parent = adapter.getParent(elem);
-                return parent != null && adapter.isTag(parent) && next(parent);
-            };
-        }
-        case SelectorType.Sibling: {
-            return function sibling(elem) {
-                const siblings = adapter.getSiblings(elem);
-                for (let i = 0; i < siblings.length; i++) {
-                    const currentSibling = siblings[i];
-                    if (equals(elem, currentSibling))
-                        break;
-                    if (adapter.isTag(currentSibling) && next(currentSibling)) {
-                        return true;
-                    }
-                }
-                return false;
-            };
-        }
-        case SelectorType.Adjacent: {
-            if (adapter.prevElementSibling) {
-                return function adjacent(elem) {
-                    const previous = adapter.prevElementSibling(elem);
-                    return previous != null && next(previous);
-                };
-            }
-            return function adjacent(elem) {
-                const siblings = adapter.getSiblings(elem);
-                let lastElement;
-                for (let i = 0; i < siblings.length; i++) {
-                    const currentSibling = siblings[i];
-                    if (equals(elem, currentSibling))
-                        break;
-                    if (adapter.isTag(currentSibling)) {
-                        lastElement = currentSibling;
-                    }
-                }
-                return !!lastElement && next(lastElement);
-            };
-        }
-        case SelectorType.Universal: {
-            if (selector.namespace != null && selector.namespace !== "*") {
-                throw new Error("Namespaced universal selectors are not yet supported by css-select");
-            }
-            return next;
-        }
-    }
-}
-
-function includesScopePseudo(t) {
-    return (t.type === SelectorType.Pseudo &&
-        (t.name === "scope" ||
-            (Array.isArray(t.data) &&
-                t.data.some((data) => data.some(includesScopePseudo)))));
-}
-const DESCENDANT_TOKEN = { type: SelectorType.Descendant };
-const FLEXIBLE_DESCENDANT_TOKEN = {
-    type: "_flexibleDescendant",
-};
-const SCOPE_TOKEN = {
-    type: SelectorType.Pseudo,
-    name: "scope",
-    data: null,
-};
-/*
- * CSS 4 Spec (Draft): 3.4.1. Absolutizing a Relative Selector
- * http://www.w3.org/TR/selectors4/#absolutizing
- */
-function absolutize(token, { adapter }, context) {
-    // TODO Use better check if the context is a document
-    const hasContext = !!(context === null || context === void 0 ? void 0 : context.every((e) => {
-        const parent = adapter.isTag(e) && adapter.getParent(e);
-        return e === PLACEHOLDER_ELEMENT || (parent && adapter.isTag(parent));
-    }));
-    for (const t of token) {
-        if (t.length > 0 &&
-            isTraversal(t[0]) &&
-            t[0].type !== SelectorType.Descendant) ;
-        else if (hasContext && !t.some(includesScopePseudo)) {
-            t.unshift(DESCENDANT_TOKEN);
-        }
-        else {
-            continue;
-        }
-        t.unshift(SCOPE_TOKEN);
-    }
-}
-function compileToken(token, options, context) {
-    var _a;
-    token.forEach(sortByProcedure);
-    context = (_a = options.context) !== null && _a !== void 0 ? _a : context;
-    const isArrayContext = Array.isArray(context);
-    const finalContext = context && (Array.isArray(context) ? context : [context]);
-    // Check if the selector is relative
-    if (options.relativeSelector !== false) {
-        absolutize(token, options, finalContext);
-    }
-    else if (token.some((t) => t.length > 0 && isTraversal(t[0]))) {
-        throw new Error("Relative selectors are not allowed when the `relativeSelector` option is disabled");
-    }
-    let shouldTestNextSiblings = false;
-    const query = token
-        .map((rules) => {
-        if (rules.length >= 2) {
-            const [first, second] = rules;
-            if (first.type !== SelectorType.Pseudo ||
-                first.name !== "scope") ;
-            else if (isArrayContext &&
-                second.type === SelectorType.Descendant) {
-                rules[1] = FLEXIBLE_DESCENDANT_TOKEN;
-            }
-            else if (second.type === SelectorType.Adjacent ||
-                second.type === SelectorType.Sibling) {
-                shouldTestNextSiblings = true;
-            }
-        }
-        return compileRules(rules, options, finalContext);
-    })
-        .reduce(reduceRules, boolbase.falseFunc);
-    query.shouldTestNextSiblings = shouldTestNextSiblings;
-    return query;
-}
-function compileRules(rules, options, context) {
-    var _a;
-    return rules.reduce((previous, rule) => previous === boolbase.falseFunc
-        ? boolbase.falseFunc
-        : compileGeneralSelector(previous, rule, options, context, compileToken), (_a = options.rootFunc) !== null && _a !== void 0 ? _a : boolbase.trueFunc);
-}
-function reduceRules(a, b) {
-    if (b === boolbase.falseFunc || a === boolbase.trueFunc) {
-        return a;
-    }
-    if (a === boolbase.falseFunc || b === boolbase.trueFunc) {
-        return b;
-    }
-    return function combine(elem) {
-        return a(elem) || b(elem);
-    };
-}
-
-const defaultEquals = (a, b) => a === b;
-const defaultOptions = {
-    adapter: DomUtils,
-    equals: defaultEquals,
-};
-function convertOptionFormats(options) {
-    var _a, _b, _c, _d;
-    /*
-     * We force one format of options to the other one.
-     */
-    // @ts-expect-error Default options may have incompatible `Node` / `ElementNode`.
-    const opts = options !== null && options !== void 0 ? options : defaultOptions;
-    // @ts-expect-error Same as above.
-    (_a = opts.adapter) !== null && _a !== void 0 ? _a : (opts.adapter = DomUtils);
-    // @ts-expect-error `equals` does not exist on `Options`
-    (_b = opts.equals) !== null && _b !== void 0 ? _b : (opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals);
-    return opts;
-}
-function wrapCompile(func) {
-    return function addAdapter(selector, options, context) {
-        const opts = convertOptionFormats(options);
-        return func(selector, opts, context);
-    };
-}
-const _compileToken = wrapCompile(compileToken);
-function prepareContext(elems, adapter, shouldTestNextSiblings = false) {
-    /*
-     * Add siblings if the query requires them.
-     * See https://github.com/fb55/css-select/pull/43#issuecomment-225414692
-     */
-    if (shouldTestNextSiblings) {
-        elems = appendNextSiblings(elems, adapter);
-    }
-    return Array.isArray(elems)
-        ? adapter.removeSubsets(elems)
-        : adapter.getChildren(elems);
-}
-function appendNextSiblings(elem, adapter) {
-    // Order matters because jQuery seems to check the children before the siblings
-    const elems = Array.isArray(elem) ? elem.slice(0) : [elem];
-    const elemsLength = elems.length;
-    for (let i = 0; i < elemsLength; i++) {
-        const nextSiblings = getNextSiblings(elems[i], adapter);
-        elems.push(...nextSiblings);
-    }
-    return elems;
-}
-
-export { _compileToken as _, prepareContext as p };