diff options
Diffstat (limited to 'node_modules/css-select/lib/pseudo-selectors')
15 files changed, 480 insertions, 0 deletions
diff --git a/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts b/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts new file mode 100644 index 0000000..1bcb31a --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts @@ -0,0 +1,5 @@ +/** + * Aliases are pseudos that are expressed as selectors. + */ +export declare const aliases: Record<string, string>; +//# sourceMappingURL=aliases.d.ts.map
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts.map b/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts.map new file mode 100644 index 0000000..5734659 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"aliases.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/aliases.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwC1C,CAAC"}
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/aliases.js b/node_modules/css-select/lib/pseudo-selectors/aliases.js new file mode 100644 index 0000000..f9a03da --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/aliases.js @@ -0,0 +1,33 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.aliases = void 0; +/** + * Aliases are pseudos that are expressed as selectors. + */ +exports.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(\n :is(button, input, select, textarea, optgroup, option)[disabled],\n optgroup[disabled] > option,\n fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)\n )", + 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])", +}; diff --git a/node_modules/css-select/lib/pseudo-selectors/filters.d.ts b/node_modules/css-select/lib/pseudo-selectors/filters.d.ts new file mode 100644 index 0000000..90634f7 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/filters.d.ts @@ -0,0 +1,4 @@ +import type { CompiledQuery, InternalOptions } from "../types"; +export declare type Filter = <Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, text: string, options: InternalOptions<Node, ElementNode>, context?: Node[]) => CompiledQuery<ElementNode>; +export declare const filters: Record<string, Filter>; +//# sourceMappingURL=filters.d.ts.map
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/filters.d.ts.map b/node_modules/css-select/lib/pseudo-selectors/filters.d.ts.map new file mode 100644 index 0000000..c2caa25 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/filters.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/filters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAW,MAAM,UAAU,CAAC;AAExE,oBAAY,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAChD,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,CAAC,EAAE,IAAI,EAAE,KACf,aAAa,CAAC,WAAW,CAAC,CAAC;AAYhC,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2I1C,CAAC"}
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/filters.js b/node_modules/css-select/lib/pseudo-selectors/filters.js new file mode 100644 index 0000000..84f86c1 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/filters.js @@ -0,0 +1,156 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.filters = void 0; +var nth_check_1 = __importDefault(require("nth-check")); +var boolbase_1 = require("boolbase"); +function getChildFunc(next, adapter) { + return function (elem) { + var parent = adapter.getParent(elem); + return parent != null && adapter.isTag(parent) && next(elem); + }; +} +exports.filters = { + contains: function (next, text, _a) { + var adapter = _a.adapter; + return function contains(elem) { + return next(elem) && adapter.getText(elem).includes(text); + }; + }, + icontains: function (next, text, _a) { + var adapter = _a.adapter; + var itext = text.toLowerCase(); + return function icontains(elem) { + return (next(elem) && + adapter.getText(elem).toLowerCase().includes(itext)); + }; + }, + // Location specific methods + "nth-child": function (next, rule, _a) { + var adapter = _a.adapter, equals = _a.equals; + var func = (0, nth_check_1.default)(rule); + if (func === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + if (func === boolbase_1.trueFunc) + return getChildFunc(next, adapter); + return function nthChild(elem) { + var siblings = adapter.getSiblings(elem); + var pos = 0; + for (var 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": function (next, rule, _a) { + var adapter = _a.adapter, equals = _a.equals; + var func = (0, nth_check_1.default)(rule); + if (func === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + if (func === boolbase_1.trueFunc) + return getChildFunc(next, adapter); + return function nthLastChild(elem) { + var siblings = adapter.getSiblings(elem); + var pos = 0; + for (var 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": function (next, rule, _a) { + var adapter = _a.adapter, equals = _a.equals; + var func = (0, nth_check_1.default)(rule); + if (func === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + if (func === boolbase_1.trueFunc) + return getChildFunc(next, adapter); + return function nthOfType(elem) { + var siblings = adapter.getSiblings(elem); + var pos = 0; + for (var i = 0; i < siblings.length; i++) { + var 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": function (next, rule, _a) { + var adapter = _a.adapter, equals = _a.equals; + var func = (0, nth_check_1.default)(rule); + if (func === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + if (func === boolbase_1.trueFunc) + return getChildFunc(next, adapter); + return function nthLastOfType(elem) { + var siblings = adapter.getSiblings(elem); + var pos = 0; + for (var i = siblings.length - 1; i >= 0; i--) { + var 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: function (next, _rule, _a) { + var adapter = _a.adapter; + return function (elem) { + var parent = adapter.getParent(elem); + return (parent == null || !adapter.isTag(parent)) && next(elem); + }; + }, + scope: function (next, rule, options, context) { + var equals = options.equals; + if (!context || context.length === 0) { + // Equivalent to :root + return exports.filters.root(next, rule, options); + } + if (context.length === 1) { + // NOTE: can't be unpacked, as :has uses this for side-effects + return function (elem) { return equals(context[0], elem) && next(elem); }; + } + return function (elem) { return 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, _a) { + var adapter = _a.adapter; + var func = adapter[name]; + if (typeof func !== "function") { + return boolbase_1.falseFunc; + } + return function active(elem) { + return func(elem) && next(elem); + }; + }; +} diff --git a/node_modules/css-select/lib/pseudo-selectors/index.d.ts b/node_modules/css-select/lib/pseudo-selectors/index.d.ts new file mode 100644 index 0000000..70f467d --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/index.d.ts @@ -0,0 +1,8 @@ +import type { CompiledQuery, InternalOptions, CompileToken } from "../types"; +import { PseudoSelector } from "css-what"; +import { filters } from "./filters"; +import { pseudos } from "./pseudos"; +import { aliases } from "./aliases"; +export { filters, pseudos, aliases }; +export declare function compilePseudoSelector<Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, selector: PseudoSelector, options: InternalOptions<Node, ElementNode>, context: Node[] | undefined, compileToken: CompileToken<Node, ElementNode>): CompiledQuery<ElementNode>; +//# sourceMappingURL=index.d.ts.map
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/index.d.ts.map b/node_modules/css-select/lib/pseudo-selectors/index.d.ts.map new file mode 100644 index 0000000..abe85a6 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAS,cAAc,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAoB,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAErC,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAChE,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,EAAE,IAAI,EAAE,GAAG,SAAS,EAC3B,YAAY,EAAE,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,WAAW,CAAC,CA6B5B"}
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/index.js b/node_modules/css-select/lib/pseudo-selectors/index.js new file mode 100644 index 0000000..feaf7e5 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/index.js @@ -0,0 +1,54 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.compilePseudoSelector = exports.aliases = exports.pseudos = exports.filters = void 0; +/* + * Pseudo selectors + * + * Pseudo selectors are available in three forms: + * + * 1. Filters are called when the selector is compiled and return a function + * that has to return either false, or the results of `next()`. + * 2. Pseudos are called on execution. They have to return a boolean. + * 3. Subselects work like filters, but have an embedded selector that will be run separately. + * + * Filters are great if you want to do some pre-processing, or change the call order + * of `next()` and your code. + * Pseudos should be used to implement simple checks. + */ +var boolbase_1 = require("boolbase"); +var css_what_1 = require("css-what"); +var filters_1 = require("./filters"); +Object.defineProperty(exports, "filters", { enumerable: true, get: function () { return filters_1.filters; } }); +var pseudos_1 = require("./pseudos"); +Object.defineProperty(exports, "pseudos", { enumerable: true, get: function () { return pseudos_1.pseudos; } }); +var aliases_1 = require("./aliases"); +Object.defineProperty(exports, "aliases", { enumerable: true, get: function () { return aliases_1.aliases; } }); +var subselects_1 = require("./subselects"); +function compilePseudoSelector(next, selector, options, context, compileToken) { + var name = selector.name, data = selector.data; + if (Array.isArray(data)) { + return subselects_1.subselects[name](next, data, options, context, compileToken); + } + if (name in aliases_1.aliases) { + if (data != null) { + throw new Error("Pseudo ".concat(name, " doesn't have any arguments")); + } + // The alias has to be parsed here, to make sure options are respected. + var alias = (0, css_what_1.parse)(aliases_1.aliases[name], options); + return subselects_1.subselects.is(next, alias, options, context, compileToken); + } + if (name in filters_1.filters) { + return filters_1.filters[name](next, data, options, context); + } + if (name in pseudos_1.pseudos) { + var pseudo_1 = pseudos_1.pseudos[name]; + (0, pseudos_1.verifyPseudoArgs)(pseudo_1, name, data); + return pseudo_1 === boolbase_1.falseFunc + ? boolbase_1.falseFunc + : next === boolbase_1.trueFunc + ? function (elem) { return pseudo_1(elem, options, data); } + : function (elem) { return pseudo_1(elem, options, data) && next(elem); }; + } + throw new Error("unmatched pseudo-class :".concat(name)); +} +exports.compilePseudoSelector = compilePseudoSelector; diff --git a/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts b/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts new file mode 100644 index 0000000..afd483f --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts @@ -0,0 +1,6 @@ +import { PseudoSelector } from "css-what"; +import type { InternalOptions } from "../types"; +export declare type Pseudo = <Node, ElementNode extends Node>(elem: ElementNode, options: InternalOptions<Node, ElementNode>, subselect?: ElementNode | string | null) => boolean; +export declare const pseudos: Record<string, Pseudo>; +export declare function verifyPseudoArgs(func: Pseudo, name: string, subselect: PseudoSelector["data"]): void; +//# sourceMappingURL=pseudos.d.ts.map
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts.map b/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts.map new file mode 100644 index 0000000..daa0f45 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/pseudos.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"pseudos.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/pseudos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,oBAAY,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAChD,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,SAAS,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,KACtC,OAAO,CAAC;AAGb,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA8E1C,CAAC;AAEF,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,cAAc,CAAC,MAAM,CAAC,GAClC,IAAI,CAQN"}
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/pseudos.js b/node_modules/css-select/lib/pseudo-selectors/pseudos.js new file mode 100644 index 0000000..c5da839 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/pseudos.js @@ -0,0 +1,89 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.verifyPseudoArgs = exports.pseudos = void 0; +// While filters are precompiled, pseudos get called when they are needed +exports.pseudos = { + empty: function (elem, _a) { + var adapter = _a.adapter; + return !adapter.getChildren(elem).some(function (elem) { + // FIXME: `getText` call is potentially expensive. + return adapter.isTag(elem) || adapter.getText(elem) !== ""; + }); + }, + "first-child": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + var firstChild = adapter + .getSiblings(elem) + .find(function (elem) { return adapter.isTag(elem); }); + return firstChild != null && equals(elem, firstChild); + }, + "last-child": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + var siblings = adapter.getSiblings(elem); + for (var 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": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + var siblings = adapter.getSiblings(elem); + var elemName = adapter.getName(elem); + for (var i = 0; i < siblings.length; i++) { + var currentSibling = siblings[i]; + if (equals(elem, currentSibling)) + return true; + if (adapter.isTag(currentSibling) && + adapter.getName(currentSibling) === elemName) { + break; + } + } + return false; + }, + "last-of-type": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + var siblings = adapter.getSiblings(elem); + var elemName = adapter.getName(elem); + for (var i = siblings.length - 1; i >= 0; i--) { + var currentSibling = siblings[i]; + if (equals(elem, currentSibling)) + return true; + if (adapter.isTag(currentSibling) && + adapter.getName(currentSibling) === elemName) { + break; + } + } + return false; + }, + "only-of-type": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + var elemName = adapter.getName(elem); + return adapter + .getSiblings(elem) + .every(function (sibling) { + return equals(elem, sibling) || + !adapter.isTag(sibling) || + adapter.getName(sibling) !== elemName; + }); + }, + "only-child": function (elem, _a) { + var adapter = _a.adapter, equals = _a.equals; + return adapter + .getSiblings(elem) + .every(function (sibling) { return equals(elem, sibling) || !adapter.isTag(sibling); }); + }, +}; +function verifyPseudoArgs(func, name, subselect) { + if (subselect === null) { + if (func.length > 2) { + throw new Error("pseudo-selector :".concat(name, " requires an argument")); + } + } + else if (func.length === 2) { + throw new Error("pseudo-selector :".concat(name, " doesn't have any arguments")); + } +} +exports.verifyPseudoArgs = verifyPseudoArgs; diff --git a/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts b/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts new file mode 100644 index 0000000..192d880 --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts @@ -0,0 +1,10 @@ +import { CompileToken } from "./../types"; +import type { Selector } from "css-what"; +import type { CompiledQuery, InternalOptions, Adapter } from "../types"; +/** Used as a placeholder for :has. Will be replaced with the actual element. */ +export declare const PLACEHOLDER_ELEMENT: {}; +export declare function ensureIsTag<Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, adapter: Adapter<Node, ElementNode>): CompiledQuery<Node>; +export declare type Subselect = <Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, subselect: Selector[][], options: InternalOptions<Node, ElementNode>, context: Node[] | undefined, compileToken: CompileToken<Node, ElementNode>) => CompiledQuery<ElementNode>; +export declare function getNextSiblings<Node, ElementNode extends Node>(elem: Node, adapter: Adapter<Node, ElementNode>): ElementNode[]; +export declare const subselects: Record<string, Subselect>; +//# sourceMappingURL=subselects.d.ts.map
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts.map b/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts.map new file mode 100644 index 0000000..a6f188f --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/subselects.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"subselects.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/subselects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGxE,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,IAAK,CAAC;AAEtC,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACtD,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,GACpC,aAAa,CAAC,IAAI,CAAC,CAGrB;AAED,oBAAY,SAAS,GAAG,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACnD,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,SAAS,EAAE,QAAQ,EAAE,EAAE,EACvB,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,EAAE,IAAI,EAAE,GAAG,SAAS,EAC3B,YAAY,EAAE,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,KAC5C,aAAa,CAAC,WAAW,CAAC,CAAC;AAEhC,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAC1D,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,GACpC,WAAW,EAAE,CAMf;AAkBD,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CA6EhD,CAAC"}
\ No newline at end of file diff --git a/node_modules/css-select/lib/pseudo-selectors/subselects.js b/node_modules/css-select/lib/pseudo-selectors/subselects.js new file mode 100644 index 0000000..a42ee0c --- /dev/null +++ b/node_modules/css-select/lib/pseudo-selectors/subselects.js @@ -0,0 +1,110 @@ +"use strict"; +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.subselects = exports.getNextSiblings = exports.ensureIsTag = exports.PLACEHOLDER_ELEMENT = void 0; +var boolbase_1 = require("boolbase"); +var procedure_1 = require("../procedure"); +/** Used as a placeholder for :has. Will be replaced with the actual element. */ +exports.PLACEHOLDER_ELEMENT = {}; +function ensureIsTag(next, adapter) { + if (next === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + return function (elem) { return adapter.isTag(elem) && next(elem); }; +} +exports.ensureIsTag = ensureIsTag; +function getNextSiblings(elem, adapter) { + var siblings = adapter.getSiblings(elem); + if (siblings.length <= 1) + return []; + var elemIndex = siblings.indexOf(elem); + if (elemIndex < 0 || elemIndex === siblings.length - 1) + return []; + return siblings.slice(elemIndex + 1).filter(adapter.isTag); +} +exports.getNextSiblings = getNextSiblings; +var is = function (next, token, options, context, compileToken) { + var opts = { + xmlMode: !!options.xmlMode, + adapter: options.adapter, + equals: options.equals, + }; + var func = compileToken(token, opts, context); + return function (elem) { return 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 + */ +exports.subselects = { + is: is, + /** + * `:matches` and `:where` are aliases for `:is`. + */ + matches: is, + where: is, + not: function (next, token, options, context, compileToken) { + var opts = { + xmlMode: !!options.xmlMode, + adapter: options.adapter, + equals: options.equals, + }; + var func = compileToken(token, opts, context); + if (func === boolbase_1.falseFunc) + return next; + if (func === boolbase_1.trueFunc) + return boolbase_1.falseFunc; + return function not(elem) { + return !func(elem) && next(elem); + }; + }, + has: function (next, subselect, options, _context, compileToken) { + var adapter = options.adapter; + var opts = { + xmlMode: !!options.xmlMode, + adapter: adapter, + equals: options.equals, + }; + // @ts-expect-error Uses an array as a pointer to the current element (side effects) + var context = subselect.some(function (s) { + return s.some(procedure_1.isTraversal); + }) + ? [exports.PLACEHOLDER_ELEMENT] + : undefined; + var compiled = compileToken(subselect, opts, context); + if (compiled === boolbase_1.falseFunc) + return boolbase_1.falseFunc; + if (compiled === boolbase_1.trueFunc) { + return function (elem) { + return adapter.getChildren(elem).some(adapter.isTag) && next(elem); + }; + } + var hasElement = ensureIsTag(compiled, adapter); + var _a = compiled.shouldTestNextSiblings, shouldTestNextSiblings = _a === void 0 ? false : _a; + /* + * `shouldTestNextSiblings` will only be true if the query starts with + * a traversal (sibling or adjacent). That means we will always have a context. + */ + if (context) { + return function (elem) { + context[0] = elem; + var childs = adapter.getChildren(elem); + var nextElements = shouldTestNextSiblings + ? __spreadArray(__spreadArray([], childs, true), getNextSiblings(elem, adapter), true) : childs; + return (next(elem) && adapter.existsOne(hasElement, nextElements)); + }; + } + return function (elem) { + return next(elem) && + adapter.existsOne(hasElement, adapter.getChildren(elem)); + }; + }, +}; |