{"version":3,"file":"static/js/8577_9faeab0d7846b3489579.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dom-helpers@5.2.1/node_modules/dom-helpers/esm/addClass.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dom-helpers@5.2.1/node_modules/dom-helpers/esm/hasClass.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dom-helpers@5.2.1/node_modules/dom-helpers/esm/removeClass.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dom-serializer@2.0.0/node_modules/dom-serializer/lib/foreignNames.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dom-serializer@2.0.0/node_modules/dom-serializer/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domelementtype@2.3.0/node_modules/domelementtype/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domhandler@5.0.3/node_modules/domhandler/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domhandler@5.0.3/node_modules/domhandler/lib/node.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/dompurify@3.0.8/node_modules/dompurify/dist/purify.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/feeds.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/helpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/legacy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/manipulation.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/querying.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/stringify.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/domutils@3.1.0/node_modules/domutils/lib/traversal.js"],"sourcesContent":["import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.attributeNames = exports.elementNames = void 0;\nexports.elementNames = new Map([\n    \"altGlyph\",\n    \"altGlyphDef\",\n    \"altGlyphItem\",\n    \"animateColor\",\n    \"animateMotion\",\n    \"animateTransform\",\n    \"clipPath\",\n    \"feBlend\",\n    \"feColorMatrix\",\n    \"feComponentTransfer\",\n    \"feComposite\",\n    \"feConvolveMatrix\",\n    \"feDiffuseLighting\",\n    \"feDisplacementMap\",\n    \"feDistantLight\",\n    \"feDropShadow\",\n    \"feFlood\",\n    \"feFuncA\",\n    \"feFuncB\",\n    \"feFuncG\",\n    \"feFuncR\",\n    \"feGaussianBlur\",\n    \"feImage\",\n    \"feMerge\",\n    \"feMergeNode\",\n    \"feMorphology\",\n    \"feOffset\",\n    \"fePointLight\",\n    \"feSpecularLighting\",\n    \"feSpotLight\",\n    \"feTile\",\n    \"feTurbulence\",\n    \"foreignObject\",\n    \"glyphRef\",\n    \"linearGradient\",\n    \"radialGradient\",\n    \"textPath\",\n].map(function (val) { return [val.toLowerCase(), val]; }));\nexports.attributeNames = new Map([\n    \"definitionURL\",\n    \"attributeName\",\n    \"attributeType\",\n    \"baseFrequency\",\n    \"baseProfile\",\n    \"calcMode\",\n    \"clipPathUnits\",\n    \"diffuseConstant\",\n    \"edgeMode\",\n    \"filterUnits\",\n    \"glyphRef\",\n    \"gradientTransform\",\n    \"gradientUnits\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keyPoints\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"lengthAdjust\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerUnits\",\n    \"markerWidth\",\n    \"maskContentUnits\",\n    \"maskUnits\",\n    \"numOctaves\",\n    \"pathLength\",\n    \"patternContentUnits\",\n    \"patternTransform\",\n    \"patternUnits\",\n    \"pointsAtX\",\n    \"pointsAtY\",\n    \"pointsAtZ\",\n    \"preserveAlpha\",\n    \"preserveAspectRatio\",\n    \"primitiveUnits\",\n    \"refX\",\n    \"refY\",\n    \"repeatCount\",\n    \"repeatDur\",\n    \"requiredExtensions\",\n    \"requiredFeatures\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"spreadMethod\",\n    \"startOffset\",\n    \"stdDeviation\",\n    \"stitchTiles\",\n    \"surfaceScale\",\n    \"systemLanguage\",\n    \"tableValues\",\n    \"targetX\",\n    \"targetY\",\n    \"textLength\",\n    \"viewBox\",\n    \"viewTarget\",\n    \"xChannelSelector\",\n    \"yChannelSelector\",\n    \"zoomAndPan\",\n].map(function (val) { return [val.toLowerCase(), val]; }));\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.render = void 0;\n/*\n * Module dependencies\n */\nvar ElementType = __importStar(require(\"domelementtype\"));\nvar entities_1 = require(\"entities\");\n/**\n * Mixed-case SVG and MathML tags & attributes\n * recognized by the HTML parser.\n *\n * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign\n */\nvar foreignNames_js_1 = require(\"./foreignNames.js\");\nvar unencodedElements = new Set([\n    \"style\",\n    \"script\",\n    \"xmp\",\n    \"iframe\",\n    \"noembed\",\n    \"noframes\",\n    \"plaintext\",\n    \"noscript\",\n]);\nfunction replaceQuotes(value) {\n    return value.replace(/\"/g, \"&quot;\");\n}\n/**\n * Format attributes\n */\nfunction formatAttributes(attributes, opts) {\n    var _a;\n    if (!attributes)\n        return;\n    var encode = ((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) === false\n        ? replaceQuotes\n        : opts.xmlMode || opts.encodeEntities !== \"utf8\"\n            ? entities_1.encodeXML\n            : entities_1.escapeAttribute;\n    return Object.keys(attributes)\n        .map(function (key) {\n        var _a, _b;\n        var value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : \"\";\n        if (opts.xmlMode === \"foreign\") {\n            /* Fix up mixed-case attribute names */\n            key = (_b = foreignNames_js_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;\n        }\n        if (!opts.emptyAttrs && !opts.xmlMode && value === \"\") {\n            return key;\n        }\n        return \"\".concat(key, \"=\\\"\").concat(encode(value), \"\\\"\");\n    })\n        .join(\" \");\n}\n/**\n * Self-enclosing tags\n */\nvar singleTag = new Set([\n    \"area\",\n    \"base\",\n    \"basefont\",\n    \"br\",\n    \"col\",\n    \"command\",\n    \"embed\",\n    \"frame\",\n    \"hr\",\n    \"img\",\n    \"input\",\n    \"isindex\",\n    \"keygen\",\n    \"link\",\n    \"meta\",\n    \"param\",\n    \"source\",\n    \"track\",\n    \"wbr\",\n]);\n/**\n * Renders a DOM node or an array of DOM nodes to a string.\n *\n * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).\n *\n * @param node Node to be rendered.\n * @param options Changes serialization behavior\n */\nfunction render(node, options) {\n    if (options === void 0) { options = {}; }\n    var nodes = \"length\" in node ? node : [node];\n    var output = \"\";\n    for (var i = 0; i < nodes.length; i++) {\n        output += renderNode(nodes[i], options);\n    }\n    return output;\n}\nexports.render = render;\nexports.default = render;\nfunction renderNode(node, options) {\n    switch (node.type) {\n        case ElementType.Root:\n            return render(node.children, options);\n        // @ts-expect-error We don't use `Doctype` yet\n        case ElementType.Doctype:\n        case ElementType.Directive:\n            return renderDirective(node);\n        case ElementType.Comment:\n            return renderComment(node);\n        case ElementType.CDATA:\n            return renderCdata(node);\n        case ElementType.Script:\n        case ElementType.Style:\n        case ElementType.Tag:\n            return renderTag(node, options);\n        case ElementType.Text:\n            return renderText(node, options);\n    }\n}\nvar foreignModeIntegrationPoints = new Set([\n    \"mi\",\n    \"mo\",\n    \"mn\",\n    \"ms\",\n    \"mtext\",\n    \"annotation-xml\",\n    \"foreignObject\",\n    \"desc\",\n    \"title\",\n]);\nvar foreignElements = new Set([\"svg\", \"math\"]);\nfunction renderTag(elem, opts) {\n    var _a;\n    // Handle SVG / MathML in HTML\n    if (opts.xmlMode === \"foreign\") {\n        /* Fix up mixed-case element names */\n        elem.name = (_a = foreignNames_js_1.elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;\n        /* Exit foreign mode at integration points */\n        if (elem.parent &&\n            foreignModeIntegrationPoints.has(elem.parent.name)) {\n            opts = __assign(__assign({}, opts), { xmlMode: false });\n        }\n    }\n    if (!opts.xmlMode && foreignElements.has(elem.name)) {\n        opts = __assign(__assign({}, opts), { xmlMode: \"foreign\" });\n    }\n    var tag = \"<\".concat(elem.name);\n    var attribs = formatAttributes(elem.attribs, opts);\n    if (attribs) {\n        tag += \" \".concat(attribs);\n    }\n    if (elem.children.length === 0 &&\n        (opts.xmlMode\n            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags\n                opts.selfClosingTags !== false\n            : // User explicitly asked for self-closing tags, even in HTML mode\n                opts.selfClosingTags && singleTag.has(elem.name))) {\n        if (!opts.xmlMode)\n            tag += \" \";\n        tag += \"/>\";\n    }\n    else {\n        tag += \">\";\n        if (elem.children.length > 0) {\n            tag += render(elem.children, opts);\n        }\n        if (opts.xmlMode || !singleTag.has(elem.name)) {\n            tag += \"</\".concat(elem.name, \">\");\n        }\n    }\n    return tag;\n}\nfunction renderDirective(elem) {\n    return \"<\".concat(elem.data, \">\");\n}\nfunction renderText(elem, opts) {\n    var _a;\n    var data = elem.data || \"\";\n    // If entities weren't decoded, no need to encode them back\n    if (((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) !== false &&\n        !(!opts.xmlMode &&\n            elem.parent &&\n            unencodedElements.has(elem.parent.name))) {\n        data =\n            opts.xmlMode || opts.encodeEntities !== \"utf8\"\n                ? (0, entities_1.encodeXML)(data)\n                : (0, entities_1.escapeText)(data);\n    }\n    return data;\n}\nfunction renderCdata(elem) {\n    return \"<![CDATA[\".concat(elem.children[0].data, \"]]>\");\n}\nfunction renderComment(elem) {\n    return \"<!--\".concat(elem.data, \"-->\");\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;\n/** Types of elements found in htmlparser2's DOM */\nvar ElementType;\n(function (ElementType) {\n    /** Type for the root element of a document */\n    ElementType[\"Root\"] = \"root\";\n    /** Type for Text */\n    ElementType[\"Text\"] = \"text\";\n    /** Type for <? ... ?> */\n    ElementType[\"Directive\"] = \"directive\";\n    /** Type for <!-- ... --> */\n    ElementType[\"Comment\"] = \"comment\";\n    /** Type for <script> tags */\n    ElementType[\"Script\"] = \"script\";\n    /** Type for <style> tags */\n    ElementType[\"Style\"] = \"style\";\n    /** Type for Any tag */\n    ElementType[\"Tag\"] = \"tag\";\n    /** Type for <![CDATA[ ... ]]> */\n    ElementType[\"CDATA\"] = \"cdata\";\n    /** Type for <!doctype ...> */\n    ElementType[\"Doctype\"] = \"doctype\";\n})(ElementType = exports.ElementType || (exports.ElementType = {}));\n/**\n * Tests whether an element is a tag or not.\n *\n * @param elem Element to test\n */\nfunction isTag(elem) {\n    return (elem.type === ElementType.Tag ||\n        elem.type === ElementType.Script ||\n        elem.type === ElementType.Style);\n}\nexports.isTag = isTag;\n// Exports for backwards compatibility\n/** Type for the root element of a document */\nexports.Root = ElementType.Root;\n/** Type for Text */\nexports.Text = ElementType.Text;\n/** Type for <? ... ?> */\nexports.Directive = ElementType.Directive;\n/** Type for <!-- ... --> */\nexports.Comment = ElementType.Comment;\n/** Type for <script> tags */\nexports.Script = ElementType.Script;\n/** Type for <style> tags */\nexports.Style = ElementType.Style;\n/** Type for Any tag */\nexports.Tag = ElementType.Tag;\n/** Type for <![CDATA[ ... ]]> */\nexports.CDATA = ElementType.CDATA;\n/** Type for <!doctype ...> */\nexports.Doctype = ElementType.Doctype;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\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.DomHandler = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\nvar node_js_1 = require(\"./node.js\");\n__exportStar(require(\"./node.js\"), exports);\n// Default options\nvar defaultOpts = {\n    withStartIndices: false,\n    withEndIndices: false,\n    xmlMode: false,\n};\nvar DomHandler = /** @class */ (function () {\n    /**\n     * @param callback Called once parsing has completed.\n     * @param options Settings for the handler.\n     * @param elementCB Callback whenever a tag is closed.\n     */\n    function DomHandler(callback, options, elementCB) {\n        /** The elements of the DOM */\n        this.dom = [];\n        /** The root element for the DOM */\n        this.root = new node_js_1.Document(this.dom);\n        /** Indicated whether parsing has been completed. */\n        this.done = false;\n        /** Stack of open tags. */\n        this.tagStack = [this.root];\n        /** A data node that is still being written to. */\n        this.lastNode = null;\n        /** Reference to the parser instance. Used for location information. */\n        this.parser = null;\n        // Make it possible to skip arguments, for backwards-compatibility\n        if (typeof options === \"function\") {\n            elementCB = options;\n            options = defaultOpts;\n        }\n        if (typeof callback === \"object\") {\n            options = callback;\n            callback = undefined;\n        }\n        this.callback = callback !== null && callback !== void 0 ? callback : null;\n        this.options = options !== null && options !== void 0 ? options : defaultOpts;\n        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;\n    }\n    DomHandler.prototype.onparserinit = function (parser) {\n        this.parser = parser;\n    };\n    // Resets the handler back to starting state\n    DomHandler.prototype.onreset = function () {\n        this.dom = [];\n        this.root = new node_js_1.Document(this.dom);\n        this.done = false;\n        this.tagStack = [this.root];\n        this.lastNode = null;\n        this.parser = null;\n    };\n    // Signals the handler that parsing is done\n    DomHandler.prototype.onend = function () {\n        if (this.done)\n            return;\n        this.done = true;\n        this.parser = null;\n        this.handleCallback(null);\n    };\n    DomHandler.prototype.onerror = function (error) {\n        this.handleCallback(error);\n    };\n    DomHandler.prototype.onclosetag = function () {\n        this.lastNode = null;\n        var elem = this.tagStack.pop();\n        if (this.options.withEndIndices) {\n            elem.endIndex = this.parser.endIndex;\n        }\n        if (this.elementCB)\n            this.elementCB(elem);\n    };\n    DomHandler.prototype.onopentag = function (name, attribs) {\n        var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;\n        var element = new node_js_1.Element(name, attribs, undefined, type);\n        this.addNode(element);\n        this.tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var lastNode = this.lastNode;\n        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {\n            lastNode.data += data;\n            if (this.options.withEndIndices) {\n                lastNode.endIndex = this.parser.endIndex;\n            }\n        }\n        else {\n            var node = new node_js_1.Text(data);\n            this.addNode(node);\n            this.lastNode = node;\n        }\n    };\n    DomHandler.prototype.oncomment = function (data) {\n        if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {\n            this.lastNode.data += data;\n            return;\n        }\n        var node = new node_js_1.Comment(data);\n        this.addNode(node);\n        this.lastNode = node;\n    };\n    DomHandler.prototype.oncommentend = function () {\n        this.lastNode = null;\n    };\n    DomHandler.prototype.oncdatastart = function () {\n        var text = new node_js_1.Text(\"\");\n        var node = new node_js_1.CDATA([text]);\n        this.addNode(node);\n        text.parent = node;\n        this.lastNode = text;\n    };\n    DomHandler.prototype.oncdataend = function () {\n        this.lastNode = null;\n    };\n    DomHandler.prototype.onprocessinginstruction = function (name, data) {\n        var node = new node_js_1.ProcessingInstruction(name, data);\n        this.addNode(node);\n    };\n    DomHandler.prototype.handleCallback = function (error) {\n        if (typeof this.callback === \"function\") {\n            this.callback(error, this.dom);\n        }\n        else if (error) {\n            throw error;\n        }\n    };\n    DomHandler.prototype.addNode = function (node) {\n        var parent = this.tagStack[this.tagStack.length - 1];\n        var previousSibling = parent.children[parent.children.length - 1];\n        if (this.options.withStartIndices) {\n            node.startIndex = this.parser.startIndex;\n        }\n        if (this.options.withEndIndices) {\n            node.endIndex = this.parser.endIndex;\n        }\n        parent.children.push(node);\n        if (previousSibling) {\n            node.prev = previousSibling;\n            previousSibling.next = node;\n        }\n        node.parent = parent;\n        this.lastNode = null;\n    };\n    return DomHandler;\n}());\nexports.DomHandler = DomHandler;\nexports.default = DomHandler;\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cloneNode = exports.hasChildren = exports.isDocument = exports.isDirective = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = exports.Element = exports.Document = exports.CDATA = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\n/**\n * This object will be used as the prototype for Nodes when creating a\n * DOM-Level-1-compliant structure.\n */\nvar Node = /** @class */ (function () {\n    function Node() {\n        /** Parent of the node */\n        this.parent = null;\n        /** Previous sibling */\n        this.prev = null;\n        /** Next sibling */\n        this.next = null;\n        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */\n        this.startIndex = null;\n        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */\n        this.endIndex = null;\n    }\n    Object.defineProperty(Node.prototype, \"parentNode\", {\n        // Read-write aliases for properties\n        /**\n         * Same as {@link parent}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.parent;\n        },\n        set: function (parent) {\n            this.parent = parent;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"previousSibling\", {\n        /**\n         * Same as {@link prev}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.prev;\n        },\n        set: function (prev) {\n            this.prev = prev;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"nextSibling\", {\n        /**\n         * Same as {@link next}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.next;\n        },\n        set: function (next) {\n            this.next = next;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Clone this node, and optionally its children.\n     *\n     * @param recursive Clone child nodes as well.\n     * @returns A clone of the node.\n     */\n    Node.prototype.cloneNode = function (recursive) {\n        if (recursive === void 0) { recursive = false; }\n        return cloneNode(this, recursive);\n    };\n    return Node;\n}());\nexports.Node = Node;\n/**\n * A node that contains some data.\n */\nvar DataNode = /** @class */ (function (_super) {\n    __extends(DataNode, _super);\n    /**\n     * @param data The content of the data node\n     */\n    function DataNode(data) {\n        var _this = _super.call(this) || this;\n        _this.data = data;\n        return _this;\n    }\n    Object.defineProperty(DataNode.prototype, \"nodeValue\", {\n        /**\n         * Same as {@link data}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.data;\n        },\n        set: function (data) {\n            this.data = data;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return DataNode;\n}(Node));\nexports.DataNode = DataNode;\n/**\n * Text within the document.\n */\nvar Text = /** @class */ (function (_super) {\n    __extends(Text, _super);\n    function Text() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Text;\n        return _this;\n    }\n    Object.defineProperty(Text.prototype, \"nodeType\", {\n        get: function () {\n            return 3;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Text;\n}(DataNode));\nexports.Text = Text;\n/**\n * Comments within the document.\n */\nvar Comment = /** @class */ (function (_super) {\n    __extends(Comment, _super);\n    function Comment() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Comment;\n        return _this;\n    }\n    Object.defineProperty(Comment.prototype, \"nodeType\", {\n        get: function () {\n            return 8;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Comment;\n}(DataNode));\nexports.Comment = Comment;\n/**\n * Processing instructions, including doc types.\n */\nvar ProcessingInstruction = /** @class */ (function (_super) {\n    __extends(ProcessingInstruction, _super);\n    function ProcessingInstruction(name, data) {\n        var _this = _super.call(this, data) || this;\n        _this.name = name;\n        _this.type = domelementtype_1.ElementType.Directive;\n        return _this;\n    }\n    Object.defineProperty(ProcessingInstruction.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ProcessingInstruction;\n}(DataNode));\nexports.ProcessingInstruction = ProcessingInstruction;\n/**\n * A `Node` that can have children.\n */\nvar NodeWithChildren = /** @class */ (function (_super) {\n    __extends(NodeWithChildren, _super);\n    /**\n     * @param children Children of the node. Only certain node types can have children.\n     */\n    function NodeWithChildren(children) {\n        var _this = _super.call(this) || this;\n        _this.children = children;\n        return _this;\n    }\n    Object.defineProperty(NodeWithChildren.prototype, \"firstChild\", {\n        // Aliases\n        /** First child of the node. */\n        get: function () {\n            var _a;\n            return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"lastChild\", {\n        /** Last child of the node. */\n        get: function () {\n            return this.children.length > 0\n                ? this.children[this.children.length - 1]\n                : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"childNodes\", {\n        /**\n         * Same as {@link children}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.children;\n        },\n        set: function (children) {\n            this.children = children;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return NodeWithChildren;\n}(Node));\nexports.NodeWithChildren = NodeWithChildren;\nvar CDATA = /** @class */ (function (_super) {\n    __extends(CDATA, _super);\n    function CDATA() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.CDATA;\n        return _this;\n    }\n    Object.defineProperty(CDATA.prototype, \"nodeType\", {\n        get: function () {\n            return 4;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return CDATA;\n}(NodeWithChildren));\nexports.CDATA = CDATA;\n/**\n * The root node of the document.\n */\nvar Document = /** @class */ (function (_super) {\n    __extends(Document, _super);\n    function Document() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Root;\n        return _this;\n    }\n    Object.defineProperty(Document.prototype, \"nodeType\", {\n        get: function () {\n            return 9;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Document;\n}(NodeWithChildren));\nexports.Document = Document;\n/**\n * An element within the DOM.\n */\nvar Element = /** @class */ (function (_super) {\n    __extends(Element, _super);\n    /**\n     * @param name Name of the tag, eg. `div`, `span`.\n     * @param attribs Object mapping attribute names to attribute values.\n     * @param children Children of the node.\n     */\n    function Element(name, attribs, children, type) {\n        if (children === void 0) { children = []; }\n        if (type === void 0) { type = name === \"script\"\n            ? domelementtype_1.ElementType.Script\n            : name === \"style\"\n                ? domelementtype_1.ElementType.Style\n                : domelementtype_1.ElementType.Tag; }\n        var _this = _super.call(this, children) || this;\n        _this.name = name;\n        _this.attribs = attribs;\n        _this.type = type;\n        return _this;\n    }\n    Object.defineProperty(Element.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"tagName\", {\n        // DOM Level 1 aliases\n        /**\n         * Same as {@link name}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.name;\n        },\n        set: function (name) {\n            this.name = name;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"attributes\", {\n        get: function () {\n            var _this = this;\n            return Object.keys(this.attribs).map(function (name) {\n                var _a, _b;\n                return ({\n                    name: name,\n                    value: _this.attribs[name],\n                    namespace: (_a = _this[\"x-attribsNamespace\"]) === null || _a === void 0 ? void 0 : _a[name],\n                    prefix: (_b = _this[\"x-attribsPrefix\"]) === null || _b === void 0 ? void 0 : _b[name],\n                });\n            });\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Element;\n}(NodeWithChildren));\nexports.Element = Element;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `Element`, `false` otherwise.\n */\nfunction isTag(node) {\n    return (0, domelementtype_1.isTag)(node);\n}\nexports.isTag = isTag;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `CDATA`, `false` otherwise.\n */\nfunction isCDATA(node) {\n    return node.type === domelementtype_1.ElementType.CDATA;\n}\nexports.isCDATA = isCDATA;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Text`, `false` otherwise.\n */\nfunction isText(node) {\n    return node.type === domelementtype_1.ElementType.Text;\n}\nexports.isText = isText;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Comment`, `false` otherwise.\n */\nfunction isComment(node) {\n    return node.type === domelementtype_1.ElementType.Comment;\n}\nexports.isComment = isComment;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDirective(node) {\n    return node.type === domelementtype_1.ElementType.Directive;\n}\nexports.isDirective = isDirective;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDocument(node) {\n    return node.type === domelementtype_1.ElementType.Root;\n}\nexports.isDocument = isDocument;\n/**\n * @param node Node to check.\n * @returns `true` if the node has children, `false` otherwise.\n */\nfunction hasChildren(node) {\n    return Object.prototype.hasOwnProperty.call(node, \"children\");\n}\nexports.hasChildren = hasChildren;\n/**\n * Clone a node, and optionally its children.\n *\n * @param recursive Clone child nodes as well.\n * @returns A clone of the node.\n */\nfunction cloneNode(node, recursive) {\n    if (recursive === void 0) { recursive = false; }\n    var result;\n    if (isText(node)) {\n        result = new Text(node.data);\n    }\n    else if (isComment(node)) {\n        result = new Comment(node.data);\n    }\n    else if (isTag(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_1 = new Element(node.name, __assign({}, node.attribs), children);\n        children.forEach(function (child) { return (child.parent = clone_1); });\n        if (node.namespace != null) {\n            clone_1.namespace = node.namespace;\n        }\n        if (node[\"x-attribsNamespace\"]) {\n            clone_1[\"x-attribsNamespace\"] = __assign({}, node[\"x-attribsNamespace\"]);\n        }\n        if (node[\"x-attribsPrefix\"]) {\n            clone_1[\"x-attribsPrefix\"] = __assign({}, node[\"x-attribsPrefix\"]);\n        }\n        result = clone_1;\n    }\n    else if (isCDATA(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_2 = new CDATA(children);\n        children.forEach(function (child) { return (child.parent = clone_2); });\n        result = clone_2;\n    }\n    else if (isDocument(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_3 = new Document(children);\n        children.forEach(function (child) { return (child.parent = clone_3); });\n        if (node[\"x-mode\"]) {\n            clone_3[\"x-mode\"] = node[\"x-mode\"];\n        }\n        result = clone_3;\n    }\n    else if (isDirective(node)) {\n        var instruction = new ProcessingInstruction(node.name, node.data);\n        if (node[\"x-name\"] != null) {\n            instruction[\"x-name\"] = node[\"x-name\"];\n            instruction[\"x-publicId\"] = node[\"x-publicId\"];\n            instruction[\"x-systemId\"] = node[\"x-systemId\"];\n        }\n        result = instruction;\n    }\n    else {\n        throw new Error(\"Not implemented yet: \".concat(node.type));\n    }\n    result.startIndex = node.startIndex;\n    result.endIndex = node.endIndex;\n    if (node.sourceCodeLocation != null) {\n        result.sourceCodeLocation = node.sourceCodeLocation;\n    }\n    return result;\n}\nexports.cloneNode = cloneNode;\nfunction cloneChildren(childs) {\n    var children = childs.map(function (child) { return cloneNode(child, true); });\n    for (var i = 1; i < children.length; i++) {\n        children[i].prev = children[i - 1];\n        children[i - 1].next = children[i];\n    }\n    return children;\n}\n","/*! @license DOMPurify 3.0.8 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.0.8/LICENSE */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.DOMPurify = factory());\n})(this, (function () { 'use strict';\n\n  const {\n    entries,\n    setPrototypeOf,\n    isFrozen,\n    getPrototypeOf,\n    getOwnPropertyDescriptor\n  } = Object;\n  let {\n    freeze,\n    seal,\n    create\n  } = Object; // eslint-disable-line import/no-mutable-exports\n  let {\n    apply,\n    construct\n  } = typeof Reflect !== 'undefined' && Reflect;\n  if (!freeze) {\n    freeze = function freeze(x) {\n      return x;\n    };\n  }\n  if (!seal) {\n    seal = function seal(x) {\n      return x;\n    };\n  }\n  if (!apply) {\n    apply = function apply(fun, thisValue, args) {\n      return fun.apply(thisValue, args);\n    };\n  }\n  if (!construct) {\n    construct = function construct(Func, args) {\n      return new Func(...args);\n    };\n  }\n  const arrayForEach = unapply(Array.prototype.forEach);\n  const arrayPop = unapply(Array.prototype.pop);\n  const arrayPush = unapply(Array.prototype.push);\n  const stringToLowerCase = unapply(String.prototype.toLowerCase);\n  const stringToString = unapply(String.prototype.toString);\n  const stringMatch = unapply(String.prototype.match);\n  const stringReplace = unapply(String.prototype.replace);\n  const stringIndexOf = unapply(String.prototype.indexOf);\n  const stringTrim = unapply(String.prototype.trim);\n  const regExpTest = unapply(RegExp.prototype.test);\n  const typeErrorCreate = unconstruct(TypeError);\n\n  /**\n   * Creates a new function that calls the given function with a specified thisArg and arguments.\n   *\n   * @param {Function} func - The function to be wrapped and called.\n   * @returns {Function} A new function that calls the given function with a specified thisArg and arguments.\n   */\n  function unapply(func) {\n    return function (thisArg) {\n      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n      return apply(func, thisArg, args);\n    };\n  }\n\n  /**\n   * Creates a new function that constructs an instance of the given constructor function with the provided arguments.\n   *\n   * @param {Function} func - The constructor function to be wrapped and called.\n   * @returns {Function} A new function that constructs an instance of the given constructor function with the provided arguments.\n   */\n  function unconstruct(func) {\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n      return construct(func, args);\n    };\n  }\n\n  /**\n   * Add properties to a lookup table\n   *\n   * @param {Object} set - The set to which elements will be added.\n   * @param {Array} array - The array containing elements to be added to the set.\n   * @param {Function} transformCaseFunc - An optional function to transform the case of each element before adding to the set.\n   * @returns {Object} The modified set with added elements.\n   */\n  function addToSet(set, array) {\n    let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;\n    if (setPrototypeOf) {\n      // Make 'in' and truthy checks like Boolean(set.constructor)\n      // independent of any properties defined on Object.prototype.\n      // Prevent prototype setters from intercepting set as a this value.\n      setPrototypeOf(set, null);\n    }\n    let l = array.length;\n    while (l--) {\n      let element = array[l];\n      if (typeof element === 'string') {\n        const lcElement = transformCaseFunc(element);\n        if (lcElement !== element) {\n          // Config presets (e.g. tags.js, attrs.js) are immutable.\n          if (!isFrozen(array)) {\n            array[l] = lcElement;\n          }\n          element = lcElement;\n        }\n      }\n      set[element] = true;\n    }\n    return set;\n  }\n\n  /**\n   * Clean up an array to harden against CSPP\n   *\n   * @param {Array} array - The array to be cleaned.\n   * @returns {Array} The cleaned version of the array\n   */\n  function cleanArray(array) {\n    for (let index = 0; index < array.length; index++) {\n      if (getOwnPropertyDescriptor(array, index) === undefined) {\n        array[index] = null;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * Shallow clone an object\n   *\n   * @param {Object} object - The object to be cloned.\n   * @returns {Object} A new object that copies the original.\n   */\n  function clone(object) {\n    const newObject = create(null);\n    for (const [property, value] of entries(object)) {\n      if (getOwnPropertyDescriptor(object, property) !== undefined) {\n        if (Array.isArray(value)) {\n          newObject[property] = cleanArray(value);\n        } else if (value && typeof value === 'object' && value.constructor === Object) {\n          newObject[property] = clone(value);\n        } else {\n          newObject[property] = value;\n        }\n      }\n    }\n    return newObject;\n  }\n\n  /**\n   * This method automatically checks if the prop is function or getter and behaves accordingly.\n   *\n   * @param {Object} object - The object to look up the getter function in its prototype chain.\n   * @param {String} prop - The property name for which to find the getter function.\n   * @returns {Function} The getter function found in the prototype chain or a fallback function.\n   */\n  function lookupGetter(object, prop) {\n    while (object !== null) {\n      const desc = getOwnPropertyDescriptor(object, prop);\n      if (desc) {\n        if (desc.get) {\n          return unapply(desc.get);\n        }\n        if (typeof desc.value === 'function') {\n          return unapply(desc.value);\n        }\n      }\n      object = getPrototypeOf(object);\n    }\n    function fallbackValue(element) {\n      console.warn('fallback value for', element);\n      return null;\n    }\n    return fallbackValue;\n  }\n\n  const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);\n\n  // SVG\n  const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);\n  const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);\n\n  // List of SVG elements that are disallowed by default.\n  // We still need to know them so that we can do namespace\n  // checks properly in case one wants to add them to\n  // allow-list.\n  const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);\n  const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);\n\n  // Similarly to SVG, we want to know all MathML elements,\n  // even those that we disallow by default.\n  const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);\n  const text = freeze(['#text']);\n\n  const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns', 'slot']);\n  const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);\n  const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);\n  const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);\n\n  // eslint-disable-next-line unicorn/better-regex\n  const MUSTACHE_EXPR = seal(/\\{\\{[\\w\\W]*|[\\w\\W]*\\}\\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode\n  const ERB_EXPR = seal(/<%[\\w\\W]*|[\\w\\W]*%>/gm);\n  const TMPLIT_EXPR = seal(/\\${[\\w\\W]*}/gm);\n  const DATA_ATTR = seal(/^data-[\\-\\w.\\u00B7-\\uFFFF]/); // eslint-disable-line no-useless-escape\n  const ARIA_ATTR = seal(/^aria-[\\-\\w]+$/); // eslint-disable-line no-useless-escape\n  const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i // eslint-disable-line no-useless-escape\n  );\n\n  const IS_SCRIPT_OR_DATA = seal(/^(?:\\w+script|data):/i);\n  const ATTR_WHITESPACE = seal(/[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205F\\u3000]/g // eslint-disable-line no-control-regex\n  );\n\n  const DOCTYPE_NAME = seal(/^html$/i);\n\n  var EXPRESSIONS = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    MUSTACHE_EXPR: MUSTACHE_EXPR,\n    ERB_EXPR: ERB_EXPR,\n    TMPLIT_EXPR: TMPLIT_EXPR,\n    DATA_ATTR: DATA_ATTR,\n    ARIA_ATTR: ARIA_ATTR,\n    IS_ALLOWED_URI: IS_ALLOWED_URI,\n    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,\n    ATTR_WHITESPACE: ATTR_WHITESPACE,\n    DOCTYPE_NAME: DOCTYPE_NAME\n  });\n\n  const getGlobal = function getGlobal() {\n    return typeof window === 'undefined' ? null : window;\n  };\n\n  /**\n   * Creates a no-op policy for internal use only.\n   * Don't export this function outside this module!\n   * @param {TrustedTypePolicyFactory} trustedTypes The policy factory.\n   * @param {HTMLScriptElement} purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).\n   * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types\n   * are not supported or creating the policy failed).\n   */\n  const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {\n    if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {\n      return null;\n    }\n\n    // Allow the callers to control the unique policy name\n    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.\n    // Policy creation with duplicate names throws in Trusted Types.\n    let suffix = null;\n    const ATTR_NAME = 'data-tt-policy-suffix';\n    if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {\n      suffix = purifyHostElement.getAttribute(ATTR_NAME);\n    }\n    const policyName = 'dompurify' + (suffix ? '#' + suffix : '');\n    try {\n      return trustedTypes.createPolicy(policyName, {\n        createHTML(html) {\n          return html;\n        },\n        createScriptURL(scriptUrl) {\n          return scriptUrl;\n        }\n      });\n    } catch (_) {\n      // Policy creation failed (most likely another DOMPurify script has\n      // already run). Skip creating the policy, as this will only cause errors\n      // if TT are enforced.\n      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');\n      return null;\n    }\n  };\n  function createDOMPurify() {\n    let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();\n    const DOMPurify = root => createDOMPurify(root);\n\n    /**\n     * Version label, exposed for easier checks\n     * if DOMPurify is up to date or not\n     */\n    DOMPurify.version = '3.0.8';\n\n    /**\n     * Array of elements that DOMPurify removed during sanitation.\n     * Empty if nothing was removed.\n     */\n    DOMPurify.removed = [];\n    if (!window || !window.document || window.document.nodeType !== 9) {\n      // Not running in a browser, provide a factory function\n      // so that you can pass your own Window\n      DOMPurify.isSupported = false;\n      return DOMPurify;\n    }\n    let {\n      document\n    } = window;\n    const originalDocument = document;\n    const currentScript = originalDocument.currentScript;\n    const {\n      DocumentFragment,\n      HTMLTemplateElement,\n      Node,\n      Element,\n      NodeFilter,\n      NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,\n      HTMLFormElement,\n      DOMParser,\n      trustedTypes\n    } = window;\n    const ElementPrototype = Element.prototype;\n    const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');\n    const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');\n    const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');\n    const getParentNode = lookupGetter(ElementPrototype, 'parentNode');\n\n    // As per issue #47, the web-components registry is inherited by a\n    // new document created via createHTMLDocument. As per the spec\n    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)\n    // a new empty registry is used when creating a template contents owner\n    // document, so we use that as our parent document to ensure nothing\n    // is inherited.\n    if (typeof HTMLTemplateElement === 'function') {\n      const template = document.createElement('template');\n      if (template.content && template.content.ownerDocument) {\n        document = template.content.ownerDocument;\n      }\n    }\n    let trustedTypesPolicy;\n    let emptyHTML = '';\n    const {\n      implementation,\n      createNodeIterator,\n      createDocumentFragment,\n      getElementsByTagName\n    } = document;\n    const {\n      importNode\n    } = originalDocument;\n    let hooks = {};\n\n    /**\n     * Expose whether this browser supports running the full DOMPurify.\n     */\n    DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;\n    const {\n      MUSTACHE_EXPR,\n      ERB_EXPR,\n      TMPLIT_EXPR,\n      DATA_ATTR,\n      ARIA_ATTR,\n      IS_SCRIPT_OR_DATA,\n      ATTR_WHITESPACE\n    } = EXPRESSIONS;\n    let {\n      IS_ALLOWED_URI: IS_ALLOWED_URI$1\n    } = EXPRESSIONS;\n\n    /**\n     * We consider the elements and attributes below to be safe. Ideally\n     * don't add any new ones but feel free to remove unwanted ones.\n     */\n\n    /* allowed element names */\n    let ALLOWED_TAGS = null;\n    const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);\n\n    /* Allowed attribute names */\n    let ALLOWED_ATTR = null;\n    const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);\n\n    /*\n     * Configure how DOMPUrify should handle custom elements and their attributes as well as customized built-in elements.\n     * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)\n     * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)\n     * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.\n     */\n    let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {\n      tagNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      attributeNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      allowCustomizedBuiltInElements: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: false\n      }\n    }));\n\n    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */\n    let FORBID_TAGS = null;\n\n    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */\n    let FORBID_ATTR = null;\n\n    /* Decide if ARIA attributes are okay */\n    let ALLOW_ARIA_ATTR = true;\n\n    /* Decide if custom data attributes are okay */\n    let ALLOW_DATA_ATTR = true;\n\n    /* Decide if unknown protocols are okay */\n    let ALLOW_UNKNOWN_PROTOCOLS = false;\n\n    /* Decide if self-closing tags in attributes are allowed.\n     * Usually removed due to a mXSS issue in jQuery 3.0 */\n    let ALLOW_SELF_CLOSE_IN_ATTR = true;\n\n    /* Output should be safe for common template engines.\n     * This means, DOMPurify removes data attributes, mustaches and ERB\n     */\n    let SAFE_FOR_TEMPLATES = false;\n\n    /* Decide if document with <html>... should be returned */\n    let WHOLE_DOCUMENT = false;\n\n    /* Track whether config is already set on this instance of DOMPurify. */\n    let SET_CONFIG = false;\n\n    /* Decide if all elements (e.g. style, script) must be children of\n     * document.body. By default, browsers might move them to document.head */\n    let FORCE_BODY = false;\n\n    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html\n     * string (or a TrustedHTML object if Trusted Types are supported).\n     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead\n     */\n    let RETURN_DOM = false;\n\n    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html\n     * string  (or a TrustedHTML object if Trusted Types are supported) */\n    let RETURN_DOM_FRAGMENT = false;\n\n    /* Try to return a Trusted Type object instead of a string, return a string in\n     * case Trusted Types are not supported  */\n    let RETURN_TRUSTED_TYPE = false;\n\n    /* Output should be free from DOM clobbering attacks?\n     * This sanitizes markups named with colliding, clobberable built-in DOM APIs.\n     */\n    let SANITIZE_DOM = true;\n\n    /* Achieve full DOM Clobbering protection by isolating the namespace of named\n     * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.\n     *\n     * HTML/DOM spec rules that enable DOM Clobbering:\n     *   - Named Access on Window (§7.3.3)\n     *   - DOM Tree Accessors (§3.1.5)\n     *   - Form Element Parent-Child Relations (§4.10.3)\n     *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)\n     *   - HTMLCollection (§4.2.10.2)\n     *\n     * Namespace isolation is implemented by prefixing `id` and `name` attributes\n     * with a constant string, i.e., `user-content-`\n     */\n    let SANITIZE_NAMED_PROPS = false;\n    const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';\n\n    /* Keep element content when removing element? */\n    let KEEP_CONTENT = true;\n\n    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead\n     * of importing it into a new Document and returning a sanitized copy */\n    let IN_PLACE = false;\n\n    /* Allow usage of profiles like html, svg and mathMl */\n    let USE_PROFILES = {};\n\n    /* Tags to ignore content of when KEEP_CONTENT is true */\n    let FORBID_CONTENTS = null;\n    const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);\n\n    /* Tags that are safe for data: URIs */\n    let DATA_URI_TAGS = null;\n    const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);\n\n    /* Attributes safe for values like \"javascript:\" */\n    let URI_SAFE_ATTRIBUTES = null;\n    const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);\n    const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\n    const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n    const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';\n    /* Document namespace */\n    let NAMESPACE = HTML_NAMESPACE;\n    let IS_EMPTY_INPUT = false;\n\n    /* Allowed XHTML+XML namespaces */\n    let ALLOWED_NAMESPACES = null;\n    const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);\n\n    /* Parsing of strict XHTML documents */\n    let PARSER_MEDIA_TYPE = null;\n    const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];\n    const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';\n    let transformCaseFunc = null;\n\n    /* Keep a reference to config to pass to hooks */\n    let CONFIG = null;\n\n    /* Ideally, do not touch anything below this line */\n    /* ______________________________________________ */\n\n    const formElement = document.createElement('form');\n    const isRegexOrFunction = function isRegexOrFunction(testValue) {\n      return testValue instanceof RegExp || testValue instanceof Function;\n    };\n\n    /**\n     * _parseConfig\n     *\n     * @param  {Object} cfg optional config literal\n     */\n    // eslint-disable-next-line complexity\n    const _parseConfig = function _parseConfig() {\n      let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      if (CONFIG && CONFIG === cfg) {\n        return;\n      }\n\n      /* Shield configuration object from tampering */\n      if (!cfg || typeof cfg !== 'object') {\n        cfg = {};\n      }\n\n      /* Shield configuration object from prototype pollution */\n      cfg = clone(cfg);\n      PARSER_MEDIA_TYPE =\n      // eslint-disable-next-line unicorn/prefer-includes\n      SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;\n\n      // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.\n      transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;\n\n      /* Set configuration parameters */\n      ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;\n      ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;\n      ALLOWED_NAMESPACES = 'ALLOWED_NAMESPACES' in cfg ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;\n      URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES),\n      // eslint-disable-line indent\n      cfg.ADD_URI_SAFE_ATTR,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_URI_SAFE_ATTRIBUTES;\n      DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS),\n      // eslint-disable-line indent\n      cfg.ADD_DATA_URI_TAGS,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_DATA_URI_TAGS;\n      FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;\n      FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};\n      FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};\n      USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;\n      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true\n      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true\n      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false\n      ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true\n      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false\n      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false\n      RETURN_DOM = cfg.RETURN_DOM || false; // Default false\n      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false\n      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false\n      FORCE_BODY = cfg.FORCE_BODY || false; // Default false\n      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true\n      SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false\n      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true\n      IN_PLACE = cfg.IN_PLACE || false; // Default false\n      IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;\n      NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;\n      CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {\n        CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;\n      }\n      if (SAFE_FOR_TEMPLATES) {\n        ALLOW_DATA_ATTR = false;\n      }\n      if (RETURN_DOM_FRAGMENT) {\n        RETURN_DOM = true;\n      }\n\n      /* Parse profile info */\n      if (USE_PROFILES) {\n        ALLOWED_TAGS = addToSet({}, text);\n        ALLOWED_ATTR = [];\n        if (USE_PROFILES.html === true) {\n          addToSet(ALLOWED_TAGS, html$1);\n          addToSet(ALLOWED_ATTR, html);\n        }\n        if (USE_PROFILES.svg === true) {\n          addToSet(ALLOWED_TAGS, svg$1);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.svgFilters === true) {\n          addToSet(ALLOWED_TAGS, svgFilters);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.mathMl === true) {\n          addToSet(ALLOWED_TAGS, mathMl$1);\n          addToSet(ALLOWED_ATTR, mathMl);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n      }\n\n      /* Merge configuration parameters */\n      if (cfg.ADD_TAGS) {\n        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {\n          ALLOWED_TAGS = clone(ALLOWED_TAGS);\n        }\n        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);\n      }\n      if (cfg.ADD_ATTR) {\n        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {\n          ALLOWED_ATTR = clone(ALLOWED_ATTR);\n        }\n        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);\n      }\n      if (cfg.ADD_URI_SAFE_ATTR) {\n        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);\n      }\n      if (cfg.FORBID_CONTENTS) {\n        if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {\n          FORBID_CONTENTS = clone(FORBID_CONTENTS);\n        }\n        addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);\n      }\n\n      /* Add #text in case KEEP_CONTENT is set to true */\n      if (KEEP_CONTENT) {\n        ALLOWED_TAGS['#text'] = true;\n      }\n\n      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */\n      if (WHOLE_DOCUMENT) {\n        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);\n      }\n\n      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */\n      if (ALLOWED_TAGS.table) {\n        addToSet(ALLOWED_TAGS, ['tbody']);\n        delete FORBID_TAGS.tbody;\n      }\n      if (cfg.TRUSTED_TYPES_POLICY) {\n        if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== 'function') {\n          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a \"createHTML\" hook.');\n        }\n        if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {\n          throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a \"createScriptURL\" hook.');\n        }\n\n        // Overwrite existing TrustedTypes policy.\n        trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;\n\n        // Sign local variables required by `sanitize`.\n        emptyHTML = trustedTypesPolicy.createHTML('');\n      } else {\n        // Uninitialized policy, attempt to initialize the internal dompurify policy.\n        if (trustedTypesPolicy === undefined) {\n          trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);\n        }\n\n        // If creating the internal policy succeeded sign internal variables.\n        if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {\n          emptyHTML = trustedTypesPolicy.createHTML('');\n        }\n      }\n\n      // Prevent further manipulation of configuration.\n      // Not available in IE8, Safari 5, etc.\n      if (freeze) {\n        freeze(cfg);\n      }\n      CONFIG = cfg;\n    };\n    const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);\n    const HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']);\n\n    // Certain elements are allowed in both SVG and HTML\n    // namespace. We need to specify them explicitly\n    // so that they don't get erroneously deleted from\n    // HTML namespace.\n    const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);\n\n    /* Keep track of all possible SVG and MathML tags\n     * so that we can perform the namespace checks\n     * correctly. */\n    const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);\n    const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);\n\n    /**\n     * @param  {Element} element a DOM element whose namespace is being checked\n     * @returns {boolean} Return false if the element has a\n     *  namespace that a spec-compliant parser would never\n     *  return. Return true otherwise.\n     */\n    const _checkValidNamespace = function _checkValidNamespace(element) {\n      let parent = getParentNode(element);\n\n      // In JSDOM, if we're inside shadow DOM, then parentNode\n      // can be null. We just simulate parent in this case.\n      if (!parent || !parent.tagName) {\n        parent = {\n          namespaceURI: NAMESPACE,\n          tagName: 'template'\n        };\n      }\n      const tagName = stringToLowerCase(element.tagName);\n      const parentTagName = stringToLowerCase(parent.tagName);\n      if (!ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return false;\n      }\n      if (element.namespaceURI === SVG_NAMESPACE) {\n        // The only way to switch from HTML namespace to SVG\n        // is via <svg>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'svg';\n        }\n\n        // The only way to switch from MathML to SVG is via`\n        // svg if parent is either <annotation-xml> or MathML\n        // text integration points.\n        if (parent.namespaceURI === MATHML_NAMESPACE) {\n          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);\n        }\n\n        // We only allow elements that are defined in SVG\n        // spec. All others are disallowed in SVG namespace.\n        return Boolean(ALL_SVG_TAGS[tagName]);\n      }\n      if (element.namespaceURI === MATHML_NAMESPACE) {\n        // The only way to switch from HTML namespace to MathML\n        // is via <math>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'math';\n        }\n\n        // The only way to switch from SVG to MathML is via\n        // <math> and HTML integration points\n        if (parent.namespaceURI === SVG_NAMESPACE) {\n          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];\n        }\n\n        // We only allow elements that are defined in MathML\n        // spec. All others are disallowed in MathML namespace.\n        return Boolean(ALL_MATHML_TAGS[tagName]);\n      }\n      if (element.namespaceURI === HTML_NAMESPACE) {\n        // The only way to switch from SVG to HTML is via\n        // HTML integration points, and from MathML to HTML\n        // is via MathML text integration points\n        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n\n        // We disallow tags that are specific for MathML\n        // or SVG and should never appear in HTML namespace\n        return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);\n      }\n\n      // For XHTML and XML documents that support custom namespaces\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return true;\n      }\n\n      // The code should never reach this place (this means\n      // that the element somehow got namespace that is not\n      // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).\n      // Return false just in case.\n      return false;\n    };\n\n    /**\n     * _forceRemove\n     *\n     * @param  {Node} node a DOM node\n     */\n    const _forceRemove = function _forceRemove(node) {\n      arrayPush(DOMPurify.removed, {\n        element: node\n      });\n      try {\n        // eslint-disable-next-line unicorn/prefer-dom-node-remove\n        node.parentNode.removeChild(node);\n      } catch (_) {\n        node.remove();\n      }\n    };\n\n    /**\n     * _removeAttribute\n     *\n     * @param  {String} name an Attribute name\n     * @param  {Node} node a DOM node\n     */\n    const _removeAttribute = function _removeAttribute(name, node) {\n      try {\n        arrayPush(DOMPurify.removed, {\n          attribute: node.getAttributeNode(name),\n          from: node\n        });\n      } catch (_) {\n        arrayPush(DOMPurify.removed, {\n          attribute: null,\n          from: node\n        });\n      }\n      node.removeAttribute(name);\n\n      // We void attribute values for unremovable \"is\"\" attributes\n      if (name === 'is' && !ALLOWED_ATTR[name]) {\n        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {\n          try {\n            _forceRemove(node);\n          } catch (_) {}\n        } else {\n          try {\n            node.setAttribute(name, '');\n          } catch (_) {}\n        }\n      }\n    };\n\n    /**\n     * _initDocument\n     *\n     * @param  {String} dirty a string of dirty markup\n     * @return {Document} a DOM, filled with the dirty markup\n     */\n    const _initDocument = function _initDocument(dirty) {\n      /* Create a HTML document */\n      let doc = null;\n      let leadingWhitespace = null;\n      if (FORCE_BODY) {\n        dirty = '<remove></remove>' + dirty;\n      } else {\n        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */\n        const matches = stringMatch(dirty, /^[\\r\\n\\t ]+/);\n        leadingWhitespace = matches && matches[0];\n      }\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {\n        // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)\n        dirty = '<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>' + dirty + '</body></html>';\n      }\n      const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;\n      /*\n       * Use the DOMParser API by default, fallback later if needs be\n       * DOMParser not work for svg when has multiple root element.\n       */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        try {\n          doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);\n        } catch (_) {}\n      }\n\n      /* Use createHTMLDocument in case DOMParser is not available */\n      if (!doc || !doc.documentElement) {\n        doc = implementation.createDocument(NAMESPACE, 'template', null);\n        try {\n          doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;\n        } catch (_) {\n          // Syntax error if dirtyPayload is invalid xml\n        }\n      }\n      const body = doc.body || doc.documentElement;\n      if (dirty && leadingWhitespace) {\n        body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);\n      }\n\n      /* Work on whole document or just its body */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];\n      }\n      return WHOLE_DOCUMENT ? doc.documentElement : body;\n    };\n\n    /**\n     * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.\n     *\n     * @param  {Node} root The root element or node to start traversing on.\n     * @return {NodeIterator} The created NodeIterator\n     */\n    const _createNodeIterator = function _createNodeIterator(root) {\n      return createNodeIterator.call(root.ownerDocument || root, root,\n      // eslint-disable-next-line no-bitwise\n      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null);\n    };\n\n    /**\n     * _isClobbered\n     *\n     * @param  {Node} elm element to check for clobbering attacks\n     * @return {Boolean} true if clobbered, false if safe\n     */\n    const _isClobbered = function _isClobbered(elm) {\n      return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');\n    };\n\n    /**\n     * Checks whether the given object is a DOM node.\n     *\n     * @param  {Node} object object to check whether it's a DOM node\n     * @return {Boolean} true is object is a DOM node\n     */\n    const _isNode = function _isNode(object) {\n      return typeof Node === 'function' && object instanceof Node;\n    };\n\n    /**\n     * _executeHook\n     * Execute user configurable hooks\n     *\n     * @param  {String} entryPoint  Name of the hook's entry point\n     * @param  {Node} currentNode node to work on with the hook\n     * @param  {Object} data additional hook parameters\n     */\n    const _executeHook = function _executeHook(entryPoint, currentNode, data) {\n      if (!hooks[entryPoint]) {\n        return;\n      }\n      arrayForEach(hooks[entryPoint], hook => {\n        hook.call(DOMPurify, currentNode, data, CONFIG);\n      });\n    };\n\n    /**\n     * _sanitizeElements\n     *\n     * @protect nodeName\n     * @protect textContent\n     * @protect removeChild\n     *\n     * @param   {Node} currentNode to check for permission to exist\n     * @return  {Boolean} true if node was killed, false if left alive\n     */\n    const _sanitizeElements = function _sanitizeElements(currentNode) {\n      let content = null;\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeElements', currentNode, null);\n\n      /* Check if element is clobbered or can clobber */\n      if (_isClobbered(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Now let's check the element's type and name */\n      const tagName = transformCaseFunc(currentNode.nodeName);\n\n      /* Execute a hook if present */\n      _executeHook('uponSanitizeElement', currentNode, {\n        tagName,\n        allowedTags: ALLOWED_TAGS\n      });\n\n      /* Detect mXSS attempts abusing namespace confusion */\n      if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\\w]/g, currentNode.innerHTML) && regExpTest(/<[/\\w]/g, currentNode.textContent)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove element if anything forbids its presence */\n      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n        /* Check if we have a custom element to handle */\n        if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {\n            return false;\n          }\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {\n            return false;\n          }\n        }\n\n        /* Keep content except for bad-listed elements */\n        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {\n          const parentNode = getParentNode(currentNode) || currentNode.parentNode;\n          const childNodes = getChildNodes(currentNode) || currentNode.childNodes;\n          if (childNodes && parentNode) {\n            const childCount = childNodes.length;\n            for (let i = childCount - 1; i >= 0; --i) {\n              parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));\n            }\n          }\n        }\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check whether element has a valid namespace */\n      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Make sure that older browsers don't get fallback-tag mXSS */\n      if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\\/no(script|embed|frames)/i, currentNode.innerHTML)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Sanitize element content to be template-safe */\n      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {\n        /* Get the element's text content */\n        content = currentNode.textContent;\n        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n          content = stringReplace(content, expr, ' ');\n        });\n        if (currentNode.textContent !== content) {\n          arrayPush(DOMPurify.removed, {\n            element: currentNode.cloneNode()\n          });\n          currentNode.textContent = content;\n        }\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeElements', currentNode, null);\n      return false;\n    };\n\n    /**\n     * _isValidAttribute\n     *\n     * @param  {string} lcTag Lowercase tag name of containing element.\n     * @param  {string} lcName Lowercase attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid, otherwise false.\n     */\n    // eslint-disable-next-line complexity\n    const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {\n      /* Make sure attribute cannot clobber */\n      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {\n        return false;\n      }\n\n      /* Allow valid data-* attributes: At least one character after \"-\"\n          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)\n          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)\n          We don't need to check the value; it's always URI safe. */\n      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {\n        if (\n        // First condition does a very basic check if a) it's basically a valid custom element tagname AND\n        // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck\n        _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||\n        // Alternative, second condition checks if it's an `is`-attribute, AND\n        // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {\n          return false;\n        }\n        /* Check value is safe. First, is attr inert? If so, is safe */\n      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {\n        return false;\n      } else ;\n      return true;\n    };\n\n    /**\n     * _isBasicCustomElement\n     * checks if at least one dash is included in tagName, and it's not the first char\n     * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name\n     *\n     * @param {string} tagName name of the tag of the node to sanitize\n     * @returns {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.\n     */\n    const _isBasicCustomElement = function _isBasicCustomElement(tagName) {\n      return tagName.indexOf('-') > 0;\n    };\n\n    /**\n     * _sanitizeAttributes\n     *\n     * @protect attributes\n     * @protect nodeName\n     * @protect removeAttribute\n     * @protect setAttribute\n     *\n     * @param  {Node} currentNode to sanitize\n     */\n    const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeAttributes', currentNode, null);\n      const {\n        attributes\n      } = currentNode;\n\n      /* Check if we have attributes; if not we might have a text node */\n      if (!attributes) {\n        return;\n      }\n      const hookEvent = {\n        attrName: '',\n        attrValue: '',\n        keepAttr: true,\n        allowedAttributes: ALLOWED_ATTR\n      };\n      let l = attributes.length;\n\n      /* Go backwards over all attributes; safely remove bad ones */\n      while (l--) {\n        const attr = attributes[l];\n        const {\n          name,\n          namespaceURI,\n          value: attrValue\n        } = attr;\n        const lcName = transformCaseFunc(name);\n        let value = name === 'value' ? attrValue : stringTrim(attrValue);\n\n        /* Execute a hook if present */\n        hookEvent.attrName = lcName;\n        hookEvent.attrValue = value;\n        hookEvent.keepAttr = true;\n        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set\n        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);\n        value = hookEvent.attrValue;\n        /* Did the hooks approve of the attribute? */\n        if (hookEvent.forceKeepAttr) {\n          continue;\n        }\n\n        /* Remove attribute */\n        _removeAttribute(name, currentNode);\n\n        /* Did the hooks approve of the attribute? */\n        if (!hookEvent.keepAttr) {\n          continue;\n        }\n\n        /* Work around a security issue in jQuery 3.0 */\n        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\\/>/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Sanitize attribute content to be template-safe */\n        if (SAFE_FOR_TEMPLATES) {\n          arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n            value = stringReplace(value, expr, ' ');\n          });\n        }\n\n        /* Is `value` valid for this attribute? */\n        const lcTag = transformCaseFunc(currentNode.nodeName);\n        if (!_isValidAttribute(lcTag, lcName, value)) {\n          continue;\n        }\n\n        /* Full DOM Clobbering protection via namespace isolation,\n         * Prefix id and name attributes with `user-content-`\n         */\n        if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {\n          // Remove the attribute with this value\n          _removeAttribute(name, currentNode);\n\n          // Prefix the value and later re-create the attribute with the sanitized value\n          value = SANITIZE_NAMED_PROPS_PREFIX + value;\n        }\n\n        /* Handle attributes that require Trusted Types */\n        if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {\n          if (namespaceURI) ; else {\n            switch (trustedTypes.getAttributeType(lcTag, lcName)) {\n              case 'TrustedHTML':\n                {\n                  value = trustedTypesPolicy.createHTML(value);\n                  break;\n                }\n              case 'TrustedScriptURL':\n                {\n                  value = trustedTypesPolicy.createScriptURL(value);\n                  break;\n                }\n            }\n          }\n        }\n\n        /* Handle invalid data-* attribute set by try-catching it */\n        try {\n          if (namespaceURI) {\n            currentNode.setAttributeNS(namespaceURI, name, value);\n          } else {\n            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. \"x-schema\". */\n            currentNode.setAttribute(name, value);\n          }\n          arrayPop(DOMPurify.removed);\n        } catch (_) {}\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeAttributes', currentNode, null);\n    };\n\n    /**\n     * _sanitizeShadowDOM\n     *\n     * @param  {DocumentFragment} fragment to iterate over recursively\n     */\n    const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {\n      let shadowNode = null;\n      const shadowIterator = _createNodeIterator(fragment);\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeShadowDOM', fragment, null);\n      while (shadowNode = shadowIterator.nextNode()) {\n        /* Execute a hook if present */\n        _executeHook('uponSanitizeShadowNode', shadowNode, null);\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(shadowNode)) {\n          continue;\n        }\n\n        /* Deep shadow DOM detected */\n        if (shadowNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(shadowNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(shadowNode);\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeShadowDOM', fragment, null);\n    };\n\n    /**\n     * Sanitize\n     * Public method providing core sanitation functionality\n     *\n     * @param {String|Node} dirty string or DOM node\n     * @param {Object} cfg object\n     */\n    // eslint-disable-next-line complexity\n    DOMPurify.sanitize = function (dirty) {\n      let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      let body = null;\n      let importedNode = null;\n      let currentNode = null;\n      let returnNode = null;\n      /* Make sure we have a string to sanitize.\n        DO NOT return early, as this will return the wrong type if\n        the user has requested a DOM object rather than a string */\n      IS_EMPTY_INPUT = !dirty;\n      if (IS_EMPTY_INPUT) {\n        dirty = '<!-->';\n      }\n\n      /* Stringify, in case dirty is an object */\n      if (typeof dirty !== 'string' && !_isNode(dirty)) {\n        if (typeof dirty.toString === 'function') {\n          dirty = dirty.toString();\n          if (typeof dirty !== 'string') {\n            throw typeErrorCreate('dirty is not a string, aborting');\n          }\n        } else {\n          throw typeErrorCreate('toString is not a function');\n        }\n      }\n\n      /* Return dirty HTML if DOMPurify cannot run */\n      if (!DOMPurify.isSupported) {\n        return dirty;\n      }\n\n      /* Assign config vars */\n      if (!SET_CONFIG) {\n        _parseConfig(cfg);\n      }\n\n      /* Clean up removed elements */\n      DOMPurify.removed = [];\n\n      /* Check if dirty is correctly typed for IN_PLACE */\n      if (typeof dirty === 'string') {\n        IN_PLACE = false;\n      }\n      if (IN_PLACE) {\n        /* Do some early pre-sanitization to avoid unsafe root nodes */\n        if (dirty.nodeName) {\n          const tagName = transformCaseFunc(dirty.nodeName);\n          if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n            throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');\n          }\n        }\n      } else if (dirty instanceof Node) {\n        /* If dirty is a DOM element, append to an empty document to avoid\n           elements being stripped by the parser */\n        body = _initDocument('<!---->');\n        importedNode = body.ownerDocument.importNode(dirty, true);\n        if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {\n          /* Node is already a body, use as is */\n          body = importedNode;\n        } else if (importedNode.nodeName === 'HTML') {\n          body = importedNode;\n        } else {\n          // eslint-disable-next-line unicorn/prefer-dom-node-append\n          body.appendChild(importedNode);\n        }\n      } else {\n        /* Exit directly if we have nothing to do */\n        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&\n        // eslint-disable-next-line unicorn/prefer-includes\n        dirty.indexOf('<') === -1) {\n          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;\n        }\n\n        /* Initialize the document to work on */\n        body = _initDocument(dirty);\n\n        /* Check we have a DOM node from the data */\n        if (!body) {\n          return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';\n        }\n      }\n\n      /* Remove first element node (ours) if FORCE_BODY is set */\n      if (body && FORCE_BODY) {\n        _forceRemove(body.firstChild);\n      }\n\n      /* Get node iterator */\n      const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);\n\n      /* Now start iterating over the created document */\n      while (currentNode = nodeIterator.nextNode()) {\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(currentNode)) {\n          continue;\n        }\n\n        /* Shadow DOM detected, sanitize it */\n        if (currentNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(currentNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(currentNode);\n      }\n\n      /* If we sanitized `dirty` in-place, return it. */\n      if (IN_PLACE) {\n        return dirty;\n      }\n\n      /* Return sanitized string or DOM */\n      if (RETURN_DOM) {\n        if (RETURN_DOM_FRAGMENT) {\n          returnNode = createDocumentFragment.call(body.ownerDocument);\n          while (body.firstChild) {\n            // eslint-disable-next-line unicorn/prefer-dom-node-append\n            returnNode.appendChild(body.firstChild);\n          }\n        } else {\n          returnNode = body;\n        }\n        if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {\n          /*\n            AdoptNode() is not used because internal state is not reset\n            (e.g. the past names map of a HTMLFormElement), this is safe\n            in theory but we would rather not risk another attack vector.\n            The state that is cloned by importNode() is explicitly defined\n            by the specs.\n          */\n          returnNode = importNode.call(originalDocument, returnNode, true);\n        }\n        return returnNode;\n      }\n      let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;\n\n      /* Serialize doctype if allowed */\n      if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {\n        serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\\n' + serializedHTML;\n      }\n\n      /* Sanitize final string template-safe */\n      if (SAFE_FOR_TEMPLATES) {\n        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {\n          serializedHTML = stringReplace(serializedHTML, expr, ' ');\n        });\n      }\n      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;\n    };\n\n    /**\n     * Public method to set the configuration once\n     * setConfig\n     *\n     * @param {Object} cfg configuration object\n     */\n    DOMPurify.setConfig = function () {\n      let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      _parseConfig(cfg);\n      SET_CONFIG = true;\n    };\n\n    /**\n     * Public method to remove the configuration\n     * clearConfig\n     *\n     */\n    DOMPurify.clearConfig = function () {\n      CONFIG = null;\n      SET_CONFIG = false;\n    };\n\n    /**\n     * Public method to check if an attribute value is valid.\n     * Uses last set config, if any. Otherwise, uses config defaults.\n     * isValidAttribute\n     *\n     * @param  {String} tag Tag name of containing element.\n     * @param  {String} attr Attribute name.\n     * @param  {String} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.\n     */\n    DOMPurify.isValidAttribute = function (tag, attr, value) {\n      /* Initialize shared config vars if necessary. */\n      if (!CONFIG) {\n        _parseConfig({});\n      }\n      const lcTag = transformCaseFunc(tag);\n      const lcName = transformCaseFunc(attr);\n      return _isValidAttribute(lcTag, lcName, value);\n    };\n\n    /**\n     * AddHook\n     * Public method to add DOMPurify hooks\n     *\n     * @param {String} entryPoint entry point for the hook to add\n     * @param {Function} hookFunction function to execute\n     */\n    DOMPurify.addHook = function (entryPoint, hookFunction) {\n      if (typeof hookFunction !== 'function') {\n        return;\n      }\n      hooks[entryPoint] = hooks[entryPoint] || [];\n      arrayPush(hooks[entryPoint], hookFunction);\n    };\n\n    /**\n     * RemoveHook\n     * Public method to remove a DOMPurify hook at a given entryPoint\n     * (pops it from the stack of hooks if more are present)\n     *\n     * @param {String} entryPoint entry point for the hook to remove\n     * @return {Function} removed(popped) hook\n     */\n    DOMPurify.removeHook = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        return arrayPop(hooks[entryPoint]);\n      }\n    };\n\n    /**\n     * RemoveHooks\n     * Public method to remove all DOMPurify hooks at a given entryPoint\n     *\n     * @param  {String} entryPoint entry point for the hooks to remove\n     */\n    DOMPurify.removeHooks = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        hooks[entryPoint] = [];\n      }\n    };\n\n    /**\n     * RemoveAllHooks\n     * Public method to remove all DOMPurify hooks\n     */\n    DOMPurify.removeAllHooks = function () {\n      hooks = {};\n    };\n    return DOMPurify;\n  }\n  var purify = createDOMPurify();\n\n  return purify;\n\n}));\n//# sourceMappingURL=purify.js.map\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getFeed = void 0;\nvar stringify_js_1 = require(\"./stringify.js\");\nvar legacy_js_1 = require(\"./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 */\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_js_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_js_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) || 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    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_js_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 = 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_js_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_js_1.textContent)((0, legacy_js_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//# sourceMappingURL=feeds.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.uniqueSort = exports.compareDocumentPosition = exports.DocumentPosition = 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 * member.\n *\n * @category Helpers\n * @param nodes Nodes to filter.\n * @returns Remaining nodes that aren't contained by other nodes.\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 * @category Helpers\n * @see {@link http://dom.spec.whatwg.org/#dom-node-comparedocumentposition}\n */\nvar 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 = exports.DocumentPosition || (exports.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 */\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 DocumentPosition.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 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}\nexports.compareDocumentPosition = compareDocumentPosition;\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 */\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 & DocumentPosition.PRECEDING) {\n            return -1;\n        }\n        else if (relative & DocumentPosition.FOLLOWING) {\n            return 1;\n        }\n        return 0;\n    });\n    return nodes;\n}\nexports.uniqueSort = uniqueSort;\n//# sourceMappingURL=helpers.js.map","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\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.js\"), exports);\n__exportStar(require(\"./traversal.js\"), exports);\n__exportStar(require(\"./manipulation.js\"), exports);\n__exportStar(require(\"./querying.js\"), exports);\n__exportStar(require(\"./legacy.js\"), exports);\n__exportStar(require(\"./helpers.js\"), exports);\n__exportStar(require(\"./feeds.js\"), 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//# sourceMappingURL=index.js.map","\"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_js_1 = require(\"./querying.js\");\n/**\n * A map of functions to check nodes against.\n */\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 * 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 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 * 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 function (elem) { return 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    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 * 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 */\nfunction testElement(options, node) {\n    var test = compileTest(options);\n    return test ? test(node) : true;\n}\nexports.testElement = testElement;\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 */\nfunction getElements(options, nodes, recurse, limit) {\n    if (limit === void 0) { limit = Infinity; }\n    var test = compileTest(options);\n    return test ? (0, querying_js_1.filter)(test, nodes, recurse, limit) : [];\n}\nexports.getElements = getElements;\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 */\nfunction getElementById(id, nodes, recurse) {\n    if (recurse === void 0) { recurse = true; }\n    if (!Array.isArray(nodes))\n        nodes = [nodes];\n    return (0, querying_js_1.findOne)(getAttribCheck(\"id\", id), nodes, recurse);\n}\nexports.getElementById = getElementById;\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 */\nfunction getElementsByTagName(tagName, nodes, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    return (0, querying_js_1.filter)(Checks[\"tag_name\"](tagName), nodes, recurse, limit);\n}\nexports.getElementsByTagName = getElementsByTagName;\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 */\nfunction getElementsByTagType(type, nodes, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    return (0, querying_js_1.filter)(Checks[\"tag_type\"](type), nodes, recurse, limit);\n}\nexports.getElementsByTagType = getElementsByTagType;\n//# sourceMappingURL=legacy.js.map","\"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 * @category Manipulation\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        var 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}\nexports.removeElement = removeElement;\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 */\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        elem.parent = null;\n    }\n}\nexports.replaceElement = replaceElement;\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 */\nfunction appendChild(parent, child) {\n    removeElement(child);\n    child.next = null;\n    child.parent = parent;\n    if (parent.children.push(child) > 1) {\n        var sibling = parent.children[parent.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 * @category Manipulation\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 * @category Manipulation\n * @param parent The element to prepend before.\n * @param child The element to be added as a child.\n */\nfunction prependChild(parent, child) {\n    removeElement(child);\n    child.parent = parent;\n    child.prev = null;\n    if (parent.children.unshift(child) !== 1) {\n        var sibling = parent.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 * @category Manipulation\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//# sourceMappingURL=manipulation.js.map","\"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. 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 */\nfunction filter(test, node, recurse, limit) {\n    if (recurse === void 0) { recurse = true; }\n    if (limit === void 0) { limit = Infinity; }\n    return find(test, Array.isArray(node) ? node : [node], recurse, limit);\n}\nexports.filter = filter;\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 */\nfunction find(test, nodes, recurse, limit) {\n    var result = [];\n    /** Stack of the arrays we are looking at. */\n    var nodeStack = [nodes];\n    /** Stack of the indices within the arrays. */\n    var 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        var elem = nodeStack[0][indexStack[0]++];\n        if (test(elem)) {\n            result.push(elem);\n            if (--limit <= 0)\n                return result;\n        }\n        if (recurse && (0, domhandler_1.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}\nexports.find = find;\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 */\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 * @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 */\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 node = nodes[i];\n        if (!(0, domhandler_1.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}\nexports.findOne = findOne;\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 */\nfunction existsOne(test, nodes) {\n    return nodes.some(function (checked) {\n        return (0, domhandler_1.isTag)(checked) &&\n            (test(checked) || existsOne(test, checked.children));\n    });\n}\nexports.existsOne = existsOne;\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 */\nfunction findAll(test, nodes) {\n    var result = [];\n    var nodeStack = [nodes];\n    var 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        var elem = nodeStack[0][indexStack[0]++];\n        if (!(0, domhandler_1.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}\nexports.findAll = findAll;\n//# sourceMappingURL=querying.js.map","\"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 * @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 */\nfunction getOuterHTML(node, options) {\n    return (0, dom_serializer_1.default)(node, options);\n}\nexports.getOuterHTML = getOuterHTML;\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 */\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. 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 */\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. 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 */\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, 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 */\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//# sourceMappingURL=stringify.js.map","\"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\");\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 */\nfunction getChildren(elem) {\n    return (0, domhandler_1.hasChildren)(elem) ? elem.children : [];\n}\nexports.getChildren = getChildren;\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 */\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. 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 */\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 * @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 */\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 * @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 */\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 * @category Traversal\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 * @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 */\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 * @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 */\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//# sourceMappingURL=traversal.js.map"],"names":["addClass","element","className","classList","add","contains","baseVal","indexOf","hasClass","setAttribute","replaceClassName","origClass","classToRemove","replace","RegExp","removeClass","remove","Object","defineProperty","exports","value","attributeNames","elementNames","Map","map","val","toLowerCase","__assign","this","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","__createBinding","create","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","__setModuleDefault","v","__importStar","mod","result","render","ElementType","entities_1","foreignNames_js_1","unencodedElements","Set","replaceQuotes","singleTag","node","options","nodes","output","renderNode","type","Root","children","Doctype","Directive","concat","data","Comment","elem","renderComment","CDATA","renderCdata","Script","Style","Tag","opts","_a","xmlMode","name","parent","foreignModeIntegrationPoints","has","foreignElements","tag","attribs","attributes","encode","encodeEntities","decodeEntities","encodeXML","escapeAttribute","keys","key","_b","emptyAttrs","join","formatAttributes","selfClosingTags","renderTag","Text","escapeText","renderText","isTag","__exportStar","DomHandler","domelementtype_1","node_js_1","defaultOpts","withStartIndices","withEndIndices","callback","elementCB","dom","root","Document","done","tagStack","lastNode","parser","onparserinit","onreset","onend","handleCallback","onerror","error","onclosetag","pop","endIndex","onopentag","Element","addNode","push","ontext","oncomment","oncommentend","oncdatastart","text","oncdataend","onprocessinginstruction","ProcessingInstruction","previousSibling","startIndex","prev","next","extendStatics","__extends","d","b","setPrototypeOf","__proto__","Array","TypeError","String","__","constructor","cloneNode","hasChildren","isDocument","isDirective","isComment","isText","isCDATA","NodeWithChildren","DataNode","Node","set","recursive","_super","_this","namespace","prefix","cloneChildren","clone_1","forEach","child","clone_2","clone_3","Error","instruction","sourceCodeLocation","childs","module","entries","isFrozen","getPrototypeOf","freeze","seal","construct","Reflect","x","fun","thisValue","args","Func","arrayForEach","unapply","arrayPop","arrayPush","stringToLowerCase","stringToString","toString","stringMatch","match","stringReplace","stringIndexOf","stringTrim","trim","regExpTest","test","typeErrorCreate","unconstruct","func","thisArg","_len","_key","_len2","_key2","addToSet","array","transformCaseFunc","l","lcElement","cleanArray","index","clone","object","newObject","property","isArray","lookupGetter","prop","fallbackValue","console","warn","html$1","svg$1","svgFilters","svgDisallowed","mathMl$1","mathMlDisallowed","html","svg","mathMl","xml","MUSTACHE_EXPR","ERB_EXPR","TMPLIT_EXPR","DATA_ATTR","ARIA_ATTR","IS_ALLOWED_URI","IS_SCRIPT_OR_DATA","ATTR_WHITESPACE","DOCTYPE_NAME","EXPRESSIONS","getGlobal","window","_createTrustedTypesPolicy","trustedTypes","purifyHostElement","createPolicy","suffix","ATTR_NAME","hasAttribute","getAttribute","policyName","createHTML","createScriptURL","scriptUrl","_","createDOMPurify","DOMPurify","version","removed","document","nodeType","isSupported","originalDocument","currentScript","DocumentFragment","HTMLTemplateElement","NodeFilter","NamedNodeMap","MozNamedAttrMap","HTMLFormElement","DOMParser","ElementPrototype","getNextSibling","getChildNodes","getParentNode","template","createElement","content","ownerDocument","trustedTypesPolicy","emptyHTML","implementation","createNodeIterator","createDocumentFragment","getElementsByTagName","importNode","hooks","createHTMLDocument","IS_ALLOWED_URI$1","ALLOWED_TAGS","DEFAULT_ALLOWED_TAGS","ALLOWED_ATTR","DEFAULT_ALLOWED_ATTR","CUSTOM_ELEMENT_HANDLING","tagNameCheck","attributeNameCheck","allowCustomizedBuiltInElements","FORBID_TAGS","FORBID_ATTR","ALLOW_ARIA_ATTR","ALLOW_DATA_ATTR","ALLOW_UNKNOWN_PROTOCOLS","ALLOW_SELF_CLOSE_IN_ATTR","SAFE_FOR_TEMPLATES","WHOLE_DOCUMENT","SET_CONFIG","FORCE_BODY","RETURN_DOM","RETURN_DOM_FRAGMENT","RETURN_TRUSTED_TYPE","SANITIZE_DOM","SANITIZE_NAMED_PROPS","SANITIZE_NAMED_PROPS_PREFIX","KEEP_CONTENT","IN_PLACE","USE_PROFILES","FORBID_CONTENTS","DEFAULT_FORBID_CONTENTS","DATA_URI_TAGS","DEFAULT_DATA_URI_TAGS","URI_SAFE_ATTRIBUTES","DEFAULT_URI_SAFE_ATTRIBUTES","MATHML_NAMESPACE","SVG_NAMESPACE","HTML_NAMESPACE","NAMESPACE","IS_EMPTY_INPUT","ALLOWED_NAMESPACES","DEFAULT_ALLOWED_NAMESPACES","PARSER_MEDIA_TYPE","SUPPORTED_PARSER_MEDIA_TYPES","DEFAULT_PARSER_MEDIA_TYPE","CONFIG","formElement","isRegexOrFunction","testValue","Function","_parseConfig","cfg","ADD_URI_SAFE_ATTR","ADD_DATA_URI_TAGS","ALLOWED_URI_REGEXP","ADD_TAGS","ADD_ATTR","table","tbody","TRUSTED_TYPES_POLICY","MATHML_TEXT_INTEGRATION_POINTS","HTML_INTEGRATION_POINTS","COMMON_SVG_AND_HTML_ELEMENTS","ALL_SVG_TAGS","ALL_MATHML_TAGS","_checkValidNamespace","tagName","namespaceURI","parentTagName","Boolean","_forceRemove","parentNode","removeChild","_removeAttribute","attribute","getAttributeNode","from","removeAttribute","_initDocument","dirty","doc","leadingWhitespace","matches","dirtyPayload","parseFromString","documentElement","createDocument","innerHTML","body","insertBefore","createTextNode","childNodes","_createNodeIterator","SHOW_ELEMENT","SHOW_COMMENT","SHOW_TEXT","_isClobbered","elm","nodeName","textContent","hasChildNodes","_isNode","_executeHook","entryPoint","currentNode","hook","_sanitizeElements","allowedTags","firstElementChild","_isBasicCustomElement","expr","_isValidAttribute","lcTag","lcName","_sanitizeAttributes","hookEvent","attrName","attrValue","keepAttr","allowedAttributes","attr","forceKeepAttr","getAttributeType","setAttributeNS","_sanitizeShadowDOM","fragment","shadowNode","shadowIterator","nextNode","sanitize","importedNode","returnNode","appendChild","firstChild","nodeIterator","shadowroot","shadowrootmode","serializedHTML","outerHTML","doctype","setConfig","clearConfig","isValidAttribute","addHook","hookFunction","removeHook","removeHooks","removeAllHooks","factory","getFeed","stringify_js_1","legacy_js_1","feedRoot","getOneElement","isValidFeed","feed","items","item","entry","media","getMediaElements","addConditionally","href","link","description","fetch","pubDate","Date","updated","getAtomFeed","substr","id","getRssFeed","MEDIA_KEYS_STRING","MEDIA_KEYS_INT","where","medium","isDefault","_i","MEDIA_KEYS_STRING_1","attrib","MEDIA_KEYS_INT_1","parseInt","expression","recurse","obj","uniqueSort","compareDocumentPosition","DocumentPosition","removeSubsets","domhandler_1","nodeA","nodeB","aParents","bParents","current","unshift","maxIdx","Math","min","idx","DISCONNECTED","sharedParent","siblings","aSibling","bSibling","FOLLOWING","CONTAINED_BY","PRECEDING","CONTAINS","lastIndexOf","splice","ancestor","includes","filter","arr","sort","a","relative","getElementsByTagType","getElementById","getElements","testElement","querying_js_1","Checks","tag_name","tag_type","tag_contains","getAttribCheck","combineFuncs","compileTest","funcs","reduce","limit","Infinity","findOne","removeElement","childsIndex","prepend","prependChild","append","replaceElement","replacement","sibling","currNext","findAll","existsOne","findOneChild","find","nodeStack","indexStack","shift","some","checked","__importDefault","innerText","getText","getInnerHTML","getOuterHTML","dom_serializer_1","default","prevElementSibling","nextElementSibling","getName","hasAttrib","getAttributeValue","getSiblings","getParent","getChildren"],"sourceRoot":""}