From 22a25ded9f7d9c9a96cce8d1bc12475ca0434201 Mon Sep 17 00:00:00 2001 From: Minteck Date: Wed, 9 Feb 2022 17:58:07 +0100 Subject: Major update --- node_modules/cheerio-select/lib/helpers.d.ts | 5 + node_modules/cheerio-select/lib/helpers.d.ts.map | 1 + node_modules/cheerio-select/lib/helpers.js | 25 ++ node_modules/cheerio-select/lib/index.d.ts | 12 + node_modules/cheerio-select/lib/index.d.ts.map | 1 + node_modules/cheerio-select/lib/index.js | 296 +++++++++++++++++++++ node_modules/cheerio-select/lib/positionals.d.ts | 10 + .../cheerio-select/lib/positionals.d.ts.map | 1 + node_modules/cheerio-select/lib/positionals.js | 42 +++ 9 files changed, 393 insertions(+) create mode 100644 node_modules/cheerio-select/lib/helpers.d.ts create mode 100644 node_modules/cheerio-select/lib/helpers.d.ts.map create mode 100644 node_modules/cheerio-select/lib/helpers.js create mode 100644 node_modules/cheerio-select/lib/index.d.ts create mode 100644 node_modules/cheerio-select/lib/index.d.ts.map create mode 100644 node_modules/cheerio-select/lib/index.js create mode 100644 node_modules/cheerio-select/lib/positionals.d.ts create mode 100644 node_modules/cheerio-select/lib/positionals.d.ts.map create mode 100644 node_modules/cheerio-select/lib/positionals.js (limited to 'node_modules/cheerio-select/lib') diff --git a/node_modules/cheerio-select/lib/helpers.d.ts b/node_modules/cheerio-select/lib/helpers.d.ts new file mode 100644 index 0000000..4e9a298 --- /dev/null +++ b/node_modules/cheerio-select/lib/helpers.d.ts @@ -0,0 +1,5 @@ +import type { Node } from "domhandler"; +import type { Selector } from "css-what"; +export declare function getDocumentRoot(node: Node): Node; +export declare function groupSelectors(selectors: Selector[][]): [plain: Selector[][], filtered: Selector[][]]; +//# sourceMappingURL=helpers.d.ts.map \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/helpers.d.ts.map b/node_modules/cheerio-select/lib/helpers.d.ts.map new file mode 100644 index 0000000..43d0e80 --- /dev/null +++ b/node_modules/cheerio-select/lib/helpers.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGzC,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGhD;AAED,wBAAgB,cAAc,CAC1B,SAAS,EAAE,QAAQ,EAAE,EAAE,GACxB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC,CAa/C"} \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/helpers.js b/node_modules/cheerio-select/lib/helpers.js new file mode 100644 index 0000000..1954691 --- /dev/null +++ b/node_modules/cheerio-select/lib/helpers.js @@ -0,0 +1,25 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.groupSelectors = exports.getDocumentRoot = void 0; +var positionals_1 = require("./positionals"); +function getDocumentRoot(node) { + while (node.parent) + node = node.parent; + return node; +} +exports.getDocumentRoot = getDocumentRoot; +function groupSelectors(selectors) { + var filteredSelectors = []; + var plainSelectors = []; + for (var _i = 0, selectors_1 = selectors; _i < selectors_1.length; _i++) { + var selector = selectors_1[_i]; + if (selector.some(positionals_1.isFilter)) { + filteredSelectors.push(selector); + } + else { + plainSelectors.push(selector); + } + } + return [plainSelectors, filteredSelectors]; +} +exports.groupSelectors = groupSelectors; diff --git a/node_modules/cheerio-select/lib/index.d.ts b/node_modules/cheerio-select/lib/index.d.ts new file mode 100644 index 0000000..4ecf774 --- /dev/null +++ b/node_modules/cheerio-select/lib/index.d.ts @@ -0,0 +1,12 @@ +import { Options as CSSSelectOptions } from "css-select"; +import type { Element, Node, Document } from "domhandler"; +export { filters, pseudos, aliases } from "css-select"; +export interface Options extends CSSSelectOptions { + /** Optional reference to the root of the document. If not set, this will be computed when needed. */ + root?: Document; +} +export declare function is(element: Element, selector: string | ((el: Element) => boolean), options?: Options): boolean; +export declare function some(elements: Element[], selector: string | ((el: Element) => boolean), options?: Options): boolean; +export declare function filter(selector: string, elements: Node[], options?: Options): Element[]; +export declare function select(selector: string | ((el: Element) => boolean), root: Node | Node[], options?: Options): Element[]; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/index.d.ts.map b/node_modules/cheerio-select/lib/index.d.ts.map new file mode 100644 index 0000000..c53a9da --- /dev/null +++ b/node_modules/cheerio-select/lib/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,OAAO,IAAI,gBAAgB,EAE9B,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK1D,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAYvD,MAAM,WAAW,OAAQ,SAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC;IAC5D,qGAAqG;IACrG,IAAI,CAAC,EAAE,QAAQ,CAAC;CACnB;AAED,wBAAgB,EAAE,CACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAET;AAED,wBAAgB,IAAI,CAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAWT;AAsCD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,GAAE,OAAY,GACtB,OAAO,EAAE,CAEX;AA6FD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,EACnB,OAAO,GAAE,OAAY,GACtB,OAAO,EAAE,CAuBX"} \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/index.js b/node_modules/cheerio-select/lib/index.js new file mode 100644 index 0000000..facd2ba --- /dev/null +++ b/node_modules/cheerio-select/lib/index.js @@ -0,0 +1,296 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __spreadArray = (this && this.__spreadArray) || function (to, from) { + for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) + to[j] = from[i]; + return to; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.select = exports.filter = exports.some = exports.is = exports.aliases = exports.pseudos = exports.filters = void 0; +var css_what_1 = require("css-what"); +var css_select_1 = require("css-select"); +var DomUtils = __importStar(require("domutils")); +var helpers_1 = require("./helpers"); +var positionals_1 = require("./positionals"); +// Re-export pseudo extension points +var css_select_2 = require("css-select"); +Object.defineProperty(exports, "filters", { enumerable: true, get: function () { return css_select_2.filters; } }); +Object.defineProperty(exports, "pseudos", { enumerable: true, get: function () { return css_select_2.pseudos; } }); +Object.defineProperty(exports, "aliases", { enumerable: true, get: function () { return css_select_2.aliases; } }); +/** Used to indicate a scope should be filtered. Might be ignored when filtering. */ +var SCOPE_PSEUDO = { + type: "pseudo", + name: "scope", + data: null, +}; +/** Used for actually filtering for scope. */ +var CUSTOM_SCOPE_PSEUDO = __assign({}, SCOPE_PSEUDO); +var UNIVERSAL_SELECTOR = { type: "universal", namespace: null }; +function is(element, selector, options) { + if (options === void 0) { options = {}; } + return some([element], selector, options); +} +exports.is = is; +function some(elements, selector, options) { + if (options === void 0) { options = {}; } + if (typeof selector === "function") + return elements.some(selector); + var _a = helpers_1.groupSelectors(css_what_1.parse(selector, options)), plain = _a[0], filtered = _a[1]; + return ((plain.length > 0 && elements.some(css_select_1._compileToken(plain, options))) || + filtered.some(function (sel) { return filterBySelector(sel, elements, options).length > 0; })); +} +exports.some = some; +function filterByPosition(filter, elems, data, options) { + var num = typeof data === "string" ? parseInt(data, 10) : NaN; + switch (filter) { + case "first": + case "lt": + // Already done in `getLimit` + return elems; + case "last": + return elems.length > 0 ? [elems[elems.length - 1]] : elems; + case "nth": + case "eq": + return isFinite(num) && Math.abs(num) < elems.length + ? [num < 0 ? elems[elems.length + num] : elems[num]] + : []; + case "gt": + return isFinite(num) ? elems.slice(num + 1) : []; + case "even": + return elems.filter(function (_, i) { return i % 2 === 0; }); + case "odd": + return elems.filter(function (_, i) { return i % 2 === 1; }); + case "not": { + var filtered_1 = new Set(filterParsed(data, elems, options)); + return elems.filter(function (e) { return !filtered_1.has(e); }); + } + } +} +function filter(selector, elements, options) { + if (options === void 0) { options = {}; } + return filterParsed(css_what_1.parse(selector, options), elements, options); +} +exports.filter = filter; +/** + * Filter a set of elements by a selector. + * + * Will return elements in the original order. + * + * @param selector Selector to filter by. + * @param elements Elements to filter. + * @param options Options for selector. + */ +function filterParsed(selector, elements, options) { + if (elements.length === 0) + return []; + var _a = helpers_1.groupSelectors(selector), plainSelectors = _a[0], filteredSelectors = _a[1]; + var found; + if (plainSelectors.length) { + var filtered = filterElements(elements, plainSelectors, options); + // If there are no filters, just return + if (filteredSelectors.length === 0) { + return filtered; + } + // Otherwise, we have to do some filtering + if (filtered.length) { + found = new Set(filtered); + } + } + for (var i = 0; i < filteredSelectors.length && (found === null || found === void 0 ? void 0 : found.size) !== elements.length; i++) { + var filteredSelector = filteredSelectors[i]; + var missing = found + ? elements.filter(function (e) { return DomUtils.isTag(e) && !found.has(e); }) + : elements; + if (missing.length === 0) + break; + var filtered = filterBySelector(filteredSelector, elements, options); + if (filtered.length) { + if (!found) { + /* + * If we haven't found anything before the last selector, + * just return what we found now. + */ + if (i === filteredSelectors.length - 1) { + return filtered; + } + found = new Set(filtered); + } + else { + filtered.forEach(function (el) { return found.add(el); }); + } + } + } + return typeof found !== "undefined" + ? (found.size === elements.length + ? elements + : // Filter elements to preserve order + elements.filter(function (el) { + return found.has(el); + })) + : []; +} +function filterBySelector(selector, elements, options) { + var _a; + if (selector.some(css_what_1.isTraversal)) { + /* + * Get root node, run selector with the scope + * set to all of our nodes. + */ + var root = (_a = options.root) !== null && _a !== void 0 ? _a : helpers_1.getDocumentRoot(elements[0]); + var sel = __spreadArray(__spreadArray([], selector), [CUSTOM_SCOPE_PSEUDO]); + return findFilterElements(root, sel, options, true, elements); + } + // Performance optimization: If we don't have to traverse, just filter set. + return findFilterElements(elements, selector, options, false); +} +function select(selector, root, options) { + if (options === void 0) { options = {}; } + if (typeof selector === "function") { + return find(root, selector); + } + var _a = helpers_1.groupSelectors(css_what_1.parse(selector, options)), plain = _a[0], filtered = _a[1]; + var results = filtered.map(function (sel) { + return findFilterElements(root, sel, options, true); + }); + // Plain selectors can be queried in a single go + if (plain.length) { + results.push(findElements(root, plain, options, Infinity)); + } + // If there was only a single selector, just return the result + if (results.length === 1) { + return results[0]; + } + // Sort results, filtering for duplicates + return DomUtils.uniqueSort(results.reduce(function (a, b) { return __spreadArray(__spreadArray([], a), b); })); +} +exports.select = select; +// Traversals that are treated differently in css-select. +var specialTraversal = new Set(["descendant", "adjacent"]); +function includesScopePseudo(t) { + return (t !== SCOPE_PSEUDO && + t.type === "pseudo" && + (t.name === "scope" || + (Array.isArray(t.data) && + t.data.some(function (data) { return data.some(includesScopePseudo); })))); +} +function addContextIfScope(selector, options, scopeContext) { + return scopeContext && selector.some(includesScopePseudo) + ? __assign(__assign({}, options), { context: scopeContext }) : options; +} +/** + * + * @param root Element(s) to search from. + * @param selector Selector to look for. + * @param options Options for querying. + * @param queryForSelector Query multiple levels deep for the initial selector, even if it doesn't contain a traversal. + * @param scopeContext Optional context for a :scope. + */ +function findFilterElements(root, selector, options, queryForSelector, scopeContext) { + var filterIndex = selector.findIndex(positionals_1.isFilter); + var sub = selector.slice(0, filterIndex); + var filter = selector[filterIndex]; + /* + * Set the number of elements to retrieve. + * Eg. for :first, we only have to get a single element. + */ + var limit = positionals_1.getLimit(filter.name, filter.data); + if (limit === 0) + return []; + var subOpts = addContextIfScope(sub, options, scopeContext); + /* + * Skip `findElements` call if our selector starts with a positional + * pseudo. + */ + var elemsNoLimit = sub.length === 0 && !Array.isArray(root) + ? DomUtils.getChildren(root).filter(DomUtils.isTag) + : sub.length === 0 || (sub.length === 1 && sub[0] === SCOPE_PSEUDO) + ? (Array.isArray(root) ? root : [root]).filter(DomUtils.isTag) + : queryForSelector || sub.some(css_what_1.isTraversal) + ? findElements(root, [sub], subOpts, limit) + : filterElements(root, [sub], subOpts); + var elems = elemsNoLimit.slice(0, limit); + var result = filterByPosition(filter.name, elems, filter.data, options); + if (result.length === 0 || selector.length === filterIndex + 1) { + return result; + } + var remainingSelector = selector.slice(filterIndex + 1); + var remainingHasTraversal = remainingSelector.some(css_what_1.isTraversal); + var remainingOpts = addContextIfScope(remainingSelector, options, scopeContext); + if (remainingHasTraversal) { + /* + * Some types of traversals have special logic when they start a selector + * in css-select. If this is the case, add a universal selector in front of + * the selector to avoid this behavior. + */ + if (specialTraversal.has(remainingSelector[0].type)) { + remainingSelector.unshift(UNIVERSAL_SELECTOR); + } + /* + * Add a scope token in front of the remaining selector, + * to make sure traversals don't match elements that aren't a + * part of the considered tree. + */ + remainingSelector.unshift(SCOPE_PSEUDO); + } + /* + * If we have another filter, recursively call `findFilterElements`, + * with the `recursive` flag disabled. We only have to look for more + * elements when we see a traversal. + * + * Otherwise, + */ + return remainingSelector.some(positionals_1.isFilter) + ? findFilterElements(result, remainingSelector, options, false, scopeContext) + : remainingHasTraversal + ? // Query existing elements to resolve traversal. + findElements(result, [remainingSelector], remainingOpts, Infinity) + : // If we don't have any more traversals, simply filter elements. + filterElements(result, [remainingSelector], remainingOpts); +} +function findElements(root, sel, options, limit) { + if (limit === 0) + return []; + var query = css_select_1._compileToken(sel, options, root); + return find(root, query, limit); +} +function find(root, query, limit) { + if (limit === void 0) { limit = Infinity; } + var elems = css_select_1.prepareContext(root, DomUtils, query.shouldTestNextSiblings); + return DomUtils.find(function (node) { return DomUtils.isTag(node) && query(node); }, elems, true, limit); +} +function filterElements(elements, sel, options) { + var els = (Array.isArray(elements) ? elements : [elements]).filter(DomUtils.isTag); + if (els.length === 0) + return els; + var query = css_select_1._compileToken(sel, options); + return els.filter(query); +} diff --git a/node_modules/cheerio-select/lib/positionals.d.ts b/node_modules/cheerio-select/lib/positionals.d.ts new file mode 100644 index 0000000..9e581d3 --- /dev/null +++ b/node_modules/cheerio-select/lib/positionals.d.ts @@ -0,0 +1,10 @@ +import type { Selector, PseudoSelector } from "css-what"; +export declare type Filter = "first" | "last" | "eq" | "nth" | "gt" | "lt" | "even" | "odd" | "not"; +export declare const filterNames: Set; +export interface CheerioSelector extends PseudoSelector { + name: Filter; + data: string | null; +} +export declare function isFilter(s: Selector): s is CheerioSelector; +export declare function getLimit(filter: Filter, data: string | null): number; +//# sourceMappingURL=positionals.d.ts.map \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/positionals.d.ts.map b/node_modules/cheerio-select/lib/positionals.d.ts.map new file mode 100644 index 0000000..0d755cc --- /dev/null +++ b/node_modules/cheerio-select/lib/positionals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"positionals.d.ts","sourceRoot":"","sources":["../src/positionals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEzD,oBAAY,MAAM,GACZ,OAAO,GACP,MAAM,GACN,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,KAAK,GACL,KAAK,CAAC;AACZ,eAAO,MAAM,WAAW,EAAE,GAAG,CAAC,MAAM,CASlC,CAAC;AAEH,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,IAAI,eAAe,CAS1D;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAgBpE"} \ No newline at end of file diff --git a/node_modules/cheerio-select/lib/positionals.js b/node_modules/cheerio-select/lib/positionals.js new file mode 100644 index 0000000..a2ccaa7 --- /dev/null +++ b/node_modules/cheerio-select/lib/positionals.js @@ -0,0 +1,42 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getLimit = exports.isFilter = exports.filterNames = void 0; +exports.filterNames = new Set([ + "first", + "last", + "eq", + "gt", + "nth", + "lt", + "even", + "odd", +]); +function isFilter(s) { + if (s.type !== "pseudo") + return false; + if (exports.filterNames.has(s.name)) + return true; + if (s.name === "not" && Array.isArray(s.data)) { + // Only consider `:not` with embedded filters + return s.data.some(function (s) { return s.some(isFilter); }); + } + return false; +} +exports.isFilter = isFilter; +function getLimit(filter, data) { + var num = data != null ? parseInt(data, 10) : NaN; + switch (filter) { + case "first": + return 1; + case "nth": + case "eq": + return isFinite(num) ? (num >= 0 ? num + 1 : Infinity) : 0; + case "lt": + return isFinite(num) ? (num >= 0 ? num : Infinity) : 0; + case "gt": + return isFinite(num) ? Infinity : 0; + default: + return Infinity; + } +} +exports.getLimit = getLimit; -- cgit