q2-tecton-elements 1.51.0 → 1.52.0

package/dist/q2-tecton-elements/q2-action-sheet.entry.js

@@ -0,0 +1,1480 @@
+import { r as e, c as t, h as n, F as o, g as i } from "./index-7a5365e2.js";
+
+import { l as a, w as r } from "./index-d18e2a20.js";
+
+var s = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+
+var l = {
+  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(e, t) {
+  (function(t, n) {
+    e.exports = n();
+  })(s, (function() {
+    const {entries: e, setPrototypeOf: t, isFrozen: n, getPrototypeOf: o, getOwnPropertyDescriptor: i} = Object;
+    let {freeze: a, seal: r, create: s} = Object;
+ // eslint-disable-line import/no-mutable-exports
+        let {apply: l, construct: c} = typeof Reflect !== "undefined" && Reflect;
+    if (!a) {
+      a = function freeze(e) {
+        return e;
+      };
+    }
+    if (!r) {
+      r = function seal(e) {
+        return e;
+      };
+    }
+    if (!l) {
+      l = function apply(e, t, n) {
+        return e.apply(t, n);
+      };
+    }
+    if (!c) {
+      c = function construct(e, t) {
+        return new e(...t);
+      };
+    }
+    const d = unapply(Array.prototype.forEach);
+    const u = unapply(Array.prototype.lastIndexOf);
+    const f = unapply(Array.prototype.pop);
+    const p = unapply(Array.prototype.push);
+    const h = unapply(Array.prototype.splice);
+    const m = unapply(String.prototype.toLowerCase);
+    const g = unapply(String.prototype.toString);
+    const b = unapply(String.prototype.match);
+    const y = unapply(String.prototype.replace);
+    const v = unapply(String.prototype.indexOf);
+    const x = unapply(String.prototype.trim);
+    const w = unapply(Object.prototype.hasOwnProperty);
+    const k = unapply(RegExp.prototype.test);
+    const T = 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 l(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] : m;
+      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 a = o.length;
+      while (a--) {
+        let t = o[a];
+        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[a] = 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 = w(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 = s(null);
+      for (const [o, i] of e(t)) {
+        const e = w(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 S = a([ "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 _ = a([ "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 = a([ "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 = a([ "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 z = a([ "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 R = a([ "maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none" ]);
+    const O = a([ "#text" ]);
+    const M = a([ "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 D = a([ "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 = a([ "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 C = a([ "xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink" ]);
+    // eslint-disable-next-line unicorn/better-regex
+        const P = r(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+ // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+        const I = r(/<%[\w\W]*|[\w\W]*%>/gm);
+    const N = r(/\$\{[\w\W]*/gm);
+ // eslint-disable-line unicorn/better-regex
+        const H = r(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+ // eslint-disable-line no-useless-escape
+        const F = r(/^aria-[\-\w]+$/);
+ // eslint-disable-line no-useless-escape
+        const j = r(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i);
+    const B = r(/^(?:\w+script|data):/i);
+    const q = r(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g);
+    const U = r(/^html$/i);
+    const G = r(/^[a-z][.\w]*(-[.\w]+)+$/i);
+    var W =  Object.freeze({
+      __proto__: null,
+      ARIA_ATTR: F,
+      ATTR_WHITESPACE: q,
+      CUSTOM_ELEMENT: G,
+      DATA_ATTR: H,
+      DOCTYPE_NAME: U,
+      ERB_EXPR: I,
+      IS_ALLOWED_URI: j,
+      IS_SCRIPT_OR_DATA: B,
+      MUSTACHE_EXPR: P,
+      TMPLIT_EXPR: N
+    });
+    /* 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 $ = 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 V = 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 X = function _createHooksMap() {
+      return {
+        afterSanitizeAttributes: [],
+        afterSanitizeElements: [],
+        afterSanitizeShadowDOM: [],
+        beforeSanitizeAttributes: [],
+        beforeSanitizeElements: [],
+        beforeSanitizeShadowDOM: [],
+        uponSanitizeAttribute: [],
+        uponSanitizeElement: [],
+        uponSanitizeShadowNode: []
+      };
+    };
+    function createDOMPurify() {
+      let t = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : $();
+      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: r, HTMLTemplateElement: l, Node: c, Element: P, NodeFilter: I, NamedNodeMap: N = t.NamedNodeMap || t.MozNamedAttrMap, HTMLFormElement: H, DOMParser: F, trustedTypes: B} = t;
+      const q = P.prototype;
+      const G = lookupGetter(q, "cloneNode");
+      const K = lookupGetter(q, "remove");
+      const J = lookupGetter(q, "nextSibling");
+      const Q = lookupGetter(q, "childNodes");
+      const Z = lookupGetter(q, "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 l === "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: ae} = n;
+      const {importNode: re} = o;
+      let se = X();
+      /**
+     * Expose whether this browser supports running the full DOMPurify.
+     */      DOMPurify.isSupported = typeof e === "function" && typeof Z === "function" && ne && ne.createHTMLDocument !== undefined;
+      const {MUSTACHE_EXPR: le, ERB_EXPR: ce, TMPLIT_EXPR: de, DATA_ATTR: ue, ARIA_ATTR: fe, IS_SCRIPT_OR_DATA: pe, ATTR_WHITESPACE: he, CUSTOM_ELEMENT: me} = W;
+      let {IS_ALLOWED_URI: ge} = W;
+      /**
+     * 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 be = null;
+      const ye = addToSet({}, [ ...S, ..._, ...A, ...z, ...O ]);
+      /* Allowed attribute names */      let ve = null;
+      const xe = addToSet({}, [ ...M, ...D, ...L, ...C ]);
+      /*
+     * 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(s(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 ke = null;
+      /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */      let Te = null;
+      /* Decide if ARIA attributes are okay */      let Se = true;
+      /* Decide if custom data attributes are okay */      let _e = 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 ze = false;
+      /* Output should be safe even for XML used within HTML and alike.
+     * This means, DOMPurify removes comments when containing risky content.
+     */      let Re = 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 De = 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 Ce = false;
+      /* Try to return a Trusted Type object instead of a string, return a string in
+     * case Trusted Types are not supported  */      let Pe = false;
+      /* Output should be free from DOM clobbering attacks?
+     * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
+     */      let Ie = 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 Ne = false;
+      const He = "user-content-";
+      /* Keep element content when removing element? */      let Fe = 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 je = false;
+      /* Allow usage of profiles like html, svg and mathMl */      let Be = {};
+      /* Tags to ignore content of when KEEP_CONTENT is true */      let qe = null;
+      const Ue = 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 Ge = null;
+      const We = addToSet({}, [ "audio", "video", "img", "source", "image", "track" ]);
+      /* Attributes safe for values like "javascript:" */      let Ye = 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 Xe = "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({}, [ Ve, Xe, Ke ], g);
+      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 at = [ "application/xhtml+xml", "text/html" ];
+      const rt = "text/html";
+      let st = null;
+      /* Keep a reference to config to pass to hooks */      let lt = null;
+      /* Ideally, do not touch anything below this line */
+      /* ______________________________________________ */      const ct = n.createElement("form");
+      const dt = 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 (lt && lt === 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
+        at.indexOf(e.PARSER_MEDIA_TYPE) === -1 ? rt : e.PARSER_MEDIA_TYPE;
+        // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
+                st = it === "application/xhtml+xml" ? g : m;
+        /* Set configuration parameters */        be = w(e, "ALLOWED_TAGS") ? addToSet({}, e.ALLOWED_TAGS, st) : ye;
+        ve = w(e, "ALLOWED_ATTR") ? addToSet({}, e.ALLOWED_ATTR, st) : xe;
+        Ze = w(e, "ALLOWED_NAMESPACES") ? addToSet({}, e.ALLOWED_NAMESPACES, g) : et;
+        Ye = w(e, "ADD_URI_SAFE_ATTR") ? addToSet(clone($e), e.ADD_URI_SAFE_ATTR, st) : $e;
+        Ge = w(e, "ADD_DATA_URI_TAGS") ? addToSet(clone(We), e.ADD_DATA_URI_TAGS, st) : We;
+        qe = w(e, "FORBID_CONTENTS") ? addToSet({}, e.FORBID_CONTENTS, st) : Ue;
+        ke = w(e, "FORBID_TAGS") ? addToSet({}, e.FORBID_TAGS, st) : {};
+        Te = w(e, "FORBID_ATTR") ? addToSet({}, e.FORBID_ATTR, st) : {};
+        Be = w(e, "USE_PROFILES") ? e.USE_PROFILES : false;
+        Se = e.ALLOW_ARIA_ATTR !== false;
+ // Default true
+                _e = 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
+                ze = e.SAFE_FOR_TEMPLATES || false;
+ // Default false
+                Re = e.SAFE_FOR_XML !== false;
+ // Default true
+                Oe = e.WHOLE_DOCUMENT || false;
+ // Default false
+                Le = e.RETURN_DOM || false;
+ // Default false
+                Ce = e.RETURN_DOM_FRAGMENT || false;
+ // Default false
+                Pe = e.RETURN_TRUSTED_TYPE || false;
+ // Default false
+                De = e.FORCE_BODY || false;
+ // Default false
+                Ie = e.SANITIZE_DOM !== false;
+ // Default true
+                Ne = e.SANITIZE_NAMED_PROPS || false;
+ // Default false
+                Fe = e.KEEP_CONTENT !== false;
+ // Default true
+                je = e.IN_PLACE || false;
+ // Default false
+                ge = e.ALLOWED_URI_REGEXP || j;
+        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 && dt(e.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+          we.tagNameCheck = e.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+        }
+        if (e.CUSTOM_ELEMENT_HANDLING && dt(e.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+          we.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;
+        }
+        if (ze) {
+          _e = false;
+        }
+        if (Ce) {
+          Le = true;
+        }
+        /* Parse profile info */        if (Be) {
+          be = addToSet({}, O);
+          ve = [];
+          if (Be.html === true) {
+            addToSet(be, S);
+            addToSet(ve, M);
+          }
+          if (Be.svg === true) {
+            addToSet(be, _);
+            addToSet(ve, D);
+            addToSet(ve, C);
+          }
+          if (Be.svgFilters === true) {
+            addToSet(be, A);
+            addToSet(ve, D);
+            addToSet(ve, C);
+          }
+          if (Be.mathMl === true) {
+            addToSet(be, z);
+            addToSet(ve, L);
+            addToSet(ve, C);
+          }
+        }
+        /* Merge configuration parameters */        if (e.ADD_TAGS) {
+          if (be === ye) {
+            be = clone(be);
+          }
+          addToSet(be, e.ADD_TAGS, st);
+        }
+        if (e.ADD_ATTR) {
+          if (ve === xe) {
+            ve = clone(ve);
+          }
+          addToSet(ve, e.ADD_ATTR, st);
+        }
+        if (e.ADD_URI_SAFE_ATTR) {
+          addToSet(Ye, e.ADD_URI_SAFE_ATTR, st);
+        }
+        if (e.FORBID_CONTENTS) {
+          if (qe === Ue) {
+            qe = clone(qe);
+          }
+          addToSet(qe, e.FORBID_CONTENTS, st);
+        }
+        /* Add #text in case KEEP_CONTENT is set to true */        if (Fe) {
+          be["#text"] = true;
+        }
+        /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */        if (Oe) {
+          addToSet(be, [ "html", "head", "body" ]);
+        }
+        /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */        if (be.table) {
+          addToSet(be, [ "tbody" ]);
+          delete ke.tbody;
+        }
+        if (e.TRUSTED_TYPES_POLICY) {
+          if (typeof e.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+            throw T('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+          }
+          if (typeof e.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+            throw T('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 = V(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 (a) {
+          a(e);
+        }
+        lt = e;
+      };
+      /* Keep track of all possible SVG and MathML tags
+     * so that we can perform the namespace checks
+     * correctly. */      const ft = addToSet({}, [ ..._, ...A, ...E ]);
+      const pt = addToSet({}, [ ...z, ...R ]);
+      /**
+     * @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 ht = 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 = m(e.tagName);
+        const o = m(t.tagName);
+        if (!Ze[e.namespaceURI]) {
+          return false;
+        }
+        if (e.namespaceURI === Xe) {
+          // 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 === Ve) {
+            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(ft[n]);
+        }
+        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) {
+            return n === "math";
+          }
+          // The only way to switch from SVG to MathML is via
+          // <math> and HTML integration points
+                    if (t.namespaceURI === Xe) {
+            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 === Xe && !nt[o]) {
+            return false;
+          }
+          if (t.namespaceURI === Ve && !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] || !ft[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 mt = 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 gt = 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 || Ce) {
+            try {
+              mt(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 bt = function _initDocument(e) {
+        /* Create a HTML document */
+        let t = null;
+        let o = null;
+        if (De) {
+          e = "<remove></remove>" + e;
+        } else {
+          /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+          const t = b(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 F).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 a = t.body || t.documentElement;
+        if (e && o) {
+          a.insertBefore(n.createTextNode(o), a.childNodes[0] || null);
+        }
+        /* Work on whole document or just its body */        if (Je === Ke) {
+          return ae.call(t, Oe ? "html" : "body")[0];
+        }
+        return Oe ? t.documentElement : a;
+      };
+      /**
+     * 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 yt = function _createNodeIterator(e) {
+        return oe.call(e.ownerDocument || e, e, 
+        // eslint-disable-next-line no-bitwise
+        I.SHOW_ELEMENT | I.SHOW_COMMENT | I.SHOW_TEXT | I.SHOW_PROCESSING_INSTRUCTION | I.SHOW_CDATA_SECTION, null);
+      };
+      /**
+     * _isClobbered
+     *
+     * @param element element to check for clobbering attacks
+     * @return true if clobbered, false if safe
+     */      const vt = function _isClobbered(e) {
+        return e instanceof H && (typeof e.nodeName !== "string" || typeof e.textContent !== "string" || typeof e.removeChild !== "function" || !(e.attributes instanceof N) || 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 xt = function _isNode(e) {
+        return typeof c === "function" && e instanceof c;
+      };
+      function _executeHooks(e, t, n) {
+        d(e, (e => {
+          e.call(DOMPurify, t, n, lt);
+        }));
+      }
+      /**
+     * _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 wt = function _sanitizeElements(e) {
+        let t = null;
+        /* Execute a hook if present */        _executeHooks(se.beforeSanitizeElements, e, null);
+        /* Check if element is clobbered or can clobber */        if (vt(e)) {
+          mt(e);
+          return true;
+        }
+        /* Now let's check the element's type and name */        const n = st(e.nodeName);
+        /* Execute a hook if present */        _executeHooks(se.uponSanitizeElement, e, {
+          tagName: n,
+          allowedTags: be
+        });
+        /* Detect mXSS attempts abusing namespace confusion */        if (e.hasChildNodes() && !xt(e.firstElementChild) && k(/<[/\w]/g, e.innerHTML) && k(/<[/\w]/g, e.textContent)) {
+          mt(e);
+          return true;
+        }
+        /* Remove any occurrence of processing instructions */        if (e.nodeType === Y.progressingInstruction) {
+          mt(e);
+          return true;
+        }
+        /* Remove any kind of possibly harmful comments */        if (Re && e.nodeType === Y.comment && k(/<[/\w]/g, e.data)) {
+          mt(e);
+          return true;
+        }
+        /* Remove element if anything forbids its presence */        if (!be[n] || ke[n]) {
+          /* Check if we have a custom element to handle */
+          if (!ke[n] && Tt(n)) {
+            if (we.tagNameCheck instanceof RegExp && k(we.tagNameCheck, n)) {
+              return false;
+            }
+            if (we.tagNameCheck instanceof Function && we.tagNameCheck(n)) {
+              return false;
+            }
+          }
+          /* Keep content except for bad-listed elements */          if (Fe && !qe[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 = G(n[i], true);
+                o.__removalCount = (e.__removalCount || 0) + 1;
+                t.insertBefore(o, J(e));
+              }
+            }
+          }
+          mt(e);
+          return true;
+        }
+        /* Check whether element has a valid namespace */        if (e instanceof P && !ht(e)) {
+          mt(e);
+          return true;
+        }
+        /* Make sure that older browsers don't get fallback-tag mXSS */        if ((n === "noscript" || n === "noembed" || n === "noframes") && k(/<\/no(script|embed|frames)/i, e.innerHTML)) {
+          mt(e);
+          return true;
+        }
+        /* Sanitize element content to be template-safe */        if (ze && e.nodeType === Y.text) {
+          /* Get the element's text content */
+          t = e.textContent;
+          d([ le, ce, de ], (e => {
+            t = y(t, e, " ");
+          }));
+          if (e.textContent !== t) {
+            p(DOMPurify.removed, {
+              element: e.cloneNode()
+            });
+            e.textContent = t;
+          }
+        }
+        /* Execute a hook if present */        _executeHooks(se.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 kt = function _isValidAttribute(e, t, o) {
+        /* Make sure attribute cannot clobber */
+        if (Ie && (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 (_e && !Te[t] && k(ue, t)) ; else if (Se && k(fe, t)) ; else if (!ve[t] || Te[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
+          Tt(e) && (we.tagNameCheck instanceof RegExp && k(we.tagNameCheck, e) || we.tagNameCheck instanceof Function && we.tagNameCheck(e)) && (we.attributeNameCheck instanceof RegExp && k(we.attributeNameCheck, t) || we.attributeNameCheck instanceof Function && we.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" && we.allowCustomizedBuiltInElements && (we.tagNameCheck instanceof RegExp && k(we.tagNameCheck, o) || we.tagNameCheck instanceof Function && we.tagNameCheck(o))) ; else {
+            return false;
+          }
+          /* Check value is safe. First, is attr inert? If so, is safe */        } else if (Ye[t]) ; else if (k(ge, y(o, he, ""))) ; else if ((t === "src" || t === "xlink:href" || t === "href") && e !== "script" && v(o, "data:") === 0 && Ge[e]) ; else if (Ae && !k(pe, y(o, he, ""))) ; 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 Tt = function _isBasicCustomElement(e) {
+        return e !== "annotation-xml" && b(e, me);
+      };
+      /**
+     * _sanitizeAttributes
+     *
+     * @protect attributes
+     * @protect nodeName
+     * @protect removeAttribute
+     * @protect setAttribute
+     *
+     * @param currentNode to sanitize
+     */      const St = function _sanitizeAttributes(e) {
+        /* Execute a hook if present */
+        _executeHooks(se.beforeSanitizeAttributes, e, null);
+        const {attributes: t} = e;
+        /* Check if we have attributes; if not we might have a text node */        if (!t || vt(e)) {
+          return;
+        }
+        const n = {
+          attrName: "",
+          attrValue: "",
+          keepAttr: true,
+          allowedAttributes: ve,
+          forceKeepAttr: undefined
+        };
+        let o = t.length;
+        /* Go backwards over all attributes; safely remove bad ones */        while (o--) {
+          const i = t[o];
+          const {name: a, namespaceURI: r, value: s} = i;
+          const l = st(a);
+          let c = a === "value" ? s : x(s);
+          /* Execute a hook if present */          n.attrName = l;
+          n.attrValue = c;
+          n.keepAttr = true;
+          n.forceKeepAttr = undefined;
+ // Allows developers to see this is a property they can set
+                    _executeHooks(se.uponSanitizeAttribute, e, n);
+          c = n.attrValue;
+          /* Full DOM Clobbering protection via namespace isolation,
+         * Prefix id and name attributes with `user-content-`
+         */          if (Ne && (l === "id" || l === "name")) {
+            // Remove the attribute with this value
+            gt(a, e);
+            // Prefix the value and later re-create the attribute with the sanitized value
+                        c = He + c;
+          }
+          /* Work around a security issue with comments inside attributes */          if (Re && k(/((--!?|])>)|<\/(style|title)/i, c)) {
+            gt(a, e);
+            continue;
+          }
+          /* Did the hooks approve of the attribute? */          if (n.forceKeepAttr) {
+            continue;
+          }
+          /* Remove attribute */          gt(a, e);
+          /* Did the hooks approve of the attribute? */          if (!n.keepAttr) {
+            continue;
+          }
+          /* Work around a security issue in jQuery 3.0 */          if (!Ee && k(/\/>/i, c)) {
+            gt(a, e);
+            continue;
+          }
+          /* Sanitize attribute content to be template-safe */          if (ze) {
+            d([ le, ce, de ], (e => {
+              c = y(c, e, " ");
+            }));
+          }
+          /* Is `value` valid for this attribute? */          const u = st(e.nodeName);
+          if (!kt(u, l, c)) {
+            continue;
+          }
+          /* Handle attributes that require Trusted Types */          if (ee && typeof B === "object" && typeof B.getAttributeType === "function") {
+            if (r) ; else {
+              switch (B.getAttributeType(u, l)) {
+               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 (r) {
+              e.setAttributeNS(r, a, c);
+            } else {
+              /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+              e.setAttribute(a, c);
+            }
+            if (vt(e)) {
+              mt(e);
+            } else {
+              f(DOMPurify.removed);
+            }
+          } catch (e) {}
+        }
+        /* Execute a hook if present */        _executeHooks(se.afterSanitizeAttributes, e, null);
+      };
+      /**
+     * _sanitizeShadowDOM
+     *
+     * @param fragment to iterate over recursively
+     */      const _t = function _sanitizeShadowDOM(e) {
+        let t = null;
+        const n = yt(e);
+        /* Execute a hook if present */        _executeHooks(se.beforeSanitizeShadowDOM, e, null);
+        while (t = n.nextNode()) {
+          /* Execute a hook if present */
+          _executeHooks(se.uponSanitizeShadowNode, t, null);
+          /* Sanitize tags and elements */          wt(t);
+          /* Check attributes next */          St(t);
+          /* Deep shadow DOM detected */          if (t.content instanceof r) {
+            _sanitizeShadowDOM(t.content);
+          }
+        }
+        /* Execute a hook if present */        _executeHooks(se.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 a = null;
+        let s = 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" && !xt(e)) {
+          if (typeof e.toString === "function") {
+            e = e.toString();
+            if (typeof e !== "string") {
+              throw T("dirty is not a string, aborting");
+            }
+          } else {
+            throw T("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") {
+          je = false;
+        }
+        if (je) {
+          /* Do some early pre-sanitization to avoid unsafe root nodes */
+          if (e.nodeName) {
+            const t = st(e.nodeName);
+            if (!be[t] || ke[t]) {
+              throw T("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 = 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 */
+            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 && !ze && !Oe && 
+          // eslint-disable-next-line unicorn/prefer-includes
+          e.indexOf("<") === -1) {
+            return ee && Pe ? ee.createHTML(e) : e;
+          }
+          /* Initialize the document to work on */          n = bt(e);
+          /* Check we have a DOM node from the data */          if (!n) {
+            return Le ? null : Pe ? te : "";
+          }
+        }
+        /* Remove first element node (ours) if FORCE_BODY is set */        if (n && De) {
+          mt(n.firstChild);
+        }
+        /* Get node iterator */        const l = yt(je ? e : n);
+        /* Now start iterating over the created document */        while (a = l.nextNode()) {
+          /* Sanitize tags and elements */
+          wt(a);
+          /* Check attributes next */          St(a);
+          /* Shadow DOM detected, sanitize it */          if (a.content instanceof r) {
+            _t(a.content);
+          }
+        }
+        /* If we sanitized `dirty` in-place, return it. */        if (je) {
+          return e;
+        }
+        /* Return sanitized string or DOM */        if (Le) {
+          if (Ce) {
+            s = ie.call(n.ownerDocument);
+            while (n.firstChild) {
+              // eslint-disable-next-line unicorn/prefer-dom-node-append
+              s.appendChild(n.firstChild);
+            }
+          } else {
+            s = n;
+          }
+          if (ve.shadowroot || ve.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.
+          */
+            s = re.call(o, s, true);
+          }
+          return s;
+        }
+        let u = Oe ? n.outerHTML : n.innerHTML;
+        /* Serialize doctype if allowed */        if (Oe && be["!doctype"] && n.ownerDocument && n.ownerDocument.doctype && n.ownerDocument.doctype.name && k(U, n.ownerDocument.doctype.name)) {
+          u = "<!DOCTYPE " + n.ownerDocument.doctype.name + ">\n" + u;
+        }
+        /* Sanitize final string template-safe */        if (ze) {
+          d([ le, ce, de ], (e => {
+            u = y(u, e, " ");
+          }));
+        }
+        return ee && Pe ? ee.createHTML(u) : u;
+      };
+      DOMPurify.setConfig = function() {
+        let e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        ut(e);
+        Me = true;
+      };
+      DOMPurify.clearConfig = function() {
+        lt = null;
+        Me = false;
+      };
+      DOMPurify.isValidAttribute = function(e, t, n) {
+        /* Initialize shared config vars if necessary. */
+        if (!lt) {
+          ut({});
+        }
+        const o = st(e);
+        const i = st(t);
+        return kt(o, i, n);
+      };
+      DOMPurify.addHook = function(e, t) {
+        if (typeof t !== "function") {
+          return;
+        }
+        p(se[e], t);
+      };
+      DOMPurify.removeHook = function(e, t) {
+        if (t !== undefined) {
+          const n = u(se[e], t);
+          return n === -1 ? undefined : h(se[e], n, 1)[0];
+        }
+        return f(se[e]);
+      };
+      DOMPurify.removeHooks = function(e) {
+        se[e] = [];
+      };
+      DOMPurify.removeAllHooks = function() {
+        se = X();
+      };
+      return DOMPurify;
+    }
+    var K = createDOMPurify();
+    return K;
+  }));
+})(l);
+
+const c = l.exports;
+
+function sanitizeHTMLString(e) {
+  return c(window).sanitize(e, {
+    FORBID_TAGS: [ "style" ],
+    CUSTOM_ELEMENT_HANDLING: {
+      tagNameCheck: /^q2-/
+    }
+  });
+}
+
+const d = '*{box-sizing:border-box}*:active{outline:none}*:focus{outline:none;box-shadow:var(--const-double-focus-ring, 0 0 0 2px #ffffff, 0 0 0 4px #0066cc)}:host{box-shadow:none !important}::-moz-focus-inner{border:none}input,textarea,button{font-family:inherit;font-size:inherit;font-stretch:inherit}:host(.sr),:host(.sr) button{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap}.sr,.sr button{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap}.hidden{display:none}:host([hidden]){display:none}.invisible{visibility:hidden}@keyframes showBackdrop{from{opacity:0}}@keyframes hideBackdrop{to{opacity:0}}dialog{--comp-border-radius-default:var(--app-scale-3x, 15px) var(--app-scale-3x, 15px) 0 0;--comp-border-radius:var(--tct-action-sheet-border-radius, var(--comp-border-radius-default));--comp-desktop-border-radius:var(--tct-action-sheet-border-radius, var(--app-scale-3x, 15px));--comp-close-button-size:var(--tct-action-sheet-close-button-size, var(--t-a11y-min-size, 44px));--comp-header-height:var(--tct-action-sheet-header-height, var(--t-a11y-min-size, 44px));--comp-dialog-background:var(--tct-action-sheet-background, var(--t-base, #ffffff));--comp-dialog-color:var(--tct-action-sheet-color, var(--t-text, #4d4d4d));--comp-dialog-padding:var(--tct-action-sheet-padding, var(--app-scale-3x, 15px));--comp-content-gradient-height:var(--tct-action-sheet-content-gradient-height, var(--app-scale-2x, 10px));--comp-dialog-gap:var(--tct-action-sheet-gap, var(--app-scale-2x, 10px));--comp-dialog-max-width:var(--tct-action-sheet-max-width, 400px);--comp-dialog-max-height:var(--tct-action-sheet-max-height, var(--comp-action-sheet-computed-max-height, 75vh));--comp-dialog-min-height:var(--tct-action-sheet-min-height, var(--comp-action-sheet-computed-min-height, 20vh));--comp-dialog-box-shadow:var(--tct-action-sheet-box-shadow, var(--app-shadow-2, 0px 0px 2px rgba(0, 0, 0, 0.12), 0px 4px 8px rgba(0, 0, 0, 0.14)));position:fixed;top:100%;bottom:unset;color:var(--comp-dialog-color);background:var(--comp-dialog-background);transition:transform var(--tct-action-sheet-tween, var(--app-tween-2, 0.4s ease)), opacity var(--tct-action-sheet-tween, var(--app-tween-2, 0.4s ease));width:100%;max-width:var(--comp-dialog-max-width);border:0;border-radius:var(--comp-border-radius);box-shadow:var(--comp-dialog-box-shadow);padding:0;height:auto;overflow:hidden;min-height:var(--comp-dialog-min-height);max-height:var(--comp-dialog-max-height)}dialog::backdrop{opacity:0;background:var(--tct-action-sheet-backdrop-background, var(--t-top-a2, rgba(13, 13, 13, 0.6)))}dialog[open].is-opening,dialog[open].is-open{transform:translateY(-100%)}@media screen and (min-width: 1200px){dialog[open].is-opening,dialog[open].is-open{opacity:1;transform:translateY(0)}}dialog[open].is-opening::backdrop,dialog[open].is-open::backdrop{opacity:1;animation:showBackdrop var(--tct-action-sheet-tween, var(--app-tween-2, 0.4s ease))}dialog[open].is-closing{transform:translateY(10%)}dialog[open].is-closing::backdrop{animation:hideBackdrop var(--tct-action-sheet-tween, var(--app-tween-2, 0.4s ease))}@media screen and (min-width: 1200px){dialog{border-radius:var(--comp-desktop-border-radius);top:0px;bottom:0px;height:fit-content;transform:translateY(10%);opacity:0}}.content{overflow-y:auto;--comp-scrollbar-size:var(--tct-scrollbar-size, var(--t-scrollbar-size, var(--app-scale-1x, 5px)));--comp-scrollbar-border-radius:var(--tct-scrollbar-border-radius, var(--t-scrollbar-border-radius, var(--app-border-radius-1, 4px)));--comp-scrollbar-color:var(--tct-scrollbar-color, var(--t-scrollbar-color, var(--t-a11y-gray-color, #747474)));scrollbar-width:thin;scrollbar-color:var(--comp-scrollbar-color) transparent}.content::-webkit-scrollbar{width:var(--comp-scrollbar-size);height:var(--comp-scrollbar-size);margin:5px}.content::-webkit-scrollbar-thumb{background:var(--comp-scrollbar-color);border-radius:var(--comp-scrollbar-border-radius)}.content::-webkit-scrollbar-track{background:transparent;border-radius:var(--comp-scrollbar-border-radius)}.interior{display:grid;grid-template-rows:44px 1fr auto;gap:var(--comp-dialog-gap);max-height:calc(var(--comp-dialog-max-height) - var(--comp-dialog-padding));padding:var(--comp-dialog-padding)}.interior.is-list header,.interior.is-list footer{position:relative}.interior.is-list header:before,.interior.is-list footer:before{content:"";display:block;position:absolute;left:0;height:var(--comp-content-gradient-height);width:100%;z-index:1}header{display:grid;grid-template-columns:var(--comp-close-button-size) 1fr var(--comp-close-button-size);grid-template-areas:". title close";gap:var(--comp-dialog-gap)}header .title{grid-area:title;text-align:center;line-height:var(--comp-header-height)}header .btn-close{grid-area:close;width:var(--comp-close-button-size);height:var(--comp-close-button-size)}footer{display:flex;justify-content:end}';
+
+const u = d;
+
+var f = undefined && undefined.__rest || function(e, t) {
+  var n = {};
+  for (var o in e) if (Object.prototype.hasOwnProperty.call(e, o) && t.indexOf(o) < 0) n[o] = e[o];
+  if (e != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, o = Object.getOwnPropertySymbols(e); i < o.length; i++) {
+    if (t.indexOf(o[i]) < 0 && Object.prototype.propertyIsEnumerable.call(e, o[i])) n[o[i]] = e[o[i]];
+  }
+  return n;
+};
+
+const p = class {
+  constructor(i) {
+    e(this, i);
+    this.close = t(this, "close", 7);
+    this.ready = t(this, "ready", 3);
+    this.initialSelectedOptions = [];
+    this.maxHeight = .75;
+    this.minHeight = .2;
+    this.selectedOptions = {
+      values: [],
+      value: ""
+    };
+    this.generateOptgroup = e => {
+      const t = document.createElement("q2-optgroup");
+      if (e.label) t.setAttribute("label", e.label);
+      if (e.disabled) t.setAttribute("disabled", "");
+      if (!!e.options.length) e.options.forEach((e => t.appendChild(this.generateOption(e))));
+      return t;
+    };
+    this.generateOption = e => {
+      const t = document.createElement("q2-option");
+      const {innerHTML: n} = e, o = f(e, [ "innerHTML" ]);
+      if (n) t.innerHTML = sanitizeHTMLString(n);
+      Object.entries(o).forEach((([e, n]) => {
+        if (n === undefined) return;
+        if (typeof n === "boolean") {
+          if (n) t.setAttribute(e, "");
+        } else {
+          t.setAttribute(e, n);
+        }
+      }));
+      return t;
+    };
+    this.onCancel = e => {
+      var t, n;
+      e.preventDefault();
+      const {initialSelectedOptions: o} = this;
+      this.hide({
+        value: (n = (t = o === null || o === void 0 ? void 0 : o[0]) === null || t === void 0 ? void 0 : t.value) !== null && n !== void 0 ? n : "",
+        values: o,
+        type: "cancel"
+      });
+    };
+    this.onClick = e => {
+      const t = e.target;
+      if (!(t instanceof HTMLElement)) return;
+      const n = !!t.closest(".interior, q2-action-sheet");
+      if (n) return;
+      this.onCancel(e);
+    };
+    this.onListChange = e => {
+      this.selectedOptions = e.detail;
+    };
+    this.onListDone = () => {
+      this.hide(Object.assign(Object.assign({}, this.selectedOptions), {
+        type: "confirm"
+      }));
+    };
+    this.onListPopoverStateChange = e => {
+      if (e.detail.open) return;
+      if (e.detail.action === "close") {
+        this.onCancel(e);
+      } else {
+        this.onListDone();
+      }
+    };
+    // #endregion
+    // #region Render Methods
+        this.renderList = ({data: e}) => {
+      const {listProps: t} = e;
+      return n(o, null, n("div", {
+        class: "content",
+        ref: e => this.contentElement = e
+      }, n("q2-option-list", {
+        ref: e => this.optionListElement = e,
+        multiple: t.multiple,
+        noSelect: t.noSelect,
+        onChange: this.onListChange,
+        onPopoverState: this.onListPopoverStateChange,
+        selectedOptions: t.selectedOptions
+      }, n("slot", null))), n("footer", null, t.multiple && n("q2-btn", {
+        "test-id": "btnDone",
+        intent: "workflow-primary",
+        onClick: this.onListDone
+      }, a("tecton.element.actionSheet.done"))));
+    };
+    this.renderMessage = ({data: e}) => n("q2-message", {
+      type: e.type
+    }, e.title && n("h2", null, e.title), e.description && n("p", null, e.description));
+    this.renderSlot = () => n("div", {
+      class: "content",
+      ref: e => this.contentElement = e
+    }, n("slot", null));
+    this.isScrollable = false;
+    this.renderStatus = "is-closing";
+    this.data = undefined;
+    this.hideClose = undefined;
+    this.title = undefined;
+  }
+  // #endregion
+  // #region Component Lifecycle Events
+  disconnectedCallback() {
+    this.dialogElement.removeEventListener("cancel", this.onCancel);
+  }
+  componentDidLoad() {
+    this.dialogElement.addEventListener("cancel", this.onCancel);
+    this.ready.emit();
+  }
+  // #endregion
+  // #region Public Methods API
+  async hide(e = {
+    value: "",
+    values: [],
+    type: "confirm"
+  }) {
+    this.close.emit(e);
+    this.renderStatus = "is-closing";
+    this.dialogElement.addEventListener("transitionend", (() => {
+      if (this.renderStatus !== "is-closing") return;
+      this.dialogElement.close();
+      this.renderStatus = null;
+      this.data = undefined;
+      this.initialSelectedOptions = [];
+      this.selectedOptions = {
+        values: [],
+        value: ""
+      };
+      this.hidePostHook();
+    }), {
+      once: true
+    });
+  }
+  async show() {
+    this.showPreHook();
+    await r();
+    this.updateDialogMinMaxHeight();
+    this.storeInitialValues();
+    if (this.dialogElement.open) return;
+    this.dialogElement.showModal();
+    this.renderStatus = "is-opening";
+    this.dialogElement.addEventListener("transitionend", (() => {
+      if (this.renderStatus !== "is-opening") return;
+      this.renderStatus = "is-open";
+      this.focusContent();
+    }), {
+      once: true
+    });
+  }
+  // #endregion
+  // #region Local Methods
+  focusContent() {
+    const {data: e} = this;
+    if (!e) return;
+    if (e.appearance === "list") {
+      const {event: t} = e;
+      if (t instanceof KeyboardEvent) {
+        this.optionListElement.handleExternalKeydown(t);
+      } else {
+        this.optionListElement.focus();
+      }
+    }
+  }
+  hidePostHook() {
+    const {data: e} = this;
+    if (!e) return;
+    if (e.appearance === "list") {
+      this.hostElement.innerHTML = null;
+    }
+  }
+  showPreHook() {
+    const {data: e} = this;
+    if (!e) return;
+    if (e.appearance === "list") {
+      this.hostElement.innerHTML = null;
+      e.options.forEach((e => {
+        this.hostElement.appendChild("options" in e ? this.generateOptgroup(e) : this.generateOption(e));
+      }));
+    }
+  }
+  storeInitialValues() {
+    const {data: e} = this;
+    if (!e) return;
+    if (e.appearance === "list") {
+      this.initialSelectedOptions = e.listProps.selectedOptions;
+    }
+  }
+  updateDialogMinMaxHeight() {
+    const e = window.innerHeight;
+    this.dialogElement.style.setProperty("--comp-action-sheet-computed-min-height", `${Math.floor(e * this.minHeight)}px`);
+    this.dialogElement.style.setProperty("--comp-action-sheet-computed-max-height", `${Math.floor(e * this.maxHeight)}px`);
+  }
+  render() {
+    var e;
+    const {data: t} = this;
+    const o = (t === null || t === void 0 ? void 0 : t.title) || this.title || !this.hideClose;
+    const i = this.renderStatus || "";
+    let a = null;
+    switch (t === null || t === void 0 ? void 0 : t.appearance) {
+     case "message":
+      a = this.renderMessage;
+      break;
+
+     case "list":
+      a = this.renderList;
+      break;
+
+     default:
+      a = this.renderSlot;
+      break;
+    }
+    const r = (t === null || t === void 0 ? void 0 : t.appearance) || "slot";
+    const s = `interior is-${r}`;
+    return n("dialog", {
+      key: "89438ac3af7a795d3b83a4171c74e0b1255ccb95",
+      ref: e => this.dialogElement = e,
+      class: i,
+      onClick: this.onClick
+    }, n("div", {
+      key: "a17e57ba2693ee5dbd70ae888fde0d5df2837ccb",
+      class: s
+    }, o && n("header", {
+      key: "7da7a414195ed0e3e3f8dbc1692adeabd4dee09b"
+    }, n("div", {
+      key: "f83976916359a1c9318086c486ab59e7f001e9ca",
+      class: "title"
+    }, (t === null || t === void 0 ? void 0 : t.title) || this.title), !this.hideClose && n("q2-btn", {
+      key: "873a7f92f6103bb671594640c56786d3dcb389d8",
+      class: "btn-close",
+      "test-id": "btnClose",
+      onClick: this.onCancel,
+      label: "tecton.element.actionSheet.close",
+      "hide-label": true
+    }, n("q2-icon", {
+      key: "bb5d5f0d92186171564b2fe74d7b95e98962ed9c",
+      type: "close"
+    }))), ((e = this.data) === null || e === void 0 ? void 0 : e.description) && n("p", {
+      key: "2620549f6ca4b669011a4dbd2be0a470d65ee857"
+    }, t.description), a && n(a, {
+      key: "bf22c21f56b4551f4bf6ddbcc6385669ed02b66b",
+      data: this.data
+    })));
+  }
+  get hostElement() {
+    return i(this);
+  }
+};
+
+p.style = u;
+
+export { p as q2_action_sheet };
+//# sourceMappingURL=q2-action-sheet.entry.js.map