@mtkruto/node 0.1.289 → 0.1.299

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.d.ts

@@ -0,0 +1,109 @@
+declare const _default: {
+    Aacute: string;
+    aacute: string;
+    Acirc: string;
+    acirc: string;
+    acute: string;
+    AElig: string;
+    aelig: string;
+    Agrave: string;
+    agrave: string;
+    amp: string;
+    AMP: string;
+    Aring: string;
+    aring: string;
+    Atilde: string;
+    atilde: string;
+    Auml: string;
+    auml: string;
+    brvbar: string;
+    Ccedil: string;
+    ccedil: string;
+    cedil: string;
+    cent: string;
+    copy: string;
+    COPY: string;
+    curren: string;
+    deg: string;
+    divide: string;
+    Eacute: string;
+    eacute: string;
+    Ecirc: string;
+    ecirc: string;
+    Egrave: string;
+    egrave: string;
+    ETH: string;
+    eth: string;
+    Euml: string;
+    euml: string;
+    frac12: string;
+    frac14: string;
+    frac34: string;
+    gt: string;
+    GT: string;
+    Iacute: string;
+    iacute: string;
+    Icirc: string;
+    icirc: string;
+    iexcl: string;
+    Igrave: string;
+    igrave: string;
+    iquest: string;
+    Iuml: string;
+    iuml: string;
+    laquo: string;
+    lt: string;
+    LT: string;
+    macr: string;
+    micro: string;
+    middot: string;
+    nbsp: string;
+    not: string;
+    Ntilde: string;
+    ntilde: string;
+    Oacute: string;
+    oacute: string;
+    Ocirc: string;
+    ocirc: string;
+    Ograve: string;
+    ograve: string;
+    ordf: string;
+    ordm: string;
+    Oslash: string;
+    oslash: string;
+    Otilde: string;
+    otilde: string;
+    Ouml: string;
+    ouml: string;
+    para: string;
+    plusmn: string;
+    pound: string;
+    quot: string;
+    QUOT: string;
+    raquo: string;
+    reg: string;
+    REG: string;
+    sect: string;
+    shy: string;
+    sup1: string;
+    sup2: string;
+    sup3: string;
+    szlig: string;
+    THORN: string;
+    thorn: string;
+    times: string;
+    Uacute: string;
+    uacute: string;
+    Ucirc: string;
+    ucirc: string;
+    Ugrave: string;
+    ugrave: string;
+    uml: string;
+    Uuml: string;
+    uuml: string;
+    Yacute: string;
+    yacute: string;
+    yen: string;
+    yuml: string;
+};
+export default _default;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/legacy.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    Aacute: 'Á',
+    aacute: 'á',
+    Acirc: 'Â',
+    acirc: 'â',
+    acute: '´',
+    AElig: 'Æ',
+    aelig: 'æ',
+    Agrave: 'À',
+    agrave: 'à',
+    amp: '&',
+    AMP: '&',
+    Aring: 'Å',
+    aring: 'å',
+    Atilde: 'Ã',
+    atilde: 'ã',
+    Auml: 'Ä',
+    auml: 'ä',
+    brvbar: '¦',
+    Ccedil: 'Ç',
+    ccedil: 'ç',
+    cedil: '¸',
+    cent: '¢',
+    copy: '©',
+    COPY: '©',
+    curren: '¤',
+    deg: '°',
+    divide: '÷',
+    Eacute: 'É',
+    eacute: 'é',
+    Ecirc: 'Ê',
+    ecirc: 'ê',
+    Egrave: 'È',
+    egrave: 'è',
+    ETH: 'Ð',
+    eth: 'ð',
+    Euml: 'Ë',
+    euml: 'ë',
+    frac12: '½',
+    frac14: '¼',
+    frac34: '¾',
+    gt: '>',
+    GT: '>',
+    Iacute: 'Í',
+    iacute: 'í',
+    Icirc: 'Î',
+    icirc: 'î',
+    iexcl: '¡',
+    Igrave: 'Ì',
+    igrave: 'ì',
+    iquest: '¿',
+    Iuml: 'Ï',
+    iuml: 'ï',
+    laquo: '«',
+    lt: '<',
+    LT: '<',
+    macr: '¯',
+    micro: 'µ',
+    middot: '·',
+    nbsp: ' ',
+    not: '¬',
+    Ntilde: 'Ñ',
+    ntilde: 'ñ',
+    Oacute: 'Ó',
+    oacute: 'ó',
+    Ocirc: 'Ô',
+    ocirc: 'ô',
+    Ograve: 'Ò',
+    ograve: 'ò',
+    ordf: 'ª',
+    ordm: 'º',
+    Oslash: 'Ø',
+    oslash: 'ø',
+    Otilde: 'Õ',
+    otilde: 'õ',
+    Ouml: 'Ö',
+    ouml: 'ö',
+    para: '¶',
+    plusmn: '±',
+    pound: '£',
+    quot: '"',
+    QUOT: '"',
+    raquo: '»',
+    reg: '®',
+    REG: '®',
+    sect: '§',
+    shy: '­',
+    sup1: '¹',
+    sup2: '²',
+    sup3: '³',
+    szlig: 'ß',
+    THORN: 'Þ',
+    thorn: 'þ',
+    times: '×',
+    Uacute: 'Ú',
+    uacute: 'ú',
+    Ucirc: 'Û',
+    ucirc: 'û',
+    Ugrave: 'Ù',
+    ugrave: 'ù',
+    uml: '¨',
+    Uuml: 'Ü',
+    uuml: 'ü',
+    Yacute: 'Ý',
+    yacute: 'ý',
+    yen: '¥',
+    yuml: 'ÿ',
+};

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    amp: string;
+    apos: string;
+    gt: string;
+    lt: string;
+    quot: string;
+};
+export default _default;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/xml.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = { amp: '&', apos: "'", gt: '>', lt: '<', quot: '"' };

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.d.ts

@@ -0,0 +1,90 @@
+/** The level of entities to support. */
+export declare enum EntityLevel {
+    /** Support only XML entities. */
+    XML = 0,
+    /** Support HTML entities, which are a superset of XML entities. */
+    HTML = 1
+}
+/** Determines whether some entities are allowed to be written without a trailing `;`. */
+export declare enum DecodingMode {
+    /** Support legacy HTML entities. */
+    Legacy = 0,
+    /** Do not support legacy HTML entities. */
+    Strict = 1
+}
+export declare enum EncodingMode {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * HTML will be escaped.
+     */
+    UTF8 = 0,
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    ASCII = 1,
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    Extensive = 2
+}
+interface DecodingOptions {
+    /**
+     * The level of entities to support.
+     * @default EntityLevel.XML
+     */
+    level?: EntityLevel;
+    /**
+     * Decoding mode. If `Legacy`, will support legacy entities not terminated
+     * with a semicolon (`;`).
+     *
+     * Always `Strict` for XML. For HTML, set this to `true` if you are parsing
+     * an attribute value.
+     *
+     * The deprecated `decodeStrict` function defaults this to `Strict`.
+     *
+     * @default DecodingMode.Legacy
+     */
+    mode?: DecodingMode;
+}
+/**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ */
+export declare function decode(data: string, options?: DecodingOptions | EntityLevel): string;
+/**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ * @deprecated Use `decode` with the `mode` set to `Strict`.
+ */
+export declare function decodeStrict(data: string, options?: DecodingOptions | EntityLevel): string;
+/**
+ * Options for `encode`.
+ */
+export interface EncodingOptions {
+    /**
+     * The level of entities to support.
+     * @default EntityLevel.XML
+     */
+    level?: EntityLevel;
+    /**
+     * Output format.
+     * @default EncodingMode.Extensive
+     */
+    mode?: EncodingMode;
+}
+/**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param options Encoding options.
+ */
+export declare function encode(data: string, options?: EncodingOptions | EntityLevel): string;
+export { encodeXML, encodeHTML, encodeNonAsciiHTML, escape, escapeUTF8, encodeHTML as encodeHTML4, encodeHTML as encodeHTML5, } from './encode.js';
+export { decodeXML, decodeHTML, decodeHTMLStrict, decodeHTML as decodeHTML4, decodeHTML as decodeHTML5, decodeHTMLStrict as decodeHTML4Strict, decodeHTMLStrict as decodeHTML5Strict, decodeXML as decodeXMLStrict, } from './decode.js';

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/mod.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = exports.EncodingMode = exports.DecodingMode = exports.EntityLevel = void 0;
+const decode_js_1 = require("./decode.js");
+const encode_js_1 = require("./encode.js");
+/** The level of entities to support. */
+var EntityLevel;
+(function (EntityLevel) {
+    /** Support only XML entities. */
+    EntityLevel[EntityLevel["XML"] = 0] = "XML";
+    /** Support HTML entities, which are a superset of XML entities. */
+    EntityLevel[EntityLevel["HTML"] = 1] = "HTML";
+})(EntityLevel || (exports.EntityLevel = EntityLevel = {}));
+/** Determines whether some entities are allowed to be written without a trailing `;`. */
+var DecodingMode;
+(function (DecodingMode) {
+    /** Support legacy HTML entities. */
+    DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+    /** Do not support legacy HTML entities. */
+    DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+})(DecodingMode || (exports.DecodingMode = DecodingMode = {}));
+var EncodingMode;
+(function (EncodingMode) {
+    /**
+     * The output is UTF-8 encoded. Only characters that need escaping within
+     * HTML will be escaped.
+     */
+    EncodingMode[EncodingMode["UTF8"] = 0] = "UTF8";
+    /**
+     * The output consists only of ASCII characters. Characters that need
+     * escaping within HTML, and characters that aren't ASCII characters will
+     * be escaped.
+     */
+    EncodingMode[EncodingMode["ASCII"] = 1] = "ASCII";
+    /**
+     * Encode all characters that have an equivalent entity, as well as all
+     * characters that are not ASCII characters.
+     */
+    EncodingMode[EncodingMode["Extensive"] = 2] = "Extensive";
+})(EncodingMode || (exports.EncodingMode = EncodingMode = {}));
+/**
+ * Decodes a string with entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ */
+function decode(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === DecodingMode.Strict) {
+            return (0, decode_js_1.decodeHTMLStrict)(data);
+        }
+        return (0, decode_js_1.decodeHTML)(data);
+    }
+    return (0, decode_js_1.decodeXML)(data);
+}
+exports.decode = decode;
+/**
+ * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
+ *
+ * @param data String to decode.
+ * @param options Decoding options.
+ * @deprecated Use `decode` with the `mode` set to `Strict`.
+ */
+function decodeStrict(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === DecodingMode.Legacy) {
+            return (0, decode_js_1.decodeHTML)(data);
+        }
+        return (0, decode_js_1.decodeHTMLStrict)(data);
+    }
+    return (0, decode_js_1.decodeXML)(data);
+}
+exports.decodeStrict = decodeStrict;
+/**
+ * Encodes a string with entities.
+ *
+ * @param data String to encode.
+ * @param options Encoding options.
+ */
+function encode(data, options = EntityLevel.XML) {
+    const opts = typeof options === 'number' ? { level: options } : options;
+    if (opts.level === EntityLevel.HTML) {
+        if (opts.mode === EncodingMode.ASCII) {
+            return (0, encode_js_1.encodeNonAsciiHTML)(data);
+        }
+        // TODO Support opts.mode === 'UTF8'
+        return (0, encode_js_1.encodeHTML)(data);
+    }
+    // TODO Support opts.mode === 'UTF8'
+    // ASCII and Extensive are equivalent
+    return (0, encode_js_1.encodeXML)(data);
+}
+exports.encode = encode;
+var encode_js_2 = require("./encode.js");
+Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function () { return encode_js_2.encodeXML; } });
+Object.defineProperty(exports, "encodeHTML", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+Object.defineProperty(exports, "encodeNonAsciiHTML", { enumerable: true, get: function () { return encode_js_2.encodeNonAsciiHTML; } });
+Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return encode_js_2.escape; } });
+Object.defineProperty(exports, "escapeUTF8", { enumerable: true, get: function () { return encode_js_2.escapeUTF8; } });
+// Legacy aliases (deprecated)
+Object.defineProperty(exports, "encodeHTML4", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+Object.defineProperty(exports, "encodeHTML5", { enumerable: true, get: function () { return encode_js_2.encodeHTML; } });
+var decode_js_2 = require("./decode.js");
+Object.defineProperty(exports, "decodeXML", { enumerable: true, get: function () { return decode_js_2.decodeXML; } });
+Object.defineProperty(exports, "decodeHTML", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTMLStrict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+// Legacy aliases (deprecated)
+Object.defineProperty(exports, "decodeHTML4", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTML5", { enumerable: true, get: function () { return decode_js_2.decodeHTML; } });
+Object.defineProperty(exports, "decodeHTML4Strict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+Object.defineProperty(exports, "decodeHTML5Strict", { enumerable: true, get: function () { return decode_js_2.decodeHTMLStrict; } });
+Object.defineProperty(exports, "decodeXMLStrict", { enumerable: true, get: function () { return decode_js_2.decodeXML; } });

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/helpers.d.ts

@@ -0,0 +1,50 @@
+import { Node } from '../Node.js';
+/**
+ * Given an array of nodes, remove any member that is contained by another.
+ *
+ * @param nodes Nodes to filter.
+ * @returns Remaining nodes that aren't subtrees of each other.
+ */
+export declare function removeSubsets(nodes: Node[]): Node[];
+export declare 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.
+ * The return value is a bitmask with the following values:
+ *
+ * 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
+ *
+ * @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 declare function compareDocumentPosition(nodeA: Node, nodeB: Node): number;
+/**
+ * Sort an array of nodes based on their relative position in the document and
+ * remove any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
+ *
+ * @param nodes Array of DOM nodes.
+ * @returns Collection of unique nodes, sorted in document order.
+ */
+export declare function uniqueSort<T extends Node>(nodes: T[]): T[];

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/helpers.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueSort = exports.compareDocumentPosition = exports.DocumentPosition = exports.removeSubsets = void 0;
+const Node_js_1 = require("../Node.js");
+/**
+ * Given an array of nodes, remove any member that is contained by another.
+ *
+ * @param nodes Nodes to filter.
+ * @returns Remaining nodes that aren't subtrees of each other.
+ */
+function removeSubsets(nodes) {
+    let idx = nodes.length;
+    /*
+     * Check if each node (or one of its ancestors) is already contained in the
+     * array.
+     */
+    while (--idx >= 0) {
+        const node = nodes[idx];
+        /*
+         * 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 (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
+            nodes.splice(idx, 1);
+            continue;
+        }
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+            if (nodes.includes(ancestor)) {
+                nodes.splice(idx, 1);
+                break;
+            }
+        }
+    }
+    return nodes;
+}
+exports.removeSubsets = removeSubsets;
+// Source: http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
+var DocumentPosition;
+(function (DocumentPosition) {
+    DocumentPosition[DocumentPosition["DISCONNECTED"] = 1] = "DISCONNECTED";
+    DocumentPosition[DocumentPosition["PRECEDING"] = 2] = "PRECEDING";
+    DocumentPosition[DocumentPosition["FOLLOWING"] = 4] = "FOLLOWING";
+    DocumentPosition[DocumentPosition["CONTAINS"] = 8] = "CONTAINS";
+    DocumentPosition[DocumentPosition["CONTAINED_BY"] = 16] = "CONTAINED_BY";
+})(DocumentPosition || (exports.DocumentPosition = DocumentPosition = {}));
+/**
+ * Compare the position of one node against another node in any other document.
+ * The return value is a bitmask with the following values:
+ *
+ * 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
+ *
+ * @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.
+ */
+function compareDocumentPosition(nodeA, nodeB) {
+    const aParents = [];
+    const bParents = [];
+    if (nodeA === nodeB) {
+        return 0;
+    }
+    let current = (0, Node_js_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
+    while (current) {
+        aParents.unshift(current);
+        current = current.parent;
+    }
+    current = (0, Node_js_1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
+    while (current) {
+        bParents.unshift(current);
+        current = current.parent;
+    }
+    const maxIdx = Math.min(aParents.length, bParents.length);
+    let idx = 0;
+    while (idx < maxIdx && aParents[idx] === bParents[idx]) {
+        idx++;
+    }
+    if (idx === 0) {
+        return DocumentPosition.DISCONNECTED;
+    }
+    const sharedParent = aParents[idx - 1];
+    const siblings = sharedParent.children;
+    const aSibling = aParents[idx];
+    const bSibling = bParents[idx];
+    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;
+}
+exports.compareDocumentPosition = compareDocumentPosition;
+/**
+ * Sort an array of nodes based on their relative position in the document and
+ * remove any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
+ *
+ * @param nodes Array of DOM nodes.
+ * @returns Collection of unique nodes, sorted in document order.
+ */
+function uniqueSort(nodes) {
+    nodes = nodes.filter((node, i, arr) => !arr.includes(node, i + 1));
+    nodes.sort((a, b) => {
+        const relative = compareDocumentPosition(a, b);
+        if (relative & DocumentPosition.PRECEDING) {
+            return -1;
+        }
+        else if (relative & DocumentPosition.FOLLOWING) {
+            return 1;
+        }
+        return 0;
+    });
+    return nodes;
+}
+exports.uniqueSort = uniqueSort;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/utils/legacy.d.ts

@@ -0,0 +1,46 @@
+import { Node, Element } from '../Node.js';
+import { ElementType } from '../ElementType.js';
+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);
+}
+/**
+ * @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 declare function testElement(options: TestElementOpts, node: Node): boolean;
+/**
+ * @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 declare function getElements(options: TestElementOpts, nodes: Node | Node[], recurse: boolean, limit?: number): Node[];
+/**
+ * @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 declare function getElementById(id: string | ((id: string) => boolean), nodes: Node | Node[], recurse?: boolean): Element | null;
+/**
+ * @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 declare function getElementsByTagName(tagName: string | ((name: string) => boolean), nodes: Node | Node[], recurse?: boolean, limit?: number): Element[];
+/**
+ * @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 declare function getElementsByTagType(type: ElementType | ((type: ElementType) => boolean), nodes: Node | Node[], recurse?: boolean, limit?: number): Node[];
+export {};