{"version":3,"file":"js/chunk-vendors-88153be5-legacy.783971d1.js","mappings":"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","sources":["webpack://i4proportal/./node_modules/deepmerge/dist/cjs.js","webpack://i4proportal/./node_modules/dom-serializer/lib/foreignNames.js","webpack://i4proportal/./node_modules/dom-serializer/lib/index.js","webpack://i4proportal/./node_modules/dom-serializer/node_modules/entities/lib/decode.js","webpack://i4proportal/./node_modules/dom-serializer/node_modules/entities/lib/decode_codepoint.js","webpack://i4proportal/./node_modules/dom-serializer/node_modules/entities/lib/encode.js","webpack://i4proportal/./node_modules/dom-serializer/node_modules/entities/lib/index.js","webpack://i4proportal/./node_modules/domelementtype/lib/index.js","webpack://i4proportal/./node_modules/domhandler/lib/index.js","webpack://i4proportal/./node_modules/domhandler/lib/node.js"],"sourcesContent":["'use strict';\n\nvar isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction getMergeFunction(key, options) {\n\tif (!options.customMerge) {\n\t\treturn deepmerge\n\t}\n\tvar customMerge = options.customMerge(key);\n\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n}\n\nfunction getEnumerableOwnPropertySymbols(target) {\n\treturn Object.getOwnPropertySymbols\n\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\treturn Object.propertyIsEnumerable.call(target, symbol)\n\t\t})\n\t\t: []\n}\n\nfunction getKeys(target) {\n\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n}\n\nfunction propertyIsOnObject(object, property) {\n\ttry {\n\t\treturn property in object\n\t} catch(_) {\n\t\treturn false\n\t}\n}\n\n// Protects from prototype poisoning and unexpected merging up the prototype chain.\nfunction propertyIsUnsafe(target, key) {\n\treturn propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,\n\t\t&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,\n\t\t\t&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tgetKeys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tgetKeys(source).forEach(function(key) {\n\t\tif (propertyIsUnsafe(target, key)) {\n\t\t\treturn\n\t\t}\n\n\t\tif (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {\n\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\t// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()\n\t// implementations can use it. The caller may not replace it.\n\toptions.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nmodule.exports = deepmerge_1;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.attributeNames = exports.elementNames = void 0;\nexports.elementNames = new Map([\n    [\"altglyph\", \"altGlyph\"],\n    [\"altglyphdef\", \"altGlyphDef\"],\n    [\"altglyphitem\", \"altGlyphItem\"],\n    [\"animatecolor\", \"animateColor\"],\n    [\"animatemotion\", \"animateMotion\"],\n    [\"animatetransform\", \"animateTransform\"],\n    [\"clippath\", \"clipPath\"],\n    [\"feblend\", \"feBlend\"],\n    [\"fecolormatrix\", \"feColorMatrix\"],\n    [\"fecomponenttransfer\", \"feComponentTransfer\"],\n    [\"fecomposite\", \"feComposite\"],\n    [\"feconvolvematrix\", \"feConvolveMatrix\"],\n    [\"fediffuselighting\", \"feDiffuseLighting\"],\n    [\"fedisplacementmap\", \"feDisplacementMap\"],\n    [\"fedistantlight\", \"feDistantLight\"],\n    [\"fedropshadow\", \"feDropShadow\"],\n    [\"feflood\", \"feFlood\"],\n    [\"fefunca\", \"feFuncA\"],\n    [\"fefuncb\", \"feFuncB\"],\n    [\"fefuncg\", \"feFuncG\"],\n    [\"fefuncr\", \"feFuncR\"],\n    [\"fegaussianblur\", \"feGaussianBlur\"],\n    [\"feimage\", \"feImage\"],\n    [\"femerge\", \"feMerge\"],\n    [\"femergenode\", \"feMergeNode\"],\n    [\"femorphology\", \"feMorphology\"],\n    [\"feoffset\", \"feOffset\"],\n    [\"fepointlight\", \"fePointLight\"],\n    [\"fespecularlighting\", \"feSpecularLighting\"],\n    [\"fespotlight\", \"feSpotLight\"],\n    [\"fetile\", \"feTile\"],\n    [\"feturbulence\", \"feTurbulence\"],\n    [\"foreignobject\", \"foreignObject\"],\n    [\"glyphref\", \"glyphRef\"],\n    [\"lineargradient\", \"linearGradient\"],\n    [\"radialgradient\", \"radialGradient\"],\n    [\"textpath\", \"textPath\"],\n]);\nexports.attributeNames = new Map([\n    [\"definitionurl\", \"definitionURL\"],\n    [\"attributename\", \"attributeName\"],\n    [\"attributetype\", \"attributeType\"],\n    [\"basefrequency\", \"baseFrequency\"],\n    [\"baseprofile\", \"baseProfile\"],\n    [\"calcmode\", \"calcMode\"],\n    [\"clippathunits\", \"clipPathUnits\"],\n    [\"diffuseconstant\", \"diffuseConstant\"],\n    [\"edgemode\", \"edgeMode\"],\n    [\"filterunits\", \"filterUnits\"],\n    [\"glyphref\", \"glyphRef\"],\n    [\"gradienttransform\", \"gradientTransform\"],\n    [\"gradientunits\", \"gradientUnits\"],\n    [\"kernelmatrix\", \"kernelMatrix\"],\n    [\"kernelunitlength\", \"kernelUnitLength\"],\n    [\"keypoints\", \"keyPoints\"],\n    [\"keysplines\", \"keySplines\"],\n    [\"keytimes\", \"keyTimes\"],\n    [\"lengthadjust\", \"lengthAdjust\"],\n    [\"limitingconeangle\", \"limitingConeAngle\"],\n    [\"markerheight\", \"markerHeight\"],\n    [\"markerunits\", \"markerUnits\"],\n    [\"markerwidth\", \"markerWidth\"],\n    [\"maskcontentunits\", \"maskContentUnits\"],\n    [\"maskunits\", \"maskUnits\"],\n    [\"numoctaves\", \"numOctaves\"],\n    [\"pathlength\", \"pathLength\"],\n    [\"patterncontentunits\", \"patternContentUnits\"],\n    [\"patterntransform\", \"patternTransform\"],\n    [\"patternunits\", \"patternUnits\"],\n    [\"pointsatx\", \"pointsAtX\"],\n    [\"pointsaty\", \"pointsAtY\"],\n    [\"pointsatz\", \"pointsAtZ\"],\n    [\"preservealpha\", \"preserveAlpha\"],\n    [\"preserveaspectratio\", \"preserveAspectRatio\"],\n    [\"primitiveunits\", \"primitiveUnits\"],\n    [\"refx\", \"refX\"],\n    [\"refy\", \"refY\"],\n    [\"repeatcount\", \"repeatCount\"],\n    [\"repeatdur\", \"repeatDur\"],\n    [\"requiredextensions\", \"requiredExtensions\"],\n    [\"requiredfeatures\", \"requiredFeatures\"],\n    [\"specularconstant\", \"specularConstant\"],\n    [\"specularexponent\", \"specularExponent\"],\n    [\"spreadmethod\", \"spreadMethod\"],\n    [\"startoffset\", \"startOffset\"],\n    [\"stddeviation\", \"stdDeviation\"],\n    [\"stitchtiles\", \"stitchTiles\"],\n    [\"surfacescale\", \"surfaceScale\"],\n    [\"systemlanguage\", \"systemLanguage\"],\n    [\"tablevalues\", \"tableValues\"],\n    [\"targetx\", \"targetX\"],\n    [\"targety\", \"targetY\"],\n    [\"textlength\", \"textLength\"],\n    [\"viewbox\", \"viewBox\"],\n    [\"viewtarget\", \"viewTarget\"],\n    [\"xchannelselector\", \"xChannelSelector\"],\n    [\"ychannelselector\", \"yChannelSelector\"],\n    [\"zoomandpan\", \"zoomAndPan\"],\n]);\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    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __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 });\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_1 = require(\"./foreignNames\");\nvar unencodedElements = new Set([\n    \"style\",\n    \"script\",\n    \"xmp\",\n    \"iframe\",\n    \"noembed\",\n    \"noframes\",\n    \"plaintext\",\n    \"noscript\",\n]);\n/**\n * Format attributes\n */\nfunction formatAttributes(attributes, opts) {\n    if (!attributes)\n        return;\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_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;\n        }\n        if (!opts.emptyAttrs && !opts.xmlMode && value === \"\") {\n            return key;\n        }\n        return key + \"=\\\"\" + (opts.decodeEntities !== false\n            ? entities_1.encodeXML(value)\n            : value.replace(/\"/g, \"&quot;\")) + \"\\\"\";\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.default = render;\nfunction renderNode(node, options) {\n    switch (node.type) {\n        case ElementType.Root:\n            return render(node.children, options);\n        case ElementType.Directive:\n        case ElementType.Doctype:\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_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 = \"<\" + elem.name;\n    var attribs = formatAttributes(elem.attribs, opts);\n    if (attribs) {\n        tag += \" \" + 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 += \"</\" + elem.name + \">\";\n        }\n    }\n    return tag;\n}\nfunction renderDirective(elem) {\n    return \"<\" + elem.data + \">\";\n}\nfunction renderText(elem, opts) {\n    var data = elem.data || \"\";\n    // If entities weren't decoded, no need to encode them back\n    if (opts.decodeEntities !== false &&\n        !(!opts.xmlMode &&\n            elem.parent &&\n            unencodedElements.has(elem.parent.name))) {\n        data = entities_1.encodeXML(data);\n    }\n    return data;\n}\nfunction renderCdata(elem) {\n    return \"<![CDATA[\" + elem.children[0].data + \"]]>\";\n}\nfunction renderComment(elem) {\n    return \"<!--\" + elem.data + \"-->\";\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeHTML = exports.decodeHTMLStrict = exports.decodeXML = void 0;\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar legacy_json_1 = __importDefault(require(\"./maps/legacy.json\"));\nvar xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar decode_codepoint_1 = __importDefault(require(\"./decode_codepoint\"));\nvar strictEntityRe = /&(?:[a-zA-Z0-9]+|#[xX][\\da-fA-F]+|#\\d+);/g;\nexports.decodeXML = getStrictDecoder(xml_json_1.default);\nexports.decodeHTMLStrict = getStrictDecoder(entities_json_1.default);\nfunction getStrictDecoder(map) {\n    var replace = getReplacer(map);\n    return function (str) { return String(str).replace(strictEntityRe, replace); };\n}\nvar sorter = function (a, b) { return (a < b ? 1 : -1); };\nexports.decodeHTML = (function () {\n    var legacy = Object.keys(legacy_json_1.default).sort(sorter);\n    var keys = Object.keys(entities_json_1.default).sort(sorter);\n    for (var i = 0, j = 0; i < keys.length; i++) {\n        if (legacy[j] === keys[i]) {\n            keys[i] += \";?\";\n            j++;\n        }\n        else {\n            keys[i] += \";\";\n        }\n    }\n    var re = new RegExp(\"&(?:\" + keys.join(\"|\") + \"|#[xX][\\\\da-fA-F]+;?|#\\\\d+;?)\", \"g\");\n    var replace = getReplacer(entities_json_1.default);\n    function replacer(str) {\n        if (str.substr(-1) !== \";\")\n            str += \";\";\n        return replace(str);\n    }\n    // TODO consider creating a merged map\n    return function (str) { return String(str).replace(re, replacer); };\n})();\nfunction getReplacer(map) {\n    return function replace(str) {\n        if (str.charAt(1) === \"#\") {\n            var secondChar = str.charAt(2);\n            if (secondChar === \"X\" || secondChar === \"x\") {\n                return decode_codepoint_1.default(parseInt(str.substr(3), 16));\n            }\n            return decode_codepoint_1.default(parseInt(str.substr(2), 10));\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n        return map[str.slice(1, -1)] || str;\n    };\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar decode_json_1 = __importDefault(require(\"./maps/decode.json\"));\n// Adapted from https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119\nvar fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.fromCodePoint ||\n    function (codePoint) {\n        var output = \"\";\n        if (codePoint > 0xffff) {\n            codePoint -= 0x10000;\n            output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n            codePoint = 0xdc00 | (codePoint & 0x3ff);\n        }\n        output += String.fromCharCode(codePoint);\n        return output;\n    };\nfunction decodeCodePoint(codePoint) {\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return \"\\uFFFD\";\n    }\n    if (codePoint in decode_json_1.default) {\n        codePoint = decode_json_1.default[codePoint];\n    }\n    return fromCodePoint(codePoint);\n}\nexports.default = decodeCodePoint;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = void 0;\nvar xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar inverseXML = getInverseObj(xml_json_1.default);\nvar xmlReplacer = getInverseReplacer(inverseXML);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeXML = getASCIIEncoder(inverseXML);\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar inverseHTML = getInverseObj(entities_json_1.default);\nvar htmlReplacer = getInverseReplacer(inverseHTML);\n/**\n * Encodes all entities and non-ASCII characters in the input.\n *\n * This includes characters that are valid ASCII characters in HTML documents.\n * For example `#` will be encoded as `&num;`. To get a more compact output,\n * consider using the `encodeNonAsciiHTML` function.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeHTML = getInverse(inverseHTML, htmlReplacer);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in HTML\n * documents using HTML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeNonAsciiHTML = getASCIIEncoder(inverseHTML);\nfunction getInverseObj(obj) {\n    return Object.keys(obj)\n        .sort()\n        .reduce(function (inverse, name) {\n        inverse[obj[name]] = \"&\" + name + \";\";\n        return inverse;\n    }, {});\n}\nfunction getInverseReplacer(inverse) {\n    var single = [];\n    var multiple = [];\n    for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {\n        var k = _a[_i];\n        if (k.length === 1) {\n            // Add value to single array\n            single.push(\"\\\\\" + k);\n        }\n        else {\n            // Add value to multiple array\n            multiple.push(k);\n        }\n    }\n    // Add ranges to single characters.\n    single.sort();\n    for (var start = 0; start < single.length - 1; start++) {\n        // Find the end of a run of characters\n        var end = start;\n        while (end < single.length - 1 &&\n            single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {\n            end += 1;\n        }\n        var count = 1 + end - start;\n        // We want to replace at least three characters\n        if (count < 3)\n            continue;\n        single.splice(start, count, single[start] + \"-\" + single[end]);\n    }\n    multiple.unshift(\"[\" + single.join(\"\") + \"]\");\n    return new RegExp(multiple.join(\"|\"), \"g\");\n}\n// /[^\\0-\\x7F]/gu\nvar reNonASCII = /(?:[\\x80-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])/g;\nvar getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        function (str) { return str.codePointAt(0); }\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        function (c) {\n            return (c.charCodeAt(0) - 0xd800) * 0x400 +\n                c.charCodeAt(1) -\n                0xdc00 +\n                0x10000;\n        };\nfunction singleCharReplacer(c) {\n    return \"&#x\" + (c.length > 1 ? getCodePoint(c) : c.charCodeAt(0))\n        .toString(16)\n        .toUpperCase() + \";\";\n}\nfunction getInverse(inverse, re) {\n    return function (data) {\n        return data\n            .replace(re, function (name) { return inverse[name]; })\n            .replace(reNonASCII, singleCharReplacer);\n    };\n}\nvar reEscapeChars = new RegExp(xmlReplacer.source + \"|\" + reNonASCII.source, \"g\");\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nfunction escape(data) {\n    return data.replace(reEscapeChars, singleCharReplacer);\n}\nexports.escape = escape;\n/**\n * Encodes all characters not valid in XML documents using numeric hexadecimal\n * reference (eg. `&#xfc;`).\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nfunction escapeUTF8(data) {\n    return data.replace(xmlReplacer, singleCharReplacer);\n}\nexports.escapeUTF8 = escapeUTF8;\nfunction getASCIIEncoder(obj) {\n    return function (data) {\n        return data.replace(reEscapeChars, function (c) { return obj[c] || singleCharReplacer(c); });\n    };\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = void 0;\nvar decode_1 = require(\"./decode\");\nvar encode_1 = require(\"./encode\");\n/**\n * Decodes a string with entities.\n *\n * @param data String to decode.\n * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `decodeXML` or `decodeHTML` directly.\n */\nfunction decode(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);\n}\nexports.decode = decode;\n/**\n * Decodes a string with entities. Does not allow missing trailing semicolons for entities.\n *\n * @param data String to decode.\n * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `decodeHTMLStrict` or `decodeXML` directly.\n */\nfunction decodeStrict(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);\n}\nexports.decodeStrict = decodeStrict;\n/**\n * Encodes a string with entities.\n *\n * @param data String to encode.\n * @param level Optional level to encode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `encodeHTML`, `encodeXML` or `encodeNonAsciiHTML` directly.\n */\nfunction encode(data, level) {\n    return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);\n}\nexports.encode = encode;\nvar encode_2 = require(\"./encode\");\nObject.defineProperty(exports, \"encodeXML\", { enumerable: true, get: function () { return encode_2.encodeXML; } });\nObject.defineProperty(exports, \"encodeHTML\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeNonAsciiHTML\", { enumerable: true, get: function () { return encode_2.encodeNonAsciiHTML; } });\nObject.defineProperty(exports, \"escape\", { enumerable: true, get: function () { return encode_2.escape; } });\nObject.defineProperty(exports, \"escapeUTF8\", { enumerable: true, get: function () { return encode_2.escapeUTF8; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"encodeHTML4\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeHTML5\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nvar decode_2 = require(\"./decode\");\nObject.defineProperty(exports, \"decodeXML\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\nObject.defineProperty(exports, \"decodeHTML\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTMLStrict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"decodeHTML4\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML5\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML4Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeHTML5Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeXMLStrict\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\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_1 = require(\"./node\");\n__exportStar(require(\"./node\"), exports);\nvar reWhitespace = /\\s+/g;\n// Default options\nvar defaultOpts = {\n    normalizeWhitespace: false,\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_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_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_1.Element(name, attribs, undefined, type);\n        this.addNode(element);\n        this.tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var normalizeWhitespace = this.options.normalizeWhitespace;\n        var lastNode = this.lastNode;\n        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {\n            if (normalizeWhitespace) {\n                lastNode.data = (lastNode.data + data).replace(reWhitespace, \" \");\n            }\n            else {\n                lastNode.data += data;\n            }\n            if (this.options.withEndIndices) {\n                lastNode.endIndex = this.parser.endIndex;\n            }\n        }\n        else {\n            if (normalizeWhitespace) {\n                data = data.replace(reWhitespace, \" \");\n            }\n            var node = new node_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_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_1.Text(\"\");\n        var node = new node_1.NodeWithChildren(domelementtype_1.ElementType.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_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.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\nvar nodeTypes = new Map([\n    [domelementtype_1.ElementType.Tag, 1],\n    [domelementtype_1.ElementType.Script, 1],\n    [domelementtype_1.ElementType.Style, 1],\n    [domelementtype_1.ElementType.Directive, 1],\n    [domelementtype_1.ElementType.Text, 3],\n    [domelementtype_1.ElementType.CDATA, 4],\n    [domelementtype_1.ElementType.Comment, 8],\n    [domelementtype_1.ElementType.Root, 9],\n]);\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    /**\n     *\n     * @param type The type of the node.\n     */\n    function Node(type) {\n        this.type = type;\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, \"nodeType\", {\n        // Read-only aliases\n        /**\n         * [DOM spec](https://dom.spec.whatwg.org/#dom-node-nodetype)-compatible\n         * node {@link type}.\n         */\n        get: function () {\n            var _a;\n            return (_a = nodeTypes.get(this.type)) !== null && _a !== void 0 ? _a : 1;\n        },\n        enumerable: false,\n        configurable: true\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 type The type of the node\n     * @param data The content of the data node\n     */\n    function DataNode(type, data) {\n        var _this = _super.call(this, type) || 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(data) {\n        return _super.call(this, domelementtype_1.ElementType.Text, data) || this;\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(data) {\n        return _super.call(this, domelementtype_1.ElementType.Comment, data) || this;\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, domelementtype_1.ElementType.Directive, data) || this;\n        _this.name = name;\n        return _this;\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 type Type of the node.\n     * @param children Children of the node. Only certain node types can have children.\n     */\n    function NodeWithChildren(type, children) {\n        var _this = _super.call(this, type) || 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;\n/**\n * The root node of the document.\n */\nvar Document = /** @class */ (function (_super) {\n    __extends(Document, _super);\n    function Document(children) {\n        return _super.call(this, domelementtype_1.ElementType.Root, children) || this;\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, type, children) || this;\n        _this.name = name;\n        _this.attribs = attribs;\n        return _this;\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 is a `NodeWithChildren` (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 NodeWithChildren(domelementtype_1.ElementType.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"],"names":["isMergeableObject","value","isNonNullObject","isSpecial","stringValue","Object","prototype","toString","call","isReactElement","canUseSymbol","Symbol","for","REACT_ELEMENT_TYPE","$$typeof","emptyTarget","val","Array","isArray","cloneUnlessOtherwiseSpecified","options","clone","deepmerge","defaultArrayMerge","target","source","concat","map","element","getMergeFunction","key","customMerge","getEnumerableOwnPropertySymbols","getOwnPropertySymbols","filter","symbol","propertyIsEnumerable","getKeys","keys","propertyIsOnObject","object","property","_","propertyIsUnsafe","hasOwnProperty","mergeObject","destination","forEach","arrayMerge","sourceIsArray","targetIsArray","sourceAndTargetTypesMatch","all","array","Error","reduce","prev","next","deepmerge_1","module","exports","defineProperty","attributeNames","elementNames","Map","__assign","this","assign","t","s","i","n","arguments","length","p","apply","__createBinding","create","o","m","k","k2","undefined","enumerable","get","__setModuleDefault","v","__importStar","mod","__esModule","result","ElementType","entities_1","foreignNames_1","unencodedElements","Set","formatAttributes","attributes","opts","_a","_b","xmlMode","emptyAttrs","decodeEntities","encodeXML","replace","join","singleTag","render","node","nodes","output","renderNode","type","Root","children","Directive","Doctype","renderDirective","Comment","renderComment","CDATA","renderCdata","Script","Style","Tag","renderTag","Text","renderText","foreignModeIntegrationPoints","foreignElements","elem","name","parent","has","tag","attribs","selfClosingTags","data","__importDefault","decodeHTML","decodeHTMLStrict","decodeXML","entities_json_1","legacy_json_1","xml_json_1","decode_codepoint_1","strictEntityRe","getStrictDecoder","getReplacer","str","String","default","sorter","a","b","charAt","secondChar","parseInt","substr","slice","legacy","sort","j","re","RegExp","replacer","decode_json_1","fromCodePoint","codePoint","fromCharCode","decodeCodePoint","escapeUTF8","escape","encodeNonAsciiHTML","encodeHTML","inverseXML","getInverseObj","xmlReplacer","getInverseReplacer","getASCIIEncoder","inverseHTML","htmlReplacer","obj","inverse","single","multiple","_i","push","start","end","charCodeAt","count","splice","unshift","getInverse","reNonASCII","getCodePoint","codePointAt","c","singleCharReplacer","toUpperCase","reEscapeChars","decodeXMLStrict","decodeHTML5Strict","decodeHTML4Strict","decodeHTML5","decodeHTML4","encodeHTML5","encodeHTML4","encode","decodeStrict","decode","decode_1","encode_1","level","encode_2","decode_2","isTag","desc","getOwnPropertyDescriptor","writable","configurable","__exportStar","DomHandler","domelementtype_1","node_1","reWhitespace","defaultOpts","normalizeWhitespace","withStartIndices","withEndIndices","callback","elementCB","dom","root","Document","done","tagStack","lastNode","parser","onparserinit","onreset","onend","handleCallback","onerror","error","onclosetag","pop","endIndex","onopentag","Element","addNode","ontext","oncomment","oncommentend","oncdatastart","text","NodeWithChildren","oncdataend","onprocessinginstruction","ProcessingInstruction","previousSibling","startIndex","__extends","extendStatics","d","setPrototypeOf","__proto__","TypeError","__","constructor","cloneNode","hasChildren","isDocument","isDirective","isComment","isText","isCDATA","DataNode","Node","nodeTypes","set","recursive","_super","_this","namespace","prefix","cloneChildren","clone_1","child","clone_2","clone_3","instruction","sourceCodeLocation","childs"],"sourceRoot":""}