q2-tecton-elements 1.54.3 → 1.55.0

package/dist/q2-tecton-elements/sanitize-html-string-735c19f5.js

@@ -0,0 +1,1214 @@
+var e = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+
+var t = {
+  exports: {}
+};
+
+/*! @license DOMPurify 3.2.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.4/LICENSE */ (function(t, n) {
+  (function(e, n) {
+    t.exports = n();
+  })(e, (function() {
+    const {entries: e, setPrototypeOf: t, isFrozen: n, getPrototypeOf: o, getOwnPropertyDescriptor: i} = Object;
+    let {freeze: r, seal: a, create: l} = Object;
+ // eslint-disable-line import/no-mutable-exports
+        let {apply: s, construct: c} = typeof Reflect !== "undefined" && Reflect;
+    if (!r) {
+      r = function freeze(e) {
+        return e;
+      };
+    }
+    if (!a) {
+      a = function seal(e) {
+        return e;
+      };
+    }
+    if (!s) {
+      s = function apply(e, t, n) {
+        return e.apply(t, n);
+      };
+    }
+    if (!c) {
+      c = function construct(e, t) {
+        return new e(...t);
+      };
+    }
+    const f = unapply(Array.prototype.forEach);
+    const u = unapply(Array.prototype.lastIndexOf);
+    const d = unapply(Array.prototype.pop);
+    const p = unapply(Array.prototype.push);
+    const m = unapply(Array.prototype.splice);
+    const g = unapply(String.prototype.toLowerCase);
+    const h = unapply(String.prototype.toString);
+    const y = unapply(String.prototype.match);
+    const T = unapply(String.prototype.replace);
+    const b = unapply(String.prototype.indexOf);
+    const w = unapply(String.prototype.trim);
+    const S = unapply(Object.prototype.hasOwnProperty);
+    const x = unapply(RegExp.prototype.test);
+    const k = unconstruct(TypeError);
+    /**
+   * Creates a new function that calls the given function with a specified thisArg and arguments.
+   *
+   * @param func - The function to be wrapped and called.
+   * @returns A new function that calls the given function with a specified thisArg and arguments.
+   */    function unapply(e) {
+      return function(t) {
+        for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), i = 1; i < n; i++) {
+          o[i - 1] = arguments[i];
+        }
+        return s(e, t, o);
+      };
+    }
+    /**
+   * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
+   *
+   * @param func - The constructor function to be wrapped and called.
+   * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
+   */    function unconstruct(e) {
+      return function() {
+        for (var t = arguments.length, n = new Array(t), o = 0; o < t; o++) {
+          n[o] = arguments[o];
+        }
+        return c(e, n);
+      };
+    }
+    /**
+   * Add properties to a lookup table
+   *
+   * @param set - The set to which elements will be added.
+   * @param array - The array containing elements to be added to the set.
+   * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
+   * @returns The modified set with added elements.
+   */    function addToSet(e, o) {
+      let i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : g;
+      if (t) {
+        // Make 'in' and truthy checks like Boolean(set.constructor)
+        // independent of any properties defined on Object.prototype.
+        // Prevent prototype setters from intercepting set as a this value.
+        t(e, null);
+      }
+      let r = o.length;
+      while (r--) {
+        let t = o[r];
+        if (typeof t === "string") {
+          const e = i(t);
+          if (e !== t) {
+            // Config presets (e.g. tags.js, attrs.js) are immutable.
+            if (!n(o)) {
+              o[r] = e;
+            }
+            t = e;
+          }
+        }
+        e[t] = true;
+      }
+      return e;
+    }
+    /**
+   * Clean up an array to harden against CSPP
+   *
+   * @param array - The array to be cleaned.
+   * @returns The cleaned version of the array
+   */    function cleanArray(e) {
+      for (let t = 0; t < e.length; t++) {
+        const n = S(e, t);
+        if (!n) {
+          e[t] = null;
+        }
+      }
+      return e;
+    }
+    /**
+   * Shallow clone an object
+   *
+   * @param object - The object to be cloned.
+   * @returns A new object that copies the original.
+   */    function clone(t) {
+      const n = l(null);
+      for (const [o, i] of e(t)) {
+        const e = S(t, o);
+        if (e) {
+          if (Array.isArray(i)) {
+            n[o] = cleanArray(i);
+          } else if (i && typeof i === "object" && i.constructor === Object) {
+            n[o] = clone(i);
+          } else {
+            n[o] = i;
+          }
+        }
+      }
+      return n;
+    }
+    /**
+   * This method automatically checks if the prop is function or getter and behaves accordingly.
+   *
+   * @param object - The object to look up the getter function in its prototype chain.
+   * @param prop - The property name for which to find the getter function.
+   * @returns The getter function found in the prototype chain or a fallback function.
+   */    function lookupGetter(e, t) {
+      while (e !== null) {
+        const n = i(e, t);
+        if (n) {
+          if (n.get) {
+            return unapply(n.get);
+          }
+          if (typeof n.value === "function") {
+            return unapply(n.value);
+          }
+        }
+        e = o(e);
+      }
+      function fallbackValue() {
+        return null;
+      }
+      return fallbackValue;
+    }
+    const _ = r([ "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" ]);
+    const v = r([ "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" ]);
+    const A = r([ "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" ]);
+    // List of SVG elements that are disallowed by default.
+    // We still need to know them so that we can do namespace
+    // checks properly in case one wants to add them to
+    // allow-list.
+        const E = r([ "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" ]);
+    const R = r([ "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" ]);
+    // Similarly to SVG, we want to know all MathML elements,
+    // even those that we disallow by default.
+        const D = r([ "maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none" ]);
+    const O = r([ "#text" ]);
+    const M = r([ "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", "popover", "popovertarget", "popovertargetaction", "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" ]);
+    const z = r([ "accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "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", "exponent", "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", "intercept", "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", "slope", "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", "tablevalues", "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" ]);
+    const L = r([ "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" ]);
+    const I = r([ "xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink" ]);
+    // eslint-disable-next-line unicorn/better-regex
+        const N = a(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+ // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+        const P = a(/<%[\w\W]*|[\w\W]*%>/gm);
+    const F = a(/\$\{[\w\W]*/gm);
+ // eslint-disable-line unicorn/better-regex
+        const C = a(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+ // eslint-disable-line no-useless-escape
+        const H = a(/^aria-[\-\w]+$/);
+ // eslint-disable-line no-useless-escape
+        const U = a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+    const B = a(/^(?:\w+script|data):/i);
+    const j = a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+    const G = a(/^html$/i);
+    const W = a(/^[a-z][.\w]*(-[.\w]+)+$/i);
+    var q =  Object.freeze({
+      __proto__: null,
+      ARIA_ATTR: H,
+      ATTR_WHITESPACE: j,
+      CUSTOM_ELEMENT: W,
+      DATA_ATTR: C,
+      DOCTYPE_NAME: G,
+      ERB_EXPR: P,
+      IS_ALLOWED_URI: U,
+      IS_SCRIPT_OR_DATA: B,
+      MUSTACHE_EXPR: N,
+      TMPLIT_EXPR: F
+    });
+    /* eslint-disable @typescript-eslint/indent */
+    // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+        const Y = {
+      element: 1,
+      attribute: 2,
+      text: 3,
+      cdataSection: 4,
+      entityReference: 5,
+      // Deprecated
+      entityNode: 6,
+      // Deprecated
+      progressingInstruction: 7,
+      comment: 8,
+      document: 9,
+      documentType: 10,
+      documentFragment: 11,
+      notation: 12
+    };
+    const X = function getGlobal() {
+      return typeof window === "undefined" ? null : window;
+    };
+    /**
+   * Creates a no-op policy for internal use only.
+   * Don't export this function outside this module!
+   * @param trustedTypes The policy factory.
+   * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
+   * @return The policy created (or null, if Trusted Types
+   * are not supported or creating the policy failed).
+   */    const $ = function _createTrustedTypesPolicy(e, t) {
+      if (typeof e !== "object" || typeof e.createPolicy !== "function") {
+        return null;
+      }
+      // Allow the callers to control the unique policy name
+      // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+      // Policy creation with duplicate names throws in Trusted Types.
+            let n = null;
+      const o = "data-tt-policy-suffix";
+      if (t && t.hasAttribute(o)) {
+        n = t.getAttribute(o);
+      }
+      const i = "dompurify" + (n ? "#" + n : "");
+      try {
+        return e.createPolicy(i, {
+          createHTML(e) {
+            return e;
+          },
+          createScriptURL(e) {
+            return e;
+          }
+        });
+      } catch (e) {
+        // Policy creation failed (most likely another DOMPurify script has
+        // already run). Skip creating the policy, as this will only cause errors
+        // if TT are enforced.
+        console.warn("TrustedTypes policy " + i + " could not be created.");
+        return null;
+      }
+    };
+    const V = function _createHooksMap() {
+      return {
+        afterSanitizeAttributes: [],
+        afterSanitizeElements: [],
+        afterSanitizeShadowDOM: [],
+        beforeSanitizeAttributes: [],
+        beforeSanitizeElements: [],
+        beforeSanitizeShadowDOM: [],
+        uponSanitizeAttribute: [],
+        uponSanitizeElement: [],
+        uponSanitizeShadowNode: []
+      };
+    };
+    function createDOMPurify() {
+      let t = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : X();
+      const DOMPurify = e => createDOMPurify(e);
+      DOMPurify.version = "3.2.4";
+      DOMPurify.removed = [];
+      if (!t || !t.document || t.document.nodeType !== Y.document || !t.Element) {
+        // Not running in a browser, provide a factory function
+        // so that you can pass your own Window
+        DOMPurify.isSupported = false;
+        return DOMPurify;
+      }
+      let {document: n} = t;
+      const o = n;
+      const i = o.currentScript;
+      const {DocumentFragment: a, HTMLTemplateElement: s, Node: c, Element: N, NodeFilter: P, NamedNodeMap: F = t.NamedNodeMap || t.MozNamedAttrMap, HTMLFormElement: C, DOMParser: H, trustedTypes: B} = t;
+      const j = N.prototype;
+      const W = lookupGetter(j, "cloneNode");
+      const K = lookupGetter(j, "remove");
+      const J = lookupGetter(j, "nextSibling");
+      const Q = lookupGetter(j, "childNodes");
+      const Z = lookupGetter(j, "parentNode");
+      // As per issue #47, the web-components registry is inherited by a
+      // new document created via createHTMLDocument. As per the spec
+      // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+      // a new empty registry is used when creating a template contents owner
+      // document, so we use that as our parent document to ensure nothing
+      // is inherited.
+            if (typeof s === "function") {
+        const e = n.createElement("template");
+        if (e.content && e.content.ownerDocument) {
+          n = e.content.ownerDocument;
+        }
+      }
+      let ee;
+      let te = "";
+      const {implementation: ne, createNodeIterator: oe, createDocumentFragment: ie, getElementsByTagName: re} = n;
+      const {importNode: ae} = o;
+      let le = V();
+      /**
+     * Expose whether this browser supports running the full DOMPurify.
+     */      DOMPurify.isSupported = typeof e === "function" && typeof Z === "function" && ne && ne.createHTMLDocument !== undefined;
+      const {MUSTACHE_EXPR: se, ERB_EXPR: ce, TMPLIT_EXPR: fe, DATA_ATTR: ue, ARIA_ATTR: de, IS_SCRIPT_OR_DATA: pe, ATTR_WHITESPACE: me, CUSTOM_ELEMENT: ge} = q;
+      let {IS_ALLOWED_URI: he} = q;
+      /**
+     * We consider the elements and attributes below to be safe. Ideally
+     * don't add any new ones but feel free to remove unwanted ones.
+     */
+      /* allowed element names */      let ye = null;
+      const Te = addToSet({}, [ ..._, ...v, ...A, ...R, ...O ]);
+      /* Allowed attribute names */      let be = null;
+      const we = addToSet({}, [ ...M, ...z, ...L, ...I ]);
+      /*
+     * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
+     * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
+     * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
+     * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
+     */      let Se = Object.seal(l(null, {
+        tagNameCheck: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: null
+        },
+        attributeNameCheck: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: null
+        },
+        allowCustomizedBuiltInElements: {
+          writable: true,
+          configurable: false,
+          enumerable: true,
+          value: false
+        }
+      }));
+      /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */      let xe = null;
+      /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */      let ke = null;
+      /* Decide if ARIA attributes are okay */      let _e = true;
+      /* Decide if custom data attributes are okay */      let ve = true;
+      /* Decide if unknown protocols are okay */      let Ae = false;
+      /* Decide if self-closing tags in attributes are allowed.
+     * Usually removed due to a mXSS issue in jQuery 3.0 */      let Ee = true;
+      /* Output should be safe for common template engines.
+     * This means, DOMPurify removes data attributes, mustaches and ERB
+     */      let Re = false;
+      /* Output should be safe even for XML used within HTML and alike.
+     * This means, DOMPurify removes comments when containing risky content.
+     */      let De = true;
+      /* Decide if document with <html>... should be returned */      let Oe = false;
+      /* Track whether config is already set on this instance of DOMPurify. */      let Me = false;
+      /* Decide if all elements (e.g. style, script) must be children of
+     * document.body. By default, browsers might move them to document.head */      let ze = false;
+      /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+     * string (or a TrustedHTML object if Trusted Types are supported).
+     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+     */      let Le = false;
+      /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+     * string  (or a TrustedHTML object if Trusted Types are supported) */      let Ie = false;
+      /* Try to return a Trusted Type object instead of a string, return a string in
+     * case Trusted Types are not supported  */      let Ne = false;
+      /* Output should be free from DOM clobbering attacks?
+     * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
+     */      let Pe = true;
+      /* Achieve full DOM Clobbering protection by isolating the namespace of named
+     * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
+     *
+     * HTML/DOM spec rules that enable DOM Clobbering:
+     *   - Named Access on Window (§7.3.3)
+     *   - DOM Tree Accessors (§3.1.5)
+     *   - Form Element Parent-Child Relations (§4.10.3)
+     *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)
+     *   - HTMLCollection (§4.2.10.2)
+     *
+     * Namespace isolation is implemented by prefixing `id` and `name` attributes
+     * with a constant string, i.e., `user-content-`
+     */      let Fe = false;
+      const Ce = "user-content-";
+      /* Keep element content when removing element? */      let He = true;
+      /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+     * of importing it into a new Document and returning a sanitized copy */      let Ue = false;
+      /* Allow usage of profiles like html, svg and mathMl */      let Be = {};
+      /* Tags to ignore content of when KEEP_CONTENT is true */      let je = null;
+      const Ge = 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" ]);
+      /* Tags that are safe for data: URIs */      let We = null;
+      const qe = addToSet({}, [ "audio", "video", "img", "source", "image", "track" ]);
+      /* Attributes safe for values like "javascript:" */      let Ye = null;
+      const Xe = addToSet({}, [ "alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns" ]);
+      const $e = "http://www.w3.org/1998/Math/MathML";
+      const Ve = "http://www.w3.org/2000/svg";
+      const Ke = "http://www.w3.org/1999/xhtml";
+      /* Document namespace */      let Je = Ke;
+      let Qe = false;
+      /* Allowed XHTML+XML namespaces */      let Ze = null;
+      const et = addToSet({}, [ $e, Ve, Ke ], h);
+      let tt = addToSet({}, [ "mi", "mo", "mn", "ms", "mtext" ]);
+      let nt = addToSet({}, [ "annotation-xml" ]);
+      // Certain elements are allowed in both SVG and HTML
+      // namespace. We need to specify them explicitly
+      // so that they don't get erroneously deleted from
+      // HTML namespace.
+            const ot = addToSet({}, [ "title", "style", "font", "a", "script" ]);
+      /* Parsing of strict XHTML documents */      let it = null;
+      const rt = [ "application/xhtml+xml", "text/html" ];
+      const at = "text/html";
+      let lt = null;
+      /* Keep a reference to config to pass to hooks */      let st = null;
+      /* Ideally, do not touch anything below this line */
+      /* ______________________________________________ */      const ct = n.createElement("form");
+      const ft = function isRegexOrFunction(e) {
+        return e instanceof RegExp || e instanceof Function;
+      };
+      /**
+     * _parseConfig
+     *
+     * @param cfg optional config literal
+     */
+      // eslint-disable-next-line complexity
+            const ut = function _parseConfig() {
+        let e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        if (st && st === e) {
+          return;
+        }
+        /* Shield configuration object from tampering */        if (!e || typeof e !== "object") {
+          e = {};
+        }
+        /* Shield configuration object from prototype pollution */        e = clone(e);
+        it = 
+        // eslint-disable-next-line unicorn/prefer-includes
+        rt.indexOf(e.PARSER_MEDIA_TYPE) === -1 ? at : e.PARSER_MEDIA_TYPE;
+        // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
+                lt = it === "application/xhtml+xml" ? h : g;
+        /* Set configuration parameters */        ye = S(e, "ALLOWED_TAGS") ? addToSet({}, e.ALLOWED_TAGS, lt) : Te;
+        be = S(e, "ALLOWED_ATTR") ? addToSet({}, e.ALLOWED_ATTR, lt) : we;
+        Ze = S(e, "ALLOWED_NAMESPACES") ? addToSet({}, e.ALLOWED_NAMESPACES, h) : et;
+        Ye = S(e, "ADD_URI_SAFE_ATTR") ? addToSet(clone(Xe), e.ADD_URI_SAFE_ATTR, lt) : Xe;
+        We = S(e, "ADD_DATA_URI_TAGS") ? addToSet(clone(qe), e.ADD_DATA_URI_TAGS, lt) : qe;
+        je = S(e, "FORBID_CONTENTS") ? addToSet({}, e.FORBID_CONTENTS, lt) : Ge;
+        xe = S(e, "FORBID_TAGS") ? addToSet({}, e.FORBID_TAGS, lt) : {};
+        ke = S(e, "FORBID_ATTR") ? addToSet({}, e.FORBID_ATTR, lt) : {};
+        Be = S(e, "USE_PROFILES") ? e.USE_PROFILES : false;
+        _e = e.ALLOW_ARIA_ATTR !== false;
+ // Default true
+                ve = e.ALLOW_DATA_ATTR !== false;
+ // Default true
+                Ae = e.ALLOW_UNKNOWN_PROTOCOLS || false;
+ // Default false
+                Ee = e.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+ // Default true
+                Re = e.SAFE_FOR_TEMPLATES || false;
+ // Default false
+                De = e.SAFE_FOR_XML !== false;
+ // Default true
+                Oe = e.WHOLE_DOCUMENT || false;
+ // Default false
+                Le = e.RETURN_DOM || false;
+ // Default false
+                Ie = e.RETURN_DOM_FRAGMENT || false;
+ // Default false
+                Ne = e.RETURN_TRUSTED_TYPE || false;
+ // Default false
+                ze = e.FORCE_BODY || false;
+ // Default false
+                Pe = e.SANITIZE_DOM !== false;
+ // Default true
+                Fe = e.SANITIZE_NAMED_PROPS || false;
+ // Default false
+                He = e.KEEP_CONTENT !== false;
+ // Default true
+                Ue = e.IN_PLACE || false;
+ // Default false
+                he = e.ALLOWED_URI_REGEXP || U;
+        Je = e.NAMESPACE || Ke;
+        tt = e.MATHML_TEXT_INTEGRATION_POINTS || tt;
+        nt = e.HTML_INTEGRATION_POINTS || nt;
+        Se = e.CUSTOM_ELEMENT_HANDLING || {};
+        if (e.CUSTOM_ELEMENT_HANDLING && ft(e.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+          Se.tagNameCheck = e.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+        }
+        if (e.CUSTOM_ELEMENT_HANDLING && ft(e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+          Se.attributeNameCheck = e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+        }
+        if (e.CUSTOM_ELEMENT_HANDLING && typeof e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
+          Se.allowCustomizedBuiltInElements = e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+        }
+        if (Re) {
+          ve = false;
+        }
+        if (Ie) {
+          Le = true;
+        }
+        /* Parse profile info */        if (Be) {
+          ye = addToSet({}, O);
+          be = [];
+          if (Be.html === true) {
+            addToSet(ye, _);
+            addToSet(be, M);
+          }
+          if (Be.svg === true) {
+            addToSet(ye, v);
+            addToSet(be, z);
+            addToSet(be, I);
+          }
+          if (Be.svgFilters === true) {
+            addToSet(ye, A);
+            addToSet(be, z);
+            addToSet(be, I);
+          }
+          if (Be.mathMl === true) {
+            addToSet(ye, R);
+            addToSet(be, L);
+            addToSet(be, I);
+          }
+        }
+        /* Merge configuration parameters */        if (e.ADD_TAGS) {
+          if (ye === Te) {
+            ye = clone(ye);
+          }
+          addToSet(ye, e.ADD_TAGS, lt);
+        }
+        if (e.ADD_ATTR) {
+          if (be === we) {
+            be = clone(be);
+          }
+          addToSet(be, e.ADD_ATTR, lt);
+        }
+        if (e.ADD_URI_SAFE_ATTR) {
+          addToSet(Ye, e.ADD_URI_SAFE_ATTR, lt);
+        }
+        if (e.FORBID_CONTENTS) {
+          if (je === Ge) {
+            je = clone(je);
+          }
+          addToSet(je, e.FORBID_CONTENTS, lt);
+        }
+        /* Add #text in case KEEP_CONTENT is set to true */        if (He) {
+          ye["#text"] = true;
+        }
+        /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */        if (Oe) {
+          addToSet(ye, [ "html", "head", "body" ]);
+        }
+        /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */        if (ye.table) {
+          addToSet(ye, [ "tbody" ]);
+          delete xe.tbody;
+        }
+        if (e.TRUSTED_TYPES_POLICY) {
+          if (typeof e.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+            throw k('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+          }
+          if (typeof e.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+            throw k('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+          }
+          // Overwrite existing TrustedTypes policy.
+                    ee = e.TRUSTED_TYPES_POLICY;
+          // Sign local variables required by `sanitize`.
+                    te = ee.createHTML("");
+        } else {
+          // Uninitialized policy, attempt to initialize the internal dompurify policy.
+          if (ee === undefined) {
+            ee = $(B, i);
+          }
+          // If creating the internal policy succeeded sign internal variables.
+                    if (ee !== null && typeof te === "string") {
+            te = ee.createHTML("");
+          }
+        }
+        // Prevent further manipulation of configuration.
+        // Not available in IE8, Safari 5, etc.
+                if (r) {
+          r(e);
+        }
+        st = e;
+      };
+      /* Keep track of all possible SVG and MathML tags
+     * so that we can perform the namespace checks
+     * correctly. */      const dt = addToSet({}, [ ...v, ...A, ...E ]);
+      const pt = addToSet({}, [ ...R, ...D ]);
+      /**
+     * @param element a DOM element whose namespace is being checked
+     * @returns Return false if the element has a
+     *  namespace that a spec-compliant parser would never
+     *  return. Return true otherwise.
+     */      const mt = function _checkValidNamespace(e) {
+        let t = Z(e);
+        // In JSDOM, if we're inside shadow DOM, then parentNode
+        // can be null. We just simulate parent in this case.
+                if (!t || !t.tagName) {
+          t = {
+            namespaceURI: Je,
+            tagName: "template"
+          };
+        }
+        const n = g(e.tagName);
+        const o = g(t.tagName);
+        if (!Ze[e.namespaceURI]) {
+          return false;
+        }
+        if (e.namespaceURI === Ve) {
+          // The only way to switch from HTML namespace to SVG
+          // is via <svg>. If it happens via any other tag, then
+          // it should be killed.
+          if (t.namespaceURI === Ke) {
+            return n === "svg";
+          }
+          // The only way to switch from MathML to SVG is via`
+          // svg if parent is either <annotation-xml> or MathML
+          // text integration points.
+                    if (t.namespaceURI === $e) {
+            return n === "svg" && (o === "annotation-xml" || tt[o]);
+          }
+          // We only allow elements that are defined in SVG
+          // spec. All others are disallowed in SVG namespace.
+                    return Boolean(dt[n]);
+        }
+        if (e.namespaceURI === $e) {
+          // The only way to switch from HTML namespace to MathML
+          // is via <math>. If it happens via any other tag, then
+          // it should be killed.
+          if (t.namespaceURI === Ke) {
+            return n === "math";
+          }
+          // The only way to switch from SVG to MathML is via
+          // <math> and HTML integration points
+                    if (t.namespaceURI === Ve) {
+            return n === "math" && nt[o];
+          }
+          // We only allow elements that are defined in MathML
+          // spec. All others are disallowed in MathML namespace.
+                    return Boolean(pt[n]);
+        }
+        if (e.namespaceURI === Ke) {
+          // The only way to switch from SVG to HTML is via
+          // HTML integration points, and from MathML to HTML
+          // is via MathML text integration points
+          if (t.namespaceURI === Ve && !nt[o]) {
+            return false;
+          }
+          if (t.namespaceURI === $e && !tt[o]) {
+            return false;
+          }
+          // We disallow tags that are specific for MathML
+          // or SVG and should never appear in HTML namespace
+                    return !pt[n] && (ot[n] || !dt[n]);
+        }
+        // For XHTML and XML documents that support custom namespaces
+                if (it === "application/xhtml+xml" && Ze[e.namespaceURI]) {
+          return true;
+        }
+        // The code should never reach this place (this means
+        // that the element somehow got namespace that is not
+        // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
+        // Return false just in case.
+                return false;
+      };
+      /**
+     * _forceRemove
+     *
+     * @param node a DOM node
+     */      const gt = function _forceRemove(e) {
+        p(DOMPurify.removed, {
+          element: e
+        });
+        try {
+          // eslint-disable-next-line unicorn/prefer-dom-node-remove
+          Z(e).removeChild(e);
+        } catch (t) {
+          K(e);
+        }
+      };
+      /**
+     * _removeAttribute
+     *
+     * @param name an Attribute name
+     * @param element a DOM node
+     */      const ht = function _removeAttribute(e, t) {
+        try {
+          p(DOMPurify.removed, {
+            attribute: t.getAttributeNode(e),
+            from: t
+          });
+        } catch (e) {
+          p(DOMPurify.removed, {
+            attribute: null,
+            from: t
+          });
+        }
+        t.removeAttribute(e);
+        // We void attribute values for unremovable "is" attributes
+                if (e === "is") {
+          if (Le || Ie) {
+            try {
+              gt(t);
+            } catch (e) {}
+          } else {
+            try {
+              t.setAttribute(e, "");
+            } catch (e) {}
+          }
+        }
+      };
+      /**
+     * _initDocument
+     *
+     * @param dirty - a string of dirty markup
+     * @return a DOM, filled with the dirty markup
+     */      const yt = function _initDocument(e) {
+        /* Create a HTML document */
+        let t = null;
+        let o = null;
+        if (ze) {
+          e = "<remove></remove>" + e;
+        } else {
+          /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+          const t = y(e, /^[\r\n\t ]+/);
+          o = t && t[0];
+        }
+        if (it === "application/xhtml+xml" && Je === Ke) {
+          // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
+          e = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + e + "</body></html>";
+        }
+        const i = ee ? ee.createHTML(e) : e;
+        /*
+       * Use the DOMParser API by default, fallback later if needs be
+       * DOMParser not work for svg when has multiple root element.
+       */        if (Je === Ke) {
+          try {
+            t = (new H).parseFromString(i, it);
+          } catch (e) {}
+        }
+        /* Use createHTMLDocument in case DOMParser is not available */        if (!t || !t.documentElement) {
+          t = ne.createDocument(Je, "template", null);
+          try {
+            t.documentElement.innerHTML = Qe ? te : i;
+          } catch (e) {
+            // Syntax error if dirtyPayload is invalid xml
+          }
+        }
+        const r = t.body || t.documentElement;
+        if (e && o) {
+          r.insertBefore(n.createTextNode(o), r.childNodes[0] || null);
+        }
+        /* Work on whole document or just its body */        if (Je === Ke) {
+          return re.call(t, Oe ? "html" : "body")[0];
+        }
+        return Oe ? t.documentElement : r;
+      };
+      /**
+     * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
+     *
+     * @param root The root element or node to start traversing on.
+     * @return The created NodeIterator
+     */      const Tt = function _createNodeIterator(e) {
+        return oe.call(e.ownerDocument || e, e, 
+        // eslint-disable-next-line no-bitwise
+        P.SHOW_ELEMENT | P.SHOW_COMMENT | P.SHOW_TEXT | P.SHOW_PROCESSING_INSTRUCTION | P.SHOW_CDATA_SECTION, null);
+      };
+      /**
+     * _isClobbered
+     *
+     * @param element element to check for clobbering attacks
+     * @return true if clobbered, false if safe
+     */      const bt = function _isClobbered(e) {
+        return e instanceof C && (typeof e.nodeName !== "string" || typeof e.textContent !== "string" || typeof e.removeChild !== "function" || !(e.attributes instanceof F) || typeof e.removeAttribute !== "function" || typeof e.setAttribute !== "function" || typeof e.namespaceURI !== "string" || typeof e.insertBefore !== "function" || typeof e.hasChildNodes !== "function");
+      };
+      /**
+     * Checks whether the given object is a DOM node.
+     *
+     * @param value object to check whether it's a DOM node
+     * @return true is object is a DOM node
+     */      const wt = function _isNode(e) {
+        return typeof c === "function" && e instanceof c;
+      };
+      function _executeHooks(e, t, n) {
+        f(e, (e => {
+          e.call(DOMPurify, t, n, st);
+        }));
+      }
+      /**
+     * _sanitizeElements
+     *
+     * @protect nodeName
+     * @protect textContent
+     * @protect removeChild
+     * @param currentNode to check for permission to exist
+     * @return true if node was killed, false if left alive
+     */      const St = function _sanitizeElements(e) {
+        let t = null;
+        /* Execute a hook if present */        _executeHooks(le.beforeSanitizeElements, e, null);
+        /* Check if element is clobbered or can clobber */        if (bt(e)) {
+          gt(e);
+          return true;
+        }
+        /* Now let's check the element's type and name */        const n = lt(e.nodeName);
+        /* Execute a hook if present */        _executeHooks(le.uponSanitizeElement, e, {
+          tagName: n,
+          allowedTags: ye
+        });
+        /* Detect mXSS attempts abusing namespace confusion */        if (e.hasChildNodes() && !wt(e.firstElementChild) && x(/<[/\w]/g, e.innerHTML) && x(/<[/\w]/g, e.textContent)) {
+          gt(e);
+          return true;
+        }
+        /* Remove any occurrence of processing instructions */        if (e.nodeType === Y.progressingInstruction) {
+          gt(e);
+          return true;
+        }
+        /* Remove any kind of possibly harmful comments */        if (De && e.nodeType === Y.comment && x(/<[/\w]/g, e.data)) {
+          gt(e);
+          return true;
+        }
+        /* Remove element if anything forbids its presence */        if (!ye[n] || xe[n]) {
+          /* Check if we have a custom element to handle */
+          if (!xe[n] && kt(n)) {
+            if (Se.tagNameCheck instanceof RegExp && x(Se.tagNameCheck, n)) {
+              return false;
+            }
+            if (Se.tagNameCheck instanceof Function && Se.tagNameCheck(n)) {
+              return false;
+            }
+          }
+          /* Keep content except for bad-listed elements */          if (He && !je[n]) {
+            const t = Z(e) || e.parentNode;
+            const n = Q(e) || e.childNodes;
+            if (n && t) {
+              const o = n.length;
+              for (let i = o - 1; i >= 0; --i) {
+                const o = W(n[i], true);
+                o.__removalCount = (e.__removalCount || 0) + 1;
+                t.insertBefore(o, J(e));
+              }
+            }
+          }
+          gt(e);
+          return true;
+        }
+        /* Check whether element has a valid namespace */        if (e instanceof N && !mt(e)) {
+          gt(e);
+          return true;
+        }
+        /* Make sure that older browsers don't get fallback-tag mXSS */        if ((n === "noscript" || n === "noembed" || n === "noframes") && x(/<\/no(script|embed|frames)/i, e.innerHTML)) {
+          gt(e);
+          return true;
+        }
+        /* Sanitize element content to be template-safe */        if (Re && e.nodeType === Y.text) {
+          /* Get the element's text content */
+          t = e.textContent;
+          f([ se, ce, fe ], (e => {
+            t = T(t, e, " ");
+          }));
+          if (e.textContent !== t) {
+            p(DOMPurify.removed, {
+              element: e.cloneNode()
+            });
+            e.textContent = t;
+          }
+        }
+        /* Execute a hook if present */        _executeHooks(le.afterSanitizeElements, e, null);
+        return false;
+      };
+      /**
+     * _isValidAttribute
+     *
+     * @param lcTag Lowercase tag name of containing element.
+     * @param lcName Lowercase attribute name.
+     * @param value Attribute value.
+     * @return Returns true if `value` is valid, otherwise false.
+     */
+      // eslint-disable-next-line complexity
+            const xt = function _isValidAttribute(e, t, o) {
+        /* Make sure attribute cannot clobber */
+        if (Pe && (t === "id" || t === "name") && (o in n || o in ct)) {
+          return false;
+        }
+        /* Allow valid data-* attributes: At least one character after "-"
+          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
+          We don't need to check the value; it's always URI safe. */        if (ve && !ke[t] && x(ue, t)) ; else if (_e && x(de, t)) ; else if (!be[t] || ke[t]) {
+          if (
+          // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+          // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+          kt(e) && (Se.tagNameCheck instanceof RegExp && x(Se.tagNameCheck, e) || Se.tagNameCheck instanceof Function && Se.tagNameCheck(e)) && (Se.attributeNameCheck instanceof RegExp && x(Se.attributeNameCheck, t) || Se.attributeNameCheck instanceof Function && Se.attributeNameCheck(t)) || 
+          // Alternative, second condition checks if it's an `is`-attribute, AND
+          // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          t === "is" && Se.allowCustomizedBuiltInElements && (Se.tagNameCheck instanceof RegExp && x(Se.tagNameCheck, o) || Se.tagNameCheck instanceof Function && Se.tagNameCheck(o))) ; else {
+            return false;
+          }
+          /* Check value is safe. First, is attr inert? If so, is safe */        } else if (Ye[t]) ; else if (x(he, T(o, me, ""))) ; else if ((t === "src" || t === "xlink:href" || t === "href") && e !== "script" && b(o, "data:") === 0 && We[e]) ; else if (Ae && !x(pe, T(o, me, ""))) ; else if (o) {
+          return false;
+        } else ;
+        return true;
+      };
+      /**
+     * _isBasicCustomElement
+     * checks if at least one dash is included in tagName, and it's not the first char
+     * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
+     *
+     * @param tagName name of the tag of the node to sanitize
+     * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+     */      const kt = function _isBasicCustomElement(e) {
+        return e !== "annotation-xml" && y(e, ge);
+      };
+      /**
+     * _sanitizeAttributes
+     *
+     * @protect attributes
+     * @protect nodeName
+     * @protect removeAttribute
+     * @protect setAttribute
+     *
+     * @param currentNode to sanitize
+     */      const _t = function _sanitizeAttributes(e) {
+        /* Execute a hook if present */
+        _executeHooks(le.beforeSanitizeAttributes, e, null);
+        const {attributes: t} = e;
+        /* Check if we have attributes; if not we might have a text node */        if (!t || bt(e)) {
+          return;
+        }
+        const n = {
+          attrName: "",
+          attrValue: "",
+          keepAttr: true,
+          allowedAttributes: be,
+          forceKeepAttr: undefined
+        };
+        let o = t.length;
+        /* Go backwards over all attributes; safely remove bad ones */        while (o--) {
+          const i = t[o];
+          const {name: r, namespaceURI: a, value: l} = i;
+          const s = lt(r);
+          let c = r === "value" ? l : w(l);
+          /* Execute a hook if present */          n.attrName = s;
+          n.attrValue = c;
+          n.keepAttr = true;
+          n.forceKeepAttr = undefined;
+ // Allows developers to see this is a property they can set
+                    _executeHooks(le.uponSanitizeAttribute, e, n);
+          c = n.attrValue;
+          /* Full DOM Clobbering protection via namespace isolation,
+         * Prefix id and name attributes with `user-content-`
+         */          if (Fe && (s === "id" || s === "name")) {
+            // Remove the attribute with this value
+            ht(r, e);
+            // Prefix the value and later re-create the attribute with the sanitized value
+                        c = Ce + c;
+          }
+          /* Work around a security issue with comments inside attributes */          if (De && x(/((--!?|])>)|<\/(style|title)/i, c)) {
+            ht(r, e);
+            continue;
+          }
+          /* Did the hooks approve of the attribute? */          if (n.forceKeepAttr) {
+            continue;
+          }
+          /* Remove attribute */          ht(r, e);
+          /* Did the hooks approve of the attribute? */          if (!n.keepAttr) {
+            continue;
+          }
+          /* Work around a security issue in jQuery 3.0 */          if (!Ee && x(/\/>/i, c)) {
+            ht(r, e);
+            continue;
+          }
+          /* Sanitize attribute content to be template-safe */          if (Re) {
+            f([ se, ce, fe ], (e => {
+              c = T(c, e, " ");
+            }));
+          }
+          /* Is `value` valid for this attribute? */          const u = lt(e.nodeName);
+          if (!xt(u, s, c)) {
+            continue;
+          }
+          /* Handle attributes that require Trusted Types */          if (ee && typeof B === "object" && typeof B.getAttributeType === "function") {
+            if (a) ; else {
+              switch (B.getAttributeType(u, s)) {
+               case "TrustedHTML":
+                {
+                  c = ee.createHTML(c);
+                  break;
+                }
+
+               case "TrustedScriptURL":
+                {
+                  c = ee.createScriptURL(c);
+                  break;
+                }
+              }
+            }
+          }
+          /* Handle invalid data-* attribute set by try-catching it */          try {
+            if (a) {
+              e.setAttributeNS(a, r, c);
+            } else {
+              /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+              e.setAttribute(r, c);
+            }
+            if (bt(e)) {
+              gt(e);
+            } else {
+              d(DOMPurify.removed);
+            }
+          } catch (e) {}
+        }
+        /* Execute a hook if present */        _executeHooks(le.afterSanitizeAttributes, e, null);
+      };
+      /**
+     * _sanitizeShadowDOM
+     *
+     * @param fragment to iterate over recursively
+     */      const vt = function _sanitizeShadowDOM(e) {
+        let t = null;
+        const n = Tt(e);
+        /* Execute a hook if present */        _executeHooks(le.beforeSanitizeShadowDOM, e, null);
+        while (t = n.nextNode()) {
+          /* Execute a hook if present */
+          _executeHooks(le.uponSanitizeShadowNode, t, null);
+          /* Sanitize tags and elements */          St(t);
+          /* Check attributes next */          _t(t);
+          /* Deep shadow DOM detected */          if (t.content instanceof a) {
+            _sanitizeShadowDOM(t.content);
+          }
+        }
+        /* Execute a hook if present */        _executeHooks(le.afterSanitizeShadowDOM, e, null);
+      };
+      // eslint-disable-next-line complexity
+            DOMPurify.sanitize = function(e) {
+        let t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        let n = null;
+        let i = null;
+        let r = null;
+        let l = null;
+        /* Make sure we have a string to sanitize.
+        DO NOT return early, as this will return the wrong type if
+        the user has requested a DOM object rather than a string */        Qe = !e;
+        if (Qe) {
+          e = "\x3c!--\x3e";
+        }
+        /* Stringify, in case dirty is an object */        if (typeof e !== "string" && !wt(e)) {
+          if (typeof e.toString === "function") {
+            e = e.toString();
+            if (typeof e !== "string") {
+              throw k("dirty is not a string, aborting");
+            }
+          } else {
+            throw k("toString is not a function");
+          }
+        }
+        /* Return dirty HTML if DOMPurify cannot run */        if (!DOMPurify.isSupported) {
+          return e;
+        }
+        /* Assign config vars */        if (!Me) {
+          ut(t);
+        }
+        /* Clean up removed elements */        DOMPurify.removed = [];
+        /* Check if dirty is correctly typed for IN_PLACE */        if (typeof e === "string") {
+          Ue = false;
+        }
+        if (Ue) {
+          /* Do some early pre-sanitization to avoid unsafe root nodes */
+          if (e.nodeName) {
+            const t = lt(e.nodeName);
+            if (!ye[t] || xe[t]) {
+              throw k("root node is forbidden and cannot be sanitized in-place");
+            }
+          }
+        } else if (e instanceof c) {
+          /* If dirty is a DOM element, append to an empty document to avoid
+           elements being stripped by the parser */
+          n = yt("\x3c!----\x3e");
+          i = n.ownerDocument.importNode(e, true);
+          if (i.nodeType === Y.element && i.nodeName === "BODY") {
+            /* Node is already a body, use as is */
+            n = i;
+          } else if (i.nodeName === "HTML") {
+            n = i;
+          } else {
+            // eslint-disable-next-line unicorn/prefer-dom-node-append
+            n.appendChild(i);
+          }
+        } else {
+          /* Exit directly if we have nothing to do */
+          if (!Le && !Re && !Oe && 
+          // eslint-disable-next-line unicorn/prefer-includes
+          e.indexOf("<") === -1) {
+            return ee && Ne ? ee.createHTML(e) : e;
+          }
+          /* Initialize the document to work on */          n = yt(e);
+          /* Check we have a DOM node from the data */          if (!n) {
+            return Le ? null : Ne ? te : "";
+          }
+        }
+        /* Remove first element node (ours) if FORCE_BODY is set */        if (n && ze) {
+          gt(n.firstChild);
+        }
+        /* Get node iterator */        const s = Tt(Ue ? e : n);
+        /* Now start iterating over the created document */        while (r = s.nextNode()) {
+          /* Sanitize tags and elements */
+          St(r);
+          /* Check attributes next */          _t(r);
+          /* Shadow DOM detected, sanitize it */          if (r.content instanceof a) {
+            vt(r.content);
+          }
+        }
+        /* If we sanitized `dirty` in-place, return it. */        if (Ue) {
+          return e;
+        }
+        /* Return sanitized string or DOM */        if (Le) {
+          if (Ie) {
+            l = ie.call(n.ownerDocument);
+            while (n.firstChild) {
+              // eslint-disable-next-line unicorn/prefer-dom-node-append
+              l.appendChild(n.firstChild);
+            }
+          } else {
+            l = n;
+          }
+          if (be.shadowroot || be.shadowrootmode) {
+            /*
+            AdoptNode() is not used because internal state is not reset
+            (e.g. the past names map of a HTMLFormElement), this is safe
+            in theory but we would rather not risk another attack vector.
+            The state that is cloned by importNode() is explicitly defined
+            by the specs.
+          */
+            l = ae.call(o, l, true);
+          }
+          return l;
+        }
+        let u = Oe ? n.outerHTML : n.innerHTML;
+        /* Serialize doctype if allowed */        if (Oe && ye["!doctype"] && n.ownerDocument && n.ownerDocument.doctype && n.ownerDocument.doctype.name && x(G, n.ownerDocument.doctype.name)) {
+          u = "<!DOCTYPE " + n.ownerDocument.doctype.name + ">\n" + u;
+        }
+        /* Sanitize final string template-safe */        if (Re) {
+          f([ se, ce, fe ], (e => {
+            u = T(u, e, " ");
+          }));
+        }
+        return ee && Ne ? ee.createHTML(u) : u;
+      };
+      DOMPurify.setConfig = function() {
+        let e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        ut(e);
+        Me = true;
+      };
+      DOMPurify.clearConfig = function() {
+        st = null;
+        Me = false;
+      };
+      DOMPurify.isValidAttribute = function(e, t, n) {
+        /* Initialize shared config vars if necessary. */
+        if (!st) {
+          ut({});
+        }
+        const o = lt(e);
+        const i = lt(t);
+        return xt(o, i, n);
+      };
+      DOMPurify.addHook = function(e, t) {
+        if (typeof t !== "function") {
+          return;
+        }
+        p(le[e], t);
+      };
+      DOMPurify.removeHook = function(e, t) {
+        if (t !== undefined) {
+          const n = u(le[e], t);
+          return n === -1 ? undefined : m(le[e], n, 1)[0];
+        }
+        return d(le[e]);
+      };
+      DOMPurify.removeHooks = function(e) {
+        le[e] = [];
+      };
+      DOMPurify.removeAllHooks = function() {
+        le = V();
+      };
+      return DOMPurify;
+    }
+    var K = createDOMPurify();
+    return K;
+  }));
+})(t);
+
+const n = t.exports;
+
+function sanitizeHTMLString(e) {
+  return n(window).sanitize(e, {
+    FORBID_TAGS: [ "style" ],
+    CUSTOM_ELEMENT_HANDLING: {
+      tagNameCheck: /^q2-/
+    }
+  });
+}
+
+export { sanitizeHTMLString as s };
+//# sourceMappingURL=sanitize-html-string-735c19f5.js.map