{"version":3,"sources":["webpack:///./node_modules/domutils/lib/traversal.js","webpack:///./node_modules/domutils/lib/stringify.js","webpack:///./node_modules/domutils/lib/querying.js","webpack:///./node_modules/domutils/lib/manipulation.js","webpack:///./node_modules/domutils/lib/feeds.js","webpack:///./node_modules/domutils/lib/legacy.js","webpack:///./node_modules/domutils/lib/index.js","webpack:///./node_modules/domutils/lib/helpers.js"],"names":["Object","defineProperty","exports","value","prevElementSibling","nextElementSibling","getName","hasAttrib","getAttributeValue","getSiblings","getParent","getChildren","domhandler_1","emptyArray","elem","_a","children","parent","_b","siblings","prev","next","unshift","push","name","attribs","prototype","hasOwnProperty","call","isTag","__importDefault","this","mod","__esModule","innerText","textContent","getText","getInnerHTML","getOuterHTML","dom_serializer_1","domelementtype_1","node","options","default","hasChildren","map","join","Array","isArray","isCDATA","isText","data","isComment","type","ElementType","Tag","findAll","existsOne","findOne","findOneChild","find","filter","test","recurse","limit","Infinity","nodes","result","_i","nodes_1","length","apply","i","checked","some","stack","shift","removeElement","childs","splice","lastIndexOf","replaceElement","replacement","appendChild","child","sibling","append","currNext","prependChild","prepend","indexOf","getFeed","stringify_1","legacy_1","doc","feedRoot","getOneElement","isValidFeed","getAtomFeed","getRssFeed","feed","items","getElementsByTagName","item","entry","media","getMediaElements","addConditionally","href","link","description","fetch","pubDate","Date","updated","substr","id","MEDIA_KEYS_STRING","MEDIA_KEYS_INT","where","medium","isDefault","MEDIA_KEYS_STRING_1","attrib","MEDIA_KEYS_INT_1","parseInt","expression","tagName","trim","obj","prop","val","getElementsByTagType","getElementById","getElements","testElement","querying_1","Checks","tag_name","tag_type","tag_contains","getAttribCheck","combineFuncs","a","b","compileTest","funcs","keys","key","reduce","__createBinding","create","o","m","k","k2","undefined","enumerable","get","__exportStar","p","isDocument","uniqueSort","compareDocumentPosition","removeSubsets","idx","ancestor","includes","nodeA","nodeB","aParents","bParents","current","maxIdx","Math","min","sharedParent","aSibling","bSibling","arr","sort","relative"],"mappings":"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","file":"js/npm.domutils.e3c69eda.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.prevElementSibling = exports.nextElementSibling = exports.getName = exports.hasAttrib = exports.getAttributeValue = exports.getSiblings = exports.getParent = exports.getChildren = void 0;\nvar domhandler_1 = require(\"domhandler\");\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 && !(0, domhandler_1.isTag)(next))\n        (_a = next, next = _a.next);\n    return next;\n}\nexports.nextElementSibling = nextElementSibling;\n/**\n * Returns the previous element sibling of a node.\n *\n * @param elem The element to get the previous sibling of.\n * @returns `elem`'s previous sibling that is a tag.\n */\nfunction prevElementSibling(elem) {\n    var _a;\n    var prev = elem.prev;\n    while (prev !== null && !(0, domhandler_1.isTag)(prev))\n        (_a = prev, prev = _a.prev);\n    return prev;\n}\nexports.prevElementSibling = prevElementSibling;\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.innerText = exports.textContent = exports.getText = exports.getInnerHTML = exports.getOuterHTML = void 0;\nvar domhandler_1 = require(\"domhandler\");\nvar dom_serializer_1 = __importDefault(require(\"dom-serializer\"));\nvar domelementtype_1 = require(\"domelementtype\");\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 (0, 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 (0, domhandler_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. Same as `textContent`, but inserts newlines for `<br>` tags.\n *\n * @deprecated Use `textContent` instead.\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 ((0, domhandler_1.isTag)(node))\n        return node.name === \"br\" ? \"\\n\" : getText(node.children);\n    if ((0, domhandler_1.isCDATA)(node))\n        return getText(node.children);\n    if ((0, domhandler_1.isText)(node))\n        return node.data;\n    return \"\";\n}\nexports.getText = getText;\n/**\n * Get a node's text content.\n *\n * @param node Node to get the text content of.\n * @returns `node`'s text content.\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent}\n */\nfunction textContent(node) {\n    if (Array.isArray(node))\n        return node.map(textContent).join(\"\");\n    if ((0, domhandler_1.hasChildren)(node) && !(0, domhandler_1.isComment)(node)) {\n        return textContent(node.children);\n    }\n    if ((0, domhandler_1.isText)(node))\n        return node.data;\n    return \"\";\n}\nexports.textContent = textContent;\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 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/innerText}\n */\nfunction innerText(node) {\n    if (Array.isArray(node))\n        return node.map(innerText).join(\"\");\n    if ((0, domhandler_1.hasChildren)(node) && (node.type === domelementtype_1.ElementType.Tag || (0, domhandler_1.isCDATA)(node))) {\n        return innerText(node.children);\n    }\n    if ((0, domhandler_1.isText)(node))\n        return node.data;\n    return \"\";\n}\nexports.innerText = innerText;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.findAll = exports.existsOne = exports.findOne = exports.findOneChild = exports.find = exports.filter = void 0;\nvar domhandler_1 = require(\"domhandler\");\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 && (0, domhandler_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 (!(0, domhandler_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 (0, domhandler_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(domhandler_1.isTag);\n    var elem;\n    while ((elem = stack.shift())) {\n        var children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(domhandler_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\";\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.getFeed = void 0;\nvar stringify_1 = require(\"./stringify\");\nvar legacy_1 = require(\"./legacy\");\n/**\n * Get the feed object from the root of a DOM tree.\n *\n * @param doc - The DOM to to extract the feed from.\n * @returns The feed.\n */\nfunction getFeed(doc) {\n    var feedRoot = getOneElement(isValidFeed, doc);\n    return !feedRoot\n        ? null\n        : feedRoot.name === \"feed\"\n            ? getAtomFeed(feedRoot)\n            : getRssFeed(feedRoot);\n}\nexports.getFeed = getFeed;\n/**\n * Parse an Atom feed.\n *\n * @param feedRoot The root of the feed.\n * @returns The parsed feed.\n */\nfunction getAtomFeed(feedRoot) {\n    var _a;\n    var childs = feedRoot.children;\n    var feed = {\n        type: \"atom\",\n        items: (0, legacy_1.getElementsByTagName)(\"entry\", childs).map(function (item) {\n            var _a;\n            var children = item.children;\n            var entry = { media: getMediaElements(children) };\n            addConditionally(entry, \"id\", \"id\", children);\n            addConditionally(entry, \"title\", \"title\", children);\n            var href = (_a = getOneElement(\"link\", children)) === null || _a === void 0 ? void 0 : _a.attribs.href;\n            if (href) {\n                entry.link = href;\n            }\n            var description = fetch(\"summary\", children) || fetch(\"content\", children);\n            if (description) {\n                entry.description = description;\n            }\n            var pubDate = fetch(\"updated\", children);\n            if (pubDate) {\n                entry.pubDate = new Date(pubDate);\n            }\n            return entry;\n        }),\n    };\n    addConditionally(feed, \"id\", \"id\", childs);\n    addConditionally(feed, \"title\", \"title\", childs);\n    var href = (_a = getOneElement(\"link\", childs)) === null || _a === void 0 ? void 0 : _a.attribs.href;\n    if (href) {\n        feed.link = href;\n    }\n    addConditionally(feed, \"description\", \"subtitle\", childs);\n    var updated = fetch(\"updated\", childs);\n    if (updated) {\n        feed.updated = new Date(updated);\n    }\n    addConditionally(feed, \"author\", \"email\", childs, true);\n    return feed;\n}\n/**\n * Parse a RSS feed.\n *\n * @param feedRoot The root of the feed.\n * @returns The parsed feed.\n */\nfunction getRssFeed(feedRoot) {\n    var _a, _b;\n    var childs = (_b = (_a = getOneElement(\"channel\", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];\n    var feed = {\n        type: feedRoot.name.substr(0, 3),\n        id: \"\",\n        items: (0, legacy_1.getElementsByTagName)(\"item\", feedRoot.children).map(function (item) {\n            var children = item.children;\n            var entry = { media: getMediaElements(children) };\n            addConditionally(entry, \"id\", \"guid\", children);\n            addConditionally(entry, \"title\", \"title\", children);\n            addConditionally(entry, \"link\", \"link\", children);\n            addConditionally(entry, \"description\", \"description\", children);\n            var pubDate = fetch(\"pubDate\", children);\n            if (pubDate)\n                entry.pubDate = new Date(pubDate);\n            return entry;\n        }),\n    };\n    addConditionally(feed, \"title\", \"title\", childs);\n    addConditionally(feed, \"link\", \"link\", childs);\n    addConditionally(feed, \"description\", \"description\", childs);\n    var updated = fetch(\"lastBuildDate\", childs);\n    if (updated) {\n        feed.updated = new Date(updated);\n    }\n    addConditionally(feed, \"author\", \"managingEditor\", childs, true);\n    return feed;\n}\nvar MEDIA_KEYS_STRING = [\"url\", \"type\", \"lang\"];\nvar MEDIA_KEYS_INT = [\n    \"fileSize\",\n    \"bitrate\",\n    \"framerate\",\n    \"samplingrate\",\n    \"channels\",\n    \"duration\",\n    \"height\",\n    \"width\",\n];\n/**\n * Get all media elements of a feed item.\n *\n * @param where Nodes to search in.\n * @returns Media elements.\n */\nfunction getMediaElements(where) {\n    return (0, legacy_1.getElementsByTagName)(\"media:content\", where).map(function (elem) {\n        var attribs = elem.attribs;\n        var media = {\n            medium: attribs.medium,\n            isDefault: !!attribs.isDefault,\n        };\n        for (var _i = 0, MEDIA_KEYS_STRING_1 = MEDIA_KEYS_STRING; _i < MEDIA_KEYS_STRING_1.length; _i++) {\n            var attrib = MEDIA_KEYS_STRING_1[_i];\n            if (attribs[attrib]) {\n                media[attrib] = attribs[attrib];\n            }\n        }\n        for (var _a = 0, MEDIA_KEYS_INT_1 = MEDIA_KEYS_INT; _a < MEDIA_KEYS_INT_1.length; _a++) {\n            var attrib = MEDIA_KEYS_INT_1[_a];\n            if (attribs[attrib]) {\n                media[attrib] = parseInt(attribs[attrib], 10);\n            }\n        }\n        if (attribs.expression) {\n            media.expression =\n                attribs.expression;\n        }\n        return media;\n    });\n}\n/**\n * Get one element by tag name.\n *\n * @param tagName Tag name to look for\n * @param node Node to search in\n * @returns The element or null\n */\nfunction getOneElement(tagName, node) {\n    return (0, legacy_1.getElementsByTagName)(tagName, node, true, 1)[0];\n}\n/**\n * Get the text content of an element with a certain tag name.\n *\n * @param tagName Tag name to look for.\n * @param where  Node to search in.\n * @param recurse Whether to recurse into child nodes.\n * @returns The text content of the element.\n */\nfunction fetch(tagName, where, recurse) {\n    if (recurse === void 0) { recurse = false; }\n    return (0, stringify_1.textContent)((0, legacy_1.getElementsByTagName)(tagName, where, recurse, 1)).trim();\n}\n/**\n * Adds a property to an object if it has a value.\n *\n * @param obj Object to be extended\n * @param prop Property name\n * @param tagName Tag name that contains the conditionally added property\n * @param where Element to search for the property\n * @param recurse Whether to recurse into child nodes.\n */\nfunction addConditionally(obj, prop, tagName, where, recurse) {\n    if (recurse === void 0) { recurse = false; }\n    var val = fetch(tagName, where, recurse);\n    if (val)\n        obj[prop] = val;\n}\n/**\n * Checks if an element is a feed root node.\n *\n * @param value The name of the element to check.\n * @returns Whether an element is a feed root node.\n */\nfunction isValidFeed(value) {\n    return value === \"rss\" || value === \"feed\" || value === \"rdf:RDF\";\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getElementsByTagType = exports.getElementsByTagName = exports.getElementById = exports.getElements = exports.testElement = void 0;\nvar domhandler_1 = require(\"domhandler\");\nvar querying_1 = require(\"./querying\");\nvar Checks = {\n    tag_name: function (name) {\n        if (typeof name === \"function\") {\n            return function (elem) { return (0, domhandler_1.isTag)(elem) && name(elem.name); };\n        }\n        else if (name === \"*\") {\n            return domhandler_1.isTag;\n        }\n        return function (elem) { return (0, domhandler_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 (0, domhandler_1.isText)(elem) && data(elem.data); };\n        }\n        return function (elem) { return (0, domhandler_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 (0, domhandler_1.isTag)(elem) && value(elem.attribs[attrib]); };\n    }\n    return function (elem) { return (0, domhandler_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 Object.prototype.hasOwnProperty.call(Checks, key)\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 ? (0, 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 (0, 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 (0, 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 (0, querying_1.filter)(Checks.tag_type(type), nodes, recurse, limit);\n}\nexports.getElementsByTagType = getElementsByTagType;\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 });\nexports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = void 0;\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(\"./feeds\"), exports);\n/** @deprecated Use these methods from `domhandler` directly. */\nvar domhandler_1 = require(\"domhandler\");\nObject.defineProperty(exports, \"isTag\", { enumerable: true, get: function () { return domhandler_1.isTag; } });\nObject.defineProperty(exports, \"isCDATA\", { enumerable: true, get: function () { return domhandler_1.isCDATA; } });\nObject.defineProperty(exports, \"isText\", { enumerable: true, get: function () { return domhandler_1.isText; } });\nObject.defineProperty(exports, \"isComment\", { enumerable: true, get: function () { return domhandler_1.isComment; } });\nObject.defineProperty(exports, \"isDocument\", { enumerable: true, get: function () { return domhandler_1.isDocument; } });\nObject.defineProperty(exports, \"hasChildren\", { enumerable: true, get: function () { return domhandler_1.hasChildren; } });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.uniqueSort = exports.compareDocumentPosition = exports.removeSubsets = void 0;\nvar domhandler_1 = require(\"domhandler\");\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 = (0, domhandler_1.hasChildren)(nodeA) ? nodeA : nodeA.parent;\n    while (current) {\n        aParents.unshift(current);\n        current = current.parent;\n    }\n    current = (0, domhandler_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"],"sourceRoot":""}