@syntrologie/adapt-chatbot 2.27.0 → 2.29.0

package/dist/chunk-VZIUXXAM.js

@@ -0,0 +1,4015 @@
+import {
+  __publicField
+} from "./chunk-UVKRO5ER.js";
+
+// ../../chat/dist/index.js
+import { html as html7, LitElement, nothing as nothing5 } from "lit";
+import { html as html2, nothing } from "lit";
+import { html as html6, nothing as nothing4 } from "lit";
+import { guard } from "lit/directives/guard.js";
+import { repeat } from "lit/directives/repeat.js";
+import { html as html4, nothing as nothing3 } from "lit";
+import { unsafeHTML } from "lit/directives/unsafe-html.js";
+
+// ../../../node_modules/dompurify/dist/purify.es.mjs
+var {
+  entries,
+  setPrototypeOf,
+  isFrozen,
+  getPrototypeOf,
+  getOwnPropertyDescriptor
+} = Object;
+var {
+  freeze,
+  seal,
+  create
+} = Object;
+var {
+  apply,
+  construct
+} = typeof Reflect !== "undefined" && Reflect;
+if (!freeze) {
+  freeze = function freeze2(x2) {
+    return x2;
+  };
+}
+if (!seal) {
+  seal = function seal2(x2) {
+    return x2;
+  };
+}
+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 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 objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+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);
+  }
+  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 index = 0; index < array.length; index++) {
+    const isPropertyExist = objectHasOwnProperty(array, index);
+    if (!isPropertyExist) {
+      array[index] = null;
+    }
+  }
+  return array;
+}
+function clone(object) {
+  const newObject = create(null);
+  for (const [property, value] of entries(object)) {
+    const isPropertyExist = objectHasOwnProperty(object, property);
+    if (isPropertyExist) {
+      if (Array.isArray(value)) {
+        newObject[property] = cleanArray(value);
+      } else if (value && typeof value === "object" && value.constructor === Object) {
+        newObject[property] = clone(value);
+      } else {
+        newObject[property] = value;
+      }
+    }
+  }
+  return newObject;
+}
+function lookupGetter(object, prop) {
+  while (object !== null) {
+    const desc = getOwnPropertyDescriptor(object, prop);
+    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;
+}
+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 text = freeze(["#text"]);
+var html = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
+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", "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"]);
+var xml = 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,
+  attribute: 2,
+  text: 3,
+  cdataSection: 4,
+  entityReference: 5,
+  // Deprecated
+  entityNode: 6,
+  // Deprecated
+  progressingInstruction: 7,
+  comment: 8,
+  document: 9,
+  documentType: 10,
+  documentFragment: 11,
+  notation: 12
+  // Deprecated
+};
+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(html9) {
+        return html9;
+      },
+      createScriptURL(scriptUrl) {
+        return scriptUrl;
+      }
+    });
+  } catch (_2) {
+    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 DOMPurify = (root) => createDOMPurify(root);
+  DOMPurify.version = "3.3.1";
+  DOMPurify.removed = [];
+  if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document || !window2.Element) {
+    DOMPurify.isSupported = false;
+    return DOMPurify;
+  }
+  let {
+    document: document2
+  } = window2;
+  const originalDocument = document2;
+  const currentScript = originalDocument.currentScript;
+  const {
+    DocumentFragment,
+    HTMLTemplateElement,
+    Node,
+    Element,
+    NodeFilter,
+    NamedNodeMap = window2.NamedNodeMap || window2.MozNamedAttrMap,
+    HTMLFormElement,
+    DOMParser,
+    trustedTypes
+  } = window2;
+  const ElementPrototype = Element.prototype;
+  const cloneNode = lookupGetter(ElementPrototype, "cloneNode");
+  const remove = 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
+  } = document2;
+  const {
+    importNode
+  } = originalDocument;
+  let hooks = _createHooksMap();
+  DOMPurify.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, ...text]);
+  let ALLOWED_ATTR = null;
+  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+  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 = clone(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") ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+    ALLOWED_ATTR = objectHasOwnProperty(cfg, "ALLOWED_ATTR") ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+    ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, "ALLOWED_NAMESPACES") ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+    URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, "ADD_URI_SAFE_ATTR") ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+    DATA_URI_TAGS = objectHasOwnProperty(cfg, "ADD_DATA_URI_TAGS") ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+    FORBID_CONTENTS = objectHasOwnProperty(cfg, "FORBID_CONTENTS") ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+    FORBID_TAGS = objectHasOwnProperty(cfg, "FORBID_TAGS") ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
+    FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+    USE_PROFILES = objectHasOwnProperty(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 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+    NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+    MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+    HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+    CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+    }
+    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+    }
+    if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === "boolean") {
+      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+    }
+    if (SAFE_FOR_TEMPLATES) {
+      ALLOW_DATA_ATTR = false;
+    }
+    if (RETURN_DOM_FRAGMENT) {
+      RETURN_DOM = true;
+    }
+    if (USE_PROFILES) {
+      ALLOWED_TAGS = addToSet({}, text);
+      ALLOWED_ATTR = [];
+      if (USE_PROFILES.html === true) {
+        addToSet(ALLOWED_TAGS, html$1);
+        addToSet(ALLOWED_ATTR, html);
+      }
+      if (USE_PROFILES.svg === true) {
+        addToSet(ALLOWED_TAGS, svg$1);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+      if (USE_PROFILES.svgFilters === true) {
+        addToSet(ALLOWED_TAGS, svgFilters);
+        addToSet(ALLOWED_ATTR, svg);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+      if (USE_PROFILES.mathMl === true) {
+        addToSet(ALLOWED_TAGS, mathMl$1);
+        addToSet(ALLOWED_ATTR, mathMl);
+        addToSet(ALLOWED_ATTR, xml);
+      }
+    }
+    if (cfg.ADD_TAGS) {
+      if (typeof cfg.ADD_TAGS === "function") {
+        EXTRA_ELEMENT_HANDLING.tagCheck = cfg.ADD_TAGS;
+      } else {
+        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+          ALLOWED_TAGS = clone(ALLOWED_TAGS);
+        }
+        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+      }
+    }
+    if (cfg.ADD_ATTR) {
+      if (typeof cfg.ADD_ATTR === "function") {
+        EXTRA_ELEMENT_HANDLING.attributeCheck = cfg.ADD_ATTR;
+      } else {
+        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+          ALLOWED_ATTR = clone(ALLOWED_ATTR);
+        }
+        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+      }
+    }
+    if (cfg.ADD_URI_SAFE_ATTR) {
+      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+    }
+    if (cfg.FORBID_CONTENTS) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone(FORBID_CONTENTS);
+      }
+      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+    }
+    if (cfg.ADD_FORBID_CONTENTS) {
+      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+        FORBID_CONTENTS = clone(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 parent = getParentNode(element);
+    if (!parent || !parent.tagName) {
+      parent = {
+        namespaceURI: NAMESPACE,
+        tagName: "template"
+      };
+    }
+    const tagName = stringToLowerCase(element.tagName);
+    const parentTagName = stringToLowerCase(parent.tagName);
+    if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+      return false;
+    }
+    if (element.namespaceURI === SVG_NAMESPACE) {
+      if (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "svg";
+      }
+      if (parent.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 (parent.namespaceURI === HTML_NAMESPACE) {
+        return tagName === "math";
+      }
+      if (parent.namespaceURI === SVG_NAMESPACE) {
+        return tagName === "math" && HTML_INTEGRATION_POINTS[parentTagName];
+      }
+      return Boolean(ALL_MATHML_TAGS[tagName]);
+    }
+    if (element.namespaceURI === HTML_NAMESPACE) {
+      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+        return false;
+      }
+      if (parent.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(DOMPurify.removed, {
+      element: node
+    });
+    try {
+      getParentNode(node).removeChild(node);
+    } catch (_2) {
+      remove(node);
+    }
+  };
+  const _removeAttribute = function _removeAttribute2(name, element) {
+    try {
+      arrayPush(DOMPurify.removed, {
+        attribute: element.getAttributeNode(name),
+        from: element
+      });
+    } catch (_2) {
+      arrayPush(DOMPurify.removed, {
+        attribute: null,
+        from: element
+      });
+    }
+    element.removeAttribute(name);
+    if (name === "is") {
+      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+        try {
+          _forceRemove(element);
+        } catch (_2) {
+        }
+      } else {
+        try {
+          element.setAttribute(name, "");
+        } catch (_2) {
+        }
+      }
+    }
+  };
+  const _initDocument = function _initDocument2(dirty) {
+    let doc = 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 {
+        doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+      } catch (_2) {
+      }
+    }
+    if (!doc || !doc.documentElement) {
+      doc = implementation.createDocument(NAMESPACE, "template", null);
+      try {
+        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+      } catch (_2) {
+      }
+    }
+    const body = doc.body || doc.documentElement;
+    if (dirty && leadingWhitespace) {
+      body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+    }
+    if (NAMESPACE === HTML_NAMESPACE) {
+      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
+    }
+    return WHOLE_DOCUMENT ? doc.documentElement : body;
+  };
+  const _createNodeIterator = function _createNodeIterator2(root) {
+    return createNodeIterator.call(
+      root.ownerDocument || root,
+      root,
+      // 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 Node === "function" && value instanceof Node;
+  };
+  function _executeHooks(hooks2, currentNode, data) {
+    arrayForEach(hooks2, (hook) => {
+      hook.call(DOMPurify, currentNode, data, 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 (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 (!(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && (!ALLOWED_TAGS[tagName] || FORBID_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 = cloneNode(childNodes[i], true);
+            childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+            parentNode.insertBefore(childClone, getNextSibling(currentNode));
+          }
+        }
+      }
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (currentNode instanceof Element && !_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(DOMPurify.removed, {
+          element: currentNode.cloneNode()
+        });
+        currentNode.textContent = content;
+      }
+    }
+    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+    return false;
+  };
+  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+    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 _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+    return tagName !== "annotation-xml" && stringMatch(tagName, CUSTOM_ELEMENT2);
+  };
+  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode) {
+    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+    const {
+      attributes
+    } = currentNode;
+    if (!attributes || _isClobbered(currentNode)) {
+      return;
+    }
+    const hookEvent = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: true,
+      allowedAttributes: ALLOWED_ATTR,
+      forceKeepAttr: void 0
+    };
+    let l = attributes.length;
+    while (l--) {
+      const attr = attributes[l];
+      const {
+        name,
+        namespaceURI,
+        value: attrValue
+      } = attr;
+      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")) {
+        _removeAttribute(name, currentNode);
+        value = SANITIZE_NAMED_PROPS_PREFIX + value;
+      }
+      if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title|textarea)/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(DOMPurify.removed);
+          }
+        } catch (_2) {
+          _removeAttribute(name, currentNode);
+        }
+      }
+    }
+    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+  };
+  const _sanitizeShadowDOM = function _sanitizeShadowDOM2(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);
+  };
+  DOMPurify.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)) {
+      if (typeof dirty.toString === "function") {
+        dirty = dirty.toString();
+        if (typeof dirty !== "string") {
+          throw typeErrorCreate("dirty is not a string, aborting");
+        }
+      } else {
+        throw typeErrorCreate("toString is not a function");
+      }
+    }
+    if (!DOMPurify.isSupported) {
+      return dirty;
+    }
+    if (!SET_CONFIG) {
+      _parseConfig(cfg);
+    }
+    DOMPurify.removed = [];
+    if (typeof dirty === "string") {
+      IN_PLACE = false;
+    }
+    if (IN_PLACE) {
+      if (dirty.nodeName) {
+        const tagName = transformCaseFunc(dirty.nodeName);
+        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
+        }
+      }
+    } else if (dirty instanceof Node) {
+      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) {
+        _sanitizeShadowDOM(currentNode.content);
+      }
+    }
+    if (IN_PLACE) {
+      return dirty;
+    }
+    if (RETURN_DOM) {
+      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;
+  };
+  DOMPurify.setConfig = function() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _parseConfig(cfg);
+    SET_CONFIG = true;
+  };
+  DOMPurify.clearConfig = function() {
+    CONFIG = null;
+    SET_CONFIG = false;
+  };
+  DOMPurify.isValidAttribute = function(tag, attr, value) {
+    if (!CONFIG) {
+      _parseConfig({});
+    }
+    const lcTag = transformCaseFunc(tag);
+    const lcName = transformCaseFunc(attr);
+    return _isValidAttribute(lcTag, lcName, value);
+  };
+  DOMPurify.addHook = function(entryPoint, hookFunction) {
+    if (typeof hookFunction !== "function") {
+      return;
+    }
+    arrayPush(hooks[entryPoint], hookFunction);
+  };
+  DOMPurify.removeHook = function(entryPoint, hookFunction) {
+    if (hookFunction !== void 0) {
+      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+    }
+    return arrayPop(hooks[entryPoint]);
+  };
+  DOMPurify.removeHooks = function(entryPoint) {
+    hooks[entryPoint] = [];
+  };
+  DOMPurify.removeAllHooks = function() {
+    hooks = _createHooksMap();
+  };
+  return DOMPurify;
+}
+var purify = createDOMPurify();
+
+// ../../../node_modules/marked/lib/marked.esm.js
+function M() {
+  return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
+}
+var T = M();
+function G(u3) {
+  T = u3;
+}
+var _ = { exec: () => null };
+function k(u3, e = "") {
+  let t = typeof u3 == "string" ? u3 : u3.source, n = { replace: (r, i) => {
+    let s = typeof i == "string" ? i : i.source;
+    return s = s.replace(m.caret, "$1"), t = t.replace(r, s), n;
+  }, getRegex: () => new RegExp(t, e) };
+  return n;
+}
+var Re = (() => {
+  try {
+    return !!new RegExp("(?<=1)(?<!1)");
+  } catch {
+    return false;
+  }
+})();
+var m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (u3) => new RegExp(`^( {0,3}${u3})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), hrRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}#`), htmlBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}<(?:[a-z].*>|!--)`, "i"), blockquoteBeginRegex: (u3) => new RegExp(`^ {0,${Math.min(3, u3 - 1)}}>`) };
+var Te = /^(?:[ \t]*(?:\n|$))+/;
+var Oe = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var we = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var A = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var ye = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var N = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
+var re = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var se = k(re).replace(/bull/g, N).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var Pe = k(re).replace(/bull/g, N).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var Q = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var Se = /^[^\n]+/;
+var j = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
+var $e = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", j).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var _e = k(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, N).getRegex();
+var q = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var F = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var Le = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", F).replace("tag", q).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var ie = k(Q).replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex();
+var Me = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", ie).getRegex();
+var U = { blockquote: Me, code: Oe, def: $e, fences: we, heading: ye, hr: A, html: Le, lheading: se, list: _e, newline: Te, paragraph: ie, table: _, text: Se };
+var te = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex();
+var ze = { ...U, lheading: Pe, table: te, paragraph: k(Q).replace("hr", A).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", te).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", q).getRegex() };
+var Ee = { ...U, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", F).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(Q).replace("hr", A).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", se).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
+var Ie = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var Ae = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var oe = /^( {2,}|\\)\n(?!\s*$)/;
+var Ce = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var v = /[\p{P}\p{S}]/u;
+var K = /[\s\p{P}\p{S}]/u;
+var ae = /[^\s\p{P}\p{S}]/u;
+var Be = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, K).getRegex();
+var le = /(?!~)[\p{P}\p{S}]/u;
+var De = /(?!~)[\s\p{P}\p{S}]/u;
+var qe = /(?:[^\s\p{P}\p{S}]|~)/u;
+var ue = /(?![*_])[\p{P}\p{S}]/u;
+var ve = /(?![*_])[\s\p{P}\p{S}]/u;
+var He = /(?:[^\s\p{P}\p{S}]|[*_])/u;
+var Ge = k(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Re ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
+var pe = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
+var Ze = k(pe, "u").replace(/punct/g, v).getRegex();
+var Ne = k(pe, "u").replace(/punct/g, le).getRegex();
+var ce = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+var Qe = k(ce, "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, K).replace(/punct/g, v).getRegex();
+var je = k(ce, "gu").replace(/notPunctSpace/g, qe).replace(/punctSpace/g, De).replace(/punct/g, le).getRegex();
+var Fe = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, K).replace(/punct/g, v).getRegex();
+var Ue = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, ue).getRegex();
+var Ke = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)";
+var We = k(Ke, "gu").replace(/notPunctSpace/g, He).replace(/punctSpace/g, ve).replace(/punct/g, ue).getRegex();
+var Xe = k(/\\(punct)/, "gu").replace(/punct/g, v).getRegex();
+var Je = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var Ve = k(F).replace("(?:-->|$)", "-->").getRegex();
+var Ye = k("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", Ve).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var D = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+[^`]*?`+(?!`)|[^\[\]\\`])*?/;
+var et = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", D).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var he = k(/^!?\[(label)\]\[(ref)\]/).replace("label", D).replace("ref", j).getRegex();
+var ke = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", j).getRegex();
+var tt = k("reflink|nolink(?!\\()", "g").replace("reflink", he).replace("nolink", ke).getRegex();
+var ne = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
+var W = { _backpedal: _, anyPunctuation: Xe, autolink: Je, blockSkip: Ge, br: oe, code: Ae, del: _, delLDelim: _, delRDelim: _, emStrongLDelim: Ze, emStrongRDelimAst: Qe, emStrongRDelimUnd: Fe, escape: Ie, link: et, nolink: ke, punctuation: Be, reflink: he, reflinkSearch: tt, tag: Ye, text: Ce, url: _ };
+var nt = { ...W, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", D).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", D).getRegex() };
+var Z = { ...W, emStrongRDelimAst: je, emStrongLDelim: Ne, delLDelim: Ue, delRDelim: We, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", ne).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", ne).getRegex() };
+var rt = { ...Z, br: k(oe).replace("{2,}", "*").getRegex(), text: k(Z.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
+var C = { normal: U, gfm: ze, pedantic: Ee };
+var z = { normal: W, gfm: Z, breaks: rt, pedantic: nt };
+var st = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var de = (u3) => st[u3];
+function O(u3, e) {
+  if (e) {
+    if (m.escapeTest.test(u3)) return u3.replace(m.escapeReplace, de);
+  } else if (m.escapeTestNoEncode.test(u3)) return u3.replace(m.escapeReplaceNoEncode, de);
+  return u3;
+}
+function X(u3) {
+  try {
+    u3 = encodeURI(u3).replace(m.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return u3;
+}
+function J(u3, e) {
+  let t = u3.replace(m.findPipe, (i, s, a) => {
+    let o = false, l = s;
+    for (; --l >= 0 && a[l] === "\\"; ) o = !o;
+    return o ? "|" : " |";
+  }), n = t.split(m.splitPipe), r = 0;
+  if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e) if (n.length > e) n.splice(e);
+  else for (; n.length < e; ) n.push("");
+  for (; r < n.length; r++) n[r] = n[r].trim().replace(m.slashPipe, "|");
+  return n;
+}
+function E(u3, e, t) {
+  let n = u3.length;
+  if (n === 0) return "";
+  let r = 0;
+  for (; r < n; ) {
+    let i = u3.charAt(n - r - 1);
+    if (i === e && !t) r++;
+    else if (i !== e && t) r++;
+    else break;
+  }
+  return u3.slice(0, n - r);
+}
+function ge(u3, e) {
+  if (u3.indexOf(e[1]) === -1) return -1;
+  let t = 0;
+  for (let n = 0; n < u3.length; n++) if (u3[n] === "\\") n++;
+  else if (u3[n] === e[0]) t++;
+  else if (u3[n] === e[1] && (t--, t < 0)) return n;
+  return t > 0 ? -2 : -1;
+}
+function fe(u3, e = 0) {
+  let t = e, n = "";
+  for (let r of u3) if (r === "	") {
+    let i = 4 - t % 4;
+    n += " ".repeat(i), t += i;
+  } else n += r, t++;
+  return n;
+}
+function me(u3, e, t, n, r) {
+  let i = e.href, s = e.title || null, a = u3[1].replace(r.other.outputLinkReplace, "$1");
+  n.state.inLink = true;
+  let o = { type: u3[0].charAt(0) === "!" ? "image" : "link", raw: t, href: i, title: s, text: a, tokens: n.inlineTokens(a) };
+  return n.state.inLink = false, o;
+}
+function it(u3, e, t) {
+  let n = u3.match(t.other.indentCodeCompensation);
+  if (n === null) return e;
+  let r = n[1];
+  return e.split(`
+`).map((i) => {
+    let s = i.match(t.other.beginningSpace);
+    if (s === null) return i;
+    let [a] = s;
+    return a.length >= r.length ? i.slice(r.length) : i;
+  }).join(`
+`);
+}
+var w = class {
+  constructor(e) {
+    __publicField(this, "options");
+    __publicField(this, "rules");
+    __publicField(this, "lexer");
+    this.options = e || T;
+  }
+  space(e) {
+    let t = this.rules.block.newline.exec(e);
+    if (t && t[0].length > 0) return { type: "space", raw: t[0] };
+  }
+  code(e) {
+    let t = this.rules.block.code.exec(e);
+    if (t) {
+      let n = t[0].replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: t[0], codeBlockStyle: "indented", text: this.options.pedantic ? n : E(n, `
+`) };
+    }
+  }
+  fences(e) {
+    let t = this.rules.block.fences.exec(e);
+    if (t) {
+      let n = t[0], r = it(n, t[3] || "", this.rules);
+      return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: r };
+    }
+  }
+  heading(e) {
+    let t = this.rules.block.heading.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let r = E(n, "#");
+        (this.options.pedantic || !r || this.rules.other.endingSpaceChar.test(r)) && (n = r.trim());
+      }
+      return { type: "heading", raw: t[0], depth: t[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(e) {
+    let t = this.rules.block.hr.exec(e);
+    if (t) return { type: "hr", raw: E(t[0], `
+`) };
+  }
+  blockquote(e) {
+    let t = this.rules.block.blockquote.exec(e);
+    if (t) {
+      let n = E(t[0], `
+`).split(`
+`), r = "", i = "", s = [];
+      for (; n.length > 0; ) {
+        let a = false, o = [], l;
+        for (l = 0; l < n.length; l++) if (this.rules.other.blockquoteStart.test(n[l])) o.push(n[l]), a = true;
+        else if (!a) o.push(n[l]);
+        else break;
+        n = n.slice(l);
+        let p = o.join(`
+`), c = p.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        r = r ? `${r}
+${p}` : p, i = i ? `${i}
+${c}` : c;
+        let d = this.lexer.state.top;
+        if (this.lexer.state.top = true, this.lexer.blockTokens(c, s, true), this.lexer.state.top = d, n.length === 0) break;
+        let h = s.at(-1);
+        if (h?.type === "code") break;
+        if (h?.type === "blockquote") {
+          let R = h, f = R.raw + `
+` + n.join(`
+`), S = this.blockquote(f);
+          s[s.length - 1] = S, r = r.substring(0, r.length - R.raw.length) + S.raw, i = i.substring(0, i.length - R.text.length) + S.text;
+          break;
+        } else if (h?.type === "list") {
+          let R = h, f = R.raw + `
+` + n.join(`
+`), S = this.list(f);
+          s[s.length - 1] = S, r = r.substring(0, r.length - h.raw.length) + S.raw, i = i.substring(0, i.length - R.raw.length) + S.raw, n = f.substring(s.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: r, tokens: s, text: i };
+    }
+  }
+  list(e) {
+    let t = this.rules.block.list.exec(e);
+    if (t) {
+      let n = t[1].trim(), r = n.length > 1, i = { type: "list", raw: "", ordered: r, start: r ? +n.slice(0, -1) : "", loose: false, items: [] };
+      n = r ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = r ? n : "[*+-]");
+      let s = this.rules.other.listItemRegex(n), a = false;
+      for (; e; ) {
+        let l = false, p = "", c = "";
+        if (!(t = s.exec(e)) || this.rules.block.hr.test(e)) break;
+        p = t[0], e = e.substring(p.length);
+        let d = fe(t[2].split(`
+`, 1)[0], t[1].length), h = e.split(`
+`, 1)[0], R = !d.trim(), f = 0;
+        if (this.options.pedantic ? (f = 2, c = d.trimStart()) : R ? f = t[1].length + 1 : (f = d.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = d.slice(f), f += t[1].length), R && this.rules.other.blankLine.test(h) && (p += h + `
+`, e = e.substring(h.length + 1), l = true), !l) {
+          let S = this.rules.other.nextBulletRegex(f), V = this.rules.other.hrRegex(f), Y = this.rules.other.fencesBeginRegex(f), ee = this.rules.other.headingBeginRegex(f), xe = this.rules.other.htmlBeginRegex(f), be = this.rules.other.blockquoteBeginRegex(f);
+          for (; e; ) {
+            let H = e.split(`
+`, 1)[0], I;
+            if (h = H, this.options.pedantic ? (h = h.replace(this.rules.other.listReplaceNesting, "  "), I = h) : I = h.replace(this.rules.other.tabCharGlobal, "    "), Y.test(h) || ee.test(h) || xe.test(h) || be.test(h) || S.test(h) || V.test(h)) break;
+            if (I.search(this.rules.other.nonSpaceChar) >= f || !h.trim()) c += `
+` + I.slice(f);
+            else {
+              if (R || d.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || Y.test(d) || ee.test(d) || V.test(d)) break;
+              c += `
+` + h;
+            }
+            R = !h.trim(), p += H + `
+`, e = e.substring(H.length + 1), d = I.slice(f);
+          }
+        }
+        i.loose || (a ? i.loose = true : this.rules.other.doubleBlankLine.test(p) && (a = true)), i.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), i.raw += p;
+      }
+      let o = i.items.at(-1);
+      if (o) o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd();
+      else return;
+      i.raw = i.raw.trimEnd();
+      for (let l of i.items) {
+        if (this.lexer.state.top = false, l.tokens = this.lexer.blockTokens(l.text, []), l.task) {
+          if (l.text = l.text.replace(this.rules.other.listReplaceTask, ""), l.tokens[0]?.type === "text" || l.tokens[0]?.type === "paragraph") {
+            l.tokens[0].raw = l.tokens[0].raw.replace(this.rules.other.listReplaceTask, ""), l.tokens[0].text = l.tokens[0].text.replace(this.rules.other.listReplaceTask, "");
+            for (let c = this.lexer.inlineQueue.length - 1; c >= 0; c--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[c].src)) {
+              this.lexer.inlineQueue[c].src = this.lexer.inlineQueue[c].src.replace(this.rules.other.listReplaceTask, "");
+              break;
+            }
+          }
+          let p = this.rules.other.listTaskCheckbox.exec(l.raw);
+          if (p) {
+            let c = { type: "checkbox", raw: p[0] + " ", checked: p[0] !== "[ ]" };
+            l.checked = c.checked, i.loose ? l.tokens[0] && ["paragraph", "text"].includes(l.tokens[0].type) && "tokens" in l.tokens[0] && l.tokens[0].tokens ? (l.tokens[0].raw = c.raw + l.tokens[0].raw, l.tokens[0].text = c.raw + l.tokens[0].text, l.tokens[0].tokens.unshift(c)) : l.tokens.unshift({ type: "paragraph", raw: c.raw, text: c.raw, tokens: [c] }) : l.tokens.unshift(c);
+          }
+        }
+        if (!i.loose) {
+          let p = l.tokens.filter((d) => d.type === "space"), c = p.length > 0 && p.some((d) => this.rules.other.anyLine.test(d.raw));
+          i.loose = c;
+        }
+      }
+      if (i.loose) for (let l of i.items) {
+        l.loose = true;
+        for (let p of l.tokens) p.type === "text" && (p.type = "paragraph");
+      }
+      return i;
+    }
+  }
+  html(e) {
+    let t = this.rules.block.html.exec(e);
+    if (t) return { type: "html", block: true, raw: t[0], pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: t[0] };
+  }
+  def(e) {
+    let t = this.rules.block.def.exec(e);
+    if (t) {
+      let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), r = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", i = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
+      return { type: "def", tag: n, raw: t[0], href: r, title: i };
+    }
+  }
+  table(e) {
+    let t = this.rules.block.table.exec(e);
+    if (!t || !this.rules.other.tableDelimiter.test(t[2])) return;
+    let n = J(t[1]), r = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), i = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], s = { type: "table", raw: t[0], header: [], align: [], rows: [] };
+    if (n.length === r.length) {
+      for (let a of r) this.rules.other.tableAlignRight.test(a) ? s.align.push("right") : this.rules.other.tableAlignCenter.test(a) ? s.align.push("center") : this.rules.other.tableAlignLeft.test(a) ? s.align.push("left") : s.align.push(null);
+      for (let a = 0; a < n.length; a++) s.header.push({ text: n[a], tokens: this.lexer.inline(n[a]), header: true, align: s.align[a] });
+      for (let a of i) s.rows.push(J(a, s.header.length).map((o, l) => ({ text: o, tokens: this.lexer.inline(o), header: false, align: s.align[l] })));
+      return s;
+    }
+  }
+  lheading(e) {
+    let t = this.rules.block.lheading.exec(e);
+    if (t) return { type: "heading", raw: t[0], depth: t[2].charAt(0) === "=" ? 1 : 2, text: t[1], tokens: this.lexer.inline(t[1]) };
+  }
+  paragraph(e) {
+    let t = this.rules.block.paragraph.exec(e);
+    if (t) {
+      let n = t[1].charAt(t[1].length - 1) === `
+` ? t[1].slice(0, -1) : t[1];
+      return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(e) {
+    let t = this.rules.block.text.exec(e);
+    if (t) return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) };
+  }
+  escape(e) {
+    let t = this.rules.inline.escape.exec(e);
+    if (t) return { type: "escape", raw: t[0], text: t[1] };
+  }
+  tag(e) {
+    let t = this.rules.inline.tag.exec(e);
+    if (t) return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] };
+  }
+  link(e) {
+    let t = this.rules.inline.link.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) {
+        if (!this.rules.other.endAngleBracket.test(n)) return;
+        let s = E(n.slice(0, -1), "\\");
+        if ((n.length - s.length) % 2 === 0) return;
+      } else {
+        let s = ge(t[2], "()");
+        if (s === -2) return;
+        if (s > -1) {
+          let o = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + s;
+          t[2] = t[2].substring(0, s), t[0] = t[0].substring(0, o).trim(), t[3] = "";
+        }
+      }
+      let r = t[2], i = "";
+      if (this.options.pedantic) {
+        let s = this.rules.other.pedanticHrefTitle.exec(r);
+        s && (r = s[1], i = s[3]);
+      } else i = t[3] ? t[3].slice(1, -1) : "";
+      return r = r.trim(), this.rules.other.startAngleBracket.test(r) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? r = r.slice(1) : r = r.slice(1, -1)), me(t, { href: r && r.replace(this.rules.inline.anyPunctuation, "$1"), title: i && i.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules);
+    }
+  }
+  reflink(e, t) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
+      let r = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), i = t[r.toLowerCase()];
+      if (!i) {
+        let s = n[0].charAt(0);
+        return { type: "text", raw: s, text: s };
+      }
+      return me(n, i, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(e, t, n = "") {
+    let r = this.rules.inline.emStrongLDelim.exec(e);
+    if (!r || r[3] && n.match(this.rules.other.unicodeAlphaNumeric)) return;
+    if (!(r[1] || r[2] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let s = [...r[0]].length - 1, a, o, l = s, p = 0, c = r[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (c.lastIndex = 0, t = t.slice(-1 * e.length + s); (r = c.exec(t)) != null; ) {
+        if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a) continue;
+        if (o = [...a].length, r[3] || r[4]) {
+          l += o;
+          continue;
+        } else if ((r[5] || r[6]) && s % 3 && !((s + o) % 3)) {
+          p += o;
+          continue;
+        }
+        if (l -= o, l > 0) continue;
+        o = Math.min(o, o + l + p);
+        let d = [...r[0]][0].length, h = e.slice(0, s + r.index + d + o);
+        if (Math.min(s, o) % 2) {
+          let f = h.slice(1, -1);
+          return { type: "em", raw: h, text: f, tokens: this.lexer.inlineTokens(f) };
+        }
+        let R = h.slice(2, -2);
+        return { type: "strong", raw: h, text: R, tokens: this.lexer.inlineTokens(R) };
+      }
+    }
+  }
+  codespan(e) {
+    let t = this.rules.inline.code.exec(e);
+    if (t) {
+      let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), r = this.rules.other.nonSpaceChar.test(n), i = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return r && i && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n };
+    }
+  }
+  br(e) {
+    let t = this.rules.inline.br.exec(e);
+    if (t) return { type: "br", raw: t[0] };
+  }
+  del(e, t, n = "") {
+    let r = this.rules.inline.delLDelim.exec(e);
+    if (!r) return;
+    if (!(r[1] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let s = [...r[0]].length - 1, a, o, l = s, p = this.rules.inline.delRDelim;
+      for (p.lastIndex = 0, t = t.slice(-1 * e.length + s); (r = p.exec(t)) != null; ) {
+        if (a = r[1] || r[2] || r[3] || r[4] || r[5] || r[6], !a || (o = [...a].length, o !== s)) continue;
+        if (r[3] || r[4]) {
+          l += o;
+          continue;
+        }
+        if (l -= o, l > 0) continue;
+        o = Math.min(o, o + l);
+        let c = [...r[0]][0].length, d = e.slice(0, s + r.index + c + o), h = d.slice(s, -s);
+        return { type: "del", raw: d, text: h, tokens: this.lexer.inlineTokens(h) };
+      }
+    }
+  }
+  autolink(e) {
+    let t = this.rules.inline.autolink.exec(e);
+    if (t) {
+      let n, r;
+      return t[2] === "@" ? (n = t[1], r = "mailto:" + n) : (n = t[1], r = n), { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(e) {
+    let t;
+    if (t = this.rules.inline.url.exec(e)) {
+      let n, r;
+      if (t[2] === "@") n = t[0], r = "mailto:" + n;
+      else {
+        let i;
+        do
+          i = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? "";
+        while (i !== t[0]);
+        n = t[0], t[1] === "www." ? r = "http://" + t[0] : r = t[0];
+      }
+      return { type: "link", raw: t[0], text: n, href: r, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(e) {
+    let t = this.rules.inline.text.exec(e);
+    if (t) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: t[0], text: t[0], escaped: n };
+    }
+  }
+};
+var x = class u {
+  constructor(e) {
+    __publicField(this, "tokens");
+    __publicField(this, "options");
+    __publicField(this, "state");
+    __publicField(this, "inlineQueue");
+    __publicField(this, "tokenizer");
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || T, this.options.tokenizer = this.options.tokenizer || new w(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, top: true };
+    let t = { other: m, block: C.normal, inline: z.normal };
+    this.options.pedantic ? (t.block = C.pedantic, t.inline = z.pedantic) : this.options.gfm && (t.block = C.gfm, this.options.breaks ? t.inline = z.breaks : t.inline = z.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: C, inline: z };
+  }
+  static lex(e, t) {
+    return new u(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new u(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(m.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0; t < this.inlineQueue.length; t++) {
+      let n = this.inlineQueue[t];
+      this.inlineTokens(n.src, n.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], n = false) {
+    for (this.options.pedantic && (e = e.replace(m.tabCharGlobal, "    ").replace(m.spaceLine, "")); e; ) {
+      let r;
+      if (this.options.extensions?.block?.some((s) => (r = s.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false)) continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        r.raw.length === 1 && s !== void 0 ? s.raw += `
+` : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.at(-1).src = s.text) : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "paragraph" || s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.raw, this.inlineQueue.at(-1).src = s.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      let i = e;
+      if (this.options.extensions?.startBlock) {
+        let s = 1 / 0, a = e.slice(1), o;
+        this.options.extensions.startBlock.forEach((l) => {
+          o = l.call({ lexer: this }, a), typeof o == "number" && o >= 0 && (s = Math.min(s, o));
+        }), s < 1 / 0 && s >= 0 && (i = e.substring(0, s + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(i))) {
+        let s = t.at(-1);
+        n && s?.type === "paragraph" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r), n = i.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let s = t.at(-1);
+        s?.type === "text" ? (s.raw += (s.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, s.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = s.text) : t.push(r);
+        continue;
+      }
+      if (e) {
+        let s = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(s);
+          break;
+        } else throw new Error(s);
+      }
+    }
+    return this.state.top = true, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  inlineTokens(e, t = []) {
+    let n = e, r = null;
+    if (this.tokens.links) {
+      let o = Object.keys(this.tokens.links);
+      if (o.length > 0) for (; (r = this.tokenizer.rules.inline.reflinkSearch.exec(n)) != null; ) o.includes(r[0].slice(r[0].lastIndexOf("[") + 1, -1)) && (n = n.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (r = this.tokenizer.rules.inline.anyPunctuation.exec(n)) != null; ) n = n.slice(0, r.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    let i;
+    for (; (r = this.tokenizer.rules.inline.blockSkip.exec(n)) != null; ) i = r[2] ? r[2].length : 0, n = n.slice(0, r.index + i) + "[" + "a".repeat(r[0].length - i - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
+    let s = false, a = "";
+    for (; e; ) {
+      s || (a = ""), s = false;
+      let o;
+      if (this.options.extensions?.inline?.some((p) => (o = p.call({ lexer: this }, e, t)) ? (e = e.substring(o.raw.length), t.push(o), true) : false)) continue;
+      if (o = this.tokenizer.escape(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.tag(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.link(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(o.raw.length);
+        let p = t.at(-1);
+        o.type === "text" && p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.emStrong(e, n, a)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.codespan(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.br(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.del(e, n, a)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.autolink(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (!this.state.inLink && (o = this.tokenizer.url(e))) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      let l = e;
+      if (this.options.extensions?.startInline) {
+        let p = 1 / 0, c = e.slice(1), d;
+        this.options.extensions.startInline.forEach((h) => {
+          d = h.call({ lexer: this }, c), typeof d == "number" && d >= 0 && (p = Math.min(p, d));
+        }), p < 1 / 0 && p >= 0 && (l = e.substring(0, p + 1));
+      }
+      if (o = this.tokenizer.inlineText(l)) {
+        e = e.substring(o.raw.length), o.raw.slice(-1) !== "_" && (a = o.raw.slice(-1)), s = true;
+        let p = t.at(-1);
+        p?.type === "text" ? (p.raw += o.raw, p.text += o.text) : t.push(o);
+        continue;
+      }
+      if (e) {
+        let p = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(p);
+          break;
+        } else throw new Error(p);
+      }
+    }
+    return t;
+  }
+};
+var y = class {
+  constructor(e) {
+    __publicField(this, "options");
+    __publicField(this, "parser");
+    this.options = e || T;
+  }
+  space(e) {
+    return "";
+  }
+  code({ text: e, lang: t, escaped: n }) {
+    let r = (t || "").match(m.notSpaceStart)?.[0], i = e.replace(m.endingNewline, "") + `
+`;
+    return r ? '<pre><code class="language-' + O(r) + '">' + (n ? i : O(i, true)) + `</code></pre>
+` : "<pre><code>" + (n ? i : O(i, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: e }) {
+    return `<blockquote>
+${this.parser.parse(e)}</blockquote>
+`;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  def(e) {
+    return "";
+  }
+  heading({ tokens: e, depth: t }) {
+    return `<h${t}>${this.parser.parseInline(e)}</h${t}>
+`;
+  }
+  hr(e) {
+    return `<hr>
+`;
+  }
+  list(e) {
+    let t = e.ordered, n = e.start, r = "";
+    for (let a = 0; a < e.items.length; a++) {
+      let o = e.items[a];
+      r += this.listitem(o);
+    }
+    let i = t ? "ol" : "ul", s = t && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + i + s + `>
+` + r + "</" + i + `>
+`;
+  }
+  listitem(e) {
+    return `<li>${this.parser.parse(e.tokens)}</li>
+`;
+  }
+  checkbox({ checked: e }) {
+    return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: e }) {
+    return `<p>${this.parser.parseInline(e)}</p>
+`;
+  }
+  table(e) {
+    let t = "", n = "";
+    for (let i = 0; i < e.header.length; i++) n += this.tablecell(e.header[i]);
+    t += this.tablerow({ text: n });
+    let r = "";
+    for (let i = 0; i < e.rows.length; i++) {
+      let s = e.rows[i];
+      n = "";
+      for (let a = 0; a < s.length; a++) n += this.tablecell(s[a]);
+      r += this.tablerow({ text: n });
+    }
+    return r && (r = `<tbody>${r}</tbody>`), `<table>
+<thead>
+` + t + `</thead>
+` + r + `</table>
+`;
+  }
+  tablerow({ text: e }) {
+    return `<tr>
+${e}</tr>
+`;
+  }
+  tablecell(e) {
+    let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
+    return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>
+`;
+  }
+  strong({ tokens: e }) {
+    return `<strong>${this.parser.parseInline(e)}</strong>`;
+  }
+  em({ tokens: e }) {
+    return `<em>${this.parser.parseInline(e)}</em>`;
+  }
+  codespan({ text: e }) {
+    return `<code>${O(e, true)}</code>`;
+  }
+  br(e) {
+    return "<br>";
+  }
+  del({ tokens: e }) {
+    return `<del>${this.parser.parseInline(e)}</del>`;
+  }
+  link({ href: e, title: t, tokens: n }) {
+    let r = this.parser.parseInline(n), i = X(e);
+    if (i === null) return r;
+    e = i;
+    let s = '<a href="' + e + '"';
+    return t && (s += ' title="' + O(t) + '"'), s += ">" + r + "</a>", s;
+  }
+  image({ href: e, title: t, text: n, tokens: r }) {
+    r && (n = this.parser.parseInline(r, this.parser.textRenderer));
+    let i = X(e);
+    if (i === null) return O(n);
+    e = i;
+    let s = `<img src="${e}" alt="${O(n)}"`;
+    return t && (s += ` title="${O(t)}"`), s += ">", s;
+  }
+  text(e) {
+    return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : "escaped" in e && e.escaped ? e.text : O(e.text);
+  }
+};
+var $ = class {
+  strong({ text: e }) {
+    return e;
+  }
+  em({ text: e }) {
+    return e;
+  }
+  codespan({ text: e }) {
+    return e;
+  }
+  del({ text: e }) {
+    return e;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  text({ text: e }) {
+    return e;
+  }
+  link({ text: e }) {
+    return "" + e;
+  }
+  image({ text: e }) {
+    return "" + e;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: e }) {
+    return e;
+  }
+};
+var b = class u2 {
+  constructor(e) {
+    __publicField(this, "options");
+    __publicField(this, "renderer");
+    __publicField(this, "textRenderer");
+    this.options = e || T, this.options.renderer = this.options.renderer || new y(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new $();
+  }
+  static parse(e, t) {
+    return new u2(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new u2(t).parseInline(e);
+  }
+  parse(e) {
+    let t = "";
+    for (let n = 0; n < e.length; n++) {
+      let r = e[n];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let s = r, a = this.options.extensions.renderers[s.type].call({ parser: this }, s);
+        if (a !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "def", "paragraph", "text"].includes(s.type)) {
+          t += a || "";
+          continue;
+        }
+      }
+      let i = r;
+      switch (i.type) {
+        case "space": {
+          t += this.renderer.space(i);
+          break;
+        }
+        case "hr": {
+          t += this.renderer.hr(i);
+          break;
+        }
+        case "heading": {
+          t += this.renderer.heading(i);
+          break;
+        }
+        case "code": {
+          t += this.renderer.code(i);
+          break;
+        }
+        case "table": {
+          t += this.renderer.table(i);
+          break;
+        }
+        case "blockquote": {
+          t += this.renderer.blockquote(i);
+          break;
+        }
+        case "list": {
+          t += this.renderer.list(i);
+          break;
+        }
+        case "checkbox": {
+          t += this.renderer.checkbox(i);
+          break;
+        }
+        case "html": {
+          t += this.renderer.html(i);
+          break;
+        }
+        case "def": {
+          t += this.renderer.def(i);
+          break;
+        }
+        case "paragraph": {
+          t += this.renderer.paragraph(i);
+          break;
+        }
+        case "text": {
+          t += this.renderer.text(i);
+          break;
+        }
+        default: {
+          let s = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent) return console.error(s), "";
+          throw new Error(s);
+        }
+      }
+    }
+    return t;
+  }
+  parseInline(e, t = this.renderer) {
+    let n = "";
+    for (let r = 0; r < e.length; r++) {
+      let i = e[r];
+      if (this.options.extensions?.renderers?.[i.type]) {
+        let a = this.options.extensions.renderers[i.type].call({ parser: this }, i);
+        if (a !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(i.type)) {
+          n += a || "";
+          continue;
+        }
+      }
+      let s = i;
+      switch (s.type) {
+        case "escape": {
+          n += t.text(s);
+          break;
+        }
+        case "html": {
+          n += t.html(s);
+          break;
+        }
+        case "link": {
+          n += t.link(s);
+          break;
+        }
+        case "image": {
+          n += t.image(s);
+          break;
+        }
+        case "checkbox": {
+          n += t.checkbox(s);
+          break;
+        }
+        case "strong": {
+          n += t.strong(s);
+          break;
+        }
+        case "em": {
+          n += t.em(s);
+          break;
+        }
+        case "codespan": {
+          n += t.codespan(s);
+          break;
+        }
+        case "br": {
+          n += t.br(s);
+          break;
+        }
+        case "del": {
+          n += t.del(s);
+          break;
+        }
+        case "text": {
+          n += t.text(s);
+          break;
+        }
+        default: {
+          let a = 'Token with "' + s.type + '" type was not found.';
+          if (this.options.silent) return console.error(a), "";
+          throw new Error(a);
+        }
+      }
+    }
+    return n;
+  }
+};
+var _a;
+var P = (_a = class {
+  constructor(e) {
+    __publicField(this, "options");
+    __publicField(this, "block");
+    this.options = e || T;
+  }
+  preprocess(e) {
+    return e;
+  }
+  postprocess(e) {
+    return e;
+  }
+  processAllTokens(e) {
+    return e;
+  }
+  emStrongMask(e) {
+    return e;
+  }
+  provideLexer() {
+    return this.block ? x.lex : x.lexInline;
+  }
+  provideParser() {
+    return this.block ? b.parse : b.parseInline;
+  }
+}, __publicField(_a, "passThroughHooks", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"])), __publicField(_a, "passThroughHooksRespectAsync", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"])), _a);
+var B = class {
+  constructor(...e) {
+    __publicField(this, "defaults", M());
+    __publicField(this, "options", this.setOptions);
+    __publicField(this, "parse", this.parseMarkdown(true));
+    __publicField(this, "parseInline", this.parseMarkdown(false));
+    __publicField(this, "Parser", b);
+    __publicField(this, "Renderer", y);
+    __publicField(this, "TextRenderer", $);
+    __publicField(this, "Lexer", x);
+    __publicField(this, "Tokenizer", w);
+    __publicField(this, "Hooks", P);
+    this.use(...e);
+  }
+  walkTokens(e, t) {
+    let n = [];
+    for (let r of e) switch (n = n.concat(t.call(this, r)), r.type) {
+      case "table": {
+        let i = r;
+        for (let s of i.header) n = n.concat(this.walkTokens(s.tokens, t));
+        for (let s of i.rows) for (let a of s) n = n.concat(this.walkTokens(a.tokens, t));
+        break;
+      }
+      case "list": {
+        let i = r;
+        n = n.concat(this.walkTokens(i.items, t));
+        break;
+      }
+      default: {
+        let i = r;
+        this.defaults.extensions?.childTokens?.[i.type] ? this.defaults.extensions.childTokens[i.type].forEach((s) => {
+          let a = i[s].flat(1 / 0);
+          n = n.concat(this.walkTokens(a, t));
+        }) : i.tokens && (n = n.concat(this.walkTokens(i.tokens, t)));
+      }
+    }
+    return n;
+  }
+  use(...e) {
+    let t = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return e.forEach((n) => {
+      let r = { ...n };
+      if (r.async = this.defaults.async || r.async || false, n.extensions && (n.extensions.forEach((i) => {
+        if (!i.name) throw new Error("extension name required");
+        if ("renderer" in i) {
+          let s = t.renderers[i.name];
+          s ? t.renderers[i.name] = function(...a) {
+            let o = i.renderer.apply(this, a);
+            return o === false && (o = s.apply(this, a)), o;
+          } : t.renderers[i.name] = i.renderer;
+        }
+        if ("tokenizer" in i) {
+          if (!i.level || i.level !== "block" && i.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+          let s = t[i.level];
+          s ? s.unshift(i.tokenizer) : t[i.level] = [i.tokenizer], i.start && (i.level === "block" ? t.startBlock ? t.startBlock.push(i.start) : t.startBlock = [i.start] : i.level === "inline" && (t.startInline ? t.startInline.push(i.start) : t.startInline = [i.start]));
+        }
+        "childTokens" in i && i.childTokens && (t.childTokens[i.name] = i.childTokens);
+      }), r.extensions = t), n.renderer) {
+        let i = this.defaults.renderer || new y(this.defaults);
+        for (let s in n.renderer) {
+          if (!(s in i)) throw new Error(`renderer '${s}' does not exist`);
+          if (["options", "parser"].includes(s)) continue;
+          let a = s, o = n.renderer[a], l = i[a];
+          i[a] = (...p) => {
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c || "";
+          };
+        }
+        r.renderer = i;
+      }
+      if (n.tokenizer) {
+        let i = this.defaults.tokenizer || new w(this.defaults);
+        for (let s in n.tokenizer) {
+          if (!(s in i)) throw new Error(`tokenizer '${s}' does not exist`);
+          if (["options", "rules", "lexer"].includes(s)) continue;
+          let a = s, o = n.tokenizer[a], l = i[a];
+          i[a] = (...p) => {
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c;
+          };
+        }
+        r.tokenizer = i;
+      }
+      if (n.hooks) {
+        let i = this.defaults.hooks || new P();
+        for (let s in n.hooks) {
+          if (!(s in i)) throw new Error(`hook '${s}' does not exist`);
+          if (["options", "block"].includes(s)) continue;
+          let a = s, o = n.hooks[a], l = i[a];
+          P.passThroughHooks.has(s) ? i[a] = (p) => {
+            if (this.defaults.async && P.passThroughHooksRespectAsync.has(s)) return (async () => {
+              let d = await o.call(i, p);
+              return l.call(i, d);
+            })();
+            let c = o.call(i, p);
+            return l.call(i, c);
+          } : i[a] = (...p) => {
+            if (this.defaults.async) return (async () => {
+              let d = await o.apply(i, p);
+              return d === false && (d = await l.apply(i, p)), d;
+            })();
+            let c = o.apply(i, p);
+            return c === false && (c = l.apply(i, p)), c;
+          };
+        }
+        r.hooks = i;
+      }
+      if (n.walkTokens) {
+        let i = this.defaults.walkTokens, s = n.walkTokens;
+        r.walkTokens = function(a) {
+          let o = [];
+          return o.push(s.call(this, a)), i && (o = o.concat(i.call(this, a))), o;
+        };
+      }
+      this.defaults = { ...this.defaults, ...r };
+    }), this;
+  }
+  setOptions(e) {
+    return this.defaults = { ...this.defaults, ...e }, this;
+  }
+  lexer(e, t) {
+    return x.lex(e, t ?? this.defaults);
+  }
+  parser(e, t) {
+    return b.parse(e, t ?? this.defaults);
+  }
+  parseMarkdown(e) {
+    return (n, r) => {
+      let i = { ...r }, s = { ...this.defaults, ...i }, a = this.onError(!!s.silent, !!s.async);
+      if (this.defaults.async === true && i.async === false) return a(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof n > "u" || n === null) return a(new Error("marked(): input parameter is undefined or null"));
+      if (typeof n != "string") return a(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected"));
+      if (s.hooks && (s.hooks.options = s, s.hooks.block = e), s.async) return (async () => {
+        let o = s.hooks ? await s.hooks.preprocess(n) : n, p = await (s.hooks ? await s.hooks.provideLexer() : e ? x.lex : x.lexInline)(o, s), c = s.hooks ? await s.hooks.processAllTokens(p) : p;
+        s.walkTokens && await Promise.all(this.walkTokens(c, s.walkTokens));
+        let h = await (s.hooks ? await s.hooks.provideParser() : e ? b.parse : b.parseInline)(c, s);
+        return s.hooks ? await s.hooks.postprocess(h) : h;
+      })().catch(a);
+      try {
+        s.hooks && (n = s.hooks.preprocess(n));
+        let l = (s.hooks ? s.hooks.provideLexer() : e ? x.lex : x.lexInline)(n, s);
+        s.hooks && (l = s.hooks.processAllTokens(l)), s.walkTokens && this.walkTokens(l, s.walkTokens);
+        let c = (s.hooks ? s.hooks.provideParser() : e ? b.parse : b.parseInline)(l, s);
+        return s.hooks && (c = s.hooks.postprocess(c)), c;
+      } catch (o) {
+        return a(o);
+      }
+    };
+  }
+  onError(e, t) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, e) {
+        let r = "<p>An error occurred:</p><pre>" + O(n.message + "", true) + "</pre>";
+        return t ? Promise.resolve(r) : r;
+      }
+      if (t) return Promise.reject(n);
+      throw n;
+    };
+  }
+};
+var L = new B();
+function g(u3, e) {
+  return L.parse(u3, e);
+}
+g.options = g.setOptions = function(u3) {
+  return L.setOptions(u3), g.defaults = L.defaults, G(g.defaults), g;
+};
+g.getDefaults = M;
+g.defaults = T;
+g.use = function(...u3) {
+  return L.use(...u3), g.defaults = L.defaults, G(g.defaults), g;
+};
+g.walkTokens = function(u3, e) {
+  return L.walkTokens(u3, e);
+};
+g.parseInline = L.parseInline;
+g.Parser = b;
+g.parser = b.parse;
+g.Renderer = y;
+g.TextRenderer = $;
+g.Lexer = x;
+g.lexer = x.lex;
+g.Tokenizer = w;
+g.Hooks = P;
+g.parse = g;
+var Ut = g.options;
+var Kt = g.setOptions;
+var Wt = g.use;
+var Xt = g.walkTokens;
+var Jt = g.parseInline;
+var Yt = b.parse;
+var en = x.lex;
+
+// ../../chat/dist/index.js
+import { html as html22 } from "lit";
+import { html as html3, nothing as nothing2 } from "lit";
+import { html as html5 } from "lit";
+import { html as html8, LitElement as LitElement2 } from "lit";
+function getCtor() {
+  if (typeof window === "undefined") return void 0;
+  const w2 = window;
+  return w2.SpeechRecognition ?? w2.webkitSpeechRecognition;
+}
+function isDictationSupported() {
+  return getCtor() !== void 0;
+}
+function mapError(engineCode) {
+  switch (engineCode) {
+    case "not-allowed":
+    case "service-not-allowed":
+      return "not-allowed";
+    case "no-speech":
+      return "no-speech";
+    case "aborted":
+      return "aborted";
+    case "network":
+      return "network";
+    default:
+      return "other";
+  }
+}
+var MAX_SESSION_MS = 6e4;
+function createDictation(opts) {
+  let rec = null;
+  let listening = false;
+  let capTimer = null;
+  const finish = () => {
+    if (capTimer !== null) {
+      clearTimeout(capTimer);
+      capTimer = null;
+    }
+    if (!listening) return;
+    listening = false;
+    rec = null;
+    opts.onEnd();
+  };
+  return {
+    get listening() {
+      return listening;
+    },
+    start() {
+      if (listening) return;
+      const Ctor = getCtor();
+      if (!Ctor) return;
+      rec = new Ctor();
+      rec.lang = opts.lang ?? (document.documentElement.lang || "en-US");
+      rec.continuous = true;
+      rec.interimResults = true;
+      rec.onresult = (e) => {
+        if (!listening) return;
+        const parts = [];
+        let allFinal = true;
+        for (let i = 0; i < e.results.length; i++) {
+          const result = e.results[i];
+          const seg = result[0]?.transcript.trim() ?? "";
+          if (!result.isFinal) allFinal = false;
+          if (seg && seg !== parts[parts.length - 1]) parts.push(seg);
+        }
+        opts.onTranscript(parts.join(" "), allFinal);
+      };
+      rec.onerror = (e) => {
+        const code = mapError(e.error);
+        console.debug(`chat.dictation:error ${e.error} -> ${code}`);
+        listening = false;
+        rec = null;
+        opts.onError(code);
+      };
+      rec.onend = finish;
+      listening = true;
+      capTimer = setTimeout(() => {
+        console.debug("chat.dictation:cap 60s session limit reached \u2014 stopping");
+        const active = rec;
+        finish();
+        active?.stop();
+      }, MAX_SESSION_MS);
+      rec.start();
+    },
+    stop() {
+      const active = rec;
+      finish();
+      active?.stop();
+    }
+  };
+}
+var sendIcon = html2`<svg width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M8 14V2M8 2L3 7M8 2L13 7" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+var stopIcon = html2`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><rect x="1" y="1" width="12" height="12" rx="2" fill="currentColor"/></svg>`;
+var micIcon = html2`<svg width="16" height="16" viewBox="0 0 16 16" fill="none"><rect x="6" y="1.5" width="4" height="8" rx="2" stroke="currentColor" stroke-width="1.6"/><path d="M3.5 7.5a4.5 4.5 0 0 0 9 0M8 12v2.5" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>`;
+function autoResize(e) {
+  const el = e.target;
+  el.style.height = "auto";
+  const capped = Math.min(el.scrollHeight, 150);
+  el.style.height = `${capped}px`;
+  el.style.overflowY = capped >= 150 ? "auto" : "hidden";
+}
+function renderChatInput(props) {
+  const canSend = props.value.trim().length > 0 && !props.isStreaming;
+  const buttonLabel = props.isStreaming ? "Stop generation" : "Send message";
+  const buttonAction = props.isStreaming ? props.onStop : props.onSend;
+  const handleInput = (e) => {
+    autoResize(e);
+    props.onInput(e);
+  };
+  const placeholder = props.placeholder ?? "Type a message...";
+  return html2`
+    ${props.suggestions?.length && !props.isStreaming ? html2`<div data-sc-suggestions>
+          ${props.suggestions.map(
+    (s) => html2`<button @click=${() => props.onSuggestion?.(s)}>${s}</button>`
+  )}
+        </div>` : nothing}
+    ${props.beforeInputSlot ?? nothing}
+    <div data-sc-chat-input>
+      <textarea
+        rows="1"
+        placeholder=${placeholder}
+        .value=${props.value}
+        @input=${handleInput}
+        @keydown=${props.onKeyDown}
+        @compositionstart=${props.onCompositionStart}
+        @compositionend=${props.onCompositionEnd}
+        aria-label="Message input"
+      ></textarea>
+      ${props.inputActionsSlot ?? nothing}
+      ${props.showMic ? html2`<button
+            data-sc-mic-btn
+            data-listening=${props.micListening ? "true" : "false"}
+            ?disabled=${props.micDisabled ?? false}
+            @click=${props.onMicClick}
+            aria-pressed=${props.micListening ? "true" : "false"}
+            aria-label=${props.micListening ? "Stop dictation" : "Start dictation"}
+            title=${props.micDisabled ? "Microphone blocked" : props.micListening ? "Stop dictation" : "Dictate"}
+          >${micIcon}</button>` : nothing}
+      <button
+        data-sc-send-btn
+        ?disabled=${!canSend && !props.isStreaming}
+        @click=${buttonAction}
+        aria-label=${buttonLabel}
+      >${props.isStreaming ? stopIcon : sendIcon}</button>
+    </div>
+  `;
+}
+function fingerprint(msg) {
+  const tcIds = msg.toolCalls?.map((tc) => {
+    let resultKey = "-";
+    if (tc.result !== void 0) {
+      try {
+        const json = JSON.stringify(tc.result);
+        resultKey = json === void 0 ? "u" : String(json.length);
+      } catch {
+        resultKey = String(String(tc.result).length);
+      }
+    }
+    return `${tc.id}:${tc.status}:${tc.interruptId ?? ""}:${resultKey}:${tc.error ?? ""}`;
+  }).join(",") ?? "";
+  return `${msg.id}:${msg.role}:${msg.content.length}:${msg.status}:${tcIds}`;
+}
+var marked = new B({ async: false, gfm: true, breaks: true });
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var codeRenderer = {
+  code({ text: text2, lang }) {
+    const safeLang = lang ? escapeAttr(lang) : "";
+    const langAttr = safeLang ? ` class="language-${safeLang}"` : "";
+    return `<div data-sc-code-block${safeLang ? ` data-lang="${safeLang}"` : ""}><pre><code${langAttr}>${text2}</code></pre></div>
+`;
+  }
+};
+marked.use({ renderer: codeRenderer });
+function renderMarkdown(text2) {
+  if (!text2) return "";
+  const raw = marked.parse(text2);
+  if (typeof window === "undefined") return raw;
+  return purify.sanitize(raw, {
+    ADD_ATTR: ["data-sc-code-block", "data-lang", "data-sc-copy-btn"]
+  });
+}
+var copyIcon = html22`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><rect x="4.5" y="0.5" width="9" height="9" rx="1.5" stroke="currentColor"/><rect x="0.5" y="4.5" width="9" height="9" rx="1.5" stroke="currentColor" fill="var(--sc-chat-action-bar-bg, rgba(0,0,0,0.05))"/></svg>`;
+var regenerateIcon = html22`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><path d="M1.5 7a5.5 5.5 0 0 1 9.9-3.3M12.5 7a5.5 5.5 0 0 1-9.9 3.3" stroke="currentColor" stroke-width="1.3" stroke-linecap="round"/><path d="M11.5 1v3h-3M2.5 13v-3h3" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+function renderActionBar(props) {
+  const showRegenerate = props.role === "assistant" && props.onRegenerate;
+  return html22`
+    <div data-sc-action-bar>
+      <button
+        @click=${() => props.onCopy(props.content)}
+        aria-label="Copy message"
+        title="Copy"
+      >${copyIcon}</button>
+      ${showRegenerate ? html22`<button
+            @click=${() => props.onRegenerate(props.messageId)}
+            aria-label="Regenerate response"
+            title="Regenerate"
+          >${regenerateIcon}</button>` : ""}
+    </div>
+  `;
+}
+var spinnerIcon = html3`<svg data-sc-spinner width="14" height="14" viewBox="0 0 14 14" fill="none"><circle cx="7" cy="7" r="5.5" stroke="currentColor" stroke-width="1.5" opacity="0.2"/><path d="M12.5 7a5.5 5.5 0 0 0-5.5-5.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/></svg>`;
+var checkIcon = html3`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><path d="M3 7.5L6 10.5L11 4" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+var errorIcon = html3`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><circle cx="7" cy="7" r="6" stroke="currentColor" stroke-width="1.3"/><path d="M5 5l4 4M9 5l-4 4" stroke="currentColor" stroke-width="1.3" stroke-linecap="round"/></svg>`;
+var toolIcon = html3`<svg width="14" height="14" viewBox="0 0 14 14" fill="none"><path d="M8.5 2.5l3 3-7.5 7.5H1v-3l7.5-7.5z" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+function statusIcon(status) {
+  switch (status) {
+    case "args-streaming":
+    case "running":
+      return spinnerIcon;
+    case "done":
+      return checkIcon;
+    case "error":
+      return errorIcon;
+    default:
+      return toolIcon;
+  }
+}
+var STATUS_TEXT = {
+  "args-streaming": "Running\u2026",
+  running: "Running\u2026",
+  pending: "Needs approval",
+  done: "Done",
+  error: "Failed",
+  cancelled: "Cancelled"
+};
+function humanizeToolName(name) {
+  const words = name.replace(/[_-]+/g, " ").trim();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : name;
+}
+var ARGS_SUMMARY_MAX = 90;
+var ARG_VALUE_MAX = 48;
+function summarizeArgs(args) {
+  if (!args) return "";
+  const bits = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (value === null || value === void 0) continue;
+    const t = typeof value;
+    if (t !== "string" && t !== "number" && t !== "boolean") continue;
+    let rendered = String(value);
+    if (rendered.length > ARG_VALUE_MAX) rendered = `${rendered.slice(0, ARG_VALUE_MAX)}\u2026`;
+    bits.push(`${key}: ${rendered}`);
+    if (bits.join(" \xB7 ").length >= ARGS_SUMMARY_MAX) break;
+  }
+  let summary = bits.join(" \xB7 ");
+  if (summary.length > ARGS_SUMMARY_MAX) summary = `${summary.slice(0, ARGS_SUMMARY_MAX)}\u2026`;
+  return summary;
+}
+function renderToolCallCard(props) {
+  const { toolCall, toolLabel, approve, deny } = props;
+  const displayName = toolLabel ?? humanizeToolName(toolCall.name);
+  const isActive = toolCall.status === "args-streaming" || toolCall.status === "running";
+  const statusText = STATUS_TEXT[toolCall.status] ?? "";
+  const argsSummary = summarizeArgs(toolCall.args);
+  return html3`
+    <div data-sc-tool-card ?data-sc-active=${isActive} data-sc-tool-phase=${toolCall.status}>
+      <div data-sc-tool-header>
+        <span data-sc-tool-icon data-sc-status=${toolCall.status}>${statusIcon(toolCall.status)}</span>
+        <span data-sc-tool-name>${displayName}</span>
+        ${statusText ? html3`<span data-sc-tool-status-text data-sc-status=${toolCall.status}>${statusText}</span>` : nothing2}
+      </div>
+      ${argsSummary ? html3`<div data-sc-tool-args>${argsSummary}</div>` : nothing2}
+      ${toolCall.status === "error" && toolCall.error ? html3`<div data-sc-tool-error>${toolCall.error}</div>` : nothing2}
+      ${toolCall.status === "pending" ? html3`<div data-sc-tool-actions>
+            <button data-sc-approve @click=${approve} aria-label="Approve ${displayName}">Approve</button>
+            <button data-sc-deny @click=${deny} aria-label="Deny ${displayName}">Deny</button>
+          </div>` : nothing2}
+    </div>
+  `;
+}
+var assistantIcon = html4`<svg data-sc-avatar width="24" height="24" viewBox="0 0 24 24" fill="none"><circle cx="12" cy="12" r="12" fill="var(--sc-color-primary, #6a59ce)"/><path d="M12 4l1.4 3.6L17 9l-3.6 1.4L12 14l-1.4-3.6L7 9l3.6-1.4L12 4z" fill="#fff"/><path d="M16.5 13l.7 1.8 1.8.7-1.8.7-.7 1.8-.7-1.8-1.8-.7 1.8-.7.5-1.8z" fill="#fff" opacity="0.7"/></svg>`;
+function renderBubbleContent(message) {
+  if (message.role === "user") {
+    return html4`<div data-sc-msg-user>${message.content}</div>`;
+  }
+  return html4`<div data-sc-msg-assistant>${unsafeHTML(renderMarkdown(message.content))}</div>`;
+}
+function renderMessageBubble(props) {
+  const { message, toolLabels, toolRenderers, toolContext, defaultToolRenderer } = props;
+  const isUser = message.role === "user";
+  const toolCards = message.toolCalls?.map((tc) => {
+    const approve = (payload) => props.onToolApprove(tc.id, payload);
+    const deny = () => props.onToolDeny(tc.id);
+    const context = toolContext?.[tc.name];
+    const customRenderer = toolRenderers?.[tc.name];
+    if (customRenderer) {
+      return customRenderer.render({
+        toolCall: tc,
+        phase: tc.status,
+        approve,
+        deny,
+        context
+      });
+    }
+    if (defaultToolRenderer) {
+      return defaultToolRenderer.render({
+        toolCall: tc,
+        phase: tc.status,
+        approve,
+        deny,
+        context
+      });
+    }
+    return renderToolCallCard({
+      toolCall: tc,
+      toolLabel: toolLabels?.[tc.name],
+      approve: () => approve(),
+      deny
+    });
+  });
+  return html4`
+    <div data-sc-msg-row data-sc-role=${message.role} data-sc-msg-id=${message.id}>
+      ${!isUser ? assistantIcon : nothing3}
+      <div data-sc-msg-content>
+        ${renderBubbleContent(message)}
+        ${message.status === "error" ? html4`<div data-sc-msg-error>${isUser ? "Failed to send" : "Response interrupted"}</div>` : nothing3}
+        ${toolCards ?? nothing3}
+        ${renderActionBar({
+    messageId: message.id,
+    content: message.content,
+    role: message.role,
+    onCopy: props.onCopy,
+    onRegenerate: isUser ? void 0 : props.onRegenerate
+  })}
+      </div>
+    </div>
+  `;
+}
+function renderTypingIndicator() {
+  return html5`
+    <div data-sc-typing aria-label="Assistant is typing">
+      <span></span><span></span><span></span>
+    </div>
+  `;
+}
+function renderMessageList(props) {
+  if (props.messages.length === 0 && !props.isTyping) {
+    return html6`<div role="log" aria-live="polite" aria-label="Chat messages">
+      ${props.emptyStateSlot ?? nothing4}
+    </div>`;
+  }
+  return html6`
+    <div role="log" aria-live="polite" aria-label="Chat messages" data-sc-msg-list>
+      ${repeat(
+    props.messages,
+    (msg) => msg.id,
+    (msg) => guard(
+      [fingerprint(msg), props.toolContext],
+      () => renderMessageBubble({
+        message: msg,
+        toolLabels: props.toolLabels,
+        toolRenderers: props.toolRenderers,
+        toolContext: props.toolContext,
+        defaultToolRenderer: props.defaultToolRenderer,
+        onCopy: props.onCopy,
+        onRegenerate: props.onRegenerate,
+        onToolApprove: props.onToolApprove,
+        onToolDeny: props.onToolDeny
+      })
+    )
+  )}
+      ${props.isTyping ? props.typingIndicatorSlot ?? renderTypingIndicator() : nothing4}
+    </div>
+  `;
+}
+var STYLE_ID = "sc-chat-styles";
+var STYLE_RULES = `
+@keyframes sc-fade-in {
+  from { opacity: 0; transform: translateY(6px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+@keyframes sc-typing-bounce {
+  0%, 80%, 100% { transform: scale(0.6); opacity: 0.4; }
+  40% { transform: scale(1); opacity: 1; }
+}
+
+@keyframes sc-spin {
+  to { transform: rotate(360deg); }
+}
+
+[data-sc-chat] {
+  font-family: var(--sc-font-family, system-ui, -apple-system, sans-serif);
+  color: var(--sc-content-text-color, #1a1a2e);
+  line-height: var(--sc-chat-line-height, 1.5);
+  font-size: var(--sc-chat-font-size, 0.9375rem);
+}
+
+/* \u2500\u2500 Message list \u2500\u2500 */
+[data-sc-chat] [data-sc-msg-list] {
+  display: flex;
+  flex-direction: column;
+  gap: var(--sc-chat-msg-gap, 4px);
+  padding: var(--sc-chat-msg-list-padding, 16px 16px 8px);
+}
+
+/* \u2500\u2500 Message row (avatar + content) \u2500\u2500 */
+[data-sc-chat] [data-sc-msg-row] {
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+  animation: sc-fade-in 0.25s ease-out;
+}
+
+[data-sc-chat] [data-sc-msg-row][data-sc-role="user"] {
+  flex-direction: row-reverse;
+}
+
+[data-sc-chat] [data-sc-msg-content] {
+  min-width: 0;
+  max-width: 80%;
+}
+
+[data-sc-chat] [data-sc-msg-row][data-sc-role="user"] [data-sc-msg-content] {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+}
+
+/* \u2500\u2500 Avatar \u2500\u2500 */
+[data-sc-chat] [data-sc-avatar] {
+  flex-shrink: 0;
+  margin-top: 2px;
+}
+
+/* \u2500\u2500 Bubbles \u2500\u2500 */
+[data-sc-chat] [data-sc-msg-user] {
+  background: var(--sc-chat-msg-user-bg, var(--sc-color-primary, #6a59ce));
+  color: var(--sc-chat-msg-user-color, var(--sc-color-primary-text, #ffffff));
+  border-radius: var(--sc-chat-msg-user-radius, 18px 18px 4px 18px);
+  padding: var(--sc-chat-msg-user-padding, 10px 16px);
+  word-break: break-word;
+}
+
+[data-sc-chat] [data-sc-msg-assistant] {
+  background: var(--sc-chat-msg-assistant-bg, var(--sc-chat-assistant-bubble-bg, #f4f4f8));
+  color: var(--sc-chat-msg-assistant-color, var(--sc-content-text-color, #1a1a2e));
+  border-radius: var(--sc-chat-msg-assistant-radius, 18px 18px 18px 4px);
+  padding: var(--sc-chat-msg-assistant-padding, 10px 16px);
+  box-shadow: var(--sc-chat-msg-assistant-shadow, 0 1px 2px rgba(0, 0, 0, 0.04));
+  word-break: break-word;
+}
+
+[data-sc-chat] [data-sc-msg-assistant] > :first-child { margin-top: 0; }
+[data-sc-chat] [data-sc-msg-assistant] > :last-child { margin-bottom: 0; }
+
+[data-sc-chat] [data-sc-msg-assistant] p,
+[data-sc-chat] [data-sc-msg-assistant] ul,
+[data-sc-chat] [data-sc-msg-assistant] ol,
+[data-sc-chat] [data-sc-msg-assistant] pre,
+[data-sc-chat] [data-sc-msg-assistant] blockquote {
+  margin: 0.25em 0;
+}
+
+[data-sc-chat] [data-sc-msg-assistant] code:not(pre code) {
+  background: rgba(0, 0, 0, 0.06);
+  padding: 1px 5px;
+  border-radius: 4px;
+  font-size: 0.85em;
+}
+
+[data-sc-chat] [data-sc-msg-assistant] ul,
+[data-sc-chat] [data-sc-msg-assistant] ol {
+  padding-left: 1.2em;
+}
+
+[data-sc-chat] [data-sc-msg-assistant] h1,
+[data-sc-chat] [data-sc-msg-assistant] h2,
+[data-sc-chat] [data-sc-msg-assistant] h3 {
+  margin: 0.5rem 0 0.25rem;
+  color: var(--sc-content-heading-color, #1a1a2e);
+}
+
+/* \u2500\u2500 Code blocks \u2500\u2500 */
+[data-sc-chat] [data-sc-code-block] {
+  position: relative;
+  margin: 0.5rem 0;
+}
+
+[data-sc-chat] [data-sc-code-block]::before {
+  content: attr(data-lang);
+  position: absolute;
+  top: 0;
+  right: 0;
+  padding: 2px 10px;
+  font-size: 0.7rem;
+  color: rgba(255, 255, 255, 0.4);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+[data-sc-chat] [data-sc-code-block] pre {
+  background: var(--sc-chat-code-bg, #1e1e2e);
+  color: #e0e0e0;
+  border-radius: 10px;
+  padding: 14px;
+  overflow-x: auto;
+  font-size: 0.825em;
+  margin: 0;
+  line-height: 1.6;
+}
+
+[data-sc-chat] [data-sc-code-block] [data-sc-copy-btn] {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  background: rgba(255, 255, 255, 0.08);
+  border: none;
+  color: rgba(255, 255, 255, 0.5);
+  border-radius: 6px;
+  padding: 4px 10px;
+  cursor: pointer;
+  font-size: 0.7rem;
+  opacity: 0;
+  transition: opacity 0.15s, background 0.15s;
+}
+
+[data-sc-chat] [data-sc-code-block]:hover [data-sc-copy-btn] {
+  opacity: 1;
+}
+
+[data-sc-chat] [data-sc-code-block] [data-sc-copy-btn]:hover {
+  background: rgba(255, 255, 255, 0.16);
+  color: rgba(255, 255, 255, 0.8);
+}
+
+/* \u2500\u2500 Scrollbar \u2500\u2500 */
+[data-sc-chat] [data-sc-scroll-area]::-webkit-scrollbar {
+  width: 4px;
+}
+[data-sc-chat] [data-sc-scroll-area]::-webkit-scrollbar-track {
+  background: transparent;
+}
+[data-sc-chat] [data-sc-scroll-area]::-webkit-scrollbar-thumb {
+  background: rgba(0, 0, 0, 0.12);
+  border-radius: 4px;
+}
+[data-sc-chat] [data-sc-scroll-area]::-webkit-scrollbar-thumb:hover {
+  background: rgba(0, 0, 0, 0.2);
+}
+
+[data-sc-chat] [data-sc-code-block] pre::-webkit-scrollbar {
+  height: 4px;
+}
+[data-sc-chat] [data-sc-code-block] pre::-webkit-scrollbar-track {
+  background: transparent;
+}
+[data-sc-chat] [data-sc-code-block] pre::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.15);
+  border-radius: 4px;
+}
+
+/* \u2500\u2500 Chat input area \u2500\u2500 */
+[data-sc-chat] [data-sc-chat-input] {
+  display: flex;
+  align-items: flex-end;
+  gap: 8px;
+  padding: var(--sc-chat-input-padding, 12px 16px);
+  border-top: 1px solid var(--sc-content-border-color, #e8e8ee);
+  background: var(--sc-chat-input-bg, #ffffff);
+}
+
+[data-sc-chat] [data-sc-chat-input] textarea {
+  flex: 1;
+  border: 1px solid var(--sc-content-border-color, #e8e8ee);
+  border-radius: var(--sc-chat-textarea-radius, 14px);
+  padding: var(--sc-chat-textarea-padding, 10px 16px);
+  font-family: inherit;
+  /* >= 16px: iOS Safari auto-zooms a focused input < 16px and never zooms back
+     out (same class as the vela AdaptiveChatBar composer fix). 0.9rem was 14.4px
+     \u2192 zoom-on-focus + stuck-zoomed on the native <syntro-chat> mobile surfaces.
+     A workspace can still override the token, but must keep it >= 16px on mobile. */
+  font-size: var(--sc-chat-textarea-font-size, 1rem);
+  resize: none;
+  outline: none;
+  background: var(--sc-chat-input-bg, #ffffff);
+  color: var(--sc-content-text-color, #1a1a2e);
+  min-height: 42px;
+  max-height: 150px;
+  line-height: 1.4;
+  transition: border-color 0.2s, box-shadow 0.2s;
+  overflow-y: hidden;
+}
+
+[data-sc-chat] [data-sc-chat-input] textarea:focus {
+  border-color: var(--sc-color-primary, #6a59ce);
+  box-shadow: 0 0 0 3px var(--sc-chat-focus-ring, rgba(106, 89, 206, 0.1));
+}
+
+[data-sc-chat] [data-sc-send-btn] {
+  background: var(--sc-color-primary, #6a59ce);
+  color: var(--sc-color-primary-text, #ffffff);
+  border: none;
+  border-radius: var(--sc-chat-send-btn-radius, 50%);
+  width: var(--sc-chat-send-btn-size, 38px);
+  height: var(--sc-chat-send-btn-size, 38px);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  transition: background 0.2s, transform 0.15s, opacity 0.2s;
+}
+
+[data-sc-chat] [data-sc-send-btn]:hover:not(:disabled) {
+  background: var(--sc-color-primary-hover, #5a49be);
+  transform: scale(1.05);
+}
+
+[data-sc-chat] [data-sc-send-btn]:active:not(:disabled) {
+  transform: scale(0.95);
+}
+
+[data-sc-chat] [data-sc-send-btn]:disabled {
+  background: var(--sc-content-border-color, #e8e8ee);
+  color: var(--sc-content-text-secondary-color, #87919f);
+  cursor: default;
+}
+
+[data-sc-chat] [data-sc-send-btn] svg {
+  display: block;
+}
+
+[data-sc-chat] [data-sc-mic-btn] {
+  background: transparent;
+  color: var(--sc-content-text-secondary-color, #87919f);
+  border: none;
+  border-radius: 50%;
+  width: var(--sc-chat-send-btn-size, 38px);
+  height: var(--sc-chat-send-btn-size, 38px);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+  transition: color 0.2s, transform 0.15s, opacity 0.2s;
+}
+
+[data-sc-chat] [data-sc-mic-btn]:hover:not(:disabled) {
+  color: var(--sc-color-primary, #6a59ce);
+}
+
+[data-sc-chat] [data-sc-mic-btn]:disabled {
+  opacity: 0.35;
+  cursor: not-allowed;
+}
+
+[data-sc-chat] [data-sc-mic-btn][data-listening='true'] {
+  background: var(--sc-color-primary, #6a59ce);
+  color: var(--sc-color-primary-text, #ffffff);
+  animation: sc-mic-ring 1.5s ease-out infinite;
+}
+
+@keyframes sc-mic-ring {
+  0% {
+    box-shadow: 0 0 0 0 color-mix(in srgb, var(--sc-color-primary, #6a59ce) 45%, transparent);
+    transform: scale(1);
+  }
+  50% { transform: scale(1.08); }
+  70% { box-shadow: 0 0 0 12px transparent; }
+  100% {
+    box-shadow: 0 0 0 0 transparent;
+    transform: scale(1);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  [data-sc-chat] [data-sc-mic-btn][data-listening='true'] {
+    animation: none;
+    box-shadow: 0 0 0 3px color-mix(in srgb, var(--sc-color-primary, #6a59ce) 35%, transparent);
+  }
+}
+
+[data-sc-chat] [data-sc-mic-btn] svg {
+  display: block;
+}
+
+/* \u2500\u2500 Typing indicator (compact: three bouncing dots) \u2500\u2500 */
+[data-sc-chat] [data-sc-typing] {
+  display: flex;
+  gap: 4px;
+  padding: 12px 16px;
+  background: var(--sc-chat-loading-bg, #f4f4f8);
+  border-radius: 18px 18px 18px 4px;
+  width: fit-content;
+  margin-left: 34px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
+}
+
+[data-sc-chat] [data-sc-typing] span {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--sc-content-text-secondary-color, #87919f);
+  animation: sc-typing-bounce 1.4s infinite ease-in-out both;
+}
+
+[data-sc-chat] [data-sc-typing] span:nth-child(2) { animation-delay: 0.16s; }
+[data-sc-chat] [data-sc-typing] span:nth-child(3) { animation-delay: 0.32s; }
+
+/* \u2500\u2500 Suggestion chips \u2500\u2500 */
+[data-sc-chat] [data-sc-suggestions] {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 8px 16px;
+}
+
+[data-sc-chat] [data-sc-suggestions] button {
+  background: transparent;
+  border: 1px solid var(--sc-content-border-color, #e8e8ee);
+  border-radius: 20px;
+  padding: 7px 16px;
+  font-size: 0.84rem;
+  cursor: pointer;
+  color: var(--sc-content-text-color, #1a1a2e);
+  transition: all 0.2s;
+}
+
+[data-sc-chat] [data-sc-suggestions] button:hover {
+  background: var(--sc-chat-assistant-bubble-bg, #f4f4f8);
+  border-color: var(--sc-color-primary, #6a59ce);
+  color: var(--sc-color-primary, #6a59ce);
+  transform: translateY(-1px);
+  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.06);
+}
+
+/* \u2500\u2500 Action bar (hover-revealed message actions: copy, regenerate) \u2500\u2500 */
+[data-sc-chat] [data-sc-action-bar] {
+  display: none;
+  gap: 2px;
+  padding-top: 2px;
+}
+
+[data-sc-chat] [data-sc-msg-row]:hover [data-sc-action-bar] {
+  display: flex;
+}
+
+[data-sc-chat] [data-sc-action-bar] button {
+  background: transparent;
+  border: none;
+  border-radius: 6px;
+  padding: 5px;
+  cursor: pointer;
+  color: var(--sc-content-text-secondary-color, #87919f);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  transition: background 0.15s, color 0.15s;
+}
+
+[data-sc-chat] [data-sc-action-bar] button:hover {
+  background: var(--sc-chat-action-bar-bg, rgba(0, 0, 0, 0.06));
+  color: var(--sc-content-text-color, #1a1a2e);
+}
+
+/* \u2500\u2500 Tool call cards (compact: bordered card + icon) \u2500\u2500 */
+[data-sc-chat] [data-sc-tool-card] {
+  border: 1px solid var(--sc-content-border-color, #e8e8ee);
+  border-left: 3px solid var(--sc-color-primary, #6a59ce);
+  border-radius: 4px 10px 10px 4px;
+  padding: 10px 14px;
+  margin-top: 8px;
+  font-size: 0.84rem;
+  background: var(--sc-chat-assistant-bubble-bg, #f4f4f8);
+  transition: border-color 0.2s;
+}
+
+[data-sc-chat] [data-sc-tool-card][data-sc-active] {
+  border-left-color: #3b82f6;
+}
+
+[data-sc-chat] [data-sc-tool-header] {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+[data-sc-chat] [data-sc-tool-icon] {
+  display: flex;
+  color: var(--sc-color-primary, #6a59ce);
+}
+
+[data-sc-chat] [data-sc-tool-icon][data-sc-status="done"] {
+  color: #22c55e;
+}
+
+[data-sc-chat] [data-sc-tool-icon][data-sc-status="error"] {
+  color: #ef4444;
+}
+
+[data-sc-chat] [data-sc-tool-icon][data-sc-status="running"],
+[data-sc-chat] [data-sc-tool-icon][data-sc-status="args-streaming"] {
+  color: #3b82f6;
+}
+
+[data-sc-chat] [data-sc-spinner] {
+  animation: sc-spin 0.8s linear infinite;
+}
+
+[data-sc-chat] [data-sc-tool-name] {
+  font-weight: 600;
+}
+
+[data-sc-chat] [data-sc-tool-status-text] {
+  margin-left: auto;
+  font-size: 0.72rem;
+  font-weight: 500;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  color: var(--sc-content-text-secondary-color, #6b6b80);
+  white-space: nowrap;
+}
+
+[data-sc-chat] [data-sc-tool-status-text][data-sc-status="done"] {
+  color: #22c55e;
+}
+
+[data-sc-chat] [data-sc-tool-status-text][data-sc-status="error"] {
+  color: #ef4444;
+}
+
+[data-sc-chat] [data-sc-tool-status-text][data-sc-status="running"],
+[data-sc-chat] [data-sc-tool-status-text][data-sc-status="args-streaming"] {
+  color: #3b82f6;
+}
+
+[data-sc-chat] [data-sc-tool-status-text][data-sc-status="cancelled"] {
+  color: var(--sc-content-text-secondary-color, #6b6b80);
+  text-decoration: line-through;
+}
+
+[data-sc-chat] [data-sc-tool-args] {
+  margin-top: 6px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.76rem;
+  color: var(--sc-content-text-secondary-color, #6b6b80);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+[data-sc-chat] [data-sc-tool-card][data-sc-tool-phase="cancelled"] {
+  opacity: 0.65;
+  border-left-color: var(--sc-content-border-color, #e8e8ee);
+}
+
+[data-sc-chat] [data-sc-tool-error] {
+  color: #ef4444;
+  font-size: 0.8rem;
+  margin-top: 6px;
+}
+
+[data-sc-chat] [data-sc-tool-actions] {
+  display: flex;
+  gap: 8px;
+  margin-top: 10px;
+}
+
+[data-sc-chat] [data-sc-tool-actions] button {
+  padding: 5px 14px;
+  border-radius: 8px;
+  font-size: 0.8rem;
+  cursor: pointer;
+  border: 1px solid var(--sc-content-border-color, #e8e8ee);
+  background: transparent;
+  transition: all 0.15s;
+}
+
+[data-sc-chat] [data-sc-tool-actions] [data-sc-approve] {
+  background: var(--sc-color-primary, #6a59ce);
+  color: var(--sc-color-primary-text, #ffffff);
+  border-color: transparent;
+}
+
+[data-sc-chat] [data-sc-tool-actions] [data-sc-approve]:hover {
+  filter: brightness(1.1);
+}
+
+[data-sc-chat] [data-sc-tool-actions] [data-sc-deny] {
+  color: var(--sc-content-text-secondary-color, #87919f);
+}
+
+[data-sc-chat] [data-sc-tool-actions] [data-sc-deny]:hover {
+  border-color: #ef4444;
+  color: #ef4444;
+}
+
+/* \u2500\u2500 Error banner \u2500\u2500 */
+[data-sc-chat] [data-sc-error] {
+  background: #fef2f2;
+  border-left: 3px solid #ef4444;
+  padding: 8px 12px;
+  border-radius: 0 8px 8px 0;
+  font-size: 0.84rem;
+  color: #dc2626;
+}
+
+[data-sc-chat] [data-sc-msg-error] {
+  font-size: 0.8rem;
+  color: #ef4444;
+  margin-top: 4px;
+}
+
+/* \u2500\u2500 "Scroll to most recent" pill \u2500\u2500 */
+[data-sc-chat] [data-sc-scroll-btn] {
+  position: absolute;
+  bottom: 80px;
+  left: 50%;
+  transform: translateX(-50%);
+  background: var(--sc-chat-assistant-bubble-bg, #f4f4f8);
+  color: var(--sc-content-text-color, #1a1a2e);
+  border: 1px solid var(--sc-content-border-color, #e8e8ee);
+  border-radius: 9999px;
+  height: 28px;
+  padding: 0 10px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 5px;
+  font-size: 12px;
+  font-weight: 500;
+  line-height: 1;
+  white-space: nowrap;
+  cursor: pointer;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  z-index: 1;
+  transition: box-shadow 0.2s;
+}
+
+[data-sc-chat] [data-sc-scroll-btn]:hover {
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+[data-sc-chat] [data-sc-scroll-btn] svg {
+  display: block;
+}
+
+
+`.trim();
+function injectChatStyles(root = typeof document === "undefined" ? void 0 : document) {
+  if (!root) return;
+  if (root.getElementById?.(STYLE_ID) ?? root.querySelector(`#${STYLE_ID}`)) return;
+  const style = document.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = STYLE_RULES;
+  if (root instanceof Document) {
+    root.head.appendChild(style);
+    return;
+  }
+  root.insertBefore(style, root.firstChild ?? null);
+}
+var _SyntroChat = class _SyntroChat2 extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.voiceInput = false;
+    this._messages = [];
+    this._micListening = false;
+    this._micDisabled = false;
+    this._micBase = "";
+    this._micNetworkErrors = 0;
+    this._dictation = null;
+    this._isTyping = false;
+    this._inputValue = "";
+    this._isComposing = false;
+    this._isStreaming = false;
+    this._unsubscribe = null;
+    this._scrollContainer = null;
+    this._errorMessage = null;
+    this._stickToBottom = true;
+    this._messagesBelow = 0;
+    this._lastUserScrollIntentTs = 0;
+    this._markUserScrollIntent = () => {
+      this._lastUserScrollIntentTs = Date.now();
+    };
+    this._handleScroll = () => {
+      if (!this._scrollContainer) return;
+      const atBottom = this._isAtBottom();
+      this._messagesBelow = atBottom ? 0 : this._countMessagesBelow();
+      const isUserDriven = Date.now() - this._lastUserScrollIntentTs < _SyntroChat2._USER_SCROLL_INTENT_WINDOW_MS;
+      if (isUserDriven) {
+        this._stickToBottom = atBottom;
+      }
+    };
+    this._resumeFollowing = () => {
+      this._stickToBottom = true;
+      this._scrollToBottom();
+    };
+    this._handleEvent = (event) => {
+      switch (event.type) {
+        case "session-ready":
+          break;
+        case "messages-snapshot":
+          this._messages = [...event.messages];
+          this._isStreaming = event.messages.some((m2) => m2.status === "streaming");
+          this._stickToBottom = true;
+          this._scrollToBottom();
+          break;
+        case "message-append":
+          if (!this._messages.some((m2) => m2.id === event.message.id)) {
+            this._messages = [...this._messages, event.message];
+          }
+          this._isStreaming = event.message.status === "streaming";
+          if (event.message.role === "user") {
+            this._anchorToMessage(event.message.id);
+          } else {
+            this._onContentGrowth();
+          }
+          break;
+        case "message-delta": {
+          this._messages = this._messages.map(
+            (m2) => m2.id === event.messageId ? { ...m2, content: m2.content + event.delta } : m2
+          );
+          this._onContentGrowth();
+          break;
+        }
+        case "message-complete":
+          this._messages = this._messages.map(
+            (m2) => m2.id === event.messageId ? { ...m2, status: "complete" } : m2
+          );
+          this._isStreaming = false;
+          break;
+        case "typing":
+          this._isTyping = event.isTyping;
+          if (event.isTyping) this._onContentGrowth();
+          break;
+        case "tool-call": {
+          const hasParent = this._messages.some((m2) => m2.id === event.messageId);
+          if (!hasParent) {
+            this._messages = [
+              ...this._messages,
+              {
+                id: event.messageId,
+                role: "assistant",
+                content: "",
+                timestamp: Date.now(),
+                status: "streaming"
+              }
+            ];
+          }
+          this._messages = this._messages.map((m2) => {
+            if (m2.id !== event.messageId) return m2;
+            const existing = (m2.toolCalls ?? []).findIndex((tc) => tc.id === event.toolCall.id);
+            if (existing >= 0) {
+              const toolCalls = [...m2.toolCalls ?? []];
+              toolCalls[existing] = event.toolCall;
+              return { ...m2, toolCalls };
+            }
+            return { ...m2, toolCalls: [...m2.toolCalls ?? [], event.toolCall] };
+          });
+          if (this.autoExecTools?.has(event.toolCall.name) && event.toolCall.status === "pending") {
+            this._markToolDone(event.toolCall.id);
+            this.transport.send({
+              type: "tool-result",
+              toolCallId: event.toolCall.id,
+              result: null,
+              approved: true
+            });
+          }
+          break;
+        }
+        case "tool-call-args-delta": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map(
+              (tc) => tc.id === event.toolCallId ? { ...tc, argsBuffer: tc.argsBuffer + event.delta } : tc
+            );
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-done": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map((tc) => {
+              if (tc.id !== event.toolCallId) return tc;
+              let args;
+              try {
+                args = JSON.parse(tc.argsBuffer);
+              } catch {
+                args = void 0;
+              }
+              return { ...tc, status: "done", args };
+            });
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-deferred": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map(
+              (tc) => tc.id === event.toolCallId ? { ...tc, interruptId: event.interruptId, status: "pending" } : tc
+            );
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-cancelled": {
+          this._messages = this._messages.map((m2) => {
+            if (!m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map(
+              (tc) => tc.id === event.toolCallId ? { ...tc, status: "cancelled" } : tc
+            );
+            return { ...m2, toolCalls };
+          });
+          break;
+        }
+        case "tool-call-result": {
+          let foundToolName;
+          let lastIdx = -1;
+          for (let i = this._messages.length - 1; i >= 0; i--) {
+            if (this._messages[i].toolCalls?.some((tc) => tc.id === event.toolCallId)) {
+              lastIdx = i;
+              break;
+            }
+          }
+          this._messages = this._messages.map((m2, idx) => {
+            if (idx !== lastIdx || !m2.toolCalls) return m2;
+            const toolCalls = m2.toolCalls.map((tc) => {
+              if (tc.id !== event.toolCallId) return tc;
+              foundToolName = tc.name;
+              const status = tc.status === "cancelled" ? "cancelled" : "done";
+              return { ...tc, result: event.result, status };
+            });
+            return { ...m2, toolCalls };
+          });
+          this.dispatchEvent(
+            new CustomEvent("tool-result-received", {
+              detail: {
+                toolCallId: event.toolCallId,
+                toolName: foundToolName,
+                result: event.result
+              },
+              bubbles: true,
+              composed: true
+            })
+          );
+          break;
+        }
+        case "error": {
+          const isSoftTurnEnd = event.code === "USAGE_LIMIT";
+          this._isStreaming = false;
+          this._messages = this._messages.map((m2) => {
+            const wasStreaming = m2.status === "streaming";
+            const hasLiveTool = m2.toolCalls?.some(
+              (tc) => tc.status === "args-streaming" || tc.status === "running"
+            );
+            if (!wasStreaming && !hasLiveTool) return m2;
+            const toolCalls = hasLiveTool ? m2.toolCalls?.map((tc) => {
+              if (tc.status !== "args-streaming" && tc.status !== "running") return tc;
+              return isSoftTurnEnd ? { ...tc, status: "cancelled" } : { ...tc, status: "error", error: tc.error ?? event.message };
+            }) : m2.toolCalls;
+            const nextStatus = wasStreaming ? isSoftTurnEnd ? "complete" : "error" : m2.status;
+            return { ...m2, status: nextStatus, toolCalls };
+          });
+          if (isSoftTurnEnd) {
+            const id = `usage-limit-${this._messages.length}-${event.message.length}`;
+            this._messages = [
+              ...this._messages,
+              {
+                id,
+                role: "assistant",
+                content: event.message,
+                timestamp: Date.now(),
+                status: "complete"
+              }
+            ];
+          } else {
+            console.warn("[syntro-chat] run error:", event.message);
+            this._errorMessage = "Hmm, that didn't go through. Please try again.";
+          }
+          break;
+        }
+        case "a2ui":
+          break;
+      }
+    };
+    this._onInput = (e) => {
+      if (this._micListening) this._dictation?.stop();
+      this._inputValue = e.target.value;
+    };
+    this._onMicClick = () => {
+      if (this._micListening) {
+        this._dictation?.stop();
+        return;
+      }
+      this._micBase = this._inputValue;
+      this._dictation = createDictation({
+        onTranscript: (text2) => {
+          this._micNetworkErrors = 0;
+          this._inputValue = this._micBase + (this._micBase ? " " : "") + text2;
+        },
+        onEnd: () => {
+          this._micListening = false;
+        },
+        onError: (code) => {
+          this._micListening = false;
+          if (code === "not-allowed") this._micDisabled = true;
+          if (code === "network" && ++this._micNetworkErrors >= 2) this._micDisabled = true;
+        }
+      });
+      this._dictation.start();
+      this._micListening = this._dictation.listening;
+    };
+    this._onSend = () => {
+      if (this._micListening) this._dictation?.stop();
+      const text2 = this._inputValue.trim();
+      if (!text2) return;
+      this._appendUserMessage(text2);
+      this.transport.send({ type: "user-message", text: text2 });
+      this._inputValue = "";
+    };
+    this._onStop = () => {
+      this.transport.send({ type: "stop-generation" });
+    };
+    this._onKeyDown = (e) => {
+      if (e.key === "Enter" && !e.shiftKey && !this._isComposing) {
+        e.preventDefault();
+        if (this._isStreaming) {
+          this._onStop();
+        } else {
+          this._onSend();
+        }
+      }
+    };
+    this._onCopy = (content) => {
+      navigator.clipboard?.writeText(content);
+    };
+    this._onRegenerate = (messageId) => {
+      this.transport.send({ type: "regenerate", messageId });
+    };
+    this._onToolApprove = (toolCallId, payload, _retryCount = 0) => {
+      const interruptId = this._findInterruptId(toolCallId);
+      if (interruptId) {
+        this._markToolDone(toolCallId);
+        this.transport.send({
+          type: "deferred-tool-resume",
+          interruptId,
+          decision: "approve",
+          ...payload?.editedArgs ? { editedArgs: payload.editedArgs } : {}
+        });
+        return;
+      }
+      if (this._isPendingClientTool(toolCallId)) {
+        this._markToolDone(toolCallId);
+        this.transport.send({
+          type: "tool-result",
+          toolCallId,
+          result: payload?.editedArgs ?? null,
+          approved: true
+        });
+        return;
+      }
+      if (_retryCount < 10) {
+        setTimeout(() => this._onToolApprove(toolCallId, payload, _retryCount + 1), 200);
+        return;
+      }
+      this._markToolDone(toolCallId);
+      this.transport.send({
+        type: "tool-result",
+        toolCallId,
+        result: payload?.editedArgs ?? null,
+        approved: true
+      });
+    };
+    this._onToolDeny = (toolCallId, _retryCount = 0) => {
+      const interruptId = this._findInterruptId(toolCallId);
+      if (interruptId) {
+        this._markToolCancelled(toolCallId);
+        this.transport.send({
+          type: "deferred-tool-resume",
+          interruptId,
+          decision: "deny"
+        });
+        return;
+      }
+      if (this._isPendingClientTool(toolCallId)) {
+        this._markToolCancelled(toolCallId);
+        this.transport.send({
+          type: "tool-result",
+          toolCallId,
+          result: null,
+          approved: false
+        });
+        return;
+      }
+      if (_retryCount < 10) {
+        setTimeout(() => this._onToolDeny(toolCallId, _retryCount + 1), 200);
+        return;
+      }
+      this._markToolCancelled(toolCallId);
+      this.transport.send({
+        type: "tool-result",
+        toolCallId,
+        result: null,
+        approved: false
+      });
+    };
+    this._onCompositionStart = () => {
+      this._isComposing = true;
+    };
+    this._onCompositionEnd = () => {
+      this._isComposing = false;
+    };
+    this._onSuggestion = (text2) => {
+      this.sendUserMessage(text2);
+    };
+  }
+  // ── Public API: thread navigation ──────────────────────────────────
+  //
+  // Composing elements (the per-surface wrappers like
+  // <ap-action-plan-chat>) call these to load past threads and start
+  // new ones. The chat element doesn't own the thread index — that's
+  // the consumer's job (typically a sibling <syntro-chat-thread-list>
+  // + the consumer's REST endpoint). This element just owns the
+  // visible message state.
+  /**
+   * Replace the chat's message history wholesale. Used by the host
+   * shell when switching threads (after fetching the new thread's
+   * messages from persistence) or when restoring a session.
+   *
+   * Emits `chat-messages-replaced` so dependent UI (overlay cards,
+   * action plan sidebar) can react.
+   */
+  replaceMessages(messages) {
+    this._messages = [...messages];
+    this._isStreaming = messages.some((m2) => m2.status === "streaming");
+    this._stickToBottom = true;
+    requestAnimationFrame(() => this._scrollToBottom());
+    this.dispatchEvent(
+      new CustomEvent("chat-messages-replaced", {
+        detail: { messageCount: messages.length },
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  /**
+   * Clear the chat for a fresh conversation. Equivalent to
+   * `replaceMessages([])` plus a state reset.
+   */
+  reset() {
+    this._messages = [];
+    this._isStreaming = false;
+    this._isTyping = false;
+    this._inputValue = "";
+    this._stickToBottom = true;
+    this._messagesBelow = 0;
+    this._errorMessage = null;
+  }
+  /**
+   * Externally drive the typing indicator. Used by the surface's
+   * run-state restore (BUG-1781288061): a remounted thread whose durable
+   * producer run is still in flight shows the indicator and polls — the
+   * transport's own 'typing' events only exist while the SSE stream lives.
+   */
+  setTyping(isTyping) {
+    this._isTyping = isTyping;
+    if (isTyping) this._scrollToBottom();
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._ensureStylesInRoot();
+    if (this.transport) {
+      this._unsubscribe = this.transport.subscribe(this._handleEvent);
+      this.transport.connect();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this._unsubscribe?.();
+    this._unsubscribe = null;
+    this.transport?.disconnect();
+    this._scrollContainer?.removeEventListener("scroll", this._handleScroll);
+    this._scrollContainer?.removeEventListener("wheel", this._markUserScrollIntent);
+    this._scrollContainer?.removeEventListener("touchmove", this._markUserScrollIntent);
+    this._scrollContainer = null;
+  }
+  firstUpdated() {
+    this._ensureStylesInRoot();
+    this._attachScrollListener();
+  }
+  /** Attach the scroll listener if not already attached. Called from both
+   * firstUpdated (initial mount) and updated (re-mounts — Lit never
+   * re-fires firstUpdated for the same element instance, and
+   * disconnectedCallback tears the listener down). */
+  _attachScrollListener() {
+    if (this._scrollContainer) return;
+    this._scrollContainer = this.querySelector("[data-sc-scroll-area]");
+    this._scrollContainer?.addEventListener("scroll", this._handleScroll);
+    this._scrollContainer?.addEventListener("wheel", this._markUserScrollIntent, {
+      passive: true
+    });
+    this._scrollContainer?.addEventListener("touchmove", this._markUserScrollIntent, {
+      passive: true
+    });
+  }
+  /**
+   * Resolve the *effective* rendering root for this chat instance.
+   *
+   * `this.getRootNode()` will follow shadow boundaries, but in the editor
+   * surface the chat is created via `document.createElement('syntro-chat')`
+   * and then committed into the smart-canvas shadow tree by Lit several
+   * frames after `connectedCallback`. During that window
+   * `getRootNode()` returns Document even though the element ultimately
+   * lives in a shadow root (BUG-1779636600).
+   *
+   * Walk the parent chain manually, hopping across shadow boundaries via
+   * `.host`, and return the deepest enclosing `ShadowRoot` we can reach.
+   * Fall back to `getRootNode()` (Document or self) when no shadow root
+   * is in the chain — that's the host-page chatbot case.
+   */
+  _resolveStyleRoot() {
+    let node = this;
+    while (node) {
+      const parent = node.parentNode;
+      if (parent) {
+        node = parent;
+        continue;
+      }
+      if (node instanceof ShadowRoot) return node;
+      break;
+    }
+    const r = this.getRootNode();
+    return r instanceof ShadowRoot || r instanceof Document ? r : document;
+  }
+  _ensureStylesInRoot() {
+    injectChatStyles(this._resolveStyleRoot());
+  }
+  updated() {
+    this._attachScrollListener();
+    this._injectCodeCopyButtons();
+  }
+  _injectCodeCopyButtons() {
+    const blocks = this.querySelectorAll("[data-sc-code-block]:not(:has([data-sc-copy-btn]))");
+    for (const block of blocks) {
+      const btn = document.createElement("button");
+      btn.setAttribute("data-sc-copy-btn", "");
+      btn.textContent = "Copy";
+      btn.addEventListener("click", () => {
+        const code = block.querySelector("code");
+        if (code) navigator.clipboard?.writeText(code.textContent ?? "");
+        btn.textContent = "Copied!";
+        setTimeout(() => {
+          btn.textContent = "Copy";
+        }, 1500);
+      });
+      block.appendChild(btn);
+    }
+  }
+  _isAtBottom() {
+    if (!this._scrollContainer) return true;
+    const { scrollTop, scrollHeight, clientHeight } = this._scrollContainer;
+    return scrollHeight - scrollTop - clientHeight <= _SyntroChat2._BOTTOM_EPSILON_PX;
+  }
+  /** Count messages whose bottom edge hasn't entered the viewport yet.
+   * At the bottom this is 0 (pill hidden); it decrements one-by-one as the
+   * visitor scrolls down past each message. */
+  _countMessagesBelow() {
+    const container = this._scrollContainer;
+    if (!container) return 0;
+    if (this._isAtBottom()) return 0;
+    const viewportBottom = container.getBoundingClientRect().top + container.clientHeight;
+    let count = 0;
+    for (const row of this.querySelectorAll("[data-sc-msg-row]")) {
+      if (row.getBoundingClientRect().bottom > viewportBottom + 4) count += 1;
+    }
+    return count > 0 ? count : 1;
+  }
+  /** Recompute `_messagesBelow` from live geometry. Called on scroll AND on
+   * content growth (deltas grow scrollHeight without a scroll event). */
+  _syncScrollState() {
+    this._messagesBelow = this._isAtBottom() ? 0 : this._countMessagesBelow();
+  }
+  _scrollToBottom() {
+    if (!this._stickToBottom) return;
+    requestAnimationFrame(() => {
+      if (this._scrollContainer?.scrollTo) {
+        this._scrollContainer.scrollTo({
+          top: this._scrollContainer.scrollHeight,
+          behavior: "smooth"
+        });
+      }
+      this._syncScrollState();
+    });
+  }
+  /**
+   * Anchor the view so the given (just-sent) user message sits at the TOP of
+   * the scroll area: the visitor sees their message, then reads the reply
+   * top-down instead of chasing an auto-scrolling tail.
+   */
+  _anchorToMessage(messageId) {
+    this._stickToBottom = false;
+    requestAnimationFrame(() => {
+      const container = this._scrollContainer;
+      if (!container?.scrollTo) return;
+      const row = this.querySelector(`[data-sc-msg-id="${messageId}"]`);
+      if (!row) return;
+      const top = row.getBoundingClientRect().top - container.getBoundingClientRect().top + container.scrollTop;
+      container.scrollTo({ top, behavior: "smooth" });
+      this._syncScrollState();
+    });
+  }
+  /** Content grew (delta/typing/append while anchored): don't move the
+   * view, but re-evaluate whether the pill should show. */
+  _onContentGrowth() {
+    if (this._stickToBottom) {
+      this._scrollToBottom();
+      return;
+    }
+    requestAnimationFrame(() => this._syncScrollState());
+  }
+  _appendUserMessage(text2) {
+    const msg = {
+      id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      role: "user",
+      content: text2,
+      timestamp: Date.now(),
+      status: "complete"
+    };
+    this._messages = [...this._messages, msg];
+    this._anchorToMessage(msg.id);
+  }
+  _isPendingClientTool(toolCallId) {
+    for (const m2 of this._messages) {
+      const tc = m2.toolCalls?.find((t) => t.id === toolCallId);
+      if (tc) return tc.status === "pending" && !tc.interruptId;
+    }
+    return false;
+  }
+  _findInterruptId(toolCallId) {
+    for (const m2 of this._messages) {
+      const tc = m2.toolCalls?.find((t) => t.id === toolCallId);
+      if (tc?.interruptId) return tc.interruptId;
+    }
+    return void 0;
+  }
+  _markToolDone(toolCallId) {
+    this._markToolStatus(toolCallId, "done");
+  }
+  /** Deny paths mark 'cancelled' — the frozen card must READ as rejected
+   * ("Rejected" label), never as the done-phase "Approved". */
+  _markToolCancelled(toolCallId) {
+    this._markToolStatus(toolCallId, "cancelled");
+  }
+  _markToolStatus(toolCallId, status) {
+    this._messages = this._messages.map((m2) => {
+      if (!m2.toolCalls) return m2;
+      const toolCalls = m2.toolCalls.map((tc) => tc.id === toolCallId ? { ...tc, status } : tc);
+      return { ...m2, toolCalls };
+    });
+  }
+  /**
+   * Append a user message to the local log and forward it to the
+   * transport. Equivalent to typing `text` and pressing Send — exposed
+   * publicly so consumers that render their own input affordances (e.g.
+   * suggestion rows inside a custom empty-state slot) get the same
+   * optimistic-append behavior the built-in input has, without
+   * duplicating logic.
+   */
+  sendUserMessage(text2) {
+    if (this._micListening) this._dictation?.stop();
+    const trimmed = text2.trim();
+    if (!trimmed) return;
+    this._appendUserMessage(trimmed);
+    this.transport.send({ type: "user-message", text: trimmed });
+  }
+  render() {
+    const headerSlot = this.slots?.header;
+    const emptyState = this.slots?.emptyState ?? (this.greeting ? html7`<div
+            style="padding:24px;text-align:center;color:var(--sc-content-text-secondary-color,#87919f)"
+          >
+            ${this.greeting}
+          </div>` : void 0);
+    return html7`
+      <div data-sc-chat style="display:flex;flex-direction:column;height:100%;position:relative;">
+        ${headerSlot && typeof headerSlot === "object" && "values" in headerSlot ? headerSlot : nothing5}
+        <div data-sc-scroll-area style="flex:1;overflow-y:auto;">
+          ${renderMessageList({
+      messages: this._messages,
+      isTyping: this._isTyping,
+      toolLabels: this.toolLabels,
+      toolRenderers: this.toolRenderers,
+      toolContext: this.toolContext,
+      defaultToolRenderer: this.defaultToolRenderer,
+      onCopy: this._onCopy,
+      onRegenerate: this._onRegenerate,
+      onToolApprove: this._onToolApprove,
+      onToolDeny: this._onToolDeny,
+      emptyStateSlot: emptyState,
+      typingIndicatorSlot: this.slots?.typingIndicator
+    })}
+        </div>
+        ${this._messagesBelow > 0 ? html7`<button data-sc-scroll-btn @click=${this._resumeFollowing} aria-label="Scroll to most recent — ${this._messagesBelow} ${this._messagesBelow === 1 ? "message" : "messages"} below"><svg width="14" height="14" viewBox="0 0 16 16" fill="none"><path d="M4 6l4 4 4-4" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg><span>${this._messagesBelow} ${this._messagesBelow === 1 ? "message" : "messages"}</span></button>` : nothing5}
+        ${this._errorMessage ? html7`<div data-sc-error role="alert">${this._errorMessage}</div>` : nothing5}
+        ${renderChatInput({
+      value: this._inputValue,
+      isStreaming: this._isStreaming || this._isTyping,
+      isComposing: this._isComposing,
+      onInput: this._onInput,
+      onSend: this._onSend,
+      onStop: this._onStop,
+      onKeyDown: this._onKeyDown,
+      onCompositionStart: this._onCompositionStart,
+      onCompositionEnd: this._onCompositionEnd,
+      suggestions: this._messages.length === 0 ? this.suggestions : void 0,
+      onSuggestion: this._onSuggestion,
+      inputActionsSlot: this.slots?.inputActions,
+      beforeInputSlot: this.slots?.beforeInput,
+      // Listening is a mode the visitor must be able to see AND exit:
+      // the placeholder doubles as the tap-to-stop instruction.
+      placeholder: this._micListening ? "Listening \u2014 tap the mic to stop" : this.placeholder,
+      showMic: this.voiceInput && isDictationSupported(),
+      micListening: this._micListening,
+      micDisabled: this._micDisabled,
+      onMicClick: this._onMicClick
+    })}
+      </div>
+    `;
+  }
+};
+_SyntroChat.properties = {
+  transport: { attribute: false },
+  greeting: { type: String },
+  suggestions: { attribute: false },
+  toolLabels: { attribute: false },
+  toolRenderers: { attribute: false },
+  toolContext: { attribute: false },
+  defaultToolRenderer: { attribute: false },
+  autoExecTools: { attribute: false },
+  placeholder: { type: String },
+  slots: { attribute: false },
+  voiceInput: { type: Boolean, attribute: "voice-input" },
+  _messages: { state: true },
+  _micListening: { state: true },
+  _micDisabled: { state: true },
+  _isTyping: { state: true },
+  _inputValue: { state: true },
+  _isComposing: { state: true },
+  _isStreaming: { state: true },
+  _messagesBelow: { state: true },
+  _errorMessage: { state: true }
+};
+_SyntroChat._BOTTOM_EPSILON_PX = 50;
+_SyntroChat._USER_SCROLL_INTENT_WINDOW_MS = 1200;
+var SyntroChat = _SyntroChat;
+var SyntroChatThreadList = class extends LitElement2 {
+  constructor() {
+    super(...arguments);
+    this.threadsEndpoint = "";
+    this.activeThreadId = null;
+    this.newThreadLabel = "New thread";
+    this.emptyStateLabel = "No threads yet";
+    this._threads = [];
+    this._loading = false;
+    this._error = null;
+    this._onThreadClick = (threadId) => {
+      if (threadId === this.activeThreadId) return;
+      this.dispatchEvent(
+        new CustomEvent("thread-selected", {
+          detail: { threadId },
+          bubbles: true,
+          composed: true
+        })
+      );
+    };
+  }
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.threadsEndpoint) void this.refresh();
+  }
+  updated(changed) {
+    if (changed.has("threadsEndpoint") && this.threadsEndpoint) {
+      void this.refresh();
+    }
+  }
+  /** Re-fetch the thread index. Call after creating/archiving a thread. */
+  async refresh() {
+    if (!this.threadsEndpoint) return;
+    this._loading = true;
+    this._error = null;
+    try {
+      const res = await fetch(this.threadsEndpoint, {
+        method: "GET",
+        headers: { ...this.authHeaders ?? {}, Accept: "application/json" }
+      });
+      if (!res.ok) {
+        this._error = `Failed to load threads (${res.status})`;
+        this._threads = [];
+        return;
+      }
+      const data = await res.json();
+      this._threads = (data.threads ?? []).filter((t) => t.status !== "archived");
+    } catch (e) {
+      this._error = e instanceof Error ? e.message : "Failed to load threads";
+      this._threads = [];
+    } finally {
+      this._loading = false;
+    }
+  }
+  /** Imperative: request the host to start a new thread.
+   *  Fires `new-thread-requested`. The host clears the chat element and
+   *  drops `activeThreadId` so the next user message goes to a fresh
+   *  backend thread.
+   */
+  createNewThread() {
+    this.dispatchEvent(new CustomEvent("new-thread-requested", { bubbles: true, composed: true }));
+  }
+  render() {
+    return html8`
+      <div data-sc-thread-list>
+        <button
+          type="button"
+          data-sc-new-thread-btn
+          @click=${() => this.createNewThread()}
+          aria-label=${this.newThreadLabel}
+        >
+          ${this.newThreadLabel}
+        </button>
+        ${this._loading ? html8`<div data-sc-thread-list-loading>Loading…</div>` : this._error ? html8`<div data-sc-thread-list-error>${this._error}</div>` : this._threads.length === 0 ? html8`<div data-sc-thread-list-empty>${this.emptyStateLabel}</div>` : html8`<ul data-sc-thread-list-items role="list">
+                  ${this._threads.map(
+      (t) => html8`
+                      <li
+                        data-sc-thread-list-item
+                        ?data-sc-active=${t.remoteId === this.activeThreadId}
+                      >
+                        <button
+                          type="button"
+                          @click=${() => this._onThreadClick(t.remoteId)}
+                          title=${t.title ?? t.remoteId}
+                        >
+                          ${t.title || "Untitled thread"}
+                        </button>
+                      </li>
+                    `
+    )}
+                </ul>`}
+      </div>
+    `;
+  }
+};
+SyntroChatThreadList.properties = {
+  threadsEndpoint: { type: String, attribute: "threads-endpoint" },
+  authHeaders: { attribute: false },
+  activeThreadId: { type: String, attribute: "active-thread-id" },
+  newThreadLabel: { type: String, attribute: "new-thread-label" },
+  emptyStateLabel: { type: String, attribute: "empty-state-label" },
+  _threads: { state: true },
+  _loading: { state: true },
+  _error: { state: true }
+};
+if (!customElements.get("syntro-chat-thread-list")) {
+  customElements.define("syntro-chat-thread-list", SyntroChatThreadList);
+}
+if (!customElements.get("syntro-chat")) {
+  customElements.define("syntro-chat", SyntroChat);
+}
+
+export {
+  isDictationSupported,
+  createDictation,
+  renderMarkdown
+};
+/*! Bundled license information:
+
+dompurify/dist/purify.es.mjs:
+  (*! @license DOMPurify 3.3.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.3.1/LICENSE *)
+*/
+//# sourceMappingURL=chunk-VZIUXXAM.js.map