@alan-ai/alan-sdk-web 1.8.119 → 1.8.121

package/dist/alan_lib.js

@@ -25853,6 +25853,1092 @@
     }
   });
 
+  // node_modules/dompurify/dist/purify.cjs.js
+  var require_purify_cjs = __commonJS({
+    "node_modules/dompurify/dist/purify.cjs.js"(exports, module) {
+      "use strict";
+      var {
+        entries,
+        setPrototypeOf,
+        isFrozen,
+        getPrototypeOf,
+        getOwnPropertyDescriptor
+      } = Object;
+      var {
+        freeze,
+        seal,
+        create
+      } = Object;
+      var {
+        apply,
+        construct
+      } = typeof Reflect !== "undefined" && Reflect;
+      if (!freeze) {
+        freeze = function freeze2(x) {
+          return x;
+        };
+      }
+      if (!seal) {
+        seal = function seal2(x) {
+          return x;
+        };
+      }
+      if (!apply) {
+        apply = function apply2(func, thisArg) {
+          for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+            args[_key - 2] = arguments[_key];
+          }
+          return func.apply(thisArg, args);
+        };
+      }
+      if (!construct) {
+        construct = function construct2(Func) {
+          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+          return new Func(...args);
+        };
+      }
+      var arrayForEach = unapply(Array.prototype.forEach);
+      var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+      var arrayPop = unapply(Array.prototype.pop);
+      var arrayPush = unapply(Array.prototype.push);
+      var arraySplice = unapply(Array.prototype.splice);
+      var arrayIsArray = Array.isArray;
+      var stringToLowerCase = unapply(String.prototype.toLowerCase);
+      var stringToString = unapply(String.prototype.toString);
+      var stringMatch = unapply(String.prototype.match);
+      var stringReplace = unapply(String.prototype.replace);
+      var stringIndexOf = unapply(String.prototype.indexOf);
+      var stringTrim = unapply(String.prototype.trim);
+      var numberToString = unapply(Number.prototype.toString);
+      var booleanToString = unapply(Boolean.prototype.toString);
+      var bigintToString = typeof BigInt === "undefined" ? null : unapply(BigInt.prototype.toString);
+      var symbolToString = typeof Symbol === "undefined" ? null : unapply(Symbol.prototype.toString);
+      var objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+      var objectToString = unapply(Object.prototype.toString);
+      var regExpTest = unapply(RegExp.prototype.test);
+      var typeErrorCreate = unconstruct(TypeError);
+      function unapply(func) {
+        return function(thisArg) {
+          if (thisArg instanceof RegExp) {
+            thisArg.lastIndex = 0;
+          }
+          for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+            args[_key3 - 1] = arguments[_key3];
+          }
+          return apply(func, thisArg, args);
+        };
+      }
+      function unconstruct(Func) {
+        return function() {
+          for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+            args[_key4] = arguments[_key4];
+          }
+          return construct(Func, args);
+        };
+      }
+      function addToSet(set, array) {
+        let transformCaseFunc = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : stringToLowerCase;
+        if (setPrototypeOf) {
+          setPrototypeOf(set, null);
+        }
+        if (!arrayIsArray(array)) {
+          return set;
+        }
+        let l = array.length;
+        while (l--) {
+          let element = array[l];
+          if (typeof element === "string") {
+            const lcElement = transformCaseFunc(element);
+            if (lcElement !== element) {
+              if (!isFrozen(array)) {
+                array[l] = lcElement;
+              }
+              element = lcElement;
+            }
+          }
+          set[element] = true;
+        }
+        return set;
+      }
+      function cleanArray(array) {
+        for (let index3 = 0; index3 < array.length; index3++) {
+          const isPropertyExist = objectHasOwnProperty(array, index3);
+          if (!isPropertyExist) {
+            array[index3] = null;
+          }
+        }
+        return array;
+      }
+      function clone3(object) {
+        const newObject = create(null);
+        for (const [property, value] of entries(object)) {
+          const isPropertyExist = objectHasOwnProperty(object, property);
+          if (isPropertyExist) {
+            if (arrayIsArray(value)) {
+              newObject[property] = cleanArray(value);
+            } else if (value && typeof value === "object" && value.constructor === Object) {
+              newObject[property] = clone3(value);
+            } else {
+              newObject[property] = value;
+            }
+          }
+        }
+        return newObject;
+      }
+      function stringifyValue(value) {
+        switch (typeof value) {
+          case "string": {
+            return value;
+          }
+          case "number": {
+            return numberToString(value);
+          }
+          case "boolean": {
+            return booleanToString(value);
+          }
+          case "bigint": {
+            return bigintToString ? bigintToString(value) : "0";
+          }
+          case "symbol": {
+            return symbolToString ? symbolToString(value) : "Symbol()";
+          }
+          case "undefined": {
+            return objectToString(value);
+          }
+          case "function":
+          case "object": {
+            if (value === null) {
+              return objectToString(value);
+            }
+            const valueAsRecord = value;
+            const valueToString = lookupGetter(valueAsRecord, "toString");
+            if (typeof valueToString === "function") {
+              const stringified = valueToString(valueAsRecord);
+              return typeof stringified === "string" ? stringified : objectToString(stringified);
+            }
+            return objectToString(value);
+          }
+          default: {
+            return objectToString(value);
+          }
+        }
+      }
+      function lookupGetter(object, prop3) {
+        while (object !== null) {
+          const desc = getOwnPropertyDescriptor(object, prop3);
+          if (desc) {
+            if (desc.get) {
+              return unapply(desc.get);
+            }
+            if (typeof desc.value === "function") {
+              return unapply(desc.value);
+            }
+          }
+          object = getPrototypeOf(object);
+        }
+        function fallbackValue() {
+          return null;
+        }
+        return fallbackValue;
+      }
+      function isRegex(value) {
+        try {
+          regExpTest(value, "");
+          return true;
+        } catch (_unused) {
+          return false;
+        }
+      }
+      var html$1 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "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"]);
+      var svg$1 = freeze(["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"]);
+      var svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]);
+      var svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]);
+      var mathMl$1 = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]);
+      var mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]);
+      var text5 = freeze(["#text"]);
+      var html5 = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "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"]);
+      var svg = freeze(["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"]);
+      var mathMl = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnalign", "columnlines", "columnspacing", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lquote", "lspace", "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"]);
+      var xml3 = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]);
+      var MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm);
+      var ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+      var TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm);
+      var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/);
+      var ARIA_ATTR = seal(/^aria-[\-\w]+$/);
+      var IS_ALLOWED_URI = seal(
+        /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+        // eslint-disable-line no-useless-escape
+      );
+      var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+      var ATTR_WHITESPACE = seal(
+        /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+        // eslint-disable-line no-control-regex
+      );
+      var DOCTYPE_NAME = seal(/^html$/i);
+      var CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+      var EXPRESSIONS = /* @__PURE__ */ Object.freeze({
+        __proto__: null,
+        ARIA_ATTR,
+        ATTR_WHITESPACE,
+        CUSTOM_ELEMENT,
+        DATA_ATTR,
+        DOCTYPE_NAME,
+        ERB_EXPR,
+        IS_ALLOWED_URI,
+        IS_SCRIPT_OR_DATA,
+        MUSTACHE_EXPR,
+        TMPLIT_EXPR
+      });
+      var NODE_TYPE = {
+        element: 1,
+        text: 3,
+        // Deprecated
+        progressingInstruction: 7,
+        comment: 8,
+        document: 9
+      };
+      var getGlobal = function getGlobal2() {
+        return typeof window === "undefined" ? null : window;
+      };
+      var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, purifyHostElement) {
+        if (typeof trustedTypes !== "object" || typeof trustedTypes.createPolicy !== "function") {
+          return null;
+        }
+        let suffix = null;
+        const ATTR_NAME = "data-tt-policy-suffix";
+        if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+          suffix = purifyHostElement.getAttribute(ATTR_NAME);
+        }
+        const policyName = "dompurify" + (suffix ? "#" + suffix : "");
+        try {
+          return trustedTypes.createPolicy(policyName, {
+            createHTML(html6) {
+              return html6;
+            },
+            createScriptURL(scriptUrl) {
+              return scriptUrl;
+            }
+          });
+        } catch (_) {
+          console.warn("TrustedTypes policy " + policyName + " could not be created.");
+          return null;
+        }
+      };
+      var _createHooksMap = function _createHooksMap2() {
+        return {
+          afterSanitizeAttributes: [],
+          afterSanitizeElements: [],
+          afterSanitizeShadowDOM: [],
+          beforeSanitizeAttributes: [],
+          beforeSanitizeElements: [],
+          beforeSanitizeShadowDOM: [],
+          uponSanitizeAttribute: [],
+          uponSanitizeElement: [],
+          uponSanitizeShadowNode: []
+        };
+      };
+      function createDOMPurify() {
+        let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+        const DOMPurify2 = (root3) => createDOMPurify(root3);
+        DOMPurify2.version = "3.4.1";
+        DOMPurify2.removed = [];
+        if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
+          DOMPurify2.isSupported = false;
+          return DOMPurify2;
+        }
+        let {
+          document: document2
+        } = window2;
+        const originalDocument = document2;
+        const currentScript = originalDocument.currentScript;
+        const {
+          DocumentFragment,
+          HTMLTemplateElement,
+          Node: Node5,
+          Element: Element2,
+          NodeFilter,
+          NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+          HTMLFormElement,
+          DOMParser: DOMParser2,
+          trustedTypes
+        } = window2;
+        const ElementPrototype = Element2.prototype;
+        const cloneNode2 = lookupGetter(ElementPrototype, "cloneNode");
+        const remove3 = lookupGetter(ElementPrototype, "remove");
+        const getNextSibling = lookupGetter(ElementPrototype, "nextSibling");
+        const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
+        const getParentNode = lookupGetter(ElementPrototype, "parentNode");
+        if (typeof HTMLTemplateElement === "function") {
+          const template = document2.createElement("template");
+          if (template.content && template.content.ownerDocument) {
+            document2 = template.content.ownerDocument;
+          }
+        }
+        let trustedTypesPolicy;
+        let emptyHTML = "";
+        const {
+          implementation,
+          createNodeIterator,
+          createDocumentFragment,
+          getElementsByTagName: getElementsByTagName2
+        } = document2;
+        const {
+          importNode
+        } = originalDocument;
+        let hooks = _createHooksMap();
+        DOMPurify2.isSupported = typeof entries === "function" && typeof getParentNode === "function" && implementation && implementation.createHTMLDocument !== void 0;
+        const {
+          MUSTACHE_EXPR: MUSTACHE_EXPR2,
+          ERB_EXPR: ERB_EXPR2,
+          TMPLIT_EXPR: TMPLIT_EXPR2,
+          DATA_ATTR: DATA_ATTR2,
+          ARIA_ATTR: ARIA_ATTR2,
+          IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA2,
+          ATTR_WHITESPACE: ATTR_WHITESPACE2,
+          CUSTOM_ELEMENT: CUSTOM_ELEMENT2
+        } = EXPRESSIONS;
+        let {
+          IS_ALLOWED_URI: IS_ALLOWED_URI$1
+        } = EXPRESSIONS;
+        let ALLOWED_TAGS = null;
+        const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text5]);
+        let ALLOWED_ATTR = null;
+        const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html5, ...svg, ...mathMl, ...xml3]);
+        let CUSTOM_ELEMENT_HANDLING = Object.seal(create(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
+          }
+        }));
+        let FORBID_TAGS = null;
+        let FORBID_ATTR = null;
+        const EXTRA_ELEMENT_HANDLING = Object.seal(create(null, {
+          tagCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          },
+          attributeCheck: {
+            writable: true,
+            configurable: false,
+            enumerable: true,
+            value: null
+          }
+        }));
+        let ALLOW_ARIA_ATTR = true;
+        let ALLOW_DATA_ATTR = true;
+        let ALLOW_UNKNOWN_PROTOCOLS = false;
+        let ALLOW_SELF_CLOSE_IN_ATTR = true;
+        let SAFE_FOR_TEMPLATES = false;
+        let SAFE_FOR_XML = true;
+        let WHOLE_DOCUMENT = false;
+        let SET_CONFIG = false;
+        let FORCE_BODY = false;
+        let RETURN_DOM = false;
+        let RETURN_DOM_FRAGMENT = false;
+        let RETURN_TRUSTED_TYPE = false;
+        let SANITIZE_DOM = true;
+        let SANITIZE_NAMED_PROPS = false;
+        const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
+        let KEEP_CONTENT = true;
+        let IN_PLACE = false;
+        let USE_PROFILES = {};
+        let FORBID_CONTENTS = null;
+        const DEFAULT_FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+        let DATA_URI_TAGS = null;
+        const DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]);
+        let URI_SAFE_ATTRIBUTES = null;
+        const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]);
+        const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+        const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+        const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+        let NAMESPACE = HTML_NAMESPACE;
+        let IS_EMPTY_INPUT = false;
+        let ALLOWED_NAMESPACES = null;
+        const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+        let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+        let HTML_INTEGRATION_POINTS = addToSet({}, ["annotation-xml"]);
+        const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ["title", "style", "font", "a", "script"]);
+        let PARSER_MEDIA_TYPE = null;
+        const SUPPORTED_PARSER_MEDIA_TYPES = ["application/xhtml+xml", "text/html"];
+        const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
+        let transformCaseFunc = null;
+        let CONFIG = null;
+        const formElement = document2.createElement("form");
+        const isRegexOrFunction = function isRegexOrFunction2(testValue) {
+          return testValue instanceof RegExp || testValue instanceof Function;
+        };
+        const _parseConfig = function _parseConfig2() {
+          let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          if (CONFIG && CONFIG === cfg) {
+            return;
+          }
+          if (!cfg || typeof cfg !== "object") {
+            cfg = {};
+          }
+          cfg = clone3(cfg);
+          PARSER_MEDIA_TYPE = // eslint-disable-next-line unicorn/prefer-includes
+          SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+          transformCaseFunc = PARSER_MEDIA_TYPE === "application/xhtml+xml" ? stringToString : stringToLowerCase;
+          ALLOWED_TAGS = objectHasOwnProperty(cfg, "ALLOWED_TAGS") && arrayIsArray(cfg.ALLOWED_TAGS) ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+          ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") && arrayIsArray(cfg.ALLOWED_ATTR) ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+          ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") && arrayIsArray(cfg.ALLOWED_NAMESPACES) ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+          URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") && arrayIsArray(cfg.ADD_URI_SAFE_ATTR) ? addToSet(clone3(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+          DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") && arrayIsArray(cfg.ADD_DATA_URI_TAGS) ? addToSet(clone3(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+          FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") && arrayIsArray(cfg.FORBID_CONTENTS) ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+          FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") && arrayIsArray(cfg.FORBID_TAGS) ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone3({});
+          FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") && arrayIsArray(cfg.FORBID_ATTR) ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone3({});
+          USE_PROFILES = objectHasOwnProperty(cfg, "USE_PROFILES") ? cfg.USE_PROFILES && typeof cfg.USE_PROFILES === "object" ? clone3(cfg.USE_PROFILES) : cfg.USE_PROFILES : false;
+          ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false;
+          ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false;
+          ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false;
+          ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false;
+          SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false;
+          SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false;
+          WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false;
+          RETURN_DOM = cfg.RETURN_DOM || false;
+          RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false;
+          RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false;
+          FORCE_BODY = cfg.FORCE_BODY || false;
+          SANITIZE_DOM = cfg.SANITIZE_DOM !== false;
+          SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false;
+          KEEP_CONTENT = cfg.KEEP_CONTENT !== false;
+          IN_PLACE = cfg.IN_PLACE || false;
+          IS_ALLOWED_URI$1 = isRegex(cfg.ALLOWED_URI_REGEXP) ? cfg.ALLOWED_URI_REGEXP : IS_ALLOWED_URI;
+          NAMESPACE = typeof cfg.NAMESPACE === "string" ? cfg.NAMESPACE : HTML_NAMESPACE;
+          MATHML_TEXT_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "MATHML_TEXT_INTEGRATION_POINTS") && cfg.MATHML_TEXT_INTEGRATION_POINTS && typeof cfg.MATHML_TEXT_INTEGRATION_POINTS === "object" ? clone3(cfg.MATHML_TEXT_INTEGRATION_POINTS) : addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]);
+          HTML_INTEGRATION_POINTS = objectHasOwnProperty(cfg, "HTML_INTEGRATION_POINTS") && cfg.HTML_INTEGRATION_POINTS && typeof cfg.HTML_INTEGRATION_POINTS === "object" ? clone3(cfg.HTML_INTEGRATION_POINTS) : addToSet({}, ["annotation-xml"]);
+          const customElementHandling = objectHasOwnProperty(cfg, "CUSTOM_ELEMENT_HANDLING") && cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING === "object" ? clone3(cfg.CUSTOM_ELEMENT_HANDLING) : create(null);
+          CUSTOM_ELEMENT_HANDLING = create(null);
+          if (objectHasOwnProperty(customElementHandling, "tagNameCheck") && isRegexOrFunction(customElementHandling.tagNameCheck)) {
+            CUSTOM_ELEMENT_HANDLING.tagNameCheck = customElementHandling.tagNameCheck;
+          }
+          if (objectHasOwnProperty(customElementHandling, "attributeNameCheck") && isRegexOrFunction(customElementHandling.attributeNameCheck)) {
+            CUSTOM_ELEMENT_HANDLING.attributeNameCheck = customElementHandling.attributeNameCheck;
+          }
+          if (objectHasOwnProperty(customElementHandling, "allowCustomizedBuiltInElements") && typeof customElementHandling.allowCustomizedBuiltInElements === "boolean") {
+            CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = customElementHandling.allowCustomizedBuiltInElements;
+          }
+          if (SAFE_FOR_TEMPLATES) {
+            ALLOW_DATA_ATTR = false;
+          }
+          if (RETURN_DOM_FRAGMENT) {
+            RETURN_DOM = true;
+          }
+          if (USE_PROFILES) {
+            ALLOWED_TAGS = addToSet({}, text5);
+            ALLOWED_ATTR = create(null);
+            if (USE_PROFILES.html === true) {
+              addToSet(ALLOWED_TAGS, html$1);
+              addToSet(ALLOWED_ATTR, html5);
+            }
+            if (USE_PROFILES.svg === true) {
+              addToSet(ALLOWED_TAGS, svg$1);
+              addToSet(ALLOWED_ATTR, svg);
+              addToSet(ALLOWED_ATTR, xml3);
+            }
+            if (USE_PROFILES.svgFilters === true) {
+              addToSet(ALLOWED_TAGS, svgFilters);
+              addToSet(ALLOWED_ATTR, svg);
+              addToSet(ALLOWED_ATTR, xml3);
+            }
+            if (USE_PROFILES.mathMl === true) {
+              addToSet(ALLOWED_TAGS, mathMl$1);
+              addToSet(ALLOWED_ATTR, mathMl);
+              addToSet(ALLOWED_ATTR, xml3);
+            }
+          }
+          EXTRA_ELEMENT_HANDLING.tagCheck = null;
+          EXTRA_ELEMENT_HANDLING.attributeCheck = null;
+          if (objectHasOwnProperty(cfg, "ADD_TAGS")) {
+            if (typeof cfg.ADD_TAGS === "function") {
+              EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+            } else if (arrayIsArray(cfg.ADD_TAGS)) {
+              if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+                ALLOWED_TAGS = clone3(ALLOWED_TAGS);
+              }
+              addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+            }
+          }
+          if (objectHasOwnProperty(cfg, "ADD_ATTR")) {
+            if (typeof cfg.ADD_ATTR === "function") {
+              EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+            } else if (arrayIsArray(cfg.ADD_ATTR)) {
+              if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+                ALLOWED_ATTR = clone3(ALLOWED_ATTR);
+              }
+              addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+            }
+          }
+          if (objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") && arrayIsArray(cfg.ADD_URI_SAFE_ATTR)) {
+            addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+          }
+          if (objectHasOwnProperty(cfg, "FORBID_CONTENTS") && arrayIsArray(cfg.FORBID_CONTENTS)) {
+            if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+              FORBID_CONTENTS = clone3(FORBID_CONTENTS);
+            }
+            addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+          }
+          if (objectHasOwnProperty(cfg, "ADD_FORBID_CONTENTS") && arrayIsArray(cfg.ADD_FORBID_CONTENTS)) {
+            if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+              FORBID_CONTENTS = clone3(FORBID_CONTENTS);
+            }
+            addToSet(FORBID_CONTENTS, cfg.ADD_FORBID_CONTENTS, transformCaseFunc);
+          }
+          if (KEEP_CONTENT) {
+            ALLOWED_TAGS["#text"] = true;
+          }
+          if (WHOLE_DOCUMENT) {
+            addToSet(ALLOWED_TAGS, ["html", "head", "body"]);
+          }
+          if (ALLOWED_TAGS.table) {
+            addToSet(ALLOWED_TAGS, ["tbody"]);
+            delete FORBID_TAGS.tbody;
+          }
+          if (cfg.TRUSTED_TYPES_POLICY) {
+            if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== "function") {
+              throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+            }
+            if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== "function") {
+              throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+            }
+            trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+            emptyHTML = trustedTypesPolicy.createHTML("");
+          } else {
+            if (trustedTypesPolicy === void 0) {
+              trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+            }
+            if (trustedTypesPolicy !== null && typeof emptyHTML === "string") {
+              emptyHTML = trustedTypesPolicy.createHTML("");
+            }
+          }
+          if (freeze) {
+            freeze(cfg);
+          }
+          CONFIG = cfg;
+        };
+        const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+        const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+        const _checkValidNamespace = function _checkValidNamespace2(element) {
+          let parent3 = getParentNode(element);
+          if (!parent3 || !parent3.tagName) {
+            parent3 = {
+              namespaceURI: NAMESPACE,
+              tagName: "template"
+            };
+          }
+          const tagName = stringToLowerCase(element.tagName);
+          const parentTagName = stringToLowerCase(parent3.tagName);
+          if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+            return false;
+          }
+          if (element.namespaceURI === SVG_NAMESPACE) {
+            if (parent3.namespaceURI === HTML_NAMESPACE) {
+              return tagName === "svg";
+            }
+            if (parent3.namespaceURI === MATHML_NAMESPACE) {
+              return tagName === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+            }
+            return Boolean(ALL_SVG_TAGS[tagName]);
+          }
+          if (element.namespaceURI === MATHML_NAMESPACE) {
+            if (parent3.namespaceURI === HTML_NAMESPACE) {
+              return tagName === "math";
+            }
+            if (parent3.namespaceURI === SVG_NAMESPACE) {
+              return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+            }
+            return Boolean(ALL_MATHML_TAGS[tagName]);
+          }
+          if (element.namespaceURI === HTML_NAMESPACE) {
+            if (parent3.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+              return false;
+            }
+            if (parent3.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+              return false;
+            }
+            return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+          }
+          if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) {
+            return true;
+          }
+          return false;
+        };
+        const _forceRemove = function _forceRemove2(node) {
+          arrayPush(DOMPurify2.removed, {
+            element: node
+          });
+          try {
+            getParentNode(node).removeChild(node);
+          } catch (_) {
+            remove3(node);
+          }
+        };
+        const _removeAttribute = function _removeAttribute2(name, element) {
+          try {
+            arrayPush(DOMPurify2.removed, {
+              attribute: element.getAttributeNode(name),
+              from: element
+            });
+          } catch (_) {
+            arrayPush(DOMPurify2.removed, {
+              attribute: null,
+              from: element
+            });
+          }
+          element.removeAttribute(name);
+          if (name === "is") {
+            if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+              try {
+                _forceRemove(element);
+              } catch (_) {
+              }
+            } else {
+              try {
+                element.setAttribute(name, "");
+              } catch (_) {
+              }
+            }
+          }
+        };
+        const _initDocument = function _initDocument2(dirty) {
+          let doc2 = null;
+          let leadingWhitespace = null;
+          if (FORCE_BODY) {
+            dirty = "<remove></remove>" + dirty;
+          } else {
+            const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+            leadingWhitespace = matches && matches[0];
+          }
+          if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && NAMESPACE === HTML_NAMESPACE) {
+            dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + "</body></html>";
+          }
+          const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+          if (NAMESPACE === HTML_NAMESPACE) {
+            try {
+              doc2 = new DOMParser2().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+            } catch (_) {
+            }
+          }
+          if (!doc2 || !doc2.documentElement) {
+            doc2 = implementation.createDocument(NAMESPACE, "template", null);
+            try {
+              doc2.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+            } catch (_) {
+            }
+          }
+          const body = doc2.body || doc2.documentElement;
+          if (dirty && leadingWhitespace) {
+            body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+          }
+          if (NAMESPACE === HTML_NAMESPACE) {
+            return getElementsByTagName2.call(doc2, WHOLE_DOCUMENT ? "html" : "body")[0];
+          }
+          return WHOLE_DOCUMENT ? doc2.documentElement : body;
+        };
+        const _createNodeIterator = function _createNodeIterator2(root3) {
+          return createNodeIterator.call(
+            root3.ownerDocument || root3,
+            root3,
+            // eslint-disable-next-line no-bitwise
+            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION,
+            null
+          );
+        };
+        const _isClobbered = function _isClobbered2(element) {
+          return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+        };
+        const _isNode = function _isNode2(value) {
+          return typeof Node5 === "function" && value instanceof Node5;
+        };
+        function _executeHooks(hooks2, currentNode, data4) {
+          arrayForEach(hooks2, (hook) => {
+            hook.call(DOMPurify2, currentNode, data4, CONFIG);
+          });
+        }
+        const _sanitizeElements = function _sanitizeElements2(currentNode) {
+          let content = null;
+          _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+          if (_isClobbered(currentNode)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          const tagName = transformCaseFunc(currentNode.nodeName);
+          _executeHooks(hooks.uponSanitizeElement, currentNode, {
+            tagName,
+            allowedTags: ALLOWED_TAGS
+          });
+          if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && tagName === "style" && _isNode(currentNode.firstElementChild)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
+            if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+              if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+                return false;
+              }
+              if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+                return false;
+              }
+            }
+            if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+              const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+              const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+              if (childNodes && parentNode) {
+                const childCount = childNodes.length;
+                for (let i = childCount - 1; i >= 0; --i) {
+                  const childClone = cloneNode2(childNodes[i], true);
+                  parentNode.insertBefore(childClone, getNextSibling(currentNode));
+                }
+              }
+            }
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (currentNode instanceof Element2 && !_checkValidNamespace(currentNode)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+            _forceRemove(currentNode);
+            return true;
+          }
+          if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+            content = currentNode.textContent;
+            arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+              content = stringReplace(content, expr, " ");
+            });
+            if (currentNode.textContent !== content) {
+              arrayPush(DOMPurify2.removed, {
+                element: currentNode.cloneNode()
+              });
+              currentNode.textContent = content;
+            }
+          }
+          _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+          return false;
+        };
+        const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+          if (FORBID_ATTR[lcName]) {
+            return false;
+          }
+          if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
+            return false;
+          }
+          if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName)) ;
+          else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR2, lcName)) ;
+          else if (EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag)) ;
+          else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+            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
+              _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName, lcTag)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+              // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+              lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))
+            ) ;
+            else {
+              return false;
+            }
+          } else if (URI_SAFE_ATTRIBUTES[lcName]) ;
+          else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+          else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) ;
+          else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA2, stringReplace(value, ATTR_WHITESPACE2, ""))) ;
+          else if (value) {
+            return false;
+          } else ;
+          return true;
+        };
+        const RESERVED_CUSTOM_ELEMENT_NAMES = addToSet({}, ["annotation-xml", "color-profile", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "missing-glyph"]);
+        const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+          return !RESERVED_CUSTOM_ELEMENT_NAMES[stringToLowerCase(tagName)] && regExpTest(CUSTOM_ELEMENT2, tagName);
+        };
+        const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+          _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+          const {
+            attributes: attributes2
+          } = currentNode;
+          if (!attributes2 || _isClobbered(currentNode)) {
+            return;
+          }
+          const hookEvent = {
+            attrName: "",
+            attrValue: "",
+            keepAttr: true,
+            allowedAttributes: ALLOWED_ATTR,
+            forceKeepAttr: void 0
+          };
+          let l = attributes2.length;
+          while (l--) {
+            const attr3 = attributes2[l];
+            const {
+              name,
+              namespaceURI,
+              value: attrValue
+            } = attr3;
+            const lcName = transformCaseFunc(name);
+            const initValue = attrValue;
+            let value = name === "value" ? initValue : stringTrim(initValue);
+            hookEvent.attrName = lcName;
+            hookEvent.attrValue = value;
+            hookEvent.keepAttr = true;
+            hookEvent.forceKeepAttr = void 0;
+            _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+            value = hookEvent.attrValue;
+            if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name") && stringIndexOf(value, SANITIZE_NAMED_PROPS_PREFIX) !== 0) {
+              _removeAttribute(name, currentNode);
+              value = SANITIZE_NAMED_PROPS_PREFIX + value;
+            }
+            if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (lcName === "attributename" && stringMatch(value, "href")) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (hookEvent.forceKeepAttr) {
+              continue;
+            }
+            if (!hookEvent.keepAttr) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (SAFE_FOR_TEMPLATES) {
+              arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+                value = stringReplace(value, expr, " ");
+              });
+            }
+            const lcTag = transformCaseFunc(currentNode.nodeName);
+            if (!_isValidAttribute(lcTag, lcName, value)) {
+              _removeAttribute(name, currentNode);
+              continue;
+            }
+            if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function") {
+              if (namespaceURI) ;
+              else {
+                switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+                  case "TrustedHTML": {
+                    value = trustedTypesPolicy.createHTML(value);
+                    break;
+                  }
+                  case "TrustedScriptURL": {
+                    value = trustedTypesPolicy.createScriptURL(value);
+                    break;
+                  }
+                }
+              }
+            }
+            if (value !== initValue) {
+              try {
+                if (namespaceURI) {
+                  currentNode.setAttributeNS(namespaceURI, name, value);
+                } else {
+                  currentNode.setAttribute(name, value);
+                }
+                if (_isClobbered(currentNode)) {
+                  _forceRemove(currentNode);
+                } else {
+                  arrayPop(DOMPurify2.removed);
+                }
+              } catch (_) {
+                _removeAttribute(name, currentNode);
+              }
+            }
+          }
+          _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+        };
+        const _sanitizeShadowDOM2 = function _sanitizeShadowDOM(fragment) {
+          let shadowNode = null;
+          const shadowIterator = _createNodeIterator(fragment);
+          _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+          while (shadowNode = shadowIterator.nextNode()) {
+            _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+            _sanitizeElements(shadowNode);
+            _sanitizeAttributes(shadowNode);
+            if (shadowNode.content instanceof DocumentFragment) {
+              _sanitizeShadowDOM2(shadowNode.content);
+            }
+          }
+          _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+        };
+        DOMPurify2.sanitize = function(dirty) {
+          let cfg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          let body = null;
+          let importedNode = null;
+          let currentNode = null;
+          let returnNode = null;
+          IS_EMPTY_INPUT = !dirty;
+          if (IS_EMPTY_INPUT) {
+            dirty = "<!-->";
+          }
+          if (typeof dirty !== "string" && !_isNode(dirty)) {
+            dirty = stringifyValue(dirty);
+            if (typeof dirty !== "string") {
+              throw typeErrorCreate("dirty is not a string, aborting");
+            }
+          }
+          if (!DOMPurify2.isSupported) {
+            return dirty;
+          }
+          if (!SET_CONFIG) {
+            _parseConfig(cfg);
+          }
+          DOMPurify2.removed = [];
+          if (typeof dirty === "string") {
+            IN_PLACE = false;
+          }
+          if (IN_PLACE) {
+            const nn = dirty.nodeName;
+            if (typeof nn === "string") {
+              const tagName = transformCaseFunc(nn);
+              if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+                throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+              }
+            }
+          } else if (dirty instanceof Node5) {
+            body = _initDocument("<!---->");
+            importedNode = body.ownerDocument.importNode(dirty, true);
+            if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === "BODY") {
+              body = importedNode;
+            } else if (importedNode.nodeName === "HTML") {
+              body = importedNode;
+            } else {
+              body.appendChild(importedNode);
+            }
+          } else {
+            if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && // eslint-disable-next-line unicorn/prefer-includes
+            dirty.indexOf("<") === -1) {
+              return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+            }
+            body = _initDocument(dirty);
+            if (!body) {
+              return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+            }
+          }
+          if (body && FORCE_BODY) {
+            _forceRemove(body.firstChild);
+          }
+          const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+          while (currentNode = nodeIterator.nextNode()) {
+            _sanitizeElements(currentNode);
+            _sanitizeAttributes(currentNode);
+            if (currentNode.content instanceof DocumentFragment) {
+              _sanitizeShadowDOM2(currentNode.content);
+            }
+          }
+          if (IN_PLACE) {
+            return dirty;
+          }
+          if (RETURN_DOM) {
+            if (SAFE_FOR_TEMPLATES) {
+              body.normalize();
+              let html6 = body.innerHTML;
+              arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+                html6 = stringReplace(html6, expr, " ");
+              });
+              body.innerHTML = html6;
+            }
+            if (RETURN_DOM_FRAGMENT) {
+              returnNode = createDocumentFragment.call(body.ownerDocument);
+              while (body.firstChild) {
+                returnNode.appendChild(body.firstChild);
+              }
+            } else {
+              returnNode = body;
+            }
+            if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+              returnNode = importNode.call(originalDocument, returnNode, true);
+            }
+            return returnNode;
+          }
+          let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+          if (WHOLE_DOCUMENT && ALLOWED_TAGS["!doctype"] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+            serializedHTML = "<!DOCTYPE " + body.ownerDocument.doctype.name + ">\n" + serializedHTML;
+          }
+          if (SAFE_FOR_TEMPLATES) {
+            arrayForEach([MUSTACHE_EXPR2, ERB_EXPR2, TMPLIT_EXPR2], (expr) => {
+              serializedHTML = stringReplace(serializedHTML, expr, " ");
+            });
+          }
+          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+        };
+        DOMPurify2.setConfig = function() {
+          let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          _parseConfig(cfg);
+          SET_CONFIG = true;
+        };
+        DOMPurify2.clearConfig = function() {
+          CONFIG = null;
+          SET_CONFIG = false;
+        };
+        DOMPurify2.isValidAttribute = function(tag, attr3, value) {
+          if (!CONFIG) {
+            _parseConfig({});
+          }
+          const lcTag = transformCaseFunc(tag);
+          const lcName = transformCaseFunc(attr3);
+          return _isValidAttribute(lcTag, lcName, value);
+        };
+        DOMPurify2.addHook = function(entryPoint, hookFunction) {
+          if (typeof hookFunction !== "function") {
+            return;
+          }
+          arrayPush(hooks[entryPoint], hookFunction);
+        };
+        DOMPurify2.removeHook = function(entryPoint, hookFunction) {
+          if (hookFunction !== void 0) {
+            const index3 = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+            return index3 === -1 ? void 0 : arraySplice(hooks[entryPoint], index3, 1)[0];
+          }
+          return arrayPop(hooks[entryPoint]);
+        };
+        DOMPurify2.removeHooks = function(entryPoint) {
+          hooks[entryPoint] = [];
+        };
+        DOMPurify2.removeAllHooks = function() {
+          hooks = _createHooksMap();
+        };
+        return DOMPurify2;
+      }
+      var purify = createDOMPurify();
+      module.exports = purify;
+    }
+  });
+
   // node_modules/markdown-it-for-inline/dist/index.cjs.js
   var require_index_cjs = __commonJS({
     "node_modules/markdown-it-for-inline/dist/index.cjs.js"(exports, module) {
@@ -96393,6 +97479,18 @@
         reqId: msg.reqId
       };
     }
+    if (msg.type === "response" && isFinalMessage(msg)) {
+      const lastRequestWithoutResIdIndex = (0, import_lodash.findLastIndex)(messages, (m) => m.type === "response" && m?.ctx?.resId === msg?.ctx?.resId);
+      if (lastRequestWithoutResIdIndex > -1) {
+        messages[lastRequestWithoutResIdIndex] = {
+          ...messages[lastRequestWithoutResIdIndex],
+          ctx: {
+            ...messages[lastRequestWithoutResIdIndex].ctx,
+            tsFinal: msg?.ctx?.tsFinal
+          }
+        };
+      }
+    }
     if (isNew) {
       messages.push({ ...msg });
       return {
@@ -96526,7 +97624,6 @@
       }
     }
     const rawHtml = bubbleToCopy.outerHTML;
-    console.info("CSS for copy:", rawHtml);
     let css3 = document.querySelector("style").innerHTML;
     css3 += `
      table {
@@ -97477,6 +98574,8 @@
     const requestBubbleLabelEnabled = uiState7?.textChat?.options?.bubbles?.request?.label?.enabled === true;
     const requestBubbleTimestampFontSize = getNumPropVal(textChatOptions?.bubbles?.request?.timestamp?.fontSize, 12);
     const requestBubbleTimestampPaddingLeft = getNumPropVal(textChatOptions?.bubbles?.request?.timestamp?.padding?.left, 5);
+    const requestBubbleTimestampColor = textChatOptions?.bubbles?.request?.timestamp?.color || `#999999`;
+    const requestBubbleTimestampEnabled = uiState7?.textChat?.options?.bubbles?.request?.timestamp?.enabled === true;
     const responseBubbleLabelTopPadding = getNumPropVal(textChatOptions?.bubbles?.response?.label?.padding?.top, 0);
     const responseBubbleLabelRightPadding = getNumPropVal(textChatOptions?.bubbles?.response?.label?.padding?.right, 0);
     const responseBubbleLabelBottomPadding = getNumPropVal(textChatOptions?.bubbles?.response?.label?.padding?.bottom, 4);
@@ -97486,6 +98585,8 @@
     const responseBubbleLabelEnabled = uiState7?.textChat?.options?.bubbles?.response?.label?.enabled === true;
     const responseBubbleTimestampFontSize = getNumPropVal(textChatOptions?.bubbles?.response?.timestamp?.fontSize, 12);
     const responseBubbleTimestampPaddingLeft = getNumPropVal(textChatOptions?.bubbles?.response?.timestamp?.padding?.left, 5);
+    const responseBubbleTimestampColor = textChatOptions?.bubbles?.response?.timestamp?.color || `#999999`;
+    const responseBubbleTimestampEnabled = uiState7?.textChat?.options?.bubbles?.response?.timestamp?.enabled === true;
     const btnAlignment = textChatOptions?.buttons?.alignment?.default || "right";
     const btnAlignmentFullscreen = textChatOptions?.buttons?.alignment?.fullScreen || "right";
     const textChatAppearAnimationMs = uiState7.textChat.defaults.appearAnimationMs;
@@ -98537,6 +99638,8 @@
     keyFrames += getStyleSheetMarker() + `.alan-btn__chat-request-timestamp-text {
         padding-left: ${requestBubbleTimestampPaddingLeft}px;
         font-size: ${requestBubbleTimestampFontSize}px;
+        color: ${requestBubbleTimestampColor};
+        display: ${requestBubbleTimestampEnabled ? "block" : "none"};
     }`;
     keyFrames += getStyleSheetMarker() + `.alan-btn_text-chat-full-screen .alan-btn__chat-request-label {
         text-align: left;
@@ -98620,6 +99723,8 @@
     keyFrames += getStyleSheetMarker() + `.alan-btn__chat-response-timestamp-text {
         padding-left: ${responseBubbleTimestampPaddingLeft}px;
         font-size: ${responseBubbleTimestampFontSize}px;
+        color: ${responseBubbleTimestampColor};
+        display: ${responseBubbleTimestampEnabled ? "block" : "none"};
     }`;
     keyFrames += getStyleSheetMarker() + `.alan-btn_text-chat-full-screen .alan-btn__chat-response-label {
         text-align: left;
@@ -99852,6 +100957,149 @@
     "\\exp"
   ];
 
+  // alan_btn/src/textChat/sanitization.ts
+  var DOMPurify = require_purify_cjs();
+  function sanitizeHtml(html5) {
+    if (!html5) return "";
+    return DOMPurify.sanitize(html5);
+  }
+  function encodeHtmlEntity(text5) {
+    if (!text5) return "";
+    const div = document.createElement("div");
+    div.textContent = text5;
+    return div.innerHTML;
+  }
+  function encodeHtmlAttribute(text5) {
+    if (!text5) return "";
+    return text5.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  function encodeUrl(url, allowDataUri = true) {
+    if (!url) return "";
+    const trimmed = url.trim().toLowerCase();
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("mailto:") || trimmed.startsWith("tel:")) {
+      return encodeURI(url);
+    }
+    if (allowDataUri && trimmed.startsWith("data:image/")) {
+      return url;
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("#") || trimmed.startsWith(".")) {
+      return encodeURI(url);
+    }
+    return "";
+  }
+  var CHAT_ALLOWED_TAGS = [
+    "iframe",
+    "details",
+    "summary",
+    "img",
+    "a",
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "th",
+    "td",
+    "caption",
+    "colgroup",
+    "col",
+    "code",
+    "pre",
+    "blockquote",
+    "p",
+    "br",
+    "hr",
+    "ul",
+    "ol",
+    "li",
+    "dl",
+    "dt",
+    "dd",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "strong",
+    "em",
+    "b",
+    "i",
+    "u",
+    "s",
+    "del",
+    "ins",
+    "mark",
+    "span",
+    "div",
+    "section",
+    "article",
+    "header",
+    "footer",
+    "sup",
+    "sub",
+    "small",
+    "abbr",
+    "cite",
+    "q",
+    "figure",
+    "figcaption"
+  ];
+  var CHAT_ALLOWED_ATTR = [
+    "href",
+    "src",
+    "alt",
+    "title",
+    "class",
+    "id",
+    "target",
+    "rel",
+    "loading",
+    "decoding",
+    "width",
+    "height",
+    "frameborder",
+    "scrolling",
+    "allowfullscreen",
+    "allow",
+    "sandbox",
+    "referrerpolicy",
+    "open",
+    "colspan",
+    "rowspan",
+    "scope",
+    "headers",
+    "data-*"
+  ];
+  var _chatHooksRegistered = false;
+  function registerChatHooks() {
+    if (_chatHooksRegistered) return;
+    _chatHooksRegistered = true;
+    DOMPurify.addHook("afterSanitizeAttributes", (node) => {
+      if (node.tagName === "IFRAME") {
+        if (!node.hasAttribute("sandbox")) {
+          node.setAttribute("sandbox", "allow-scripts allow-same-origin allow-popups");
+        }
+        node.setAttribute("referrerpolicy", "no-referrer");
+      }
+      if (node.tagName === "A") {
+        node.setAttribute("rel", "noopener noreferrer");
+        const href = node.getAttribute("href") || "";
+        if (/^javascript:/i.test(href.trim())) {
+          node.removeAttribute("href");
+        }
+      }
+    });
+  }
+  function sanitizeMarkdownHtml(html5) {
+    if (!html5) return "";
+    registerChatHooks();
+    const cleanedHtml = html5.replace(/<iframe([^>]*)>[\s\S]*?<\/iframe>/gi, "<iframe$1></iframe>");
+    return DOMPurify.sanitize(cleanedHtml, {
+      ADD_TAGS: CHAT_ALLOWED_TAGS,
+      ADD_ATTR: CHAT_ALLOWED_ATTR
+    });
+  }
+
   // alan_btn/src/textChat/alanMarkdown.ts
   var iterator = require_index_cjs();
   var markdownItScrollTable = require_markdown_it_scrolltable();
@@ -99870,15 +101118,15 @@
     "YES": '<span class="alan-special-markdown-tag-hl-green">YES</span></div>',
     "NO": '<span class="alan-special-markdown-tag-hl-red">NO</span></div>'
   };
-  function alanMarkdown(str = "") {
+  function alanMarkdown(str = "", options = { html: true, breaks: true }) {
     const source = str || "";
     const sanitizedInput = sanitizeCustomTags(source);
-    var md = require_index_cjs5()({ html: true, breaks: true }).use(require_index_cjs6()).use(markdownItScrollTable).use(iterator, "url_new_win", "link_open", function(tokens, idx) {
+    var md = require_index_cjs5()(options).use(require_index_cjs6()).use(markdownItScrollTable).use(iterator, "url_new_win", "link_open", function(tokens, idx) {
       tokens[idx].attrSet("target", "_blank");
     });
     const rendered = md.render(sanitizedInput);
     const upgraded = wrapPotentialMathDelimiters(rendered);
-    return sanitize(upgraded);
+    return sanitizeMarkdownHtml(upgraded);
   }
   function sanitizeCustomTags(str) {
     let result = str;
@@ -99888,38 +101136,6 @@
     }
     return result;
   }
-  function sanitize(str) {
-    let tag = "";
-    let result = "";
-    let i = 0;
-    while (i < str.length) {
-      if (str[i] === "<") {
-        if (str.substring(i, i + 4) === "&lt;") {
-          result += str[i];
-          i++;
-          continue;
-        }
-        tag = "";
-        while (i < str.length) {
-          tag += str[i];
-          i++;
-          if (str[i - 1] === ">" || i >= str.length) {
-            break;
-          }
-          if (str[i] === " ") {
-            tag += str[i];
-            i++;
-            break;
-          }
-        }
-        result += tag;
-      } else {
-        result += str[i];
-        i++;
-      }
-    }
-    return result;
-  }
 
   // alan_btn/src/textChat/helpers/getLinkIcon.ts
   function getLinkIcon(link) {
@@ -99950,9 +101166,12 @@
     for (let i = 0; i < links?.length; i++) {
       const curLink = links[i];
       const target = getLinkTarget(curLink);
-      linksHtml += `<a class="alan-btn__chat-response-link" href="${curLink.href}" target="${target}">
+      const sanitizedHref = encodeUrl(curLink.href);
+      const sanitizedTitle = encodeHtmlEntity(curLink.title || curLink.href);
+      const rel = target === "_blank" ? ' rel="noopener noreferrer"' : "";
+      linksHtml += `<a class="alan-btn__chat-response-link" href="${sanitizedHref}" target="${target}"${rel}>
             <span class="alan-btn__chat-response-link-icon-wrapper">${getLinkIcon(curLink)}</span>
-            <span class="alan-btn__chat-response-link-title">${curLink.title || curLink.href}</span>
+            <span class="alan-btn__chat-response-link-title">${sanitizedTitle}</span>
         </a>`;
     }
     if (links?.length) {
@@ -100983,10 +102202,10 @@ code.hljs {
   function renderButtons(buttons) {
     return `<div class="alan-btn__chat-buttons">
      ${buttons?.map((button) => {
-      const btnLabel = button.label || "";
+      const btnLabel = encodeHtmlAttribute(button.label || "");
       let resultBtn = `<div class="alan-chat__chat-btn" data-alan-button-label="${btnLabel}"`;
       if (button.sendText) {
-        resultBtn += ` data-alan-button-send-text="${button.sendText}" `;
+        resultBtn += ` data-alan-button-send-text="${encodeHtmlAttribute(button.sendText)}" `;
       }
       if (button.callProjectApi?.method) {
         resultBtn += ` data-alan-button-call-project-api="${button.callProjectApi?.method}" `;
@@ -100997,7 +102216,7 @@ code.hljs {
       if (button.setVisualState) {
         resultBtn += ` data-alan-button-set-visual-state="${encodeValueForHtmlAttr(button.setVisualState)}" `;
       }
-      resultBtn += ` >${button.html || button.label}</div>`;
+      resultBtn += ` >${sanitizeHtml(button.html || button.label || "")}</div>`;
       return resultBtn;
     }).join("") || ""}</div>`;
   }
@@ -101181,13 +102400,13 @@ code.hljs {
       }, IFRAME_CONTENT_TIMEOUT_MS);
     });
   }
-  function replaceIframesWithSrcDoc(page, iframeContents) {
+  function replaceIframesWithSrcDoc(page, iframeContents, visibilityMap) {
     const contentMap = new Map(iframeContents.map((item) => [item.id, item.html]));
     const iframes = page.querySelectorAll("iframe.act-embed");
     iframes.forEach((iframe) => {
       const iframeId = iframe.id;
       const html5 = contentMap.get(iframeId);
-      if (html5) {
+      if (html5 && visibilityMap.get(iframeId)) {
         iframe.removeAttribute("src");
         iframe.setAttribute("srcdoc", html5);
       }
@@ -101197,16 +102416,24 @@ code.hljs {
     const rect = element.getBoundingClientRect();
     const viewportHeight = window.innerHeight || document.documentElement.clientHeight;
     const viewportWidth = window.innerWidth || document.documentElement.clientWidth;
-    return rect.top < viewportHeight && rect.bottom > 0 && rect.left < viewportWidth && rect.right > 0;
-  }
-  function markIframeVisibility(page) {
-    const liveIframes = Array.from(document.querySelectorAll("iframe"));
-    const visibilityMap = /* @__PURE__ */ new Map();
-    liveIframes.forEach((iframe) => {
-      if (iframe.id) {
-        visibilityMap.set(iframe.id, isElementVisibleInViewport(iframe));
+    if (rect.bottom <= 0 || rect.top >= viewportHeight || rect.right <= 0 || rect.left >= viewportWidth) {
+      return false;
+    }
+    let parent3 = element.parentElement;
+    while (parent3) {
+      const style = window.getComputedStyle(parent3);
+      const overflow = style.overflow + style.overflowX + style.overflowY;
+      if (/(auto|scroll|hidden)/.test(overflow)) {
+        const parentRect = parent3.getBoundingClientRect();
+        if (rect.bottom <= parentRect.top || rect.top >= parentRect.bottom || rect.right <= parentRect.left || rect.left >= parentRect.right) {
+          return false;
+        }
       }
-    });
+      parent3 = parent3.parentElement;
+    }
+    return true;
+  }
+  function markIframeVisibility(page, visibilityMap) {
     const pageIframes = page.querySelectorAll("iframe");
     pageIframes.forEach((iframe) => {
       const isVisible = visibilityMap.get(iframe.id) || false;
@@ -101299,10 +102526,17 @@ code.hljs {
       }
       const pageContent = page.outerHTML;
       const iframeContents = await collectIframeContent();
+      const liveIframes = Array.from(document.querySelectorAll("iframe"));
+      const visibilityMap = /* @__PURE__ */ new Map();
+      liveIframes.forEach((iframe) => {
+        if (iframe.id) {
+          visibilityMap.set(iframe.id, isElementVisibleInViewport(iframe));
+        }
+      });
       if (iframeContents.length > 0) {
-        replaceIframesWithSrcDoc(page, iframeContents);
+        replaceIframesWithSrcDoc(page, iframeContents, visibilityMap);
       }
-      markIframeVisibility(page);
+      markIframeVisibility(page, visibilityMap);
       if (onSendCb) {
         onSendCb();
       }
@@ -101331,7 +102565,7 @@ code.hljs {
       }
       if (uiState10.pageState?.screenshot?.enabled) {
         params.screenshot_data = {
-          baseHref: window.location.origin,
+          baseHref: document.baseURI,
           width: window.innerWidth,
           height: window.innerHeight,
           scrollStates: collectScrollableElementStates()
@@ -108380,7 +109614,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
                 .replace(/'/g, "&#039;");
         }
         
-        var logs = ${JSON.stringify(outputPhrases)};
+        var logs = ${escapeJsonForScriptTag(JSON.stringify(outputPhrases))};
         
         logs = logs.map(el => ({
             ...el,
@@ -108594,7 +109828,8 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
             var codePart;
 
             if (typeof detailsData.value === 'object' && detailsData.value !== null) {
-                codePart = JSON.stringify(detailsData.value, null, 2);
+                // HTML-encode JSON output to prevent XSS when inserted via innerHTML
+                codePart = escapeHtml(JSON.stringify(detailsData.value, null, 2));
             } else {
                 if (detailsData.type === 'javascript') {
                     codePart = prepareJavascriptCode(detailsData.value);
@@ -108717,8 +109952,11 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
         };
     <\/script>
         `;
-    const txtMessages = data4?.textChatMessages ? JSON.stringify(data4?.textChatMessages, null, 2) : '"no-provided"';
-    const socketMessages = data4?.socketMessages ? JSON.stringify(data4?.socketMessages, null, 2) : '"no-provided"';
+    function escapeJsonForScriptTag(json) {
+      return json.replace(/<\//g, "<\\/").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+    }
+    const txtMessages = data4?.textChatMessages ? escapeJsonForScriptTag(JSON.stringify(data4?.textChatMessages, null, 2)) : '"no-provided"';
+    const socketMessages = data4?.socketMessages ? escapeJsonForScriptTag(JSON.stringify(data4?.socketMessages, null, 2)) : '"no-provided"';
     let inlinedLibraries = "";
     try {
       inlinedLibraries = getInlineLibrariesHtml();
@@ -108731,7 +109969,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
     <html lang="en">
     <head>
         <meta charset="UTF-8">
-        <title>${chatName} Chat History</title>
+        <title>${encodeHtmlEntity(chatName)} Chat History</title>
         ${inlinedLibraries}
         ${headContent ? headContent : ""}
 
@@ -108947,7 +110185,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
     </head>
     <body class="alan-btn__history-body">
     <script>
-    var imgData = ${JSON.stringify(imgData)};
+    var imgData = ${escapeJsonForScriptTag(JSON.stringify(imgData))};
     
     document.addEventListener('click', (e) => {
         const clickedEl = e.target;
@@ -109032,7 +110270,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
 
         <div class="alan-history-content ${alanMainClass}">
             <div class="alan-btn__history-chat-header">
-                <h1>${chatName} Chat History</h1>
+                <h1>${encodeHtmlEntity(chatName)} Chat History</h1>
             </div>
             <div class="alan-btn__history-chat alan-history-inner-content">
                 ${chatConteiner.outerHTML}
@@ -109454,16 +110692,17 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
     return `<div class="alan-btn__chat-suggestions">
      ${suggestions?.map((suggestion) => {
       const { textToAsk, label } = getSuggestionMetadata(suggestion);
-      return `<div class="alan-chat__suggestion" data-alan-button-send-text="${textToAsk}">${label}</div>`;
+      const sanitizedTextToAsk = encodeHtmlAttribute(textToAsk);
+      return `<div class="alan-chat__suggestion" data-alan-button-send-text="${sanitizedTextToAsk}">${label}</div>`;
     }).join("") || ""}</div>`;
   }
   function getSuggestionMetadata(suggestion) {
     const { text: text5, markdown } = suggestion;
     let label = "";
     if (markdown) {
-      label = alanMarkdown(markdown || "");
+      label = sanitizeHtml(alanMarkdown(markdown || ""));
     } else {
-      label = text5 || "";
+      label = encodeHtmlEntity(text5 || "");
     }
     const textToAsk = (text5 || label?.replace(/<\/?[^>]+(>|$)/g, "")).replace(/\n/g, " ").trim();
     return {
@@ -109539,18 +110778,13 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
 
   // alan_btn/src/textChat/helpers/getMessageTimestamp.ts
   var dayjs = require_dayjs_min();
-  function getTimestampFromReqId(reqId) {
-    if (!reqId) return null;
-    const ts = Number(reqId.split("/")[0]);
-    return ts || null;
-  }
   var DEFAULT_FORMAT = {
-    today: "[Today], HH:mm:ss",
-    yesterday: "[Yesterday], HH:mm:ss",
-    other: "MMM DD, YYYY, HH:mm:ss"
+    today: "[Today], h:mm:ss A",
+    yesterday: "[Yesterday], h:mm:ss A",
+    other: "MMM DD, YYYY, h:mm:ss A"
   };
   function getMessageTimestamp(msg, timestampFormat) {
-    const tsMs = (msg?.type === "request" ? getTimestampFromReqId(msg?.reqId) : null) ?? msg?.ctx?.ts0 ?? msg?.ts;
+    const tsMs = msg?.type === "request" ? msg?.tsInit : msg?.ctx?.tsResponseStart || msg?.ctx?.tsFinal;
     if (!tsMs) return "";
     const fmt = { ...DEFAULT_FORMAT, ...timestampFormat };
     const msgDate = dayjs(tsMs);
@@ -109565,7 +110799,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
   // alan_btn/alan_btn.ts
   (function(ns) {
     const uiState10 = getUIState();
-    const version2 = "alan-version.1.8.119".replace("alan-version.", "");
+    const version2 = "alan-version.1.8.121".replace("alan-version.", "");
     uiState10.lib.version = version2;
     window.alanLib = { version: version2 };
     if (window.alanBtn) {
@@ -111108,10 +112342,10 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
         if (!popupOptions.html) {
           if (message) {
             popup.classList.add("alan-btn-lib__default-popup");
-            popup.innerHTML = '<div class="alan-overlay-popup__body">' + message + "</div>";
+            popup.innerHTML = '<div class="alan-overlay-popup__body">' + sanitizeHtml(message) + "</div>";
           }
         } else {
-          popup.innerHTML = popupOptions.html;
+          popup.innerHTML = sanitizeHtml(popupOptions.html);
         }
         var closeIconImg = document.createElement("div");
         closeIconImg.id = "alan-overlay-ok-btn";
@@ -111208,7 +112442,7 @@ var hljs=function(){"use strict";function e(n){return n instanceof Map?n.clear=n
             if (recognisedText.length > 200) {
               recognisedText = recognisedText.substr(0, 200);
             }
-            recognisedTextContent.innerHTML = recognisedText;
+            recognisedTextContent.textContent = recognisedText;
           }
           if (recognisedTextHolder.classList.contains("alan-btn-lib__absolute-positioned")) {
             if (recognisedText.length < 33) {
@@ -111543,7 +112777,7 @@ ${curDialogId}`);
         btn.style.zIndex = maxZIndex.toString();
         overlay.style.zIndex = (maxZIndex - 3).toString();
         alertPopup.style.zIndex = (maxZIndex - 2).toString();
-        alertPopup.innerHTML = msg;
+        alertPopup.innerHTML = sanitizeHtml(msg);
         var closeIconImg = document.createElement("div");
         closeIconImg.id = "alan-alert-popup-close-btn";
         closeIconImg.classList.add("alan-alert-popup__close-btn");
@@ -112045,7 +113279,7 @@ ${curDialogId}`);
         } else {
           result = escapeHtml(msg.text);
         }
-        const wrapContentForRerender = getMessageParser(msg);
+        const wrapContentForRerender = createWrapContentForRerender();
         result = wrapContentForRerender(result).map((el) => {
           return el.type === "text" ? `<span>${el.value}</span>` : el.value;
         }).join("");
@@ -112157,10 +113391,8 @@ ${curDialogId}`);
           const isResponse = msg.type === "response";
           const requestLabel = uiState10?.textChat?.options?.bubbles?.request?.label?.text ?? "Me";
           const responseLabel = uiState10?.textChat?.options?.bubbles?.response?.label?.text ?? "Alan";
-          const requestTsEnabled = uiState10?.textChat?.options?.bubbles?.request?.timestamp?.enabled ?? false;
-          const responseTsEnabled = uiState10?.textChat?.options?.bubbles?.response?.timestamp?.enabled ?? false;
-          const requestTs = requestTsEnabled ? getMessageTimestamp(msg, options?.textChat?.timestampFormat) : "";
-          const responseTs = responseTsEnabled ? getMessageTimestamp(msg, options?.textChat?.timestampFormat) : "";
+          const requestTs = getMessageTimestamp(msg, options?.textChat?.timestampFormat);
+          const responseTs = getMessageTimestamp(msg, options?.textChat?.timestampFormat);
           const msgLabel = `<div class="alan-btn__chat-${msg.type}-label">
                 ${isResponse ? `<span class="alan-btn__chat-${msg.type}-label-icon"></span>` : ""}
                 <span class="alan-btn__chat-${msg.type}-label-and-ts-holder">
@@ -112225,11 +113457,11 @@ ${curDialogId}`);
         } else if (msg.type === "connection-separator") {
           msgHtml = `<div class="alan-btn__chat-connection-separator"></div>`;
         } else if (msg.type === "chat") {
-          msgHtml = `<div class="alan-btn__chat-popup">${msg.html}</div>`;
+          msgHtml = `<div class="alan-btn__chat-popup">${sanitizeHtml(msg.html)}</div>`;
         } else {
           if (msg.name === "text" || msg.name === "parsed" || msg.name === "recognized") {
             if (msg.type === "request") {
-              innerMsgPart = alanMarkdown(escapeHtml(msg.text) || "");
+              innerMsgPart = alanMarkdown(msg.text || "", { html: false, breaks: true });
             } else {
               if (withDetailedStatuses && msg?.queryProgress?.length > 0) {
                 innerMsgPart = `${getMsgLoaderStatuses(uiState10.textChat.options, msg, true, true)} ${buildMsgContent(msg)}`;
@@ -112308,10 +113540,10 @@ ${curDialogId}`);
             highlightCode(document.getElementById("chatMessages"));
           }
         } else {
-          const msgEl = document.getElementById("msg-" + msgInd);
-          if (msgEl) {
+          const msgEl2 = document.getElementById("msg-" + msgInd);
+          if (msgEl2) {
             if (replaceLoader) {
-              const innerEl = msgEl.querySelector(".alan-btn__chat-inner-msg");
+              const innerEl = msgEl2.querySelector(".alan-btn__chat-inner-msg");
               if (innerEl) {
                 if (innerEl.classList.contains("alan-hidden-loader")) {
                   innerEl.classList.remove("alan-hidden-loader");
@@ -112330,9 +113562,9 @@ ${curDialogId}`);
                 }
                 innerEl.classList.remove("alan-incoming-msg");
                 innerEl.id = "";
-                const chatHolder = innerEl.closest(".alan-btn__chat-bubble-holder");
-                if (chatHolder) {
-                  chatHolder.insertAdjacentHTML("beforebegin", getMsgBubbleLabel(msg));
+                const bubbleHolder = innerEl.closest(".alan-btn__chat-bubble-holder");
+                if (bubbleHolder) {
+                  bubbleHolder.insertAdjacentHTML("beforebegin", getMsgBubbleLabel(msg));
                 }
                 if (msg.type === "response" && msg.images?.length > 0) {
                   innerEl.classList.add("with-images");
@@ -112346,7 +113578,7 @@ ${curDialogId}`);
                 scrollTextChat(msgsScrollableContainer, "smooth");
               }
             } else if (updateExistingResponse && msg.type !== "chat") {
-              let innerEl = msgEl.querySelector(".alan-btn__chat-inner-msg");
+              let innerEl = msgEl2.querySelector(".alan-btn__chat-inner-msg");
               if (innerEl) {
                 if (innerEl.classList.contains("alan-hidden-loader")) {
                   innerEl.classList.remove("alan-hidden-loader");
@@ -112362,6 +113594,13 @@ ${curDialogId}`);
                 if (updatedMsg.type !== "chat" && updatedMsg.images?.length > 0) {
                   innerEl.classList.add("with-images");
                 }
+                const msgHolder2 = innerEl.closest(".alan-btn__chat-msg-holder");
+                if (msgHolder2) {
+                  const labelHolderEl = msgHolder2.querySelector(".alan-btn__chat-response-label");
+                  if (labelHolderEl) {
+                    labelHolderEl.innerHTML = getMsgBubbleLabel(msg);
+                  }
+                }
                 const loaderWrapper = innerEl.querySelector(".alan-btn__chat-incomming-msg-main-wrapper");
                 if (loaderWrapper) {
                   if (isFinalMessage(updatedMsg)) {
@@ -112409,16 +113648,16 @@ ${curDialogId}`);
               }
             } else {
               if (msg.name === "loading" && msg.type === "response") {
-                const loaderContentEl = msgEl.querySelector(".alan-btn__chat-incomming-msg-wrapper");
-                const loaderStatusContentEl = msgEl.querySelector(".alan-btn__chat-incomming-msg-loader-label");
+                const loaderContentEl = msgEl2.querySelector(".alan-btn__chat-incomming-msg-wrapper");
+                const loaderStatusContentEl = msgEl2.querySelector(".alan-btn__chat-incomming-msg-loader-label");
                 if (!loaderContentEl) {
-                  msgEl.innerHTML = msgHtml;
+                  msgEl2.innerHTML = msgHtml;
                 }
                 if (!progressUpdateIntervalId && loaderStatusContentEl) {
                   progressUpdateIntervalId = updateMessageProgressStatus(msgInd, loaderStatusContentEl, withDetailedStatuses);
                 }
               } else {
-                msgEl.innerHTML = msgHtml;
+                msgEl2.innerHTML = msgHtml;
               }
               setTimeout(() => {
                 scrollTextChat(msgsScrollableContainer);
@@ -112430,6 +113669,13 @@ ${curDialogId}`);
             highlightCode(document.getElementById("chatMessages"));
           }
         }
+        const msgEl = document.getElementById("msg-" + msgInd);
+        if (msgEl) {
+          const labelHolderEl = msgEl.querySelector(".alan-btn__chat-response-label");
+          if (labelHolderEl) {
+            labelHolderEl.innerHTML = getMsgBubbleLabel(msg);
+          }
+        }
         saveMessageHistory();
         if (uiState10.textChat.available && textChatIsHidden) {
           showChatNotifications();
@@ -112550,6 +113796,7 @@ ${curDialogId}`);
         uiState10.socketMessages = [];
         manageSaveChatHistoryBtn();
         connectToNewDialog();
+        clearChatAutocomplete(true);
       }
       function connectToNewDialog() {
         clearDialogId();
@@ -112642,11 +113889,16 @@ ${curDialogId}`);
       }
       async function _sendText(text5) {
         manageAutocompeteInChat();
+        var maxChars = uiState10.textChat.maxCharactersCount || 2e4;
+        if (text5?.length > maxChars) {
+          console.warn("Alan: message cannot be sent: maximum message limit exceeded.");
+          return;
+        }
         if (!canMsgBeSent()) {
           console.warn("Alan: message cannot be sent. Model is not ready or connection is not established.");
           return;
         }
-        var msg = { text: text5, type: "request", name: "text" };
+        var msg = { text: text5, type: "request", name: "text", tsInit: Date.now() };
         sentMessageInd = null;
         clearMessageProgressStatusInterval();
         var res = await sendText(text5);
@@ -112693,7 +113945,12 @@ ${curDialogId}`);
         var textareaHolderEl = document.getElementById("textarea-holder");
         var text5 = textareaEl.value;
         var maxChars = uiState10.textChat.maxCharactersCount || 2e4;
-        if (lastSendMsgTs || text5?.length > maxChars) {
+        if (lastSendMsgTs) {
+          console.warn("Alan: message cannot be sent: you are sending messages too fast. Please wait a moment before sending another message.");
+          return;
+        }
+        if (text5?.length > maxChars) {
+          console.warn("Alan: message cannot be sent: maximum message limit exceeded.");
           return;
         }
         if (!canMsgBeSent()) {
@@ -112771,8 +114028,8 @@ ${curDialogId}`);
         manageSendButtonAvailability();
       }
       function manageAutocompeteInChat() {
+        clearChatAutocomplete(false);
         if (!isModelReady) {
-          clearChatAutocomplete(false);
           return;
         }
         if (uiState10.textChat?.autocomplete?.enabled === true) {
@@ -114662,6 +115919,9 @@ juice/lib/utils.js:
    * @param {String} selectorText from mensch
    * @api public
    *)
+
+dompurify/dist/purify.cjs.js:
+  (*! @license DOMPurify 3.4.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.1/LICENSE *)
 */
 
 return alanBtn;