@node-core/utils 7.2.1 → 7.2.2

package/node_modules/htmlparser2/node_modules/domutils/src/helpers.ts

@@ -0,0 +1,154 @@
+import { type AnyNode, hasChildren, type ParentNode } from "domhandler";
+
+/**
+ * Given an array of nodes, remove any member that is contained by another
+ * member.
+ *
+ * @category Helpers
+ * @param nodes Nodes to filter.
+ * @returns Remaining nodes that aren't contained by other nodes.
+ */
+export function removeSubsets(nodes: AnyNode[]): AnyNode[] {
+    let index = nodes.length;
+
+    /*
+     * Check if each node (or one of its ancestors) is already contained in the
+     * array.
+     */
+    while (--index >= 0) {
+        const node = nodes[index];
+
+        /*
+         * Remove the node if it is not unique.
+         * We are going through the array from the end, so we only
+         * have to check nodes that preceed the node under consideration in the array.
+         */
+        if (index > 0 && nodes.lastIndexOf(node, index - 1) >= 0) {
+            nodes.splice(index, 1);
+            continue;
+        }
+
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+            if (nodes.includes(ancestor)) {
+                nodes.splice(index, 1);
+                break;
+            }
+        }
+    }
+
+    return nodes;
+}
+/**
+ * @category Helpers
+ * @see {@link http://dom.spec.whatwg.org/#dom-node-comparedocumentposition}
+ */
+export const enum DocumentPosition {
+    DISCONNECTED = 1,
+    PRECEDING = 2,
+    FOLLOWING = 4,
+    CONTAINS = 8,
+    CONTAINED_BY = 16,
+}
+
+/**
+ * Compare the position of one node against another node in any other document,
+ * returning a bitmask with the values from {@link DocumentPosition}.
+ *
+ * Document order:
+ * > There is an ordering, document order, defined on all the nodes in the
+ * > document corresponding to the order in which the first character of the
+ * > XML representation of each node occurs in the XML representation of the
+ * > document after expansion of general entities. Thus, the document element
+ * > node will be the first node. Element nodes occur before their children.
+ * > Thus, document order orders element nodes in order of the occurrence of
+ * > their start-tag in the XML (after expansion of entities). The attribute
+ * > nodes of an element occur after the element and before its children. The
+ * > relative order of attribute nodes is implementation-dependent.
+ *
+ * Source:
+ * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
+ *
+ * @category Helpers
+ * @param nodeA The first node to use in the comparison
+ * @param nodeB The second node to use in the comparison
+ * @returns A bitmask describing the input nodes' relative position.
+ *
+ * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
+ * a description of these values.
+ */
+export function compareDocumentPosition(
+    nodeA: AnyNode,
+    nodeB: AnyNode,
+): number {
+    const aParents: ParentNode[] = [];
+    const bParents: ParentNode[] = [];
+
+    if (nodeA === nodeB) {
+        return 0;
+    }
+
+    let current = hasChildren(nodeA) ? nodeA : nodeA.parent;
+    while (current) {
+        aParents.unshift(current);
+        current = current.parent;
+    }
+    current = hasChildren(nodeB) ? nodeB : nodeB.parent;
+    while (current) {
+        bParents.unshift(current);
+        current = current.parent;
+    }
+
+    const maxIndex = Math.min(aParents.length, bParents.length);
+    let index = 0;
+    while (index < maxIndex && aParents[index] === bParents[index]) {
+        index++;
+    }
+
+    if (index === 0) {
+        return DocumentPosition.DISCONNECTED;
+    }
+
+    const sharedParent = aParents[index - 1];
+    const siblings: AnyNode[] = sharedParent.children;
+    const aSibling = aParents[index];
+    const bSibling = bParents[index];
+
+    if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
+        if (sharedParent === nodeB) {
+            return DocumentPosition.FOLLOWING | DocumentPosition.CONTAINED_BY;
+        }
+        return DocumentPosition.FOLLOWING;
+    }
+    if (sharedParent === nodeA) {
+        return DocumentPosition.PRECEDING | DocumentPosition.CONTAINS;
+    }
+    return DocumentPosition.PRECEDING;
+}
+
+/**
+ * Sort an array of nodes based on their relative position in the document,
+ * removing any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
+ *
+ * @category Helpers
+ * @param nodes Array of DOM nodes.
+ * @returns Collection of unique nodes, sorted in document order.
+ */
+export function uniqueSort<T extends AnyNode>(nodes: T[]): T[] {
+    nodes = nodes.filter(
+        (node, index, array) => !array.includes(node, index + 1),
+    );
+
+    nodes.sort((a, b) => {
+        const relative = compareDocumentPosition(a, b);
+        if (relative & DocumentPosition.PRECEDING) {
+            return -1;
+        }
+        if (relative & DocumentPosition.FOLLOWING) {
+            return 1;
+        }
+        return 0;
+    });
+
+    return nodes;
+}

package/node_modules/htmlparser2/node_modules/domutils/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./feeds.js";
+export * from "./helpers.js";
+export * from "./legacy.js";
+export * from "./manipulation.js";
+export * from "./querying.js";
+export * from "./stringify.js";
+export * from "./traversal.js";

package/node_modules/htmlparser2/node_modules/domutils/src/legacy.ts

@@ -0,0 +1,224 @@
+import type { ElementType } from "domelementtype";
+import { type AnyNode, type Element, isTag, isText } from "domhandler";
+import { filter, findOne } from "./querying.js";
+
+type TestType = (element: AnyNode) => boolean;
+
+/**
+ * An object with keys to check elements against. If a key is `tag_name`,
+ * `tag_type` or `tag_contains`, it will check the value against that specific
+ * value. Otherwise, it will check an attribute with the key's name.
+ *
+ * @category Legacy Query Functions
+ */
+// eslint-disable-next-line unicorn/prevent-abbreviations -- Keep the exported API name for backwards compatibility.
+export interface TestElementOpts {
+    tag_name?: string | ((name: string) => boolean);
+    tag_type?: string | ((name: string) => boolean);
+    tag_contains?: string | ((data?: string) => boolean);
+    [attributeName: string]:
+        | undefined
+        | string
+        | ((attributeValue: string) => boolean);
+}
+
+/**
+ * A map of functions to check nodes against.
+ */
+const Checks: Record<
+    string,
+    (value: string | undefined | ((inputString: string) => boolean)) => TestType
+> = {
+    tag_name(name) {
+        if (typeof name === "function") {
+            return (element: AnyNode) => isTag(element) && name(element.name);
+        }
+        if (name === "*") {
+            return isTag;
+        }
+        return (element: AnyNode) => isTag(element) && element.name === name;
+    },
+    tag_type(type) {
+        if (typeof type === "function") {
+            return (element: AnyNode) => type(element.type);
+        }
+        return (element: AnyNode) => element.type === type;
+    },
+    tag_contains(data) {
+        if (typeof data === "function") {
+            return (element: AnyNode) => isText(element) && data(element.data);
+        }
+        return (element: AnyNode) => isText(element) && element.data === data;
+    },
+};
+
+/**
+ * Returns a function to check whether a node has an attribute with a particular
+ * value.
+ *
+ * @param attrib Attribute to check.
+ * @param value Attribute value to look for.
+ * @returns A function to check whether the a node has an attribute with a
+ *   particular value.
+ */
+function getAttribCheck(
+    attrib: string,
+    value: undefined | string | ((value: string) => boolean),
+): TestType {
+    if (typeof value === "function") {
+        return (element: AnyNode) =>
+            isTag(element) && value(element.attribs[attrib]);
+    }
+    return (element: AnyNode) =>
+        isTag(element) && element.attribs[attrib] === value;
+}
+
+/**
+ * Returns a function that returns `true` if either of the input functions
+ * returns `true` for a node.
+ *
+ * @param a First function to combine.
+ * @param b Second function to combine.
+ * @returns A function taking a node and returning `true` if either of the input
+ *   functions returns `true` for the node.
+ */
+function combineFuncs(a: TestType, b: TestType): TestType {
+    return (element: AnyNode) => a(element) || b(element);
+}
+
+/**
+ * Returns a function that executes all checks in `options` and returns `true`
+ * if any of them match a node.
+ *
+ * @param options An object describing nodes to look for.
+ * @returns A function that executes all checks in `options` and returns `true`
+ *   if any of them match a node.
+ */
+function compileTest(options: TestElementOpts): TestType | null {
+    const funcs = Object.keys(options).map((key) => {
+        const value = options[key];
+        return Object.hasOwn(Checks, key)
+            ? Checks[key](value)
+            : getAttribCheck(key, value);
+    });
+
+    return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
+}
+
+/**
+ * Checks whether a node matches the description in `options`.
+ *
+ * @category Legacy Query Functions
+ * @param options An object describing nodes to look for.
+ * @param node The element to test.
+ * @returns Whether the element matches the description in `options`.
+ */
+export function testElement(options: TestElementOpts, node: AnyNode): boolean {
+    const test = compileTest(options);
+    return test ? test(node) : true;
+}
+
+/**
+ * Returns all nodes that match `options`.
+ *
+ * @category Legacy Query Functions
+ * @param options An object describing nodes to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes that match `options`.
+ */
+export function getElements(
+    options: TestElementOpts,
+    nodes: AnyNode | AnyNode[],
+    recurse: boolean,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
+    const test = compileTest(options);
+    return test ? filter(test, nodes, recurse, limit) : [];
+}
+
+/**
+ * Returns the node with the supplied ID.
+ *
+ * @category Legacy Query Functions
+ * @param id The unique ID attribute value to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @returns The node with the supplied ID.
+ */
+export function getElementById(
+    id: string | ((id: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+): Element | null {
+    if (!Array.isArray(nodes)) nodes = [nodes];
+    return findOne(getAttribCheck("id", id), nodes, recurse);
+}
+
+/**
+ * Returns all nodes with the supplied `tagName`.
+ *
+ * @category Legacy Query Functions
+ * @param tagName Tag name to search for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `tagName`.
+ */
+export function getElementsByTagName(
+    tagName: string | ((name: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): Element[] {
+    return filter(
+        Checks["tag_name"](tagName),
+        nodes,
+        recurse,
+        limit,
+    ) as Element[];
+}
+
+/**
+ * Returns all nodes with the supplied `className`.
+ *
+ * @category Legacy Query Functions
+ * @param className Class name to search for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `className`.
+ */
+export function getElementsByClassName(
+    className: string | ((name: string) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): Element[] {
+    return filter(
+        getAttribCheck("class", className),
+        nodes,
+        recurse,
+        limit,
+    ) as Element[];
+}
+
+/**
+ * Returns all nodes with the supplied `type`.
+ *
+ * @category Legacy Query Functions
+ * @param type Element type to look for.
+ * @param nodes Nodes to search through.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes with the supplied `type`.
+ */
+export function getElementsByTagType(
+    type: ElementType | ((type: ElementType) => boolean),
+    nodes: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
+    return filter(Checks["tag_type"](type as string), nodes, recurse, limit);
+}

package/node_modules/htmlparser2/node_modules/domutils/src/manipulation.ts

@@ -0,0 +1,156 @@
+import type { ChildNode, ParentNode } from "domhandler";
+
+/**
+ * Remove an element from the dom
+ *
+ * @category Manipulation
+ * @param element The element to be removed.
+ */
+export function removeElement(element: ChildNode): void {
+    if (element.prev) element.prev.next = element.next;
+    if (element.next) element.next.prev = element.prev;
+
+    if (element.parent) {
+        const childs = element.parent.children;
+        const childsIndex = childs.lastIndexOf(element);
+        if (childsIndex !== -1) {
+            childs.splice(childsIndex, 1);
+        }
+    }
+    element.next = null;
+    element.prev = null;
+    element.parent = null;
+}
+
+/**
+ * Replace an element in the dom
+ *
+ * @category Manipulation
+ * @param element The element to be replaced.
+ * @param replacement The element to be added
+ */
+export function replaceElement(
+    element: ChildNode,
+    replacement: ChildNode,
+): void {
+    replacement.prev = element.prev;
+    if (replacement.prev) {
+        replacement.prev.next = replacement;
+    }
+
+    replacement.next = element.next;
+    if (replacement.next) {
+        replacement.next.prev = replacement;
+    }
+
+    replacement.parent = element.parent;
+    if (replacement.parent) {
+        const { children } = replacement.parent;
+        const elementIndex = children.lastIndexOf(element);
+        if (elementIndex === -1) {
+            return;
+        }
+
+        children[elementIndex] = replacement;
+        element.parent = null;
+    }
+}
+
+/**
+ * Append a child to an element.
+ *
+ * @category Manipulation
+ * @param parent The element to append to.
+ * @param child The element to be added as a child.
+ */
+export function appendChild(parent: ParentNode, child: ChildNode): void {
+    removeElement(child);
+
+    child.next = null;
+    child.parent = parent;
+
+    if (parent.children.push(child) > 1) {
+        const sibling = parent.children[parent.children.length - 2];
+        sibling.next = child;
+        child.prev = sibling;
+    } else {
+        child.prev = null;
+    }
+}
+
+/**
+ * Append an element after another.
+ *
+ * @category Manipulation
+ * @param element The element to append after.
+ * @param next The element be added.
+ */
+export function append(element: ChildNode, next: ChildNode): void {
+    removeElement(next);
+
+    const { parent } = element;
+    const currentNext = element.next;
+
+    next.next = currentNext;
+    next.prev = element;
+    element.next = next;
+    next.parent = parent;
+
+    if (currentNext) {
+        currentNext.prev = next;
+        if (parent) {
+            const childs = parent.children;
+            childs.splice(childs.lastIndexOf(currentNext), 0, next);
+        }
+    } else if (parent) {
+        parent.children.push(next);
+    }
+}
+
+/**
+ * Prepend a child to an element.
+ *
+ * @category Manipulation
+ * @param parent The element to prepend before.
+ * @param child The element to be added as a child.
+ */
+export function prependChild(parent: ParentNode, child: ChildNode): void {
+    removeElement(child);
+
+    child.parent = parent;
+    child.prev = null;
+
+    if (parent.children.unshift(child) === 1) {
+        child.next = null;
+    } else {
+        const sibling = parent.children[1];
+        sibling.prev = child;
+        child.next = sibling;
+    }
+}
+
+/**
+ * Prepend an element before another.
+ *
+ * @category Manipulation
+ * @param element The element to prepend before.
+ * @param previous The element to be added.
+ */
+export function prepend(element: ChildNode, previous: ChildNode): void {
+    removeElement(previous);
+
+    const { parent } = element;
+    if (parent) {
+        const childs = parent.children;
+        childs.splice(childs.indexOf(element), 0, previous);
+    }
+
+    if (element.prev) {
+        element.prev.next = previous;
+    }
+
+    previous.parent = parent;
+    previous.prev = element.prev;
+    previous.next = element;
+    element.prev = previous;
+}

package/node_modules/htmlparser2/node_modules/domutils/src/querying.ts

@@ -0,0 +1,172 @@
+import {
+    type AnyNode,
+    type Element,
+    hasChildren,
+    isTag,
+    type ParentNode,
+} from "domhandler";
+
+/**
+ * Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one.
+ *
+ * @category Querying
+ * @param test Function to test nodes on.
+ * @param node Node to search. Will be included in the result set if it matches.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes passing `test`.
+ */
+export function filter(
+    test: (element: AnyNode) => boolean,
+    node: AnyNode | AnyNode[],
+    recurse = true,
+    limit: number = Number.POSITIVE_INFINITY,
+): AnyNode[] {
+    return find(test, Array.isArray(node) ? node : [node], recurse, limit);
+}
+
+/**
+ * Search an array of nodes and their children for nodes passing a test function.
+ *
+ * @category Querying
+ * @param test Function to test nodes on.
+ * @param nodes Array of nodes to search.
+ * @param recurse Also consider child nodes.
+ * @param limit Maximum number of nodes to return.
+ * @returns All nodes passing `test`.
+ */
+export function find(
+    test: (element: AnyNode) => boolean,
+    nodes: AnyNode[] | ParentNode,
+    recurse: boolean,
+    limit: number,
+): AnyNode[] {
+    const result: AnyNode[] = [];
+    /** Stack of the arrays we are looking at. */
+    const nodeStack: AnyNode[][] = [Array.isArray(nodes) ? nodes : [nodes]];
+    /** Stack of the indices within the arrays. */
+    const indexStack = [0];
+
+    for (;;) {
+        // First, check if the current array has any more elements to look at.
+        if (indexStack[0] >= nodeStack[0].length) {
+            // If we have no more arrays to look at, we are done.
+            if (indexStack.length === 1) {
+                return result;
+            }
+
+            // Otherwise, remove the current array from the stack.
+            nodeStack.shift();
+            indexStack.shift();
+
+            // Loop back to the start to continue with the next array.
+            continue;
+        }
+
+        const element = nodeStack[0][indexStack[0]++];
+
+        if (test(element)) {
+            result.push(element);
+            if (--limit <= 0) return result;
+        }
+
+        if (recurse && hasChildren(element) && element.children.length > 0) {
+            /*
+             * Add the children to the stack. We are depth-first, so this is
+             * the next array we look at.
+             */
+            indexStack.unshift(0);
+            nodeStack.unshift(element.children);
+        }
+    }
+}
+
+/**
+ * Finds one element in a tree that passes a test.
+ *
+ * @category Querying
+ * @param test Function to test nodes on.
+ * @param nodes Node or array of nodes to search.
+ * @param recurse Also consider child nodes.
+ * @returns The first node that passes `test`.
+ */
+export function findOne(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+    recurse = true,
+): Element | null {
+    const searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
+    for (const node of searchedNodes) {
+        if (isTag(node) && test(node)) {
+            return node;
+        }
+        if (recurse && hasChildren(node) && node.children.length > 0) {
+            const found = findOne(test, node.children, true);
+            if (found) return found;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Checks if a tree of nodes contains at least one node passing a test.
+ *
+ * @category Querying
+ * @param test Function to test nodes on.
+ * @param nodes Array of nodes to search.
+ * @returns Whether a tree of nodes contains at least one node passing the test.
+ */
+export function existsOne(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+): boolean {
+    return (Array.isArray(nodes) ? nodes : [nodes]).some(
+        (node) =>
+            (isTag(node) && test(node)) ||
+            (hasChildren(node) && existsOne(test, node.children)),
+    );
+}
+
+/**
+ * Search an array of nodes and their children for elements passing a test function.
+ *
+ * Same as `find`, but limited to elements and with less options, leading to reduced complexity.
+ *
+ * @category Querying
+ * @param test Function to test nodes on.
+ * @param nodes Array of nodes to search.
+ * @returns All nodes passing `test`.
+ */
+export function findAll(
+    test: (element: Element) => boolean,
+    nodes: AnyNode[] | ParentNode,
+): Element[] {
+    const result = [];
+    const nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
+    const indexStack = [0];
+
+    for (;;) {
+        if (indexStack[0] >= nodeStack[0].length) {
+            if (nodeStack.length === 1) {
+                return result;
+            }
+
+            // Otherwise, remove the current array from the stack.
+            nodeStack.shift();
+            indexStack.shift();
+
+            // Loop back to the start to continue with the next array.
+            continue;
+        }
+
+        const element = nodeStack[0][indexStack[0]++];
+
+        if (isTag(element) && test(element)) result.push(element);
+
+        if (hasChildren(element) && element.children.length > 0) {
+            indexStack.unshift(0);
+            nodeStack.unshift(element.children);
+        }
+    }
+}