{"version":3,"file":"static/chunks/9238.94d8c55d0d3a8e84.js","mappings":"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","sources":["webpack://_N_E/./node_modules/dompurify/dist/purify.js","webpack://_N_E/./node_modules/isomorphic-dompurify/browser.js","webpack://_N_E/<anon>"],"sourcesContent":["/*! @license DOMPurify 3.1.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.3/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 objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);\n  const regExpTest = unapply(RegExp.prototype.test);\n  const typeErrorCreate = unconstruct(TypeError);\n  const numberIsNaN = unapply(Number.isNaN);\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      const isPropertyExist = objectHasOwnProperty(array, index);\n      if (!isPropertyExist) {\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      const isPropertyExist = objectHasOwnProperty(object, property);\n      if (isPropertyExist) {\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() {\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', 'wrap', '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  const CUSTOM_ELEMENT = seal(/^[a-z][.\\w]*(-[.\\w]+)+$/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    CUSTOM_ELEMENT: CUSTOM_ELEMENT\n  });\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType\n  const NODE_TYPE = {\n    element: 1,\n    attribute: 2,\n    text: 3,\n    cdataSection: 4,\n    entityReference: 5,\n    // Deprecated\n    entityNode: 6,\n    // Deprecated\n    progressingInstruction: 7,\n    comment: 8,\n    document: 9,\n    documentType: 10,\n    documentFragment: 11,\n    notation: 12 // Deprecated\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.1.3';\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 !== NODE_TYPE.document) {\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      CUSTOM_ELEMENT\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    /* Output should be safe even for XML used within HTML and alike.\n     * This means, DOMPurify removes comments when containing risky content.\n     */\n    let SAFE_FOR_XML = true;\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    /* Specify the maximum element nesting depth to prevent mXSS */\n    const MAX_NESTING_DEPTH = 255;\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 = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;\n      ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;\n      ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;\n      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? 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 = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? 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 = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;\n      FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};\n      FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};\n      USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? 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      SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true\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', '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 | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, 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 && (\n      // eslint-disable-next-line unicorn/no-typeof-undefined\n      typeof elm.__depth !== 'undefined' && typeof elm.__depth !== 'number' ||\n      // eslint-disable-next-line unicorn/no-typeof-undefined\n      typeof elm.__removalCount !== 'undefined' && typeof elm.__removalCount !== 'number' || 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 any ocurrence of processing instructions */\n      if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove any kind of possibly harmful comments */\n      if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\\w]/g, currentNode.data)) {\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              const childClone = cloneNode(childNodes[i], true);\n              childClone.__removalCount = (currentNode.__removalCount || 0) + 1;\n              parentNode.insertBefore(childClone, 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 === NODE_TYPE.text) {\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 || value === '__depth' || value === '__removalCount')) {\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 !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);\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        /* Work around a security issue with comments inside attributes */\n        if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\\/(style|title)/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          if (_isClobbered(currentNode)) {\n            _forceRemove(currentNode);\n          } else {\n            arrayPop(DOMPurify.removed);\n          }\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        const parentNode = getParentNode(shadowNode);\n\n        /* Set the nesting depth of an element */\n        if (shadowNode.nodeType === NODE_TYPE.element) {\n          if (parentNode && parentNode.__depth) {\n            /*\n              We want the depth of the node in the original tree, which can\n              change when it's removed from its parent.\n            */\n            shadowNode.__depth = (shadowNode.__removalCount || 0) + parentNode.__depth + 1;\n          } else {\n            shadowNode.__depth = 1;\n          }\n        }\n\n        /*\n         * Remove an element if nested too deeply to avoid mXSS\n         * or if the __depth might have been tampered with\n         */\n        if (shadowNode.__depth >= MAX_NESTING_DEPTH || shadowNode.__depth < 0 || numberIsNaN(shadowNode.__depth)) {\n          _forceRemove(shadowNode);\n        }\n\n        /* Deep shadow DOM detected */\n        if (shadowNode.content instanceof DocumentFragment) {\n          shadowNode.content.__depth = shadowNode.__depth;\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 === NODE_TYPE.element && 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        const parentNode = getParentNode(currentNode);\n\n        /* Set the nesting depth of an element */\n        if (currentNode.nodeType === NODE_TYPE.element) {\n          if (parentNode && parentNode.__depth) {\n            /*\n              We want the depth of the node in the original tree, which can\n              change when it's removed from its parent.\n            */\n            currentNode.__depth = (currentNode.__removalCount || 0) + parentNode.__depth + 1;\n          } else {\n            currentNode.__depth = 1;\n          }\n        }\n\n        /*\n         * Remove an element if nested too deeply to avoid mXSS\n         * or if the __depth might have been tampered with\n         */\n        if (currentNode.__depth >= MAX_NESTING_DEPTH || currentNode.__depth < 0 || numberIsNaN(currentNode.__depth)) {\n          _forceRemove(currentNode);\n        }\n\n        /* Shadow DOM detected, sanitize it */\n        if (currentNode.content instanceof DocumentFragment) {\n          currentNode.content.__depth = currentNode.__depth;\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","module.exports = window.DOMPurify || (window.DOMPurify = require('dompurify').default || require('dompurify'));","/*! For license information please see 9238.94d8c55d0d3a8e84.js.LICENSE */\n(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[9238],{27856:function(e){e.exports=function(){\"use strict\";const{entries:e,setPrototypeOf:t,isFrozen:n,getPrototypeOf:o,getOwnPropertyDescriptor:r}=Object;let{freeze:i,seal:a,create:l}=Object,{apply:c,construct:s}=\"undefined\"!=typeof Reflect&&Reflect;i||(i=function(e){return e}),a||(a=function(e){return e}),c||(c=function(e,t,n){return e.apply(t,n)}),s||(s=function(e,t){return new e(...t)});const u=S(Array.prototype.forEach),m=S(Array.prototype.pop),p=S(Array.prototype.push),f=S(String.prototype.toLowerCase),d=S(String.prototype.toString),h=S(String.prototype.match),g=S(String.prototype.replace),_=S(String.prototype.indexOf),T=S(String.prototype.trim),y=S(Object.prototype.hasOwnProperty),E=S(RegExp.prototype.test),A=(b=TypeError,function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return s(b,t)}),N=S(Number.isNaN);var b;function S(e){return function(t){for(var n=arguments.length,o=new Array(n>1?n-1:0),r=1;r<n;r++)o[r-1]=arguments[r];return c(e,t,o)}}function w(e,o){let r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:f;t&&t(e,null);let i=o.length;for(;i--;){let t=o[i];if(\"string\"==typeof t){const e=r(t);e!==t&&(n(o)||(o[i]=e),t=e)}e[t]=!0}return e}function R(e){for(let t=0;t<e.length;t++)y(e,t)||(e[t]=null);return e}function C(t){const n=l(null);for(const[o,r]of e(t))y(t,o)&&(Array.isArray(r)?n[o]=R(r):r&&\"object\"==typeof r&&r.constructor===Object?n[o]=C(r):n[o]=r);return n}function v(e,t){for(;null!==e;){const n=r(e,t);if(n){if(n.get)return S(n.get);if(\"function\"==typeof n.value)return S(n.value)}e=o(e)}return function(){return null}}const D=i([\"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\"]),L=i([\"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\"]),O=i([\"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\"]),k=i([\"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\"]),x=i([\"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\"]),M=i([\"maction\",\"maligngroup\",\"malignmark\",\"mlongdiv\",\"mscarries\",\"mscarry\",\"msgroup\",\"mstack\",\"msline\",\"msrow\",\"semantics\",\"annotation\",\"annotation-xml\",\"mprescripts\",\"none\"]),I=i([\"#text\"]),U=i([\"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\",\"wrap\",\"xmlns\",\"slot\"]),P=i([\"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\"]),F=i([\"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\"]),H=i([\"xlink:href\",\"xml:id\",\"xlink:title\",\"xml:space\",\"xmlns:xlink\"]),z=a(/\\{\\{[\\w\\W]*|[\\w\\W]*\\}\\}/gm),B=a(/<%[\\w\\W]*|[\\w\\W]*%>/gm),W=a(/\\${[\\w\\W]*}/gm),G=a(/^data-[\\-\\w.\\u00B7-\\uFFFF]/),Y=a(/^aria-[\\-\\w]+$/),j=a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i),X=a(/^(?:\\w+script|data):/i),q=a(/[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205F\\u3000]/g),$=a(/^html$/i),K=a(/^[a-z][.\\w]*(-[.\\w]+)+$/i);var V=Object.freeze({__proto__:null,MUSTACHE_EXPR:z,ERB_EXPR:B,TMPLIT_EXPR:W,DATA_ATTR:G,ARIA_ATTR:Y,IS_ALLOWED_URI:j,IS_SCRIPT_OR_DATA:X,ATTR_WHITESPACE:q,DOCTYPE_NAME:$,CUSTOM_ELEMENT:K});const Z=1,J=3,Q=7,ee=8,te=9,ne=function(){return\"undefined\"==typeof window?null:window},oe=function(e,t){if(\"object\"!=typeof e||\"function\"!=typeof e.createPolicy)return null;let n=null;t&&t.hasAttribute(\"data-tt-policy-suffix\")&&(n=t.getAttribute(\"data-tt-policy-suffix\"));const o=\"dompurify\"+(n?\"#\"+n:\"\");try{return e.createPolicy(o,{createHTML:e=>e,createScriptURL:e=>e})}catch(e){return console.warn(\"TrustedTypes policy \"+o+\" could not be created.\"),null}};return function t(){let n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:ne();const o=e=>t(e);if(o.version=\"3.1.3\",o.removed=[],!n||!n.document||n.document.nodeType!==te)return o.isSupported=!1,o;let{document:r}=n;const a=r,c=a.currentScript,{DocumentFragment:s,HTMLTemplateElement:b,Node:S,Element:R,NodeFilter:z,NamedNodeMap:B=n.NamedNodeMap||n.MozNamedAttrMap,HTMLFormElement:W,DOMParser:G,trustedTypes:Y}=n,X=R.prototype,q=v(X,\"cloneNode\"),K=v(X,\"nextSibling\"),re=v(X,\"childNodes\"),ie=v(X,\"parentNode\");if(\"function\"==typeof b){const e=r.createElement(\"template\");e.content&&e.content.ownerDocument&&(r=e.content.ownerDocument)}let ae,le=\"\";const{implementation:ce,createNodeIterator:se,createDocumentFragment:ue,getElementsByTagName:me}=r,{importNode:pe}=a;let fe={};o.isSupported=\"function\"==typeof e&&\"function\"==typeof ie&&ce&&void 0!==ce.createHTMLDocument;const{MUSTACHE_EXPR:de,ERB_EXPR:he,TMPLIT_EXPR:ge,DATA_ATTR:_e,ARIA_ATTR:Te,IS_SCRIPT_OR_DATA:ye,ATTR_WHITESPACE:Ee,CUSTOM_ELEMENT:Ae}=V;let{IS_ALLOWED_URI:Ne}=V,be=null;const Se=w({},[...D,...L,...O,...x,...I]);let we=null;const Re=w({},[...U,...P,...F,...H]);let Ce=Object.seal(l(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),ve=null,De=null,Le=!0,Oe=!0,ke=!1,xe=!0,Me=!1,Ie=!0,Ue=!1,Pe=!1,Fe=!1,He=!1,ze=!1,Be=!1,We=!0,Ge=!1;const Ye=\"user-content-\";let je=!0,Xe=!1,qe={},$e=null;const Ke=w({},[\"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\"]);let Ve=null;const Ze=w({},[\"audio\",\"video\",\"img\",\"source\",\"image\",\"track\"]);let Je=null;const Qe=w({},[\"alt\",\"class\",\"for\",\"id\",\"label\",\"name\",\"pattern\",\"placeholder\",\"role\",\"summary\",\"title\",\"value\",\"style\",\"xmlns\"]),et=\"http://www.w3.org/1998/Math/MathML\",tt=\"http://www.w3.org/2000/svg\",nt=\"http://www.w3.org/1999/xhtml\";let ot=nt,rt=!1,it=null;const at=w({},[et,tt,nt],d);let lt=null;const ct=[\"application/xhtml+xml\",\"text/html\"],st=\"text/html\";let ut=null,mt=null;const pt=255,ft=r.createElement(\"form\"),dt=function(e){return e instanceof RegExp||e instanceof Function},ht=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(!mt||mt!==e){if(e&&\"object\"==typeof e||(e={}),e=C(e),lt=-1===ct.indexOf(e.PARSER_MEDIA_TYPE)?st:e.PARSER_MEDIA_TYPE,ut=\"application/xhtml+xml\"===lt?d:f,be=y(e,\"ALLOWED_TAGS\")?w({},e.ALLOWED_TAGS,ut):Se,we=y(e,\"ALLOWED_ATTR\")?w({},e.ALLOWED_ATTR,ut):Re,it=y(e,\"ALLOWED_NAMESPACES\")?w({},e.ALLOWED_NAMESPACES,d):at,Je=y(e,\"ADD_URI_SAFE_ATTR\")?w(C(Qe),e.ADD_URI_SAFE_ATTR,ut):Qe,Ve=y(e,\"ADD_DATA_URI_TAGS\")?w(C(Ze),e.ADD_DATA_URI_TAGS,ut):Ze,$e=y(e,\"FORBID_CONTENTS\")?w({},e.FORBID_CONTENTS,ut):Ke,ve=y(e,\"FORBID_TAGS\")?w({},e.FORBID_TAGS,ut):{},De=y(e,\"FORBID_ATTR\")?w({},e.FORBID_ATTR,ut):{},qe=!!y(e,\"USE_PROFILES\")&&e.USE_PROFILES,Le=!1!==e.ALLOW_ARIA_ATTR,Oe=!1!==e.ALLOW_DATA_ATTR,ke=e.ALLOW_UNKNOWN_PROTOCOLS||!1,xe=!1!==e.ALLOW_SELF_CLOSE_IN_ATTR,Me=e.SAFE_FOR_TEMPLATES||!1,Ie=!1!==e.SAFE_FOR_XML,Ue=e.WHOLE_DOCUMENT||!1,He=e.RETURN_DOM||!1,ze=e.RETURN_DOM_FRAGMENT||!1,Be=e.RETURN_TRUSTED_TYPE||!1,Fe=e.FORCE_BODY||!1,We=!1!==e.SANITIZE_DOM,Ge=e.SANITIZE_NAMED_PROPS||!1,je=!1!==e.KEEP_CONTENT,Xe=e.IN_PLACE||!1,Ne=e.ALLOWED_URI_REGEXP||j,ot=e.NAMESPACE||nt,Ce=e.CUSTOM_ELEMENT_HANDLING||{},e.CUSTOM_ELEMENT_HANDLING&&dt(e.CUSTOM_ELEMENT_HANDLING.tagNameCheck)&&(Ce.tagNameCheck=e.CUSTOM_ELEMENT_HANDLING.tagNameCheck),e.CUSTOM_ELEMENT_HANDLING&&dt(e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)&&(Ce.attributeNameCheck=e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),e.CUSTOM_ELEMENT_HANDLING&&\"boolean\"==typeof e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements&&(Ce.allowCustomizedBuiltInElements=e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),Me&&(Oe=!1),ze&&(He=!0),qe&&(be=w({},I),we=[],!0===qe.html&&(w(be,D),w(we,U)),!0===qe.svg&&(w(be,L),w(we,P),w(we,H)),!0===qe.svgFilters&&(w(be,O),w(we,P),w(we,H)),!0===qe.mathMl&&(w(be,x),w(we,F),w(we,H))),e.ADD_TAGS&&(be===Se&&(be=C(be)),w(be,e.ADD_TAGS,ut)),e.ADD_ATTR&&(we===Re&&(we=C(we)),w(we,e.ADD_ATTR,ut)),e.ADD_URI_SAFE_ATTR&&w(Je,e.ADD_URI_SAFE_ATTR,ut),e.FORBID_CONTENTS&&($e===Ke&&($e=C($e)),w($e,e.FORBID_CONTENTS,ut)),je&&(be[\"#text\"]=!0),Ue&&w(be,[\"html\",\"head\",\"body\"]),be.table&&(w(be,[\"tbody\"]),delete ve.tbody),e.TRUSTED_TYPES_POLICY){if(\"function\"!=typeof e.TRUSTED_TYPES_POLICY.createHTML)throw A('TRUSTED_TYPES_POLICY configuration option must provide a \"createHTML\" hook.');if(\"function\"!=typeof e.TRUSTED_TYPES_POLICY.createScriptURL)throw A('TRUSTED_TYPES_POLICY configuration option must provide a \"createScriptURL\" hook.');ae=e.TRUSTED_TYPES_POLICY,le=ae.createHTML(\"\")}else void 0===ae&&(ae=oe(Y,c)),null!==ae&&\"string\"==typeof le&&(le=ae.createHTML(\"\"));i&&i(e),mt=e}},gt=w({},[\"mi\",\"mo\",\"mn\",\"ms\",\"mtext\"]),_t=w({},[\"foreignobject\",\"annotation-xml\"]),Tt=w({},[\"title\",\"style\",\"font\",\"a\",\"script\"]),yt=w({},[...L,...O,...k]),Et=w({},[...x,...M]),At=function(e){let t=ie(e);t&&t.tagName||(t={namespaceURI:ot,tagName:\"template\"});const n=f(e.tagName),o=f(t.tagName);return!!it[e.namespaceURI]&&(e.namespaceURI===tt?t.namespaceURI===nt?\"svg\"===n:t.namespaceURI===et?\"svg\"===n&&(\"annotation-xml\"===o||gt[o]):Boolean(yt[n]):e.namespaceURI===et?t.namespaceURI===nt?\"math\"===n:t.namespaceURI===tt?\"math\"===n&&_t[o]:Boolean(Et[n]):e.namespaceURI===nt?!(t.namespaceURI===tt&&!_t[o])&&!(t.namespaceURI===et&&!gt[o])&&!Et[n]&&(Tt[n]||!yt[n]):!(\"application/xhtml+xml\"!==lt||!it[e.namespaceURI]))},Nt=function(e){p(o.removed,{element:e});try{e.parentNode.removeChild(e)}catch(t){e.remove()}},bt=function(e,t){try{p(o.removed,{attribute:t.getAttributeNode(e),from:t})}catch(e){p(o.removed,{attribute:null,from:t})}if(t.removeAttribute(e),\"is\"===e&&!we[e])if(He||ze)try{Nt(t)}catch(e){}else try{t.setAttribute(e,\"\")}catch(e){}},St=function(e){let t=null,n=null;if(Fe)e=\"<remove></remove>\"+e;else{const t=h(e,/^[\\r\\n\\t ]+/);n=t&&t[0]}\"application/xhtml+xml\"===lt&&ot===nt&&(e='<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>'+e+\"</body></html>\");const o=ae?ae.createHTML(e):e;if(ot===nt)try{t=(new G).parseFromString(o,lt)}catch(e){}if(!t||!t.documentElement){t=ce.createDocument(ot,\"template\",null);try{t.documentElement.innerHTML=rt?le:o}catch(e){}}const i=t.body||t.documentElement;return e&&n&&i.insertBefore(r.createTextNode(n),i.childNodes[0]||null),ot===nt?me.call(t,Ue?\"html\":\"body\")[0]:Ue?t.documentElement:i},wt=function(e){return se.call(e.ownerDocument||e,e,z.SHOW_ELEMENT|z.SHOW_COMMENT|z.SHOW_TEXT|z.SHOW_PROCESSING_INSTRUCTION|z.SHOW_CDATA_SECTION,null)},Rt=function(e){return e instanceof W&&(void 0!==e.__depth&&\"number\"!=typeof e.__depth||void 0!==e.__removalCount&&\"number\"!=typeof e.__removalCount||\"string\"!=typeof e.nodeName||\"string\"!=typeof e.textContent||\"function\"!=typeof e.removeChild||!(e.attributes instanceof B)||\"function\"!=typeof e.removeAttribute||\"function\"!=typeof e.setAttribute||\"string\"!=typeof e.namespaceURI||\"function\"!=typeof e.insertBefore||\"function\"!=typeof e.hasChildNodes)},Ct=function(e){return\"function\"==typeof S&&e instanceof S},vt=function(e,t,n){fe[e]&&u(fe[e],e=>{e.call(o,t,n,mt)})},Dt=function(e){let t=null;if(vt(\"beforeSanitizeElements\",e,null),Rt(e))return Nt(e),!0;const n=ut(e.nodeName);if(vt(\"uponSanitizeElement\",e,{tagName:n,allowedTags:be}),e.hasChildNodes()&&!Ct(e.firstElementChild)&&E(/<[/\\w]/g,e.innerHTML)&&E(/<[/\\w]/g,e.textContent))return Nt(e),!0;if(e.nodeType===Q)return Nt(e),!0;if(Ie&&e.nodeType===ee&&E(/<[/\\w]/g,e.data))return Nt(e),!0;if(!be[n]||ve[n]){if(!ve[n]&&Ot(n)){if(Ce.tagNameCheck instanceof RegExp&&E(Ce.tagNameCheck,n))return!1;if(Ce.tagNameCheck instanceof Function&&Ce.tagNameCheck(n))return!1}if(je&&!$e[n]){const t=ie(e)||e.parentNode,n=re(e)||e.childNodes;if(n&&t)for(let o=n.length-1;o>=0;--o){const r=q(n[o],!0);r.__removalCount=(e.__removalCount||0)+1,t.insertBefore(r,K(e))}}return Nt(e),!0}return e instanceof R&&!At(e)?(Nt(e),!0):\"noscript\"!==n&&\"noembed\"!==n&&\"noframes\"!==n||!E(/<\\/no(script|embed|frames)/i,e.innerHTML)?(Me&&e.nodeType===J&&(t=e.textContent,u([de,he,ge],e=>{t=g(t,e,\" \")}),e.textContent!==t&&(p(o.removed,{element:e.cloneNode()}),e.textContent=t)),vt(\"afterSanitizeElements\",e,null),!1):(Nt(e),!0)},Lt=function(e,t,n){if(We&&(\"id\"===t||\"name\"===t)&&(n in r||n in ft||\"__depth\"===n||\"__removalCount\"===n))return!1;if(Oe&&!De[t]&&E(_e,t));else if(Le&&E(Te,t));else if(!we[t]||De[t]){if(!(Ot(e)&&(Ce.tagNameCheck instanceof RegExp&&E(Ce.tagNameCheck,e)||Ce.tagNameCheck instanceof Function&&Ce.tagNameCheck(e))&&(Ce.attributeNameCheck instanceof RegExp&&E(Ce.attributeNameCheck,t)||Ce.attributeNameCheck instanceof Function&&Ce.attributeNameCheck(t))||\"is\"===t&&Ce.allowCustomizedBuiltInElements&&(Ce.tagNameCheck instanceof RegExp&&E(Ce.tagNameCheck,n)||Ce.tagNameCheck instanceof Function&&Ce.tagNameCheck(n))))return!1}else if(Je[t]);else if(E(Ne,g(n,Ee,\"\")));else if(\"src\"!==t&&\"xlink:href\"!==t&&\"href\"!==t||\"script\"===e||0!==_(n,\"data:\")||!Ve[e])if(ke&&!E(ye,g(n,Ee,\"\")));else if(n)return!1;return!0},Ot=function(e){return\"annotation-xml\"!==e&&h(e,Ae)},kt=function(e){vt(\"beforeSanitizeAttributes\",e,null);const{attributes:t}=e;if(!t)return;const n={attrName:\"\",attrValue:\"\",keepAttr:!0,allowedAttributes:we};let r=t.length;for(;r--;){const i=t[r],{name:a,namespaceURI:l,value:c}=i,s=ut(a);let p=\"value\"===a?c:T(c);if(n.attrName=s,n.attrValue=p,n.keepAttr=!0,n.forceKeepAttr=void 0,vt(\"uponSanitizeAttribute\",e,n),p=n.attrValue,n.forceKeepAttr)continue;if(bt(a,e),!n.keepAttr)continue;if(!xe&&E(/\\/>/i,p)){bt(a,e);continue}if(Ie&&E(/((--!?|])>)|<\\/(style|title)/i,p)){bt(a,e);continue}Me&&u([de,he,ge],e=>{p=g(p,e,\" \")});const f=ut(e.nodeName);if(Lt(f,s,p)){if(!Ge||\"id\"!==s&&\"name\"!==s||(bt(a,e),p=Ye+p),ae&&\"object\"==typeof Y&&\"function\"==typeof Y.getAttributeType)if(l);else switch(Y.getAttributeType(f,s)){case\"TrustedHTML\":p=ae.createHTML(p);break;case\"TrustedScriptURL\":p=ae.createScriptURL(p)}try{l?e.setAttributeNS(l,a,p):e.setAttribute(a,p),Rt(e)?Nt(e):m(o.removed)}catch(e){}}}vt(\"afterSanitizeAttributes\",e,null)},xt=function e(t){let n=null;const o=wt(t);for(vt(\"beforeSanitizeShadowDOM\",t,null);n=o.nextNode();){if(vt(\"uponSanitizeShadowNode\",n,null),Dt(n))continue;const t=ie(n);n.nodeType===Z&&(t&&t.__depth?n.__depth=(n.__removalCount||0)+t.__depth+1:n.__depth=1),(n.__depth>=pt||n.__depth<0||N(n.__depth))&&Nt(n),n.content instanceof s&&(n.content.__depth=n.__depth,e(n.content)),kt(n)}vt(\"afterSanitizeShadowDOM\",t,null)};return o.sanitize=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=null,r=null,i=null,l=null;if(rt=!e,rt&&(e=\"\\x3c!--\\x3e\"),\"string\"!=typeof e&&!Ct(e)){if(\"function\"!=typeof e.toString)throw A(\"toString is not a function\");if(\"string\"!=typeof(e=e.toString()))throw A(\"dirty is not a string, aborting\")}if(!o.isSupported)return e;if(Pe||ht(t),o.removed=[],\"string\"==typeof e&&(Xe=!1),Xe){if(e.nodeName){const t=ut(e.nodeName);if(!be[t]||ve[t])throw A(\"root node is forbidden and cannot be sanitized in-place\")}}else if(e instanceof S)n=St(\"\\x3c!----\\x3e\"),r=n.ownerDocument.importNode(e,!0),r.nodeType===Z&&\"BODY\"===r.nodeName||\"HTML\"===r.nodeName?n=r:n.appendChild(r);else{if(!He&&!Me&&!Ue&&-1===e.indexOf(\"<\"))return ae&&Be?ae.createHTML(e):e;if(n=St(e),!n)return He?null:Be?le:\"\"}n&&Fe&&Nt(n.firstChild);const c=wt(Xe?e:n);for(;i=c.nextNode();){if(Dt(i))continue;const e=ie(i);i.nodeType===Z&&(e&&e.__depth?i.__depth=(i.__removalCount||0)+e.__depth+1:i.__depth=1),(i.__depth>=pt||i.__depth<0||N(i.__depth))&&Nt(i),i.content instanceof s&&(i.content.__depth=i.__depth,xt(i.content)),kt(i)}if(Xe)return e;if(He){if(ze)for(l=ue.call(n.ownerDocument);n.firstChild;)l.appendChild(n.firstChild);else l=n;return(we.shadowroot||we.shadowrootmode)&&(l=pe.call(a,l,!0)),l}let m=Ue?n.outerHTML:n.innerHTML;return Ue&&be[\"!doctype\"]&&n.ownerDocument&&n.ownerDocument.doctype&&n.ownerDocument.doctype.name&&E($,n.ownerDocument.doctype.name)&&(m=\"<!DOCTYPE \"+n.ownerDocument.doctype.name+\">\\n\"+m),Me&&u([de,he,ge],e=>{m=g(m,e,\" \")}),ae&&Be?ae.createHTML(m):m},o.setConfig=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};ht(e),Pe=!0},o.clearConfig=function(){mt=null,Pe=!1},o.isValidAttribute=function(e,t,n){mt||ht({});const o=ut(e),r=ut(t);return Lt(o,r,n)},o.addHook=function(e,t){\"function\"==typeof t&&(fe[e]=fe[e]||[],p(fe[e],t))},o.removeHook=function(e){if(fe[e])return m(fe[e])},o.removeHooks=function(e){fe[e]&&(fe[e]=[])},o.removeAllHooks=function(){fe={}},o}()}()},29238:function(e,t,n){e.exports=window.DOMPurify||(window.DOMPurify=n(27856).default||n(27856))}}]);"],"names":["self","webpackChunk_N_E","push","e","exports","entries","setPrototypeOf","t","isFrozen","n","getPrototypeOf","o","getOwnPropertyDescriptor","r","Object","freeze","i","seal","a","create","l","apply","c","construct","s","Reflect","u","S","Array","prototype","forEach","m","pop","p","f","String","toLowerCase","d","toString","h","match","g","replace","_","indexOf","T","trim","y","hasOwnProperty","E","RegExp","test","A","b","TypeError","arguments","length","N","Number","isNaN","w","C","isArray","R","constructor","v","get","value","D","L","O","k","x","M","I","U","P","F","H","z","B","W","G","Y","j","X","q","$","K","V","__proto__","MUSTACHE_EXPR","ERB_EXPR","TMPLIT_EXPR","DATA_ATTR","ARIA_ATTR","IS_ALLOWED_URI","IS_SCRIPT_OR_DATA","ATTR_WHITESPACE","DOCTYPE_NAME","CUSTOM_ELEMENT","oe","createPolicy","hasAttribute","getAttribute","createHTML","createScriptURL","console","warn","window","version","removed","document","nodeType","isSupported","currentScript","DocumentFragment","HTMLTemplateElement","Node","Element","NodeFilter","NamedNodeMap","MozNamedAttrMap","HTMLFormElement","DOMParser","trustedTypes","re","ie","createElement","content","ownerDocument","ae","le","implementation","ce","createNodeIterator","se","createDocumentFragment","ue","getElementsByTagName","me","importNode","pe","fe","createHTMLDocument","de","he","ge","_e","Te","ye","Ee","Ae","Ne","be","Se","we","Re","Ce","tagNameCheck","writable","configurable","enumerable","attributeNameCheck","allowCustomizedBuiltInElements","ve","De","Le","Oe","ke","xe","Me","Ie","Ue","Pe","Fe","He","ze","Be","We","Ge","je","Xe","qe","$e","Ke","Ve","Ze","Je","Qe","et","tt","nt","ot","rt","it","at","lt","ct","ut","mt","ft","dt","Function","ht","PARSER_MEDIA_TYPE","ALLOWED_TAGS","ALLOWED_ATTR","ALLOWED_NAMESPACES","ADD_URI_SAFE_ATTR","ADD_DATA_URI_TAGS","FORBID_CONTENTS","FORBID_TAGS","FORBID_ATTR","USE_PROFILES","ALLOW_ARIA_ATTR","ALLOW_DATA_ATTR","ALLOW_UNKNOWN_PROTOCOLS","ALLOW_SELF_CLOSE_IN_ATTR","SAFE_FOR_TEMPLATES","SAFE_FOR_XML","WHOLE_DOCUMENT","RETURN_DOM","RETURN_DOM_FRAGMENT","RETURN_TRUSTED_TYPE","FORCE_BODY","SANITIZE_DOM","SANITIZE_NAMED_PROPS","KEEP_CONTENT","IN_PLACE","ALLOWED_URI_REGEXP","NAMESPACE","CUSTOM_ELEMENT_HANDLING","html","svg","svgFilters","mathMl","ADD_TAGS","ADD_ATTR","table","tbody","TRUSTED_TYPES_POLICY","gt","_t","Tt","yt","Et","At","tagName","namespaceURI","Boolean","Nt","element","parentNode","removeChild","remove","bt","attribute","getAttributeNode","from","removeAttribute","setAttribute","St","parseFromString","documentElement","createDocument","innerHTML","body","insertBefore","createTextNode","childNodes","call","wt","SHOW_ELEMENT","SHOW_COMMENT","SHOW_TEXT","SHOW_PROCESSING_INSTRUCTION","SHOW_CDATA_SECTION","Rt","__depth","__removalCount","nodeName","textContent","attributes","hasChildNodes","Ct","vt","Dt","allowedTags","firstElementChild","data","Ot","cloneNode","Lt","kt","attrName","attrValue","keepAttr","allowedAttributes","name","forceKeepAttr","Ye","getAttributeType","setAttributeNS","xt","nextNode","sanitize","appendChild","firstChild","shadowroot","shadowrootmode","outerHTML","doctype","setConfig","clearConfig","isValidAttribute","addHook","removeHook","removeHooks","removeAllHooks","DOMPurify","default"],"sourceRoot":""}