{"version":3,"file":"npm.domutils.js","mappings":"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","sources":["webpack://giveeasy.cloud/./node_modules/domutils/lib/helpers.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/index.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/legacy.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/manipulation.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/querying.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/stringify.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/tagtypes.js","webpack://giveeasy.cloud/./node_modules/domutils/lib/traversal.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.uniqueSort = exports.compareDocumentPosition = exports.removeSubsets = void 0;\nvar tagtypes_1 = require(\"./tagtypes\");\n/**\n * Given an array of nodes, remove any member that is contained by another.\n *\n * @param nodes Nodes to filter.\n * @returns Remaining nodes that aren't subtrees of each other.\n */\nfunction removeSubsets(nodes) {\n    var idx = nodes.length;\n    /*\n     * Check if each node (or one of its ancestors) is already contained in the\n     * array.\n     */\n    while (--idx >= 0) {\n        var node = nodes[idx];\n        /*\n         * Remove the node if it is not unique.\n         * We are going through the array from the end, so we only\n         * have to check nodes that preceed the node under consideration in the array.\n         */\n        if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {\n            nodes.splice(idx, 1);\n            continue;\n        }\n        for (var ancestor = node.parent; ancestor; ancestor = ancestor.parent) {\n            if (nodes.includes(ancestor)) {\n                nodes.splice(idx, 1);\n                break;\n            }\n        }\n    }\n    return nodes;\n}\nexports.removeSubsets = removeSubsets;\n/**\n * Compare the position of one node against another node in any other document.\n * The return value is a bitmask with the following values:\n *\n * Document order:\n * > There is an ordering, document order, defined on all the nodes in the\n * > document corresponding to the order in which the first character of the\n * > XML representation of each node occurs in the XML representation of the\n * > document after expansion of general entities. Thus, the document element\n * > node will be the first node. Element nodes occur before their children.\n * > Thus, document order orders element nodes in order of the occurrence of\n * > their start-tag in the XML (after expansion of entities). The attribute\n * > nodes of an element occur after the element and before its children. The\n * > relative order of attribute nodes is implementation-dependent./\n *\n * Source:\n * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order\n *\n * @param nodeA The first node to use in the comparison\n * @param nodeB The second node to use in the comparison\n * @returns A bitmask describing the input nodes' relative position.\n *\n * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for\n * a description of these values.\n */\nfunction compareDocumentPosition(nodeA, nodeB) {\n    var aParents = [];\n    var bParents = [];\n    if (nodeA === nodeB) {\n        return 0;\n    }\n    var current = tagtypes_1.hasChildren(nodeA) ? nodeA : nodeA.parent;\n    while (current) {\n        aParents.unshift(current);\n        current = current.parent;\n    }\n    current = tagtypes_1.hasChildren(nodeB) ? nodeB : nodeB.parent;\n    while (current) {\n        bParents.unshift(current);\n        current = current.parent;\n    }\n    var maxIdx = Math.min(aParents.length, bParents.length);\n    var idx = 0;\n    while (idx < maxIdx && aParents[idx] === bParents[idx]) {\n        idx++;\n    }\n    if (idx === 0) {\n        return 1 /* DISCONNECTED */;\n    }\n    var sharedParent = aParents[idx - 1];\n    var siblings = sharedParent.children;\n    var aSibling = aParents[idx];\n    var bSibling = bParents[idx];\n    if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {\n        if (sharedParent === nodeB) {\n            return 4 /* FOLLOWING */ | 16 /* CONTAINED_BY */;\n        }\n        return 4 /* FOLLOWING */;\n    }\n    if (sharedParent === nodeA) {\n        return 2 /* PRECEDING */ | 8 /* CONTAINS */;\n    }\n    return 2 /* PRECEDING */;\n}\nexports.compareDocumentPosition = compareDocumentPosition;\n/**\n * Sort an array of nodes based on their relative position in the document and\n * remove any duplicate nodes. If the array contains nodes that do not belong\n * to the same document, sort order is unspecified.\n *\n * @param nodes Array of DOM nodes.\n * @returns Collection of unique nodes, sorted in document order.\n */\nfunction uniqueSort(nodes) {\n    nodes = nodes.filter(function (node, i, arr) { return !arr.includes(node, i + 1); });\n    nodes.sort(function (a, b) {\n        var relative = compareDocumentPosition(a, b);\n        if (relative & 2 /* PRECEDING */) {\n            return -1;\n        }\n        else if (relative & 4 /* FOLLOWING */) {\n            return 1;\n        }\n        return 0;\n    });\n    return nodes;\n}\nexports.uniqueSort = uniqueSort;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./stringify\"), exports);\n__exportStar(require(\"./traversal\"), exports);\n__exportStar(require(\"./manipulation\"), exports);\n__exportStar(require(\"./querying\"), exports);\n__exportStar(require(\"./legacy\"), exports);\n__exportStar(require(\"./helpers\"), exports);\n__exportStar(require(\"./tagtypes\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getElementsByTagType = exports.getElementsByTagName = exports.getElementById = exports.getElements = exports.testElement = void 0;\nvar querying_1 = require(\"./querying\");\nvar tagtypes_1 = require(\"./tagtypes\");\nvar Checks = {\n    tag_name: function (name) {\n        if (typeof name === \"function\") {\n            return function (elem) { return tagtypes_1.isTag(elem) && name(elem.name); };\n        }\n        else if (name === \"*\") {\n            return tagtypes_1.isTag;\n        }\n        return function (elem) { return tagtypes_1.isTag(elem) && elem.name === name; };\n    },\n    tag_type: function (type) {\n        if (typeof type === \"function\") {\n            return function (elem) { return type(elem.type); };\n        }\n        return function (elem) { return elem.type === type; };\n    },\n    tag_contains: function (data) {\n        if (typeof data === \"function\") {\n            return function (elem) { return tagtypes_1.isText(elem) && data(elem.data); };\n        }\n        return function (elem) { return tagtypes_1.isText(elem) && elem.data === data; };\n    },\n};\n/**\n * @param attrib Attribute to check.\n * @param value Attribute value to look for.\n * @returns A function to check whether the a node has an attribute with a particular value.\n */\nfunction getAttribCheck(attrib, value) {\n    if (typeof value === \"function\") {\n        return function (elem) { return tagtypes_1.isTag(elem) && value(elem.attribs[attrib]); };\n    }\n    return function (elem) { return tagtypes_1.isTag(elem) && elem.attribs[attrib] === value; };\n}\n/**\n * @param a First function to combine.\n * @param b Second function to combine.\n * @returns A function taking a node and returning `true` if either\n * of the input functions returns `true` for the node.\n */\nfunction combineFuncs(a, b) {\n    return function (elem) { return a(elem) || b(elem); };\n}\n/**\n * @param options An object describing nodes to look for.\n * @returns A function executing all checks in `options` and returning `true`\n * if any of them match a node.\n */\nfunction compileTest(options) {\n    var funcs = Object.keys(options).map(function (key) {\n        var value = options[key];\n        return key in Checks\n            ? Checks[key](value)\n            : getAttribCheck(key, value);\n    });\n    return funcs.length === 0 ? null : funcs.reduce(combineFuncs);\n}\n/**\n * @param options An object describing nodes to look for.\n * @param node The element to test.\n * @returns Whether the element matches the description in `options`.\n */\nfunction testElement(options, node) {\n    var test = compileTest(options);\n    return test ? test(node) : true;\n}\nexports.testElement = testElement;\n/**\n * @param options An object describing nodes to look for.\n * @param nodes Nodes to search through.\n * @param recurse Also consider child nodes.\n * @param limit Maximum number of nodes to return.\n * @returns All nodes that match `options`.\n */\nfunction getElements(options, nodes, recurse, limit) {\n    if (limit === void 0) { limit = Infinity; }\n    var test = compileTest(options);\n    return test ? querying_1.filter(test, nodes, recurse, limit) : [];\n}\nexports.getElements = getElements;\n/**\n * @param id The unique ID attribute value to look for.\n * @param nodes Nodes to search through.\n * @param recurse Also consider child nodes.\n * @returns The node with the supplied ID.\n */\nfunction getElementById(id, nodes, recurse) {\n    if (recurse === void 0) { recurse = true; }\n    if (!Array.isArray(nodes))\n        nodes = [nodes];\n    return querying_1.findOne(getAttribCheck(\"id\", id), nodes, recurse);\n}\nexports.getElementById = getElementById;\n/**\n * @param tagName Tag name to search for.\n * @param nodes Nodes to search through.\n * @param recurse Also consider child nodes.\n * @param limit Maximum number of nodes to return.\n * @returns All nodes with the supplied `tagName`.\n */\nfunction getElementsByTagName(tagName, nodes, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    return querying_1.filter(Checks.tag_name(tagName), nodes, recurse, limit);\n}\nexports.getElementsByTagName = getElementsByTagName;\n/**\n * @param type Element type to look for.\n * @param nodes Nodes to search through.\n * @param recurse Also consider child nodes.\n * @param limit Maximum number of nodes to return.\n * @returns All nodes with the supplied `type`.\n */\nfunction getElementsByTagType(type, nodes, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    return querying_1.filter(Checks.tag_type(type), nodes, recurse, limit);\n}\nexports.getElementsByTagType = getElementsByTagType;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.prepend = exports.prependChild = exports.append = exports.appendChild = exports.replaceElement = exports.removeElement = void 0;\n/**\n * Remove an element from the dom\n *\n * @param elem The element to be removed\n */\nfunction removeElement(elem) {\n    if (elem.prev)\n        elem.prev.next = elem.next;\n    if (elem.next)\n        elem.next.prev = elem.prev;\n    if (elem.parent) {\n        var childs = elem.parent.children;\n        childs.splice(childs.lastIndexOf(elem), 1);\n    }\n}\nexports.removeElement = removeElement;\n/**\n * Replace an element in the dom\n *\n * @param elem The element to be replaced\n * @param replacement The element to be added\n */\nfunction replaceElement(elem, replacement) {\n    var prev = (replacement.prev = elem.prev);\n    if (prev) {\n        prev.next = replacement;\n    }\n    var next = (replacement.next = elem.next);\n    if (next) {\n        next.prev = replacement;\n    }\n    var parent = (replacement.parent = elem.parent);\n    if (parent) {\n        var childs = parent.children;\n        childs[childs.lastIndexOf(elem)] = replacement;\n    }\n}\nexports.replaceElement = replaceElement;\n/**\n * Append a child to an element.\n *\n * @param elem The element to append to.\n * @param child The element to be added as a child.\n */\nfunction appendChild(elem, child) {\n    removeElement(child);\n    child.next = null;\n    child.parent = elem;\n    if (elem.children.push(child) > 1) {\n        var sibling = elem.children[elem.children.length - 2];\n        sibling.next = child;\n        child.prev = sibling;\n    }\n    else {\n        child.prev = null;\n    }\n}\nexports.appendChild = appendChild;\n/**\n * Append an element after another.\n *\n * @param elem The element to append after.\n * @param next The element be added.\n */\nfunction append(elem, next) {\n    removeElement(next);\n    var parent = elem.parent;\n    var currNext = elem.next;\n    next.next = currNext;\n    next.prev = elem;\n    elem.next = next;\n    next.parent = parent;\n    if (currNext) {\n        currNext.prev = next;\n        if (parent) {\n            var childs = parent.children;\n            childs.splice(childs.lastIndexOf(currNext), 0, next);\n        }\n    }\n    else if (parent) {\n        parent.children.push(next);\n    }\n}\nexports.append = append;\n/**\n * Prepend a child to an element.\n *\n * @param elem The element to prepend before.\n * @param child The element to be added as a child.\n */\nfunction prependChild(elem, child) {\n    removeElement(child);\n    child.parent = elem;\n    child.prev = null;\n    if (elem.children.unshift(child) !== 1) {\n        var sibling = elem.children[1];\n        sibling.prev = child;\n        child.next = sibling;\n    }\n    else {\n        child.next = null;\n    }\n}\nexports.prependChild = prependChild;\n/**\n * Prepend an element before another.\n *\n * @param elem The element to prepend before.\n * @param prev The element be added.\n */\nfunction prepend(elem, prev) {\n    removeElement(prev);\n    var parent = elem.parent;\n    if (parent) {\n        var childs = parent.children;\n        childs.splice(childs.indexOf(elem), 0, prev);\n    }\n    if (elem.prev) {\n        elem.prev.next = prev;\n    }\n    prev.parent = parent;\n    prev.prev = elem.prev;\n    prev.next = elem;\n    elem.prev = prev;\n}\nexports.prepend = prepend;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.findAll = exports.existsOne = exports.findOne = exports.findOneChild = exports.find = exports.filter = void 0;\nvar tagtypes_1 = require(\"./tagtypes\");\n/**\n * Search a node and its children for nodes passing a test function.\n *\n * @param test Function to test nodes on.\n * @param node Node to search. Will be included in the result set if it matches.\n * @param recurse Also consider child nodes.\n * @param limit Maximum number of nodes to return.\n * @returns All nodes passing `test`.\n */\nfunction filter(test, node, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    if (!Array.isArray(node))\n        node = [node];\n    return find(test, node, recurse, limit);\n}\nexports.filter = filter;\n/**\n * Search an array of node and its children for nodes passing a test function.\n *\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @param recurse Also consider child nodes.\n * @param limit Maximum number of nodes to return.\n * @returns All nodes passing `test`.\n */\nfunction find(test, nodes, recurse, limit) {\n    var result = [];\n    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {\n        var elem = nodes_1[_i];\n        if (test(elem)) {\n            result.push(elem);\n            if (--limit <= 0)\n                break;\n        }\n        if (recurse && tagtypes_1.hasChildren(elem) && elem.children.length > 0) {\n            var children = find(test, elem.children, recurse, limit);\n            result.push.apply(result, children);\n            limit -= children.length;\n            if (limit <= 0)\n                break;\n        }\n    }\n    return result;\n}\nexports.find = find;\n/**\n * Finds the first element inside of an array that matches a test function.\n *\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @returns The first node in the array that passes `test`.\n */\nfunction findOneChild(test, nodes) {\n    return nodes.find(test);\n}\nexports.findOneChild = findOneChild;\n/**\n * Finds one element in a tree that passes a test.\n *\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @param recurse Also consider child nodes.\n * @returns The first child node that passes `test`.\n */\nfunction findOne(test, nodes, recurse) {\n    if (recurse === void 0) { recurse = true; }\n    var elem = null;\n    for (var i = 0; i < nodes.length && !elem; i++) {\n        var checked = nodes[i];\n        if (!tagtypes_1.isTag(checked)) {\n            continue;\n        }\n        else if (test(checked)) {\n            elem = checked;\n        }\n        else if (recurse && checked.children.length > 0) {\n            elem = findOne(test, checked.children);\n        }\n    }\n    return elem;\n}\nexports.findOne = findOne;\n/**\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @returns Whether a tree of nodes contains at least one node passing a test.\n */\nfunction existsOne(test, nodes) {\n    return nodes.some(function (checked) {\n        return tagtypes_1.isTag(checked) &&\n            (test(checked) ||\n                (checked.children.length > 0 &&\n                    existsOne(test, checked.children)));\n    });\n}\nexports.existsOne = existsOne;\n/**\n * Search and array of nodes and its children for nodes passing a test function.\n *\n * Same as `find`, only with less options, leading to reduced complexity.\n *\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @returns All nodes passing `test`.\n */\nfunction findAll(test, nodes) {\n    var _a;\n    var result = [];\n    var stack = nodes.filter(tagtypes_1.isTag);\n    var elem;\n    while ((elem = stack.shift())) {\n        var children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(tagtypes_1.isTag);\n        if (children && children.length > 0) {\n            stack.unshift.apply(stack, children);\n        }\n        if (test(elem))\n            result.push(elem);\n    }\n    return result;\n}\nexports.findAll = findAll;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getText = exports.getInnerHTML = exports.getOuterHTML = void 0;\nvar tagtypes_1 = require(\"./tagtypes\");\nvar dom_serializer_1 = __importDefault(require(\"dom-serializer\"));\n/**\n * @param node Node to get the outer HTML of.\n * @param options Options for serialization.\n * @deprecated Use the `dom-serializer` module directly.\n * @returns `node`'s outer HTML.\n */\nfunction getOuterHTML(node, options) {\n    return dom_serializer_1.default(node, options);\n}\nexports.getOuterHTML = getOuterHTML;\n/**\n * @param node Node to get the inner HTML of.\n * @param options Options for serialization.\n * @deprecated Use the `dom-serializer` module directly.\n * @returns `node`'s inner HTML.\n */\nfunction getInnerHTML(node, options) {\n    return tagtypes_1.hasChildren(node)\n        ? node.children.map(function (node) { return getOuterHTML(node, options); }).join(\"\")\n        : \"\";\n}\nexports.getInnerHTML = getInnerHTML;\n/**\n * Get a node's inner text.\n *\n * @param node Node to get the inner text of.\n * @returns `node`'s inner text.\n */\nfunction getText(node) {\n    if (Array.isArray(node))\n        return node.map(getText).join(\"\");\n    if (tagtypes_1.isTag(node))\n        return node.name === \"br\" ? \"\\n\" : getText(node.children);\n    if (tagtypes_1.isCDATA(node))\n        return getText(node.children);\n    if (tagtypes_1.isText(node))\n        return node.data;\n    return \"\";\n}\nexports.getText = getText;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hasChildren = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `Element`, `false` otherwise.\n */\nfunction isTag(node) {\n    return domelementtype_1.isTag(node);\n}\nexports.isTag = isTag;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `NodeWithChildren`, `false` otherwise.\n */\nfunction isCDATA(node) {\n    return node.type === \"cdata\" /* CDATA */;\n}\nexports.isCDATA = isCDATA;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `DataNode`, `false` otherwise.\n */\nfunction isText(node) {\n    return node.type === \"text\" /* Text */;\n}\nexports.isText = isText;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `DataNode`, `false` otherwise.\n */\nfunction isComment(node) {\n    return node.type === \"comment\" /* Comment */;\n}\nexports.isComment = isComment;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `NodeWithChildren` (has children), `false` otherwise.\n */\nfunction hasChildren(node) {\n    return Object.prototype.hasOwnProperty.call(node, \"children\");\n}\nexports.hasChildren = hasChildren;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.nextElementSibling = exports.getName = exports.hasAttrib = exports.getAttributeValue = exports.getSiblings = exports.getParent = exports.getChildren = void 0;\nvar tagtypes_1 = require(\"./tagtypes\");\nvar emptyArray = [];\n/**\n * Get a node's children.\n *\n * @param elem Node to get the children of.\n * @returns `elem`'s children, or an empty array.\n */\nfunction getChildren(elem) {\n    var _a;\n    return (_a = elem.children) !== null && _a !== void 0 ? _a : emptyArray;\n}\nexports.getChildren = getChildren;\n/**\n * Get a node's parent.\n *\n * @param elem Node to get the parent of.\n * @returns `elem`'s parent node.\n */\nfunction getParent(elem) {\n    return elem.parent || null;\n}\nexports.getParent = getParent;\n/**\n * Gets an elements siblings, including the element itself.\n *\n * Attempts to get the children through the element's parent first.\n * If we don't have a parent (the element is a root node),\n * we walk the element's `prev` & `next` to get all remaining nodes.\n *\n * @param elem Element to get the siblings of.\n * @returns `elem`'s siblings.\n */\nfunction getSiblings(elem) {\n    var _a, _b;\n    var parent = getParent(elem);\n    if (parent != null)\n        return getChildren(parent);\n    var siblings = [elem];\n    var prev = elem.prev, next = elem.next;\n    while (prev != null) {\n        siblings.unshift(prev);\n        (_a = prev, prev = _a.prev);\n    }\n    while (next != null) {\n        siblings.push(next);\n        (_b = next, next = _b.next);\n    }\n    return siblings;\n}\nexports.getSiblings = getSiblings;\n/**\n * Gets an attribute from an element.\n *\n * @param elem Element to check.\n * @param name Attribute name to retrieve.\n * @returns The element's attribute value, or `undefined`.\n */\nfunction getAttributeValue(elem, name) {\n    var _a;\n    return (_a = elem.attribs) === null || _a === void 0 ? void 0 : _a[name];\n}\nexports.getAttributeValue = getAttributeValue;\n/**\n * Checks whether an element has an attribute.\n *\n * @param elem Element to check.\n * @param name Attribute name to look for.\n * @returns Returns whether `elem` has the attribute `name`.\n */\nfunction hasAttrib(elem, name) {\n    return (elem.attribs != null &&\n        Object.prototype.hasOwnProperty.call(elem.attribs, name) &&\n        elem.attribs[name] != null);\n}\nexports.hasAttrib = hasAttrib;\n/**\n * Get the tag name of an element.\n *\n * @param elem The element to get the name for.\n * @returns The tag name of `elem`.\n */\nfunction getName(elem) {\n    return elem.name;\n}\nexports.getName = getName;\n/**\n * Returns the next element sibling of a node.\n *\n * @param elem The element to get the next sibling of.\n * @returns `elem`'s next sibling that is a tag.\n */\nfunction nextElementSibling(elem) {\n    var _a;\n    var next = elem.next;\n    while (next !== null && !tagtypes_1.isTag(next))\n        (_a = next, next = _a.next);\n    return next;\n}\nexports.nextElementSibling = nextElementSibling;\n"],"names":["Object","defineProperty","exports","value","uniqueSort","compareDocumentPosition","removeSubsets","tagtypes_1","nodeA","nodeB","aParents","bParents","current","hasChildren","parent","unshift","maxIdx","Math","min","length","idx","sharedParent","siblings","children","aSibling","bSibling","indexOf","nodes","node","lastIndexOf","splice","ancestor","includes","filter","i","arr","sort","a","b","relative","__createBinding","this","create","o","m","k","k2","undefined","enumerable","get","__exportStar","p","prototype","hasOwnProperty","call","getElementsByTagType","getElementsByTagName","getElementById","getElements","testElement","querying_1","Checks","tag_name","name","elem","isTag","tag_type","type","tag_contains","data","isText","getAttribCheck","attrib","attribs","combineFuncs","compileTest","options","funcs","keys","map","key","reduce","test","recurse","limit","Infinity","id","Array","isArray","findOne","tagName","removeElement","prev","next","childs","prepend","prependChild","append","appendChild","replaceElement","replacement","child","push","sibling","currNext","findAll","existsOne","findOneChild","find","result","_i","nodes_1","apply","checked","some","_a","stack","shift","__importDefault","mod","__esModule","getText","getInnerHTML","getOuterHTML","dom_serializer_1","default","join","isCDATA","isComment","domelementtype_1","nextElementSibling","getName","hasAttrib","getAttributeValue","getSiblings","getParent","getChildren","emptyArray"],"sourceRoot":""}