q2-tecton-elements 1.60.2 → 1.61.0

package/dist/q2-tecton-elements/{sanitize-html-string-DL0kgllh.js → sanitize-html-string-DOVERJq5.js}

@@ -1,4 +1,4 @@
-/*! @license DOMPurify 3.2.6 | (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.6/LICENSE */
+/*! @license DOMPurify 3.3.0 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.3.0/LICENSE */
 const {entries: e, setPrototypeOf: t, isFrozen: n, getPrototypeOf: o, getOwnPropertyDescriptor: i} = Object;
 
 let {freeze: r, seal: a, create: l} = Object;
@@ -19,14 +19,20 @@ if (!a) {
 }
 
 if (!s) {
-  s = function apply(e, t, n) {
-    return e.apply(t, n);
+  s = function apply(e, t) {
+    for (var n = arguments.length, o = new Array(n > 2 ? n - 2 : 0), i = 2; i < n; i++) {
+      o[i - 2] = arguments[i];
+    }
+    return e.apply(t, o);
   };
 }
 
 if (!c) {
-  c = function construct(e, t) {
-    return new e(...t);
+  c = function construct(e) {
+    for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), o = 1; o < t; o++) {
+      n[o - 1] = arguments[o];
+    }
+    return new e(...n);
   };
 }
 
@@ -34,9 +40,9 @@ const f = unapply(Array.prototype.forEach);
 
 const u = unapply(Array.prototype.lastIndexOf);
 
-const d = unapply(Array.prototype.pop);
+const p = unapply(Array.prototype.pop);
 
-const p = unapply(Array.prototype.push);
+const d = unapply(Array.prototype.push);
 
 const m = unapply(Array.prototype.splice);
 
@@ -46,15 +52,15 @@ const h = unapply(String.prototype.toString);
 
 const y = unapply(String.prototype.match);
 
-const T = unapply(String.prototype.replace);
+const b = unapply(String.prototype.replace);
 
-const b = unapply(String.prototype.indexOf);
+const T = unapply(String.prototype.indexOf);
 
-const S = unapply(String.prototype.trim);
+const w = unapply(String.prototype.trim);
 
-const w = unapply(Object.prototype.hasOwnProperty);
+const x = unapply(Object.prototype.hasOwnProperty);
 
-const x = unapply(RegExp.prototype.test);
+const S = unapply(RegExp.prototype.test);
 
 const k = unconstruct(TypeError);
 
@@ -129,7 +135,7 @@ const k = unconstruct(TypeError);
  * @returns The cleaned version of the array
  */ function cleanArray(e) {
   for (let t = 0; t < e.length; t++) {
-    const n = w(e, t);
+    const n = x(e, t);
     if (!n) {
       e[t] = null;
     }
@@ -145,7 +151,7 @@ const k = unconstruct(TypeError);
  */ function clone(t) {
   const n = l(null);
   for (const [o, i] of e(t)) {
-    const e = w(t, o);
+    const e = x(t, o);
     if (e) {
       if (Array.isArray(i)) {
         n[o] = cleanArray(i);
@@ -184,9 +190,9 @@ const k = unconstruct(TypeError);
   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 _ = 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", "search", "section", "select", "shadow", "slot", "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 v = r([ "svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "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" ]);
 
@@ -200,13 +206,13 @@ const R = r([ "math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi",
 
 // 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([ "maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none" ]);
 
-const O = r([ "#text" ]);
+const D = 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 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", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "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", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "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 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", "mask-type", "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" ]);
 
@@ -216,9 +222,9 @@ const I = r([ "xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"
 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]*|[\w\W]*%>/gm);
 
-const F = a(/\$\{[\w\W]*/gm);
+const P = a(/\$\{[\w\W]*/gm);
 
  // eslint-disable-line unicorn/better-regex
 const C = a(/^data-[\-\w.\u00B7-\uFFFF]+$/);
@@ -229,9 +235,9 @@ const H = a(/^aria-[\-\w]+$/);
  // eslint-disable-line no-useless-escape
 const U = a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
 
-const B = a(/^(?:\w+script|data):/i);
+const j = a(/^(?:\w+script|data):/i);
 
-const j = a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+const B = a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
 
 const G = a(/^html$/i);
 
@@ -240,15 +246,15 @@ const W = a(/^[a-z][.\w]*(-[.\w]+)+$/i);
 var q =  Object.freeze({
   __proto__: null,
   ARIA_ATTR: H,
-  ATTR_WHITESPACE: j,
+  ATTR_WHITESPACE: B,
   CUSTOM_ELEMENT: W,
   DATA_ATTR: C,
   DOCTYPE_NAME: G,
-  ERB_EXPR: P,
+  ERB_EXPR: F,
   IS_ALLOWED_URI: U,
-  IS_SCRIPT_OR_DATA: B,
+  IS_SCRIPT_OR_DATA: j,
   MUSTACHE_EXPR: N,
-  TMPLIT_EXPR: F
+  TMPLIT_EXPR: P
 });
 
 /* eslint-disable @typescript-eslint/indent */
@@ -321,7 +327,7 @@ const V = function _createHooksMap() {
 function createDOMPurify() {
   let t = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : X();
   const DOMPurify = e => createDOMPurify(e);
-  DOMPurify.version = "3.2.6";
+  DOMPurify.version = "3.3.0";
   DOMPurify.removed = [];
   if (!t || !t.document || t.document.nodeType !== Y.document || !t.Element) {
     // Not running in a browser, provide a factory function
@@ -332,13 +338,13 @@ function createDOMPurify() {
   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");
+  const {DocumentFragment: a, HTMLTemplateElement: s, Node: c, Element: N, NodeFilter: F, NamedNodeMap: P = t.NamedNodeMap || t.MozNamedAttrMap, HTMLFormElement: C, DOMParser: H, trustedTypes: j} = t;
+  const B = N.prototype;
+  const W = lookupGetter(B, "cloneNode");
+  const K = lookupGetter(B, "remove");
+  const J = lookupGetter(B, "nextSibling");
+  const Q = lookupGetter(B, "childNodes");
+  const Z = lookupGetter(B, "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)
@@ -359,22 +365,22 @@ function createDOMPurify() {
   /**
    * 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;
+  const {MUSTACHE_EXPR: se, ERB_EXPR: ce, TMPLIT_EXPR: fe, DATA_ATTR: ue, ARIA_ATTR: pe, IS_SCRIPT_OR_DATA: de, 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 Se = addToSet({}, [ ...M, ...z, ...L, ...I ]);
+  const be = addToSet({}, [ ..._, ...v, ...A, ...R, ...D ]);
+  /* Allowed attribute names */  let Te = 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 we = Object.seal(l(null, {
+   */  let xe = Object.seal(l(null, {
     tagNameCheck: {
       writable: true,
       configurable: false,
@@ -394,31 +400,45 @@ function createDOMPurify() {
       value: false
     }
   }));
-  /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */  let xe = null;
+  /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */  let Se = 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;
+  /* Config object to store ADD_TAGS/ADD_ATTR functions (when used as functions) */  const _e = Object.seal(l(null, {
+    tagCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    },
+    attributeCheck: {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: null
+    }
+  }));
+  /* Decide if ARIA attributes are okay */  let ve = true;
+  /* Decide if custom data attributes are okay */  let Ae = true;
+  /* Decide if unknown protocols are okay */  let Ee = false;
   /* Decide if self-closing tags in attributes are allowed.
-   * Usually removed due to a mXSS issue in jQuery 3.0 */  let Ee = true;
+   * Usually removed due to a mXSS issue in jQuery 3.0 */  let Re = true;
   /* Output should be safe for common template engines.
    * This means, DOMPurify removes data attributes, mustaches and ERB
-   */  let Re = false;
+   */  let Oe = 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 document with <html>... should be returned */  let Me = false;
+  /* Track whether config is already set on this instance of DOMPurify. */  let ze = 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;
+   * document.body. By default, browsers might move them to document.head */  let Le = 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;
+   */  let Ie = 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;
+   * string  (or a TrustedHTML object if Trusted Types are supported) */  let Ne = 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;
+   * case Trusted Types are not supported  */  let Fe = false;
   /* Output should be free from DOM clobbering attacks?
    * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
    */  let Pe = true;
@@ -434,40 +454,40 @@ function createDOMPurify() {
    *
    * 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;
+   */  let Ce = false;
+  const He = "user-content-";
+  /* Keep element content when removing element? */  let Ue = 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;
+   * of importing it into a new Document and returning a sanitized copy */  let je = 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" ]);
+  /* Tags to ignore content of when KEEP_CONTENT is true */  let Ge = null;
+  const We = 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 qe = null;
+  const Ye = addToSet({}, [ "audio", "video", "img", "source", "image", "track" ]);
+  /* Attributes safe for values like "javascript:" */  let Xe = null;
+  const $e = addToSet({}, [ "alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns" ]);
+  const Ve = "http://www.w3.org/1998/Math/MathML";
+  const Ke = "http://www.w3.org/2000/svg";
+  const Je = "http://www.w3.org/1999/xhtml";
+  /* Document namespace */  let Qe = Je;
+  let Ze = false;
+  /* Allowed XHTML+XML namespaces */  let et = null;
+  const tt = addToSet({}, [ Ve, Ke, Je ], h);
+  let nt = addToSet({}, [ "mi", "mo", "mn", "ms", "mtext" ]);
+  let ot = 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;
+    const it = addToSet({}, [ "title", "style", "font", "a", "script" ]);
+  /* Parsing of strict XHTML documents */  let rt = null;
+  const at = [ "application/xhtml+xml", "text/html" ];
+  const lt = "text/html";
+  let st = null;
+  /* Keep a reference to config to pass to hooks */  let ct = null;
   /* Ideally, do not touch anything below this line */
-  /* ______________________________________________ */  const ct = n.createElement("form");
-  const ft = function isRegexOrFunction(e) {
+  /* ______________________________________________ */  const ft = n.createElement("form");
+  const ut = function isRegexOrFunction(e) {
     return e instanceof RegExp || e instanceof Function;
   };
   /**
@@ -476,132 +496,140 @@ function createDOMPurify() {
    * @param cfg optional config literal
    */
   // eslint-disable-next-line complexity
-    const ut = function _parseConfig() {
+    const pt = function _parseConfig() {
     let e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    if (st && st === e) {
+    if (ct && ct === e) {
       return;
     }
     /* Shield configuration object from tampering */    if (!e || typeof e !== "object") {
       e = {};
     }
     /* Shield configuration object from prototype pollution */    e = clone(e);
-    it = 
+    rt = 
     // eslint-disable-next-line unicorn/prefer-includes
-    rt.indexOf(e.PARSER_MEDIA_TYPE) === -1 ? at : e.PARSER_MEDIA_TYPE;
+    at.indexOf(e.PARSER_MEDIA_TYPE) === -1 ? lt : 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 = w(e, "ALLOWED_TAGS") ? addToSet({}, e.ALLOWED_TAGS, lt) : Te;
-    be = w(e, "ALLOWED_ATTR") ? addToSet({}, e.ALLOWED_ATTR, lt) : Se;
-    Ze = w(e, "ALLOWED_NAMESPACES") ? addToSet({}, e.ALLOWED_NAMESPACES, h) : et;
-    Ye = w(e, "ADD_URI_SAFE_ATTR") ? addToSet(clone(Xe), e.ADD_URI_SAFE_ATTR, lt) : Xe;
-    We = w(e, "ADD_DATA_URI_TAGS") ? addToSet(clone(qe), e.ADD_DATA_URI_TAGS, lt) : qe;
-    je = w(e, "FORBID_CONTENTS") ? addToSet({}, e.FORBID_CONTENTS, lt) : Ge;
-    xe = w(e, "FORBID_TAGS") ? addToSet({}, e.FORBID_TAGS, lt) : clone({});
-    ke = w(e, "FORBID_ATTR") ? addToSet({}, e.FORBID_ATTR, lt) : clone({});
-    Be = w(e, "USE_PROFILES") ? e.USE_PROFILES : false;
-    _e = e.ALLOW_ARIA_ATTR !== false;
+        st = rt === "application/xhtml+xml" ? h : g;
+    /* Set configuration parameters */    ye = x(e, "ALLOWED_TAGS") ? addToSet({}, e.ALLOWED_TAGS, st) : be;
+    Te = x(e, "ALLOWED_ATTR") ? addToSet({}, e.ALLOWED_ATTR, st) : we;
+    et = x(e, "ALLOWED_NAMESPACES") ? addToSet({}, e.ALLOWED_NAMESPACES, h) : tt;
+    Xe = x(e, "ADD_URI_SAFE_ATTR") ? addToSet(clone($e), e.ADD_URI_SAFE_ATTR, st) : $e;
+    qe = x(e, "ADD_DATA_URI_TAGS") ? addToSet(clone(Ye), e.ADD_DATA_URI_TAGS, st) : Ye;
+    Ge = x(e, "FORBID_CONTENTS") ? addToSet({}, e.FORBID_CONTENTS, st) : We;
+    Se = x(e, "FORBID_TAGS") ? addToSet({}, e.FORBID_TAGS, st) : clone({});
+    ke = x(e, "FORBID_ATTR") ? addToSet({}, e.FORBID_ATTR, st) : clone({});
+    Be = x(e, "USE_PROFILES") ? e.USE_PROFILES : false;
+    ve = e.ALLOW_ARIA_ATTR !== false;
  // Default true
-        ve = e.ALLOW_DATA_ATTR !== false;
+        Ae = e.ALLOW_DATA_ATTR !== false;
  // Default true
-        Ae = e.ALLOW_UNKNOWN_PROTOCOLS || false;
+        Ee = e.ALLOW_UNKNOWN_PROTOCOLS || false;
  // Default false
-        Ee = e.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+        Re = e.ALLOW_SELF_CLOSE_IN_ATTR !== false;
  // Default true
-        Re = e.SAFE_FOR_TEMPLATES || false;
+        Oe = e.SAFE_FOR_TEMPLATES || false;
  // Default false
         De = e.SAFE_FOR_XML !== false;
  // Default true
-        Oe = e.WHOLE_DOCUMENT || false;
+        Me = e.WHOLE_DOCUMENT || false;
  // Default false
-        Le = e.RETURN_DOM || false;
+        Ie = e.RETURN_DOM || false;
  // Default false
-        Ie = e.RETURN_DOM_FRAGMENT || false;
+        Ne = e.RETURN_DOM_FRAGMENT || false;
  // Default false
-        Ne = e.RETURN_TRUSTED_TYPE || false;
+        Fe = e.RETURN_TRUSTED_TYPE || false;
  // Default false
-        ze = e.FORCE_BODY || false;
+        Le = e.FORCE_BODY || false;
  // Default false
         Pe = e.SANITIZE_DOM !== false;
  // Default true
-        Fe = e.SANITIZE_NAMED_PROPS || false;
+        Ce = e.SANITIZE_NAMED_PROPS || false;
  // Default false
-        He = e.KEEP_CONTENT !== false;
+        Ue = e.KEEP_CONTENT !== false;
  // Default true
-        Ue = e.IN_PLACE || false;
+        je = 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;
-    we = e.CUSTOM_ELEMENT_HANDLING || {};
-    if (e.CUSTOM_ELEMENT_HANDLING && ft(e.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
-      we.tagNameCheck = e.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+    Qe = e.NAMESPACE || Je;
+    nt = e.MATHML_TEXT_INTEGRATION_POINTS || nt;
+    ot = e.HTML_INTEGRATION_POINTS || ot;
+    xe = e.CUSTOM_ELEMENT_HANDLING || {};
+    if (e.CUSTOM_ELEMENT_HANDLING && ut(e.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+      xe.tagNameCheck = e.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
     }
-    if (e.CUSTOM_ELEMENT_HANDLING && ft(e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
-      we.attributeNameCheck = e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+    if (e.CUSTOM_ELEMENT_HANDLING && ut(e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+      xe.attributeNameCheck = e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
     }
     if (e.CUSTOM_ELEMENT_HANDLING && typeof e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
-      we.allowCustomizedBuiltInElements = e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+      xe.allowCustomizedBuiltInElements = e.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
     }
-    if (Re) {
-      ve = false;
+    if (Oe) {
+      Ae = false;
     }
-    if (Ie) {
-      Le = true;
+    if (Ne) {
+      Ie = true;
     }
     /* Parse profile info */    if (Be) {
-      ye = addToSet({}, O);
-      be = [];
+      ye = addToSet({}, D);
+      Te = [];
       if (Be.html === true) {
         addToSet(ye, _);
-        addToSet(be, M);
+        addToSet(Te, M);
       }
       if (Be.svg === true) {
         addToSet(ye, v);
-        addToSet(be, z);
-        addToSet(be, I);
+        addToSet(Te, z);
+        addToSet(Te, I);
       }
       if (Be.svgFilters === true) {
         addToSet(ye, A);
-        addToSet(be, z);
-        addToSet(be, I);
+        addToSet(Te, z);
+        addToSet(Te, I);
       }
       if (Be.mathMl === true) {
         addToSet(ye, R);
-        addToSet(be, L);
-        addToSet(be, I);
+        addToSet(Te, L);
+        addToSet(Te, I);
       }
     }
     /* Merge configuration parameters */    if (e.ADD_TAGS) {
-      if (ye === Te) {
-        ye = clone(ye);
+      if (typeof e.ADD_TAGS === "function") {
+        _e.tagCheck = e.ADD_TAGS;
+      } else {
+        if (ye === be) {
+          ye = clone(ye);
+        }
+        addToSet(ye, e.ADD_TAGS, st);
       }
-      addToSet(ye, e.ADD_TAGS, lt);
     }
     if (e.ADD_ATTR) {
-      if (be === Se) {
-        be = clone(be);
+      if (typeof e.ADD_ATTR === "function") {
+        _e.attributeCheck = e.ADD_ATTR;
+      } else {
+        if (Te === we) {
+          Te = clone(Te);
+        }
+        addToSet(Te, e.ADD_ATTR, st);
       }
-      addToSet(be, e.ADD_ATTR, lt);
     }
     if (e.ADD_URI_SAFE_ATTR) {
-      addToSet(Ye, e.ADD_URI_SAFE_ATTR, lt);
+      addToSet(Xe, e.ADD_URI_SAFE_ATTR, st);
     }
     if (e.FORBID_CONTENTS) {
-      if (je === Ge) {
-        je = clone(je);
+      if (Ge === We) {
+        Ge = clone(Ge);
       }
-      addToSet(je, e.FORBID_CONTENTS, lt);
+      addToSet(Ge, e.FORBID_CONTENTS, st);
     }
-    /* Add #text in case KEEP_CONTENT is set to true */    if (He) {
+    /* Add #text in case KEEP_CONTENT is set to true */    if (Ue) {
       ye["#text"] = true;
     }
-    /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */    if (Oe) {
+    /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */    if (Me) {
       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;
+      delete Se.tbody;
     }
     if (e.TRUSTED_TYPES_POLICY) {
       if (typeof e.TRUSTED_TYPES_POLICY.createHTML !== "function") {
@@ -617,7 +645,7 @@ function createDOMPurify() {
     } else {
       // Uninitialized policy, attempt to initialize the internal dompurify policy.
       if (ee === undefined) {
-        ee = $(B, i);
+        ee = $(j, i);
       }
       // If creating the internal policy succeeded sign internal variables.
             if (ee !== null && typeof te === "string") {
@@ -629,81 +657,81 @@ function createDOMPurify() {
         if (r) {
       r(e);
     }
-    st = e;
+    ct = 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 ]);
+  const mt = addToSet({}, [ ...R, ...O ]);
   /**
    * @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) {
+   */  const gt = 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,
+        namespaceURI: Qe,
         tagName: "template"
       };
     }
     const n = g(e.tagName);
     const o = g(t.tagName);
-    if (!Ze[e.namespaceURI]) {
+    if (!et[e.namespaceURI]) {
       return false;
     }
-    if (e.namespaceURI === Ve) {
+    if (e.namespaceURI === Ke) {
       // 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) {
+      if (t.namespaceURI === Je) {
         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]);
+            if (t.namespaceURI === Ve) {
+        return n === "svg" && (o === "annotation-xml" || nt[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) {
+    if (e.namespaceURI === Ve) {
       // 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) {
+      if (t.namespaceURI === Je) {
         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];
+            if (t.namespaceURI === Ke) {
+        return n === "math" && ot[o];
       }
       // We only allow elements that are defined in MathML
       // spec. All others are disallowed in MathML namespace.
-            return Boolean(pt[n]);
+            return Boolean(mt[n]);
     }
-    if (e.namespaceURI === Ke) {
+    if (e.namespaceURI === Je) {
       // 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]) {
+      if (t.namespaceURI === Ke && !ot[o]) {
         return false;
       }
-      if (t.namespaceURI === $e && !tt[o]) {
+      if (t.namespaceURI === Ve && !nt[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]);
+            return !mt[n] && (it[n] || !dt[n]);
     }
     // For XHTML and XML documents that support custom namespaces
-        if (it === "application/xhtml+xml" && Ze[e.namespaceURI]) {
+        if (rt === "application/xhtml+xml" && et[e.namespaceURI]) {
       return true;
     }
     // The code should never reach this place (this means
@@ -716,8 +744,8 @@ function createDOMPurify() {
    * _forceRemove
    *
    * @param node a DOM node
-   */  const gt = function _forceRemove(e) {
-    p(DOMPurify.removed, {
+   */  const ht = function _forceRemove(e) {
+    d(DOMPurify.removed, {
       element: e
     });
     try {
@@ -732,14 +760,14 @@ function createDOMPurify() {
    *
    * @param name an Attribute name
    * @param element a DOM node
-   */  const ht = function _removeAttribute(e, t) {
+   */  const yt = function _removeAttribute(e, t) {
     try {
-      p(DOMPurify.removed, {
+      d(DOMPurify.removed, {
         attribute: t.getAttributeNode(e),
         from: t
       });
     } catch (e) {
-      p(DOMPurify.removed, {
+      d(DOMPurify.removed, {
         attribute: null,
         from: t
       });
@@ -747,9 +775,9 @@ function createDOMPurify() {
     t.removeAttribute(e);
     // We void attribute values for unremovable "is" attributes
         if (e === "is") {
-      if (Le || Ie) {
+      if (Ie || Ne) {
         try {
-          gt(t);
+          ht(t);
         } catch (e) {}
       } else {
         try {
@@ -763,18 +791,18 @@ function createDOMPurify() {
    *
    * @param dirty - a string of dirty markup
    * @return a DOM, filled with the dirty markup
-   */  const yt = function _initDocument(e) {
+   */  const bt = function _initDocument(e) {
     /* Create a HTML document */
     let t = null;
     let o = null;
-    if (ze) {
+    if (Le) {
       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) {
+    if (rt === "application/xhtml+xml" && Qe === Je) {
       // 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>";
     }
@@ -782,15 +810,15 @@ function createDOMPurify() {
     /*
      * Use the DOMParser API by default, fallback later if needs be
      * DOMParser not work for svg when has multiple root element.
-     */    if (Je === Ke) {
+     */    if (Qe === Je) {
       try {
-        t = (new H).parseFromString(i, it);
+        t = (new H).parseFromString(i, rt);
       } catch (e) {}
     }
     /* Use createHTMLDocument in case DOMParser is not available */    if (!t || !t.documentElement) {
-      t = ne.createDocument(Je, "template", null);
+      t = ne.createDocument(Qe, "template", null);
       try {
-        t.documentElement.innerHTML = Qe ? te : i;
+        t.documentElement.innerHTML = Ze ? te : i;
       } catch (e) {
         // Syntax error if dirtyPayload is invalid xml
       }
@@ -799,10 +827,10 @@ function createDOMPurify() {
     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];
+    /* Work on whole document or just its body */    if (Qe === Je) {
+      return re.call(t, Me ? "html" : "body")[0];
     }
-    return Oe ? t.documentElement : r;
+    return Me ? t.documentElement : r;
   };
   /**
    * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
@@ -812,27 +840,27 @@ function createDOMPurify() {
    */  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);
+    F.SHOW_ELEMENT | F.SHOW_COMMENT | F.SHOW_TEXT | F.SHOW_PROCESSING_INSTRUCTION | F.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");
+   */  const wt = function _isClobbered(e) {
+    return e instanceof C && (typeof e.nodeName !== "string" || typeof e.textContent !== "string" || typeof e.removeChild !== "function" || !(e.attributes instanceof P) || 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 St = function _isNode(e) {
+   */  const xt = function _isNode(e) {
     return typeof c === "function" && e instanceof c;
   };
   function _executeHooks(e, t, n) {
     f(e, (e => {
-      e.call(DOMPurify, t, n, st);
+      e.call(DOMPurify, t, n, ct);
     }));
   }
   /**
@@ -843,41 +871,41 @@ function createDOMPurify() {
    * @protect removeChild
    * @param currentNode to check for permission to exist
    * @return true if node was killed, false if left alive
-   */  const wt = function _sanitizeElements(e) {
+   */  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);
+    /* Check if element is clobbered or can clobber */    if (wt(e)) {
+      ht(e);
       return true;
     }
-    /* Now let's check the element's type and name */    const n = lt(e.nodeName);
+    /* Now let's check the element's type and name */    const n = st(e.nodeName);
     /* Execute a hook if present */    _executeHooks(le.uponSanitizeElement, e, {
       tagName: n,
       allowedTags: ye
     });
-    /* Detect mXSS attempts abusing namespace confusion */    if (De && e.hasChildNodes() && !St(e.firstElementChild) && x(/<[/\w!]/g, e.innerHTML) && x(/<[/\w!]/g, e.textContent)) {
-      gt(e);
+    /* Detect mXSS attempts abusing namespace confusion */    if (De && e.hasChildNodes() && !xt(e.firstElementChild) && S(/<[/\w!]/g, e.innerHTML) && S(/<[/\w!]/g, e.textContent)) {
+      ht(e);
       return true;
     }
     /* Remove any occurrence of processing instructions */    if (e.nodeType === Y.progressingInstruction) {
-      gt(e);
+      ht(e);
       return true;
     }
-    /* Remove any kind of possibly harmful comments */    if (De && e.nodeType === Y.comment && x(/<[/\w]/g, e.data)) {
-      gt(e);
+    /* Remove any kind of possibly harmful comments */    if (De && e.nodeType === Y.comment && S(/<[/\w]/g, e.data)) {
+      ht(e);
       return true;
     }
-    /* Remove element if anything forbids its presence */    if (!ye[n] || xe[n]) {
+    /* Remove element if anything forbids its presence */    if (!(_e.tagCheck instanceof Function && _e.tagCheck(n)) && (!ye[n] || Se[n])) {
       /* Check if we have a custom element to handle */
-      if (!xe[n] && kt(n)) {
-        if (we.tagNameCheck instanceof RegExp && x(we.tagNameCheck, n)) {
+      if (!Se[n] && _t(n)) {
+        if (xe.tagNameCheck instanceof RegExp && S(xe.tagNameCheck, n)) {
           return false;
         }
-        if (we.tagNameCheck instanceof Function && we.tagNameCheck(n)) {
+        if (xe.tagNameCheck instanceof Function && xe.tagNameCheck(n)) {
           return false;
         }
       }
-      /* Keep content except for bad-listed elements */      if (He && !je[n]) {
+      /* Keep content except for bad-listed elements */      if (Ue && !Ge[n]) {
         const t = Z(e) || e.parentNode;
         const n = Q(e) || e.childNodes;
         if (n && t) {
@@ -889,25 +917,25 @@ function createDOMPurify() {
           }
         }
       }
-      gt(e);
+      ht(e);
       return true;
     }
-    /* Check whether element has a valid namespace */    if (e instanceof N && !mt(e)) {
-      gt(e);
+    /* Check whether element has a valid namespace */    if (e instanceof N && !gt(e)) {
+      ht(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);
+    /* Make sure that older browsers don't get fallback-tag mXSS */    if ((n === "noscript" || n === "noembed" || n === "noframes") && S(/<\/no(script|embed|frames)/i, e.innerHTML)) {
+      ht(e);
       return true;
     }
-    /* Sanitize element content to be template-safe */    if (Re && e.nodeType === Y.text) {
+    /* Sanitize element content to be template-safe */    if (Oe && e.nodeType === Y.text) {
       /* Get the element's text content */
       t = e.textContent;
       f([ se, ce, fe ], (e => {
-        t = T(t, e, " ");
+        t = b(t, e, " ");
       }));
       if (e.textContent !== t) {
-        p(DOMPurify.removed, {
+        d(DOMPurify.removed, {
           element: e.cloneNode()
         });
         e.textContent = t;
@@ -925,26 +953,26 @@ function createDOMPurify() {
    * @return Returns true if `value` is valid, otherwise false.
    */
   // eslint-disable-next-line complexity
-    const xt = function _isValidAttribute(e, t, o) {
+    const kt = function _isValidAttribute(e, t, o) {
     /* Make sure attribute cannot clobber */
-    if (Pe && (t === "id" || t === "name") && (o in n || o in ct)) {
+    if (Pe && (t === "id" || t === "name") && (o in n || o in ft)) {
       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]) {
+        We don't need to check the value; it's always URI safe. */    if (Ae && !ke[t] && S(ue, t)) ; else if (ve && S(pe, t)) ; else if (_e.attributeCheck instanceof Function && _e.attributeCheck(t, e)) ; else if (!Te[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) && (we.tagNameCheck instanceof RegExp && x(we.tagNameCheck, e) || we.tagNameCheck instanceof Function && we.tagNameCheck(e)) && (we.attributeNameCheck instanceof RegExp && x(we.attributeNameCheck, t) || we.attributeNameCheck instanceof Function && we.attributeNameCheck(t)) || 
+      _t(e) && (xe.tagNameCheck instanceof RegExp && S(xe.tagNameCheck, e) || xe.tagNameCheck instanceof Function && xe.tagNameCheck(e)) && (xe.attributeNameCheck instanceof RegExp && S(xe.attributeNameCheck, t) || xe.attributeNameCheck instanceof Function && xe.attributeNameCheck(t, e)) || 
       // 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" && we.allowCustomizedBuiltInElements && (we.tagNameCheck instanceof RegExp && x(we.tagNameCheck, o) || we.tagNameCheck instanceof Function && we.tagNameCheck(o))) ; else {
+      t === "is" && xe.allowCustomizedBuiltInElements && (xe.tagNameCheck instanceof RegExp && S(xe.tagNameCheck, o) || xe.tagNameCheck instanceof Function && xe.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) {
+      /* Check value is safe. First, is attr inert? If so, is safe */    } else if (Xe[t]) ; else if (S(he, b(o, me, ""))) ; else if ((t === "src" || t === "xlink:href" || t === "href") && e !== "script" && T(o, "data:") === 0 && qe[e]) ; else if (Ee && !S(de, b(o, me, ""))) ; else if (o) {
       return false;
     } else ;
     return true;
@@ -956,7 +984,7 @@ function createDOMPurify() {
    *
    * @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) {
+   */  const _t = function _isBasicCustomElement(e) {
     return e !== "annotation-xml" && y(e, ge);
   };
   /**
@@ -968,27 +996,27 @@ function createDOMPurify() {
    * @protect setAttribute
    *
    * @param currentNode to sanitize
-   */  const _t = function _sanitizeAttributes(e) {
+   */  const vt = 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)) {
+    /* Check if we have attributes; if not we might have a text node */    if (!t || wt(e)) {
       return;
     }
     const n = {
       attrName: "",
       attrValue: "",
       keepAttr: true,
-      allowedAttributes: be,
+      allowedAttributes: Te,
       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);
+      const s = st(r);
       const c = l;
-      let u = r === "value" ? c : S(c);
+      let u = r === "value" ? c : w(c);
       /* Execute a hook if present */      n.attrName = s;
       n.attrValue = u;
       n.keepAttr = true;
@@ -998,40 +1026,44 @@ function createDOMPurify() {
       u = n.attrValue;
       /* Full DOM Clobbering protection via namespace isolation,
        * Prefix id and name attributes with `user-content-`
-       */      if (Fe && (s === "id" || s === "name")) {
+       */      if (Ce && (s === "id" || s === "name")) {
         // Remove the attribute with this value
-        ht(r, e);
+        yt(r, e);
         // Prefix the value and later re-create the attribute with the sanitized value
-                u = Ce + u;
+                u = He + u;
+      }
+      /* Work around a security issue with comments inside attributes */      if (De && S(/((--!?|])>)|<\/(style|title|textarea)/i, u)) {
+        yt(r, e);
+        continue;
       }
-      /* Work around a security issue with comments inside attributes */      if (De && x(/((--!?|])>)|<\/(style|title)/i, u)) {
-        ht(r, e);
+      /* Make sure we cannot easily use animated hrefs, even if animations are allowed */      if (s === "attributename" && y(u, "href")) {
+        yt(r, e);
         continue;
       }
       /* Did the hooks approve of the attribute? */      if (n.forceKeepAttr) {
         continue;
       }
       /* Did the hooks approve of the attribute? */      if (!n.keepAttr) {
-        ht(r, e);
+        yt(r, e);
         continue;
       }
-      /* Work around a security issue in jQuery 3.0 */      if (!Ee && x(/\/>/i, u)) {
-        ht(r, e);
+      /* Work around a security issue in jQuery 3.0 */      if (!Re && S(/\/>/i, u)) {
+        yt(r, e);
         continue;
       }
-      /* Sanitize attribute content to be template-safe */      if (Re) {
+      /* Sanitize attribute content to be template-safe */      if (Oe) {
         f([ se, ce, fe ], (e => {
-          u = T(u, e, " ");
+          u = b(u, e, " ");
         }));
       }
-      /* Is `value` valid for this attribute? */      const p = lt(e.nodeName);
-      if (!xt(p, s, u)) {
-        ht(r, e);
+      /* Is `value` valid for this attribute? */      const d = st(e.nodeName);
+      if (!kt(d, s, u)) {
+        yt(r, e);
         continue;
       }
-      /* Handle attributes that require Trusted Types */      if (ee && typeof B === "object" && typeof B.getAttributeType === "function") {
+      /* Handle attributes that require Trusted Types */      if (ee && typeof j === "object" && typeof j.getAttributeType === "function") {
         if (a) ; else {
-          switch (B.getAttributeType(p, s)) {
+          switch (j.getAttributeType(d, s)) {
            case "TrustedHTML":
             {
               u = ee.createHTML(u);
@@ -1054,13 +1086,13 @@ function createDOMPurify() {
             /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
             e.setAttribute(r, u);
           }
-          if (bt(e)) {
-            gt(e);
+          if (wt(e)) {
+            ht(e);
           } else {
-            d(DOMPurify.removed);
+            p(DOMPurify.removed);
           }
         } catch (t) {
-          ht(r, e);
+          yt(r, e);
         }
       }
     }
@@ -1070,15 +1102,15 @@ function createDOMPurify() {
    * _sanitizeShadowDOM
    *
    * @param fragment to iterate over recursively
-   */  const vt = function _sanitizeShadowDOM(e) {
+   */  const At = 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 */      wt(t);
-      /* Check attributes next */      _t(t);
+      /* Sanitize tags and elements */      St(t);
+      /* Check attributes next */      vt(t);
       /* Deep shadow DOM detected */      if (t.content instanceof a) {
         _sanitizeShadowDOM(t.content);
       }
@@ -1094,11 +1126,11 @@ function createDOMPurify() {
     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) {
+      the user has requested a DOM object rather than a string */    Ze = !e;
+    if (Ze) {
       e = "\x3c!--\x3e";
     }
-    /* Stringify, in case dirty is an object */    if (typeof e !== "string" && !St(e)) {
+    /* Stringify, in case dirty is an object */    if (typeof e !== "string" && !xt(e)) {
       if (typeof e.toString === "function") {
         e = e.toString();
         if (typeof e !== "string") {
@@ -1111,25 +1143,25 @@ function createDOMPurify() {
     /* Return dirty HTML if DOMPurify cannot run */    if (!DOMPurify.isSupported) {
       return e;
     }
-    /* Assign config vars */    if (!Me) {
-      ut(t);
+    /* Assign config vars */    if (!ze) {
+      pt(t);
     }
     /* Clean up removed elements */    DOMPurify.removed = [];
     /* Check if dirty is correctly typed for IN_PLACE */    if (typeof e === "string") {
-      Ue = false;
+      je = false;
     }
-    if (Ue) {
+    if (je) {
       /* Do some early pre-sanitization to avoid unsafe root nodes */
       if (e.nodeName) {
-        const t = lt(e.nodeName);
-        if (!ye[t] || xe[t]) {
+        const t = st(e.nodeName);
+        if (!ye[t] || Se[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");
+      n = bt("\x3c!----\x3e");
       i = n.ownerDocument.importNode(e, true);
       if (i.nodeType === Y.element && i.nodeName === "BODY") {
         /* Node is already a body, use as is */
@@ -1142,33 +1174,33 @@ function createDOMPurify() {
       }
     } else {
       /* Exit directly if we have nothing to do */
-      if (!Le && !Re && !Oe && 
+      if (!Ie && !Oe && !Me && 
       // eslint-disable-next-line unicorn/prefer-includes
       e.indexOf("<") === -1) {
-        return ee && Ne ? ee.createHTML(e) : e;
+        return ee && Fe ? ee.createHTML(e) : e;
       }
-      /* Initialize the document to work on */      n = yt(e);
+      /* Initialize the document to work on */      n = bt(e);
       /* Check we have a DOM node from the data */      if (!n) {
-        return Le ? null : Ne ? te : "";
+        return Ie ? null : Fe ? te : "";
       }
     }
-    /* Remove first element node (ours) if FORCE_BODY is set */    if (n && ze) {
-      gt(n.firstChild);
+    /* Remove first element node (ours) if FORCE_BODY is set */    if (n && Le) {
+      ht(n.firstChild);
     }
-    /* Get node iterator */    const s = Tt(Ue ? e : n);
+    /* Get node iterator */    const s = Tt(je ? e : n);
     /* Now start iterating over the created document */    while (r = s.nextNode()) {
       /* Sanitize tags and elements */
-      wt(r);
-      /* Check attributes next */      _t(r);
+      St(r);
+      /* Check attributes next */      vt(r);
       /* Shadow DOM detected, sanitize it */      if (r.content instanceof a) {
-        vt(r.content);
+        At(r.content);
       }
     }
-    /* If we sanitized `dirty` in-place, return it. */    if (Ue) {
+    /* If we sanitized `dirty` in-place, return it. */    if (je) {
       return e;
     }
-    /* Return sanitized string or DOM */    if (Le) {
-      if (Ie) {
+    /* Return sanitized string or DOM */    if (Ie) {
+      if (Ne) {
         l = ie.call(n.ownerDocument);
         while (n.firstChild) {
           // eslint-disable-next-line unicorn/prefer-dom-node-append
@@ -1177,7 +1209,7 @@ function createDOMPurify() {
       } else {
         l = n;
       }
-      if (be.shadowroot || be.shadowrootmode) {
+      if (Te.shadowroot || Te.shadowrootmode) {
         /*
           AdoptNode() is not used because internal state is not reset
           (e.g. the past names map of a HTMLFormElement), this is safe
@@ -1189,47 +1221,47 @@ function createDOMPurify() {
       }
       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)) {
+    let u = Me ? n.outerHTML : n.innerHTML;
+    /* Serialize doctype if allowed */    if (Me && ye["!doctype"] && n.ownerDocument && n.ownerDocument.doctype && n.ownerDocument.doctype.name && S(G, n.ownerDocument.doctype.name)) {
       u = "<!DOCTYPE " + n.ownerDocument.doctype.name + ">\n" + u;
     }
-    /* Sanitize final string template-safe */    if (Re) {
+    /* Sanitize final string template-safe */    if (Oe) {
       f([ se, ce, fe ], (e => {
-        u = T(u, e, " ");
+        u = b(u, e, " ");
       }));
     }
-    return ee && Ne ? ee.createHTML(u) : u;
+    return ee && Fe ? ee.createHTML(u) : u;
   };
   DOMPurify.setConfig = function() {
     let e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    ut(e);
-    Me = true;
+    pt(e);
+    ze = true;
   };
   DOMPurify.clearConfig = function() {
-    st = null;
-    Me = false;
+    ct = null;
+    ze = false;
   };
   DOMPurify.isValidAttribute = function(e, t, n) {
     /* Initialize shared config vars if necessary. */
-    if (!st) {
-      ut({});
+    if (!ct) {
+      pt({});
     }
-    const o = lt(e);
-    const i = lt(t);
-    return xt(o, i, n);
+    const o = st(e);
+    const i = st(t);
+    return kt(o, i, n);
   };
   DOMPurify.addHook = function(e, t) {
     if (typeof t !== "function") {
       return;
     }
-    p(le[e], t);
+    d(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]);
+    return p(le[e]);
   };
   DOMPurify.removeHooks = function(e) {
     le[e] = [];
@@ -1252,5 +1284,5 @@ function sanitizeHTMLString(e) {
 }
 
 export { sanitizeHTMLString as s };
-//# sourceMappingURL=sanitize-html-string-DL0kgllh.js.map
-//# sourceMappingURL=sanitize-html-string-DL0kgllh.js.map
+//# sourceMappingURL=sanitize-html-string-DOVERJq5.js.map
+//# sourceMappingURL=sanitize-html-string-DOVERJq5.js.map