{"version":3,"file":"domutils-945e93d1.js","sources":["../../node_modules/domutils/lib/esm/stringify.js","../../node_modules/domutils/lib/esm/traversal.js","../../node_modules/domutils/lib/esm/manipulation.js","../../node_modules/domutils/lib/esm/querying.js","../../node_modules/domutils/lib/esm/legacy.js","../../node_modules/domutils/lib/esm/helpers.js","../../node_modules/domutils/lib/esm/feeds.js"],"sourcesContent":["import { isTag, isCDATA, isText, hasChildren, isComment, } from \"domhandler\";\nimport renderHTML from \"dom-serializer\";\nimport { ElementType } from \"domelementtype\";\n/**\n * @category Stringify\n * @deprecated Use the `dom-serializer` module directly.\n * @param node Node to get the outer HTML of.\n * @param options Options for serialization.\n * @returns `node`'s outer HTML.\n */\nexport function getOuterHTML(node, options) {\n    return renderHTML(node, options);\n}\n/**\n * @category Stringify\n * @deprecated Use the `dom-serializer` module directly.\n * @param node Node to get the inner HTML of.\n * @param options Options for serialization.\n * @returns `node`'s inner HTML.\n */\nexport function getInnerHTML(node, options) {\n    return hasChildren(node)\n        ? node.children.map((node) => getOuterHTML(node, options)).join(\"\")\n        : \"\";\n}\n/**\n * Get a node's inner text. Same as `textContent`, but inserts newlines for `<br>` tags. Ignores comments.\n *\n * @category Stringify\n * @deprecated Use `textContent` instead.\n * @param node Node to get the inner text of.\n * @returns `node`'s inner text.\n */\nexport function getText(node) {\n    if (Array.isArray(node))\n        return node.map(getText).join(\"\");\n    if (isTag(node))\n        return node.name === \"br\" ? \"\\n\" : getText(node.children);\n    if (isCDATA(node))\n        return getText(node.children);\n    if (isText(node))\n        return node.data;\n    return \"\";\n}\n/**\n * Get a node's text content. Ignores comments.\n *\n * @category Stringify\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 */\nexport function textContent(node) {\n    if (Array.isArray(node))\n        return node.map(textContent).join(\"\");\n    if (hasChildren(node) && !isComment(node)) {\n        return textContent(node.children);\n    }\n    if (isText(node))\n        return node.data;\n    return \"\";\n}\n/**\n * Get a node's inner text, ignoring `<script>` and `<style>` tags. Ignores comments.\n *\n * @category Stringify\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 */\nexport function innerText(node) {\n    if (Array.isArray(node))\n        return node.map(innerText).join(\"\");\n    if (hasChildren(node) && (node.type === ElementType.Tag || isCDATA(node))) {\n        return innerText(node.children);\n    }\n    if (isText(node))\n        return node.data;\n    return \"\";\n}\n//# sourceMappingURL=stringify.js.map","import { isTag, hasChildren, } from \"domhandler\";\n/**\n * Get a node's children.\n *\n * @category Traversal\n * @param elem Node to get the children of.\n * @returns `elem`'s children, or an empty array.\n */\nexport function getChildren(elem) {\n    return hasChildren(elem) ? elem.children : [];\n}\n/**\n * Get a node's parent.\n *\n * @category Traversal\n * @param elem Node to get the parent of.\n * @returns `elem`'s parent node, or `null` if `elem` is a root node.\n */\nexport function getParent(elem) {\n    return elem.parent || null;\n}\n/**\n * Gets an elements siblings, including the element itself.\n *\n * Attempts to get the children through the element's parent first. If we don't\n * have a parent (the element is a root node), we walk the element's `prev` &\n * `next` to get all remaining nodes.\n *\n * @category Traversal\n * @param elem Element to get the siblings of.\n * @returns `elem`'s siblings, including `elem`.\n */\nexport function getSiblings(elem) {\n    const parent = getParent(elem);\n    if (parent != null)\n        return getChildren(parent);\n    const siblings = [elem];\n    let { prev, next } = elem;\n    while (prev != null) {\n        siblings.unshift(prev);\n        ({ prev } = prev);\n    }\n    while (next != null) {\n        siblings.push(next);\n        ({ next } = next);\n    }\n    return siblings;\n}\n/**\n * Gets an attribute from an element.\n *\n * @category Traversal\n * @param elem Element to check.\n * @param name Attribute name to retrieve.\n * @returns The element's attribute value, or `undefined`.\n */\nexport function getAttributeValue(elem, name) {\n    var _a;\n    return (_a = elem.attribs) === null || _a === void 0 ? void 0 : _a[name];\n}\n/**\n * Checks whether an element has an attribute.\n *\n * @category Traversal\n * @param elem Element to check.\n * @param name Attribute name to look for.\n * @returns Returns whether `elem` has the attribute `name`.\n */\nexport function hasAttrib(elem, name) {\n    return (elem.attribs != null &&\n        Object.prototype.hasOwnProperty.call(elem.attribs, name) &&\n        elem.attribs[name] != null);\n}\n/**\n * Get the tag name of an element.\n *\n * @category Traversal\n * @param elem The element to get the name for.\n * @returns The tag name of `elem`.\n */\nexport function getName(elem) {\n    return elem.name;\n}\n/**\n * Returns the next element sibling of a node.\n *\n * @category Traversal\n * @param elem The element to get the next sibling of.\n * @returns `elem`'s next sibling that is a tag, or `null` if there is no next\n * sibling.\n */\nexport function nextElementSibling(elem) {\n    let { next } = elem;\n    while (next !== null && !isTag(next))\n        ({ next } = next);\n    return next;\n}\n/**\n * Returns the previous element sibling of a node.\n *\n * @category Traversal\n * @param elem The element to get the previous sibling of.\n * @returns `elem`'s previous sibling that is a tag, or `null` if there is no\n * previous sibling.\n */\nexport function prevElementSibling(elem) {\n    let { prev } = elem;\n    while (prev !== null && !isTag(prev))\n        ({ prev } = prev);\n    return prev;\n}\n//# sourceMappingURL=traversal.js.map","/**\n * Remove an element from the dom\n *\n * @category Manipulation\n * @param elem The element to be removed\n */\nexport function 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        const childs = elem.parent.children;\n        const childsIndex = childs.lastIndexOf(elem);\n        if (childsIndex >= 0) {\n            childs.splice(childsIndex, 1);\n        }\n    }\n    elem.next = null;\n    elem.prev = null;\n    elem.parent = null;\n}\n/**\n * Replace an element in the dom\n *\n * @category Manipulation\n * @param elem The element to be replaced\n * @param replacement The element to be added\n */\nexport function replaceElement(elem, replacement) {\n    const prev = (replacement.prev = elem.prev);\n    if (prev) {\n        prev.next = replacement;\n    }\n    const next = (replacement.next = elem.next);\n    if (next) {\n        next.prev = replacement;\n    }\n    const parent = (replacement.parent = elem.parent);\n    if (parent) {\n        const childs = parent.children;\n        childs[childs.lastIndexOf(elem)] = replacement;\n        elem.parent = null;\n    }\n}\n/**\n * Append a child to an element.\n *\n * @category Manipulation\n * @param parent The element to append to.\n * @param child The element to be added as a child.\n */\nexport function appendChild(parent, child) {\n    removeElement(child);\n    child.next = null;\n    child.parent = parent;\n    if (parent.children.push(child) > 1) {\n        const sibling = parent.children[parent.children.length - 2];\n        sibling.next = child;\n        child.prev = sibling;\n    }\n    else {\n        child.prev = null;\n    }\n}\n/**\n * Append an element after another.\n *\n * @category Manipulation\n * @param elem The element to append after.\n * @param next The element be added.\n */\nexport function append(elem, next) {\n    removeElement(next);\n    const { parent } = elem;\n    const 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            const childs = parent.children;\n            childs.splice(childs.lastIndexOf(currNext), 0, next);\n        }\n    }\n    else if (parent) {\n        parent.children.push(next);\n    }\n}\n/**\n * Prepend a child to an element.\n *\n * @category Manipulation\n * @param parent The element to prepend before.\n * @param child The element to be added as a child.\n */\nexport function prependChild(parent, child) {\n    removeElement(child);\n    child.parent = parent;\n    child.prev = null;\n    if (parent.children.unshift(child) !== 1) {\n        const sibling = parent.children[1];\n        sibling.prev = child;\n        child.next = sibling;\n    }\n    else {\n        child.next = null;\n    }\n}\n/**\n * Prepend an element before another.\n *\n * @category Manipulation\n * @param elem The element to prepend before.\n * @param prev The element be added.\n */\nexport function prepend(elem, prev) {\n    removeElement(prev);\n    const { parent } = elem;\n    if (parent) {\n        const 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}\n//# sourceMappingURL=manipulation.js.map","import { isTag, hasChildren } from \"domhandler\";\n/**\n * Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one.\n *\n * @category Querying\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 */\nexport function filter(test, node, recurse = true, limit = Infinity) {\n    return find(test, Array.isArray(node) ? node : [node], recurse, limit);\n}\n/**\n * Search an array of nodes and their children for nodes passing a test function.\n *\n * @category Querying\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 */\nexport function find(test, nodes, recurse, limit) {\n    const result = [];\n    /** Stack of the arrays we are looking at. */\n    const nodeStack = [nodes];\n    /** Stack of the indices within the arrays. */\n    const indexStack = [0];\n    for (;;) {\n        // First, check if the current array has any more elements to look at.\n        if (indexStack[0] >= nodeStack[0].length) {\n            // If we have no more arrays to look at, we are done.\n            if (indexStack.length === 1) {\n                return result;\n            }\n            // Otherwise, remove the current array from the stack.\n            nodeStack.shift();\n            indexStack.shift();\n            // Loop back to the start to continue with the next array.\n            continue;\n        }\n        const elem = nodeStack[0][indexStack[0]++];\n        if (test(elem)) {\n            result.push(elem);\n            if (--limit <= 0)\n                return result;\n        }\n        if (recurse && hasChildren(elem) && elem.children.length > 0) {\n            /*\n             * Add the children to the stack. We are depth-first, so this is\n             * the next array we look at.\n             */\n            indexStack.unshift(0);\n            nodeStack.unshift(elem.children);\n        }\n    }\n}\n/**\n * Finds the first element inside of an array that matches a test function. This is an alias for `Array.prototype.find`.\n *\n * @category Querying\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 * @deprecated Use `Array.prototype.find` directly.\n */\nexport function findOneChild(test, nodes) {\n    return nodes.find(test);\n}\n/**\n * Finds one element in a tree that passes a test.\n *\n * @category Querying\n * @param test Function to test nodes on.\n * @param nodes Node or array of nodes to search.\n * @param recurse Also consider child nodes.\n * @returns The first node that passes `test`.\n */\nexport function findOne(test, nodes, recurse = true) {\n    let elem = null;\n    for (let i = 0; i < nodes.length && !elem; i++) {\n        const node = nodes[i];\n        if (!isTag(node)) {\n            continue;\n        }\n        else if (test(node)) {\n            elem = node;\n        }\n        else if (recurse && node.children.length > 0) {\n            elem = findOne(test, node.children, true);\n        }\n    }\n    return elem;\n}\n/**\n * Checks if a tree of nodes contains at least one node passing a test.\n *\n * @category Querying\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 the test.\n */\nexport function existsOne(test, nodes) {\n    return nodes.some((checked) => isTag(checked) &&\n        (test(checked) || existsOne(test, checked.children)));\n}\n/**\n * Search an array of nodes and their children for elements passing a test function.\n *\n * Same as `find`, but limited to elements and with less options, leading to reduced complexity.\n *\n * @category Querying\n * @param test Function to test nodes on.\n * @param nodes Array of nodes to search.\n * @returns All nodes passing `test`.\n */\nexport function findAll(test, nodes) {\n    const result = [];\n    const nodeStack = [nodes];\n    const indexStack = [0];\n    for (;;) {\n        if (indexStack[0] >= nodeStack[0].length) {\n            if (nodeStack.length === 1) {\n                return result;\n            }\n            // Otherwise, remove the current array from the stack.\n            nodeStack.shift();\n            indexStack.shift();\n            // Loop back to the start to continue with the next array.\n            continue;\n        }\n        const elem = nodeStack[0][indexStack[0]++];\n        if (!isTag(elem))\n            continue;\n        if (test(elem))\n            result.push(elem);\n        if (elem.children.length > 0) {\n            indexStack.unshift(0);\n            nodeStack.unshift(elem.children);\n        }\n    }\n}\n//# sourceMappingURL=querying.js.map","import { isTag, isText } from \"domhandler\";\nimport { filter, findOne } from \"./querying.js\";\n/**\n * A map of functions to check nodes against.\n */\nconst Checks = {\n    tag_name(name) {\n        if (typeof name === \"function\") {\n            return (elem) => isTag(elem) && name(elem.name);\n        }\n        else if (name === \"*\") {\n            return isTag;\n        }\n        return (elem) => isTag(elem) && elem.name === name;\n    },\n    tag_type(type) {\n        if (typeof type === \"function\") {\n            return (elem) => type(elem.type);\n        }\n        return (elem) => elem.type === type;\n    },\n    tag_contains(data) {\n        if (typeof data === \"function\") {\n            return (elem) => isText(elem) && data(elem.data);\n        }\n        return (elem) => isText(elem) && elem.data === data;\n    },\n};\n/**\n * Returns a function to check whether a node has an attribute with a particular\n * value.\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\n *   particular value.\n */\nfunction getAttribCheck(attrib, value) {\n    if (typeof value === \"function\") {\n        return (elem) => isTag(elem) && value(elem.attribs[attrib]);\n    }\n    return (elem) => isTag(elem) && elem.attribs[attrib] === value;\n}\n/**\n * Returns a function that returns `true` if either of the input functions\n * returns `true` for a node.\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 of the input\n *   functions returns `true` for the node.\n */\nfunction combineFuncs(a, b) {\n    return (elem) => a(elem) || b(elem);\n}\n/**\n * Returns a function that executes all checks in `options` and returns `true`\n * if any of them match a node.\n *\n * @param options An object describing nodes to look for.\n * @returns A function that executes all checks in `options` and returns `true`\n *   if any of them match a node.\n */\nfunction compileTest(options) {\n    const funcs = Object.keys(options).map((key) => {\n        const 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 * Checks whether a node matches the description in `options`.\n *\n * @category Legacy Query Functions\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 */\nexport function testElement(options, node) {\n    const test = compileTest(options);\n    return test ? test(node) : true;\n}\n/**\n * Returns all nodes that match `options`.\n *\n * @category Legacy Query Functions\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 */\nexport function getElements(options, nodes, recurse, limit = Infinity) {\n    const test = compileTest(options);\n    return test ? filter(test, nodes, recurse, limit) : [];\n}\n/**\n * Returns the node with the supplied ID.\n *\n * @category Legacy Query Functions\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 */\nexport function getElementById(id, nodes, recurse = true) {\n    if (!Array.isArray(nodes))\n        nodes = [nodes];\n    return findOne(getAttribCheck(\"id\", id), nodes, recurse);\n}\n/**\n * Returns all nodes with the supplied `tagName`.\n *\n * @category Legacy Query Functions\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 */\nexport function getElementsByTagName(tagName, nodes, recurse = true, limit = Infinity) {\n    return filter(Checks[\"tag_name\"](tagName), nodes, recurse, limit);\n}\n/**\n * Returns all nodes with the supplied `type`.\n *\n * @category Legacy Query Functions\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 */\nexport function getElementsByTagType(type, nodes, recurse = true, limit = Infinity) {\n    return filter(Checks[\"tag_type\"](type), nodes, recurse, limit);\n}\n//# sourceMappingURL=legacy.js.map","import { hasChildren } from \"domhandler\";\n/**\n * Given an array of nodes, remove any member that is contained by another\n * member.\n *\n * @category Helpers\n * @param nodes Nodes to filter.\n * @returns Remaining nodes that aren't contained by other nodes.\n */\nexport function removeSubsets(nodes) {\n    let 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        const 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 (let 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}\n/**\n * @category Helpers\n * @see {@link http://dom.spec.whatwg.org/#dom-node-comparedocumentposition}\n */\nexport var DocumentPosition;\n(function (DocumentPosition) {\n    DocumentPosition[DocumentPosition[\"DISCONNECTED\"] = 1] = \"DISCONNECTED\";\n    DocumentPosition[DocumentPosition[\"PRECEDING\"] = 2] = \"PRECEDING\";\n    DocumentPosition[DocumentPosition[\"FOLLOWING\"] = 4] = \"FOLLOWING\";\n    DocumentPosition[DocumentPosition[\"CONTAINS\"] = 8] = \"CONTAINS\";\n    DocumentPosition[DocumentPosition[\"CONTAINED_BY\"] = 16] = \"CONTAINED_BY\";\n})(DocumentPosition || (DocumentPosition = {}));\n/**\n * Compare the position of one node against another node in any other document,\n * returning a bitmask with the values from {@link DocumentPosition}.\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 * @category Helpers\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 */\nexport function compareDocumentPosition(nodeA, nodeB) {\n    const aParents = [];\n    const bParents = [];\n    if (nodeA === nodeB) {\n        return 0;\n    }\n    let current = hasChildren(nodeA) ? nodeA : nodeA.parent;\n    while (current) {\n        aParents.unshift(current);\n        current = current.parent;\n    }\n    current = hasChildren(nodeB) ? nodeB : nodeB.parent;\n    while (current) {\n        bParents.unshift(current);\n        current = current.parent;\n    }\n    const maxIdx = Math.min(aParents.length, bParents.length);\n    let idx = 0;\n    while (idx < maxIdx && aParents[idx] === bParents[idx]) {\n        idx++;\n    }\n    if (idx === 0) {\n        return DocumentPosition.DISCONNECTED;\n    }\n    const sharedParent = aParents[idx - 1];\n    const siblings = sharedParent.children;\n    const aSibling = aParents[idx];\n    const bSibling = bParents[idx];\n    if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {\n        if (sharedParent === nodeB) {\n            return DocumentPosition.FOLLOWING | DocumentPosition.CONTAINED_BY;\n        }\n        return DocumentPosition.FOLLOWING;\n    }\n    if (sharedParent === nodeA) {\n        return DocumentPosition.PRECEDING | DocumentPosition.CONTAINS;\n    }\n    return DocumentPosition.PRECEDING;\n}\n/**\n * Sort an array of nodes based on their relative position in the document,\n * removing any duplicate nodes. If the array contains nodes that do not belong\n * to the same document, sort order is unspecified.\n *\n * @category Helpers\n * @param nodes Array of DOM nodes.\n * @returns Collection of unique nodes, sorted in document order.\n */\nexport function uniqueSort(nodes) {\n    nodes = nodes.filter((node, i, arr) => !arr.includes(node, i + 1));\n    nodes.sort((a, b) => {\n        const relative = compareDocumentPosition(a, b);\n        if (relative & DocumentPosition.PRECEDING) {\n            return -1;\n        }\n        else if (relative & DocumentPosition.FOLLOWING) {\n            return 1;\n        }\n        return 0;\n    });\n    return nodes;\n}\n//# sourceMappingURL=helpers.js.map","import { textContent } from \"./stringify.js\";\nimport { getElementsByTagName } from \"./legacy.js\";\n/**\n * Get the feed object from the root of a DOM tree.\n *\n * @category Feeds\n * @param doc - The DOM to to extract the feed from.\n * @returns The feed.\n */\nexport function getFeed(doc) {\n    const feedRoot = getOneElement(isValidFeed, doc);\n    return !feedRoot\n        ? null\n        : feedRoot.name === \"feed\"\n            ? getAtomFeed(feedRoot)\n            : getRssFeed(feedRoot);\n}\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    const childs = feedRoot.children;\n    const feed = {\n        type: \"atom\",\n        items: getElementsByTagName(\"entry\", childs).map((item) => {\n            var _a;\n            const { children } = item;\n            const entry = { media: getMediaElements(children) };\n            addConditionally(entry, \"id\", \"id\", children);\n            addConditionally(entry, \"title\", \"title\", children);\n            const href = (_a = getOneElement(\"link\", children)) === null || _a === void 0 ? void 0 : _a.attribs[\"href\"];\n            if (href) {\n                entry.link = href;\n            }\n            const description = fetch(\"summary\", children) || fetch(\"content\", children);\n            if (description) {\n                entry.description = description;\n            }\n            const 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    const 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    const 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    const childs = (_b = (_a = getOneElement(\"channel\", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];\n    const feed = {\n        type: feedRoot.name.substr(0, 3),\n        id: \"\",\n        items: getElementsByTagName(\"item\", feedRoot.children).map((item) => {\n            const { children } = item;\n            const 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            const pubDate = fetch(\"pubDate\", children) || fetch(\"dc:date\", 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    const 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}\nconst MEDIA_KEYS_STRING = [\"url\", \"type\", \"lang\"];\nconst 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 getElementsByTagName(\"media:content\", where).map((elem) => {\n        const { attribs } = elem;\n        const media = {\n            medium: attribs[\"medium\"],\n            isDefault: !!attribs[\"isDefault\"],\n        };\n        for (const attrib of MEDIA_KEYS_STRING) {\n            if (attribs[attrib]) {\n                media[attrib] = attribs[attrib];\n            }\n        }\n        for (const attrib of MEDIA_KEYS_INT) {\n            if (attribs[attrib]) {\n                media[attrib] = parseInt(attribs[attrib], 10);\n            }\n        }\n        if (attribs[\"expression\"]) {\n            media.expression = 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 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 = false) {\n    return textContent(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 = false) {\n    const 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//# sourceMappingURL=feeds.js.map"],"names":["getOuterHTML","node","options","renderHTML","getInnerHTML","hasChildren","getText","isTag","isCDATA","isText","textContent","isComment","innerText","ElementType","getChildren","elem","getParent","getSiblings","parent","siblings","prev","next","getAttributeValue","name","_a","hasAttrib","getName","nextElementSibling","prevElementSibling","removeElement","childs","childsIndex","replaceElement","replacement","appendChild","child","sibling","append","currNext","prependChild","prepend","filter","test","recurse","limit","find","nodes","result","nodeStack","indexStack","findOneChild","findOne","existsOne","checked","findAll","Checks","type","data","getAttribCheck","attrib","value","combineFuncs","a","b","compileTest","funcs","key","testElement","getElements","getElementById","id","getElementsByTagName","tagName","getElementsByTagType","removeSubsets","idx","ancestor","DocumentPosition","compareDocumentPosition","nodeA","nodeB","aParents","bParents","current","maxIdx","sharedParent","aSibling","bSibling","uniqueSort","i","arr","relative","getFeed","doc","feedRoot","getOneElement","isValidFeed","getAtomFeed","getRssFeed","feed","item","children","entry","getMediaElements","addConditionally","href","description","fetch","pubDate","updated","_b","MEDIA_KEYS_STRING","MEDIA_KEYS_INT","where","attribs","media","obj","prop","val"],"mappings":"oeAUO,SAASA,EAAaC,EAAMC,EAAS,CACxC,OAAOC,EAAWF,EAAMC,CAAO,CACnC,CAQO,SAASE,EAAaH,EAAMC,EAAS,CACxC,OAAOG,EAAYJ,CAAI,EACjBA,EAAK,SAAS,IAAKA,GAASD,EAAaC,EAAMC,CAAO,CAAC,EAAE,KAAK,EAAE,EAChE,EACV,CASO,SAASI,EAAQL,EAAM,CAC1B,OAAI,MAAM,QAAQA,CAAI,EACXA,EAAK,IAAIK,CAAO,EAAE,KAAK,EAAE,EAChCC,EAAMN,CAAI,EACHA,EAAK,OAAS,KAAO;AAAA,EAAOK,EAAQL,EAAK,QAAQ,EACxDO,EAAQP,CAAI,EACLK,EAAQL,EAAK,QAAQ,EAC5BQ,EAAOR,CAAI,EACJA,EAAK,KACT,EACX,CASO,SAASS,EAAYT,EAAM,CAC9B,OAAI,MAAM,QAAQA,CAAI,EACXA,EAAK,IAAIS,CAAW,EAAE,KAAK,EAAE,EACpCL,EAAYJ,CAAI,GAAK,CAACU,EAAUV,CAAI,EAC7BS,EAAYT,EAAK,QAAQ,EAEhCQ,EAAOR,CAAI,EACJA,EAAK,KACT,EACX,CASO,SAASW,EAAUX,EAAM,CAC5B,OAAI,MAAM,QAAQA,CAAI,EACXA,EAAK,IAAIW,CAAS,EAAE,KAAK,EAAE,EAClCP,EAAYJ,CAAI,IAAMA,EAAK,OAASY,EAAY,KAAOL,EAAQP,CAAI,GAC5DW,EAAUX,EAAK,QAAQ,EAE9BQ,EAAOR,CAAI,EACJA,EAAK,KACT,EACX,CCvEO,SAASa,EAAYC,EAAM,CAC9B,OAAOV,EAAYU,CAAI,EAAIA,EAAK,SAAW,CAAA,CAC/C,CAQO,SAASC,EAAUD,EAAM,CAC5B,OAAOA,EAAK,QAAU,IAC1B,CAYO,SAASE,EAAYF,EAAM,CAC9B,MAAMG,EAASF,EAAUD,CAAI,EAC7B,GAAIG,GAAU,KACV,OAAOJ,EAAYI,CAAM,EAC7B,MAAMC,EAAW,CAACJ,CAAI,EACtB,GAAI,CAAE,KAAAK,EAAM,KAAAC,CAAM,EAAGN,EACrB,KAAOK,GAAQ,MACXD,EAAS,QAAQC,CAAI,EACpB,CAAE,KAAAA,CAAM,EAAGA,EAEhB,KAAOC,GAAQ,MACXF,EAAS,KAAKE,CAAI,EACjB,CAAE,KAAAA,CAAM,EAAGA,EAEhB,OAAOF,CACX,CASO,SAASG,EAAkBP,EAAMQ,EAAM,CAC1C,IAAIC,EACJ,OAAQA,EAAKT,EAAK,WAAa,MAAQS,IAAO,OAAS,OAASA,EAAGD,CAAI,CAC3E,CASO,SAASE,EAAUV,EAAMQ,EAAM,CAClC,OAAQR,EAAK,SAAW,MACpB,OAAO,UAAU,eAAe,KAAKA,EAAK,QAASQ,CAAI,GACvDR,EAAK,QAAQQ,CAAI,GAAK,IAC9B,CAQO,SAASG,EAAQX,EAAM,CAC1B,OAAOA,EAAK,IAChB,CASO,SAASY,EAAmBZ,EAAM,CACrC,GAAI,CAAE,KAAAM,CAAM,EAAGN,EACf,KAAOM,IAAS,MAAQ,CAACd,EAAMc,CAAI,IAC9B,CAAE,KAAAA,CAAM,EAAGA,GAChB,OAAOA,CACX,CASO,SAASO,EAAmBb,EAAM,CACrC,GAAI,CAAE,KAAAK,CAAM,EAAGL,EACf,KAAOK,IAAS,MAAQ,CAACb,EAAMa,CAAI,IAC9B,CAAE,KAAAA,CAAM,EAAGA,GAChB,OAAOA,CACX,CCxGO,SAASS,EAAcd,EAAM,CAKhC,GAJIA,EAAK,OACLA,EAAK,KAAK,KAAOA,EAAK,MACtBA,EAAK,OACLA,EAAK,KAAK,KAAOA,EAAK,MACtBA,EAAK,OAAQ,CACb,MAAMe,EAASf,EAAK,OAAO,SACrBgB,EAAcD,EAAO,YAAYf,CAAI,EACvCgB,GAAe,GACfD,EAAO,OAAOC,EAAa,CAAC,EAGpChB,EAAK,KAAO,KACZA,EAAK,KAAO,KACZA,EAAK,OAAS,IAClB,CAQO,SAASiB,EAAejB,EAAMkB,EAAa,CAC9C,MAAMb,EAAQa,EAAY,KAAOlB,EAAK,KAClCK,IACAA,EAAK,KAAOa,GAEhB,MAAMZ,EAAQY,EAAY,KAAOlB,EAAK,KAClCM,IACAA,EAAK,KAAOY,GAEhB,MAAMf,EAAUe,EAAY,OAASlB,EAAK,OAC1C,GAAIG,EAAQ,CACR,MAAMY,EAASZ,EAAO,SACtBY,EAAOA,EAAO,YAAYf,CAAI,CAAC,EAAIkB,EACnClB,EAAK,OAAS,KAEtB,CAQO,SAASmB,EAAYhB,EAAQiB,EAAO,CAIvC,GAHAN,EAAcM,CAAK,EACnBA,EAAM,KAAO,KACbA,EAAM,OAASjB,EACXA,EAAO,SAAS,KAAKiB,CAAK,EAAI,EAAG,CACjC,MAAMC,EAAUlB,EAAO,SAASA,EAAO,SAAS,OAAS,CAAC,EAC1DkB,EAAQ,KAAOD,EACfA,EAAM,KAAOC,OAGbD,EAAM,KAAO,IAErB,CAQO,SAASE,EAAOtB,EAAMM,EAAM,CAC/BQ,EAAcR,CAAI,EAClB,KAAM,CAAE,OAAAH,CAAQ,EAAGH,EACbuB,EAAWvB,EAAK,KAKtB,GAJAM,EAAK,KAAOiB,EACZjB,EAAK,KAAON,EACZA,EAAK,KAAOM,EACZA,EAAK,OAASH,EACVoB,GAEA,GADAA,EAAS,KAAOjB,EACZH,EAAQ,CACR,MAAMY,EAASZ,EAAO,SACtBY,EAAO,OAAOA,EAAO,YAAYQ,CAAQ,EAAG,EAAGjB,CAAI,QAGlDH,GACLA,EAAO,SAAS,KAAKG,CAAI,CAEjC,CAQO,SAASkB,EAAarB,EAAQiB,EAAO,CAIxC,GAHAN,EAAcM,CAAK,EACnBA,EAAM,OAASjB,EACfiB,EAAM,KAAO,KACTjB,EAAO,SAAS,QAAQiB,CAAK,IAAM,EAAG,CACtC,MAAMC,EAAUlB,EAAO,SAAS,CAAC,EACjCkB,EAAQ,KAAOD,EACfA,EAAM,KAAOC,OAGbD,EAAM,KAAO,IAErB,CAQO,SAASK,EAAQzB,EAAMK,EAAM,CAChCS,EAAcT,CAAI,EAClB,KAAM,CAAE,OAAAF,CAAQ,EAAGH,EACnB,GAAIG,EAAQ,CACR,MAAMY,EAASZ,EAAO,SACtBY,EAAO,OAAOA,EAAO,QAAQf,CAAI,EAAG,EAAGK,CAAI,EAE3CL,EAAK,OACLA,EAAK,KAAK,KAAOK,GAErBA,EAAK,OAASF,EACdE,EAAK,KAAOL,EAAK,KACjBK,EAAK,KAAOL,EACZA,EAAK,KAAOK,CAChB,CCzHO,SAASqB,EAAOC,EAAMzC,EAAM0C,EAAU,GAAMC,EAAQ,IAAU,CACjE,OAAOC,EAAKH,EAAM,MAAM,QAAQzC,CAAI,EAAIA,EAAO,CAACA,CAAI,EAAG0C,EAASC,CAAK,CACzE,CAWO,SAASC,EAAKH,EAAMI,EAAOH,EAASC,EAAO,CAC9C,MAAMG,EAAS,CAAA,EAETC,EAAY,CAACF,CAAK,EAElBG,EAAa,CAAC,CAAC,EACrB,OAAS,CAEL,GAAIA,EAAW,CAAC,GAAKD,EAAU,CAAC,EAAE,OAAQ,CAEtC,GAAIC,EAAW,SAAW,EACtB,OAAOF,EAGXC,EAAU,MAAK,EACfC,EAAW,MAAK,EAEhB,SAEJ,MAAMlC,EAAOiC,EAAU,CAAC,EAAEC,EAAW,CAAC,GAAG,EACzC,GAAIP,EAAK3B,CAAI,IACTgC,EAAO,KAAKhC,CAAI,EACZ,EAAE6B,GAAS,GACX,OAAOG,EAEXJ,GAAWtC,EAAYU,CAAI,GAAKA,EAAK,SAAS,OAAS,IAKvDkC,EAAW,QAAQ,CAAC,EACpBD,EAAU,QAAQjC,EAAK,QAAQ,GAG3C,CAUO,SAASmC,GAAaR,EAAMI,EAAO,CACtC,OAAOA,EAAM,KAAKJ,CAAI,CAC1B,CAUO,SAASS,EAAQT,EAAMI,EAAOH,EAAU,GAAM,CACjD,IAAI5B,EAAO,KACX,QAAS,EAAI,EAAG,EAAI+B,EAAM,QAAU,CAAC/B,EAAM,IAAK,CAC5C,MAAMd,EAAO6C,EAAM,CAAC,EACpB,GAAKvC,EAAMN,CAAI,EAGNyC,EAAKzC,CAAI,EACdc,EAAOd,EAEF0C,GAAW1C,EAAK,SAAS,OAAS,IACvCc,EAAOoC,EAAQT,EAAMzC,EAAK,SAAU,EAAI,OANxC,UASR,OAAOc,CACX,CASO,SAASqC,EAAUV,EAAMI,EAAO,CACnC,OAAOA,EAAM,KAAMO,GAAY9C,EAAM8C,CAAO,IACvCX,EAAKW,CAAO,GAAKD,EAAUV,EAAMW,EAAQ,QAAQ,EAAE,CAC5D,CAWO,SAASC,GAAQZ,EAAMI,EAAO,CACjC,MAAMC,EAAS,CAAA,EACTC,EAAY,CAACF,CAAK,EAClBG,EAAa,CAAC,CAAC,EACrB,OAAS,CACL,GAAIA,EAAW,CAAC,GAAKD,EAAU,CAAC,EAAE,OAAQ,CACtC,GAAIA,EAAU,SAAW,EACrB,OAAOD,EAGXC,EAAU,MAAK,EACfC,EAAW,MAAK,EAEhB,SAEJ,MAAMlC,EAAOiC,EAAU,CAAC,EAAEC,EAAW,CAAC,GAAG,EACpC1C,EAAMQ,CAAI,IAEX2B,EAAK3B,CAAI,GACTgC,EAAO,KAAKhC,CAAI,EAChBA,EAAK,SAAS,OAAS,IACvBkC,EAAW,QAAQ,CAAC,EACpBD,EAAU,QAAQjC,EAAK,QAAQ,IAG3C,CC1IA,MAAMwC,EAAS,CACX,SAAShC,EAAM,CACX,OAAI,OAAOA,GAAS,WACRR,GAASR,EAAMQ,CAAI,GAAKQ,EAAKR,EAAK,IAAI,EAEzCQ,IAAS,IACPhB,EAEHQ,GAASR,EAAMQ,CAAI,GAAKA,EAAK,OAASQ,CACjD,EACD,SAASiC,EAAM,CACX,OAAI,OAAOA,GAAS,WACRzC,GAASyC,EAAKzC,EAAK,IAAI,EAE3BA,GAASA,EAAK,OAASyC,CAClC,EACD,aAAaC,EAAM,CACf,OAAI,OAAOA,GAAS,WACR1C,GAASN,EAAOM,CAAI,GAAK0C,EAAK1C,EAAK,IAAI,EAE3CA,GAASN,EAAOM,CAAI,GAAKA,EAAK,OAAS0C,CAClD,CACL,EAUA,SAASC,EAAeC,EAAQC,EAAO,CACnC,OAAI,OAAOA,GAAU,WACT7C,GAASR,EAAMQ,CAAI,GAAK6C,EAAM7C,EAAK,QAAQ4C,CAAM,CAAC,EAEtD5C,GAASR,EAAMQ,CAAI,GAAKA,EAAK,QAAQ4C,CAAM,IAAMC,CAC7D,CAUA,SAASC,GAAaC,EAAGC,EAAG,CACxB,OAAQhD,GAAS+C,EAAE/C,CAAI,GAAKgD,EAAEhD,CAAI,CACtC,CASA,SAASiD,EAAY9D,EAAS,CAC1B,MAAM+D,EAAQ,OAAO,KAAK/D,CAAO,EAAE,IAAKgE,GAAQ,CAC5C,MAAMN,EAAQ1D,EAAQgE,CAAG,EACzB,OAAO,OAAO,UAAU,eAAe,KAAKX,EAAQW,CAAG,EACjDX,EAAOW,CAAG,EAAEN,CAAK,EACjBF,EAAeQ,EAAKN,CAAK,CACvC,CAAK,EACD,OAAOK,EAAM,SAAW,EAAI,KAAOA,EAAM,OAAOJ,EAAY,CAChE,CASO,SAASM,GAAYjE,EAASD,EAAM,CACvC,MAAMyC,EAAOsB,EAAY9D,CAAO,EAChC,OAAOwC,EAAOA,EAAKzC,CAAI,EAAI,EAC/B,CAWO,SAASmE,GAAYlE,EAAS4C,EAAOH,EAASC,EAAQ,IAAU,CACnE,MAAMF,EAAOsB,EAAY9D,CAAO,EAChC,OAAOwC,EAAOD,EAAOC,EAAMI,EAAOH,EAASC,CAAK,EAAI,EACxD,CAUO,SAASyB,GAAeC,EAAIxB,EAAOH,EAAU,GAAM,CACtD,OAAK,MAAM,QAAQG,CAAK,IACpBA,EAAQ,CAACA,CAAK,GACXK,EAAQO,EAAe,KAAMY,CAAE,EAAGxB,EAAOH,CAAO,CAC3D,CAWO,SAAS4B,EAAqBC,EAAS1B,EAAOH,EAAU,GAAMC,EAAQ,IAAU,CACnF,OAAOH,EAAOc,EAAO,SAAYiB,CAAO,EAAG1B,EAAOH,EAASC,CAAK,CACpE,CAWO,SAAS6B,GAAqBjB,EAAMV,EAAOH,EAAU,GAAMC,EAAQ,IAAU,CAChF,OAAOH,EAAOc,EAAO,SAAYC,CAAI,EAAGV,EAAOH,EAASC,CAAK,CACjE,CChIO,SAAS8B,GAAc5B,EAAO,CACjC,IAAI6B,EAAM7B,EAAM,OAKhB,KAAO,EAAE6B,GAAO,GAAG,CACf,MAAM1E,EAAO6C,EAAM6B,CAAG,EAMtB,GAAIA,EAAM,GAAK7B,EAAM,YAAY7C,EAAM0E,EAAM,CAAC,GAAK,EAAG,CAClD7B,EAAM,OAAO6B,EAAK,CAAC,EACnB,SAEJ,QAASC,EAAW3E,EAAK,OAAQ2E,EAAUA,EAAWA,EAAS,OAC3D,GAAI9B,EAAM,SAAS8B,CAAQ,EAAG,CAC1B9B,EAAM,OAAO6B,EAAK,CAAC,EACnB,OAIZ,OAAO7B,CACX,CAKO,IAAI+B,GACV,SAAUA,EAAkB,CACzBA,EAAiBA,EAAiB,aAAkB,CAAC,EAAI,eACzDA,EAAiBA,EAAiB,UAAe,CAAC,EAAI,YACtDA,EAAiBA,EAAiB,UAAe,CAAC,EAAI,YACtDA,EAAiBA,EAAiB,SAAc,CAAC,EAAI,WACrDA,EAAiBA,EAAiB,aAAkB,EAAE,EAAI,cAC9D,GAAGA,IAAqBA,EAAmB,CAAE,EAAC,EA2BvC,SAASC,EAAwBC,EAAOC,EAAO,CAClD,MAAMC,EAAW,CAAA,EACXC,EAAW,CAAA,EACjB,GAAIH,IAAUC,EACV,MAAO,GAEX,IAAIG,EAAU9E,EAAY0E,CAAK,EAAIA,EAAQA,EAAM,OACjD,KAAOI,GACHF,EAAS,QAAQE,CAAO,EACxBA,EAAUA,EAAQ,OAGtB,IADAA,EAAU9E,EAAY2E,CAAK,EAAIA,EAAQA,EAAM,OACtCG,GACHD,EAAS,QAAQC,CAAO,EACxBA,EAAUA,EAAQ,OAEtB,MAAMC,EAAS,KAAK,IAAIH,EAAS,OAAQC,EAAS,MAAM,EACxD,IAAIP,EAAM,EACV,KAAOA,EAAMS,GAAUH,EAASN,CAAG,IAAMO,EAASP,CAAG,GACjDA,IAEJ,GAAIA,IAAQ,EACR,OAAOE,EAAiB,aAE5B,MAAMQ,EAAeJ,EAASN,EAAM,CAAC,EAC/BxD,EAAWkE,EAAa,SACxBC,EAAWL,EAASN,CAAG,EACvBY,EAAWL,EAASP,CAAG,EAC7B,OAAIxD,EAAS,QAAQmE,CAAQ,EAAInE,EAAS,QAAQoE,CAAQ,EAClDF,IAAiBL,EACVH,EAAiB,UAAYA,EAAiB,aAElDA,EAAiB,UAExBQ,IAAiBN,EACVF,EAAiB,UAAYA,EAAiB,SAElDA,EAAiB,SAC5B,CAUO,SAASW,GAAW1C,EAAO,CAC9B,OAAAA,EAAQA,EAAM,OAAO,CAAC7C,EAAMwF,EAAGC,IAAQ,CAACA,EAAI,SAASzF,EAAMwF,EAAI,CAAC,CAAC,EACjE3C,EAAM,KAAK,CAACgB,EAAGC,IAAM,CACjB,MAAM4B,EAAWb,EAAwBhB,EAAGC,CAAC,EAC7C,OAAI4B,EAAWd,EAAiB,UACrB,GAEFc,EAAWd,EAAiB,UAC1B,EAEJ,CACf,CAAK,EACM/B,CACX,CC7HO,SAAS8C,GAAQC,EAAK,CACzB,MAAMC,EAAWC,EAAcC,GAAaH,CAAG,EAC/C,OAAQC,EAEFA,EAAS,OAAS,OACdG,GAAYH,CAAQ,EACpBI,GAAWJ,CAAQ,EAHvB,IAIV,CAOA,SAASG,GAAYH,EAAU,CAC3B,IAAItE,EACJ,MAAMM,EAASgE,EAAS,SAClBK,EAAO,CACT,KAAM,OACN,MAAO5B,EAAqB,QAASzC,CAAM,EAAE,IAAKsE,GAAS,CACvD,IAAI5E,EACJ,KAAM,CAAE,SAAA6E,CAAU,EAAGD,EACfE,EAAQ,CAAE,MAAOC,EAAiBF,CAAQ,CAAC,EACjDG,EAAiBF,EAAO,KAAM,KAAMD,CAAQ,EAC5CG,EAAiBF,EAAO,QAAS,QAASD,CAAQ,EAClD,MAAMI,GAAQjF,EAAKuE,EAAc,OAAQM,CAAQ,KAAO,MAAQ7E,IAAO,OAAS,OAASA,EAAG,QAAQ,KAChGiF,IACAH,EAAM,KAAOG,GAEjB,MAAMC,EAAcC,EAAM,UAAWN,CAAQ,GAAKM,EAAM,UAAWN,CAAQ,EACvEK,IACAJ,EAAM,YAAcI,GAExB,MAAME,EAAUD,EAAM,UAAWN,CAAQ,EACzC,OAAIO,IACAN,EAAM,QAAU,IAAI,KAAKM,CAAO,GAE7BN,CACnB,CAAS,CACT,EACIE,EAAiBL,EAAM,KAAM,KAAMrE,CAAM,EACzC0E,EAAiBL,EAAM,QAAS,QAASrE,CAAM,EAC/C,MAAM2E,GAAQjF,EAAKuE,EAAc,OAAQjE,CAAM,KAAO,MAAQN,IAAO,OAAS,OAASA,EAAG,QAAQ,KAC9FiF,IACAN,EAAK,KAAOM,GAEhBD,EAAiBL,EAAM,cAAe,WAAYrE,CAAM,EACxD,MAAM+E,EAAUF,EAAM,UAAW7E,CAAM,EACvC,OAAI+E,IACAV,EAAK,QAAU,IAAI,KAAKU,CAAO,GAEnCL,EAAiBL,EAAM,SAAU,QAASrE,EAAQ,EAAI,EAC/CqE,CACX,CAOA,SAASD,GAAWJ,EAAU,CAC1B,IAAItE,EAAIsF,EACR,MAAMhF,GAAUgF,GAAMtF,EAAKuE,EAAc,UAAWD,EAAS,QAAQ,KAAO,MAAQtE,IAAO,OAAS,OAASA,EAAG,YAAc,MAAQsF,IAAO,OAASA,EAAK,GACrJX,EAAO,CACT,KAAML,EAAS,KAAK,OAAO,EAAG,CAAC,EAC/B,GAAI,GACJ,MAAOvB,EAAqB,OAAQuB,EAAS,QAAQ,EAAE,IAAKM,GAAS,CACjE,KAAM,CAAE,SAAAC,CAAU,EAAGD,EACfE,EAAQ,CAAE,MAAOC,EAAiBF,CAAQ,CAAC,EACjDG,EAAiBF,EAAO,KAAM,OAAQD,CAAQ,EAC9CG,EAAiBF,EAAO,QAAS,QAASD,CAAQ,EAClDG,EAAiBF,EAAO,OAAQ,OAAQD,CAAQ,EAChDG,EAAiBF,EAAO,cAAe,cAAeD,CAAQ,EAC9D,MAAMO,EAAUD,EAAM,UAAWN,CAAQ,GAAKM,EAAM,UAAWN,CAAQ,EACvE,OAAIO,IACAN,EAAM,QAAU,IAAI,KAAKM,CAAO,GAC7BN,CACnB,CAAS,CACT,EACIE,EAAiBL,EAAM,QAAS,QAASrE,CAAM,EAC/C0E,EAAiBL,EAAM,OAAQ,OAAQrE,CAAM,EAC7C0E,EAAiBL,EAAM,cAAe,cAAerE,CAAM,EAC3D,MAAM+E,EAAUF,EAAM,gBAAiB7E,CAAM,EAC7C,OAAI+E,IACAV,EAAK,QAAU,IAAI,KAAKU,CAAO,GAEnCL,EAAiBL,EAAM,SAAU,iBAAkBrE,EAAQ,EAAI,EACxDqE,CACX,CACA,MAAMY,GAAoB,CAAC,MAAO,OAAQ,MAAM,EAC1CC,GAAiB,CACnB,WACA,UACA,YACA,eACA,WACA,WACA,SACA,OACJ,EAOA,SAAST,EAAiBU,EAAO,CAC7B,OAAO1C,EAAqB,gBAAiB0C,CAAK,EAAE,IAAKlG,GAAS,CAC9D,KAAM,CAAE,QAAAmG,CAAS,EAAGnG,EACdoG,EAAQ,CACV,OAAQD,EAAQ,OAChB,UAAW,CAAC,CAACA,EAAQ,SACjC,EACQ,UAAWvD,KAAUoD,GACbG,EAAQvD,CAAM,IACdwD,EAAMxD,CAAM,EAAIuD,EAAQvD,CAAM,GAGtC,UAAWA,KAAUqD,GACbE,EAAQvD,CAAM,IACdwD,EAAMxD,CAAM,EAAI,SAASuD,EAAQvD,CAAM,EAAG,EAAE,GAGpD,OAAIuD,EAAQ,aACRC,EAAM,WAAaD,EAAQ,YAExBC,CACf,CAAK,CACL,CAQA,SAASpB,EAAcvB,EAASvE,EAAM,CAClC,OAAOsE,EAAqBC,EAASvE,EAAM,GAAM,CAAC,EAAE,CAAC,CACzD,CASA,SAAS0G,EAAMnC,EAASyC,EAAOtE,EAAU,GAAO,CAC5C,OAAOjC,EAAY6D,EAAqBC,EAASyC,EAAOtE,EAAS,CAAC,CAAC,EAAE,MACzE,CAUA,SAAS6D,EAAiBY,EAAKC,EAAM7C,EAASyC,EAAOtE,EAAU,GAAO,CAClE,MAAM2E,EAAMX,EAAMnC,EAASyC,EAAOtE,CAAO,EACrC2E,IACAF,EAAIC,CAAI,EAAIC,EACpB,CAOA,SAAStB,GAAYpC,EAAO,CACxB,OAAOA,IAAU,OAASA,IAAU,QAAUA,IAAU,SAC5D","x_google_ignoreList":[0,1,2,3,4,5,6]}