npm - @altmd/runtime - Versions diffs - 0.1.0 - Mend

@altmd/runtime 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 Daniel Iwugo
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,46 @@
+# @altmd/runtime
+The zero-build browser runtime for
+[alt-markdown](https://github.com/elementmerc/alt-markdown): a strict CommonMark
+superset that renders charts, diagrams, maths, and other components, and still
+reads as plain markdown when the runtime is not there.
+This package is the small (~15 kB gzipped) script that upgrades a rendered
+alt-markdown page in the browser. It registers the `alt-*` custom elements, so
+the static fallbacks already baked into the HTML turn into live charts, diagrams,
+and maths. No build step, no server.
+## Use it from a CDN
+Render your document to HTML once with the `altmd` CLI, host the result, then add
+one script tag. The easiest way to get a complete page is `altmd render
+--standalone doc.alt`, which emits a self-contained HTML file with the tag
+already wired. To upgrade a page you assemble yourself:
+```html
+<script type="module">
+  import { bootstrap } from "https://cdn.jsdelivr.net/npm/@altmd/runtime@0.1.0/dist/index.js";
+  bootstrap();
+</script>
+```
+The graphics libraries (uPlot, KaTeX, Mermaid) load lazily, and only when a
+document actually uses them, so a page with no charts pays nothing for the chart
+code.
+## What it does
+- Registers the `alt-*` components: callouts, tabs, accordions, columns, charts,
+  maths, diagrams, embeds, and a table of contents.
+- Renders diagrams in a script-disabled, origin-isolated iframe.
+- Leaves plain CommonMark untouched, so the document still reads without the
+  runtime.
+## Links
+- Repository and full documentation: https://github.com/elementmerc/alt-markdown
+- Live playground: https://elementmerc.github.io/alt-markdown/
+## Licence
+MIT. See [LICENSE](./LICENSE).

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1098 @@
+var Be = (e) => {
+  throw TypeError(e);
+};
+var ae = (e, o, r) => o.has(e) || Be("Cannot " + r);
+var rt = (e, o, r) => (ae(e, o, "read from private field"), r ? r.call(e) : o.get(e)), Ot = (e, o, r) => o.has(e) ? Be("Cannot add the same private member more than once") : o instanceof WeakSet ? o.add(e) : o.set(e, r), Z = (e, o, r, s) => (ae(e, o, "write to private field"), s ? s.call(e, r) : o.set(e, r), r), Ye = (e, o, r) => (ae(e, o, "access private method"), r);
+function Yn(e, o) {
+  return [
+    "<!doctype html>",
+    "<html><head>",
+    `<meta http-equiv="Content-Security-Policy" content="${[
+      "default-src 'none'",
+      "img-src data:",
+      "style-src 'unsafe-inline'",
+      o ? "script-src 'unsafe-inline'" : "script-src 'none'",
+      "connect-src 'none'"
+    ].join("; ")}">`,
+    "</head><body>",
+    e,
+    "</body></html>"
+  ].join("");
+}
+function cn(e) {
+  const o = document.createElement("iframe");
+  return o.setAttribute("sandbox", e.allowScripts ? "allow-scripts" : ""), o.setAttribute("referrerpolicy", "no-referrer"), e.title !== void 0 && o.setAttribute("title", e.title), o.style.border = "0", o.style.width = "100%", e.height !== void 0 && (o.style.height = `${e.height}px`), o.srcdoc = Yn(e.html, e.allowScripts ?? !1), o;
+}
+/*! @license DOMPurify 3.4.11 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.11/LICENSE */
+function je(e, o) {
+  (o == null || o > e.length) && (o = e.length);
+  for (var r = 0, s = Array(o); r < o; r++) s[r] = e[r];
+  return s;
+}
+function jn(e) {
+  if (Array.isArray(e)) return e;
+}
+function $n(e, o) {
+  var r = e == null ? null : typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (r != null) {
+    var s, c, u, d, v = [], w = !0, H = !1;
+    try {
+      if (u = (r = r.call(e)).next, o !== 0) for (; !(w = (s = u.call(r)).done) && (v.push(s.value), v.length !== o); w = !0) ;
+    } catch (j) {
+      H = !0, c = j;
+    } finally {
+      try {
+        if (!w && r.return != null && (d = r.return(), Object(d) !== d)) return;
+      } finally {
+        if (H) throw c;
+      }
+    }
+    return v;
+  }
+}
+function qn() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function Xn(e, o) {
+  return jn(e) || $n(e, o) || Vn(e, o) || qn();
+}
+function Vn(e, o) {
+  if (e) {
+    if (typeof e == "string") return je(e, o);
+    var r = {}.toString.call(e).slice(8, -1);
+    return r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set" ? Array.from(e) : r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? je(e, o) : void 0;
+  }
+}
+const un = Object.entries, $e = Object.setPrototypeOf, Kn = Object.isFrozen, Zn = Object.getPrototypeOf, Jn = Object.getOwnPropertyDescriptor;
+let R = Object.freeze, N = Object.seal, dt = Object.create, fn = typeof Reflect < "u" && Reflect, me = fn.apply, pe = fn.construct;
+R || (R = function(o) {
+  return o;
+});
+N || (N = function(o) {
+  return o;
+});
+me || (me = function(o, r) {
+  for (var s = arguments.length, c = new Array(s > 2 ? s - 2 : 0), u = 2; u < s; u++)
+    c[u - 2] = arguments[u];
+  return o.apply(r, c);
+});
+pe || (pe = function(o) {
+  for (var r = arguments.length, s = new Array(r > 1 ? r - 1 : 0), c = 1; c < r; c++)
+    s[c - 1] = arguments[c];
+  return new o(...s);
+});
+const Rt = y(Array.prototype.forEach), Qn = y(Array.prototype.lastIndexOf), qe = y(Array.prototype.pop), pt = y(Array.prototype.push), to = y(Array.prototype.splice), Q = Array.isArray, It = y(String.prototype.toLowerCase), se = y(String.prototype.toString), Xe = y(String.prototype.match), Nt = y(String.prototype.replace), Ve = y(String.prototype.indexOf), eo = y(String.prototype.trim), no = y(Number.prototype.toString), oo = y(Boolean.prototype.toString), Ke = typeof BigInt > "u" ? null : y(BigInt.prototype.toString), Ze = typeof Symbol > "u" ? null : y(Symbol.prototype.toString), S = y(Object.prototype.hasOwnProperty), wt = y(Object.prototype.toString), O = y(RegExp.prototype.test), it = ro(TypeError);
+function y(e) {
+  return function(o) {
+    o instanceof RegExp && (o.lastIndex = 0);
+    for (var r = arguments.length, s = new Array(r > 1 ? r - 1 : 0), c = 1; c < r; c++)
+      s[c - 1] = arguments[c];
+    return me(e, o, s);
+  };
+}
+function ro(e) {
+  return function() {
+    for (var o = arguments.length, r = new Array(o), s = 0; s < o; s++)
+      r[s] = arguments[s];
+    return pe(e, r);
+  };
+}
+function m(e, o) {
+  let r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : It;
+  if ($e && $e(e, null), !Q(o))
+    return e;
+  let s = o.length;
+  for (; s--; ) {
+    let c = o[s];
+    if (typeof c == "string") {
+      const u = r(c);
+      u !== c && (Kn(o) || (o[s] = u), c = u);
+    }
+    e[c] = !0;
+  }
+  return e;
+}
+function io(e) {
+  for (let o = 0; o < e.length; o++)
+    S(e, o) || (e[o] = null);
+  return e;
+}
+function L(e) {
+  const o = dt(null);
+  for (const s of un(e)) {
+    var r = Xn(s, 2);
+    const c = r[0], u = r[1];
+    S(e, c) && (Q(u) ? o[c] = io(u) : u && typeof u == "object" && u.constructor === Object ? o[c] = L(u) : o[c] = u);
+  }
+  return o;
+}
+function ao(e) {
+  switch (typeof e) {
+    case "string":
+      return e;
+    case "number":
+      return no(e);
+    case "boolean":
+      return oo(e);
+    case "bigint":
+      return Ke ? Ke(e) : "0";
+    case "symbol":
+      return Ze ? Ze(e) : "Symbol()";
+    case "undefined":
+      return wt(e);
+    case "function":
+    case "object": {
+      if (e === null)
+        return wt(e);
+      const o = e, r = z(o, "toString");
+      if (typeof r == "function") {
+        const s = r(o);
+        return typeof s == "string" ? s : wt(s);
+      }
+      return wt(e);
+    }
+    default:
+      return wt(e);
+  }
+}
+function z(e, o) {
+  for (; e !== null; ) {
+    const s = Jn(e, o);
+    if (s) {
+      if (s.get)
+        return y(s.get);
+      if (typeof s.value == "function")
+        return y(s.value);
+    }
+    e = Zn(e);
+  }
+  function r() {
+    return null;
+  }
+  return r;
+}
+function so(e) {
+  try {
+    return O(e, ""), !0;
+  } catch {
+    return !1;
+  }
+}
+const Je = R(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "search", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]), le = R(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]), ce = R(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]), lo = R(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]), ue = R(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]), co = R(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]), Qe = R(["#text"]), tn = R(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "command", "commandfor", "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"]), fe = R(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "mask-type", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]), en = R(["accent", "accentunder", "align", "bevelled", "close", "columnalign", "columnlines", "columnspacing", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lquote", "lspace", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]), Ft = R(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]), uo = N(/{{[\w\W]*|^[\w\W]*}}/g), fo = N(/<%[\w\W]*|^[\w\W]*%>/g), mo = N(/\${[\w\W]*/g), po = N(/^data-[\-\w.\u00B7-\uFFFF]+$/), ho = N(/^aria-[\-\w]+$/), nn = N(
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+  // eslint-disable-line no-useless-escape
+), To = N(/^(?:\w+script|data):/i), _o = N(
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+  // eslint-disable-line no-control-regex
+), go = N(/^html$/i), Eo = N(/^[a-z][.\w]*(-[.\w]+)+$/i), on = N(/<[/\w!]/g), Ao = N(/<[/\w]/g), yo = N(/<\/no(script|embed|frames)/i), bo = N(/\/>/i), U = {
+  element: 1,
+  attribute: 2,
+  text: 3,
+  cdataSection: 4,
+  entityReference: 5,
+  // Deprecated
+  entityNode: 6,
+  // Deprecated
+  processingInstruction: 7,
+  comment: 8,
+  document: 9,
+  documentType: 10,
+  documentFragment: 11,
+  notation: 12
+  // Deprecated
+}, So = function() {
+  return typeof window > "u" ? null : window;
+}, Oo = function(o, r) {
+  if (typeof o != "object" || typeof o.createPolicy != "function")
+    return null;
+  let s = null;
+  const c = "data-tt-policy-suffix";
+  r && r.hasAttribute(c) && (s = r.getAttribute(c));
+  const u = "dompurify" + (s ? "#" + s : "");
+  try {
+    return o.createPolicy(u, {
+      createHTML(d) {
+        return d;
+      },
+      createScriptURL(d) {
+        return d;
+      }
+    });
+  } catch {
+    return console.warn("TrustedTypes policy " + u + " could not be created."), null;
+  }
+}, rn = function() {
+  return {
+    afterSanitizeAttributes: [],
+    afterSanitizeElements: [],
+    afterSanitizeShadowDOM: [],
+    beforeSanitizeAttributes: [],
+    beforeSanitizeElements: [],
+    beforeSanitizeShadowDOM: [],
+    uponSanitizeAttribute: [],
+    uponSanitizeElement: [],
+    uponSanitizeShadowNode: []
+  };
+}, J = function(o, r, s, c) {
+  return S(o, r) && Q(o[r]) ? m(c.base ? L(c.base) : {}, o[r], c.transform) : s;
+};
+function mn() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : So();
+  const o = (a) => mn(a);
+  if (o.version = "3.4.11", o.removed = [], !e || !e.document || e.document.nodeType !== U.document || !e.Element)
+    return o.isSupported = !1, o;
+  let r = e.document;
+  const s = r, c = s.currentScript;
+  e.DocumentFragment;
+  const u = e.HTMLTemplateElement, d = e.Node, v = e.Element, w = e.NodeFilter, H = e.NamedNodeMap;
+  H === void 0 && (e.NamedNodeMap || e.MozNamedAttrMap), e.HTMLFormElement;
+  const j = e.DOMParser, _t = e.trustedTypes, G = v.prototype, zt = z(G, "cloneNode"), W = z(G, "remove"), tt = z(G, "nextSibling"), x = z(G, "childNodes"), $ = z(G, "parentNode"), gt = z(G, "shadowRoot"), Ht = z(G, "attributes"), C = d && d.prototype ? z(d.prototype, "nodeType") : null, q = d && d.prototype ? z(d.prototype, "nodeName") : null;
+  if (typeof u == "function") {
+    const a = r.createElement("template");
+    a.content && a.content.ownerDocument && (r = a.content.ownerDocument);
+  }
+  let D, et = "", Gt, de = !1, Et = 0;
+  const he = function() {
+    if (Et > 0)
+      throw it('A configured TRUSTED_TYPES_POLICY callback (createHTML or createScriptURL) must not call DOMPurify.sanitize, as that causes infinite recursion. Do not pass a policy whose callbacks wrap DOMPurify as TRUSTED_TYPES_POLICY; see the "DOMPurify and Trusted Types" section of the README.');
+  }, st = function(t) {
+    he(), Et++;
+    try {
+      return D.createHTML(t);
+    } finally {
+      Et--;
+    }
+  }, Tn = function(t) {
+    he(), Et++;
+    try {
+      return D.createScriptURL(t);
+    } finally {
+      Et--;
+    }
+  }, _n = function() {
+    return de || (Gt = Oo(_t, c), de = !0), Gt;
+  }, Lt = r, Wt = Lt.implementation, Te = Lt.createNodeIterator, gn = Lt.createDocumentFragment, En = Lt.getElementsByTagName, An = s.importNode;
+  let E = rn();
+  o.isSupported = typeof un == "function" && typeof $ == "function" && Wt && Wt.createHTMLDocument !== void 0;
+  const yn = uo, bn = fo, Sn = mo, On = po, Rn = ho, Nn = To, _e = _o, wn = Eo;
+  let ge = nn, h = null;
+  const Ee = m({}, [...Je, ...le, ...ce, ...ue, ...Qe]);
+  let T = null;
+  const Ae = m({}, [...tn, ...fe, ...en, ...Ft]);
+  let _ = Object.seal(dt(null, {
+    tagNameCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    },
+    attributeNameCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    },
+    allowCustomizedBuiltInElements: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: !1
+    }
+  })), At = null, ye = null;
+  const X = Object.seal(dt(null, {
+    tagCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    },
+    attributeCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    }
+  }));
+  let be = !0, Bt = !0, Se = !1, Oe = !0, V = !1, yt = !0, nt = !1, Yt = !1, jt = null, $t = null, qt = !1, lt = !1, Dt = !1, Ct = !1, Re = !0, Ne = !1;
+  const we = "user-content-";
+  let Xt = !0, Vt = !1, ct = {}, k = null;
+  const Kt = m({}, [
+    "annotation-xml",
+    "audio",
+    "colgroup",
+    "desc",
+    "foreignobject",
+    "head",
+    "iframe",
+    "math",
+    "mi",
+    "mn",
+    "mo",
+    "ms",
+    "mtext",
+    "noembed",
+    "noframes",
+    "noscript",
+    "plaintext",
+    "script",
+    // <selectedcontent> mirrors the selected <option>'s subtree, cloned by
+    // the UA (customizable <select>) — including any on* handlers — and the
+    // engine re-mirrors synchronously whenever a removal changes which
+    // option/selectedcontent is current, even inside DOMPurify's inert
+    // DOMParser document. Hoisting its children on removal re-inserts a fresh
+    // mirror target ahead of the walk, which the engine refills, looping
+    // forever (DoS) and amplifying output. Dropping its content on removal
+    // (rather than hoisting) breaks that cascade; the content is a duplicate
+    // of the option, which is sanitized on its own. See campaign-3 F1/F6.
+    "selectedcontent",
+    "style",
+    "svg",
+    "template",
+    "thead",
+    "title",
+    "video",
+    "xmp"
+  ]);
+  let Ie = null;
+  const Le = m({}, ["audio", "video", "img", "source", "image", "track"]);
+  let Zt = null;
+  const De = m({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]), Mt = "http://www.w3.org/1998/Math/MathML", xt = "http://www.w3.org/2000/svg", F = "http://www.w3.org/1999/xhtml";
+  let ut = F, Jt = !1, Qt = null;
+  const In = m({}, [Mt, xt, F], se), Ce = R(["mi", "mo", "mn", "ms", "mtext"]);
+  let te = m({}, Ce);
+  const Me = R(["annotation-xml"]);
+  let ee = m({}, Me);
+  const Ln = m({}, ["title", "style", "font", "a", "script"]);
+  let bt = null;
+  const Dn = ["application/xhtml+xml", "text/html"], Cn = "text/html";
+  let g = null, ft = null;
+  const Mn = r.createElement("form"), xe = function(t) {
+    return t instanceof RegExp || t instanceof Function;
+  }, ne = function() {
+    let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    if (ft && ft === t)
+      return;
+    (!t || typeof t != "object") && (t = {}), t = L(t), bt = // eslint-disable-next-line unicorn/prefer-includes
+    Dn.indexOf(t.PARSER_MEDIA_TYPE) === -1 ? Cn : t.PARSER_MEDIA_TYPE, g = bt === "application/xhtml+xml" ? se : It, h = J(t, "ALLOWED_TAGS", Ee, {
+      transform: g
+    }), T = J(t, "ALLOWED_ATTR", Ae, {
+      transform: g
+    }), Qt = J(t, "ALLOWED_NAMESPACES", In, {
+      transform: se
+    }), Zt = J(t, "ADD_URI_SAFE_ATTR", De, {
+      transform: g,
+      base: De
+    }), Ie = J(t, "ADD_DATA_URI_TAGS", Le, {
+      transform: g,
+      base: Le
+    }), k = J(t, "FORBID_CONTENTS", Kt, {
+      transform: g
+    }), At = J(t, "FORBID_TAGS", L({}), {
+      transform: g
+    }), ye = J(t, "FORBID_ATTR", L({}), {
+      transform: g
+    }), ct = S(t, "USE_PROFILES") ? t.USE_PROFILES && typeof t.USE_PROFILES == "object" ? L(t.USE_PROFILES) : t.USE_PROFILES : !1, be = t.ALLOW_ARIA_ATTR !== !1, Bt = t.ALLOW_DATA_ATTR !== !1, Se = t.ALLOW_UNKNOWN_PROTOCOLS || !1, Oe = t.ALLOW_SELF_CLOSE_IN_ATTR !== !1, V = t.SAFE_FOR_TEMPLATES || !1, yt = t.SAFE_FOR_XML !== !1, nt = t.WHOLE_DOCUMENT || !1, lt = t.RETURN_DOM || !1, Dt = t.RETURN_DOM_FRAGMENT || !1, Ct = t.RETURN_TRUSTED_TYPE || !1, qt = t.FORCE_BODY || !1, Re = t.SANITIZE_DOM !== !1, Ne = t.SANITIZE_NAMED_PROPS || !1, Xt = t.KEEP_CONTENT !== !1, Vt = t.IN_PLACE || !1, ge = so(t.ALLOWED_URI_REGEXP) ? t.ALLOWED_URI_REGEXP : nn, ut = typeof t.NAMESPACE == "string" ? t.NAMESPACE : F, te = S(t, "MATHML_TEXT_INTEGRATION_POINTS") && t.MATHML_TEXT_INTEGRATION_POINTS && typeof t.MATHML_TEXT_INTEGRATION_POINTS == "object" ? L(t.MATHML_TEXT_INTEGRATION_POINTS) : m({}, Ce), ee = S(t, "HTML_INTEGRATION_POINTS") && t.HTML_INTEGRATION_POINTS && typeof t.HTML_INTEGRATION_POINTS == "object" ? L(t.HTML_INTEGRATION_POINTS) : m({}, Me);
+    const n = S(t, "CUSTOM_ELEMENT_HANDLING") && t.CUSTOM_ELEMENT_HANDLING && typeof t.CUSTOM_ELEMENT_HANDLING == "object" ? L(t.CUSTOM_ELEMENT_HANDLING) : dt(null);
+    if (_ = dt(null), S(n, "tagNameCheck") && xe(n.tagNameCheck) && (_.tagNameCheck = n.tagNameCheck), S(n, "attributeNameCheck") && xe(n.attributeNameCheck) && (_.attributeNameCheck = n.attributeNameCheck), S(n, "allowCustomizedBuiltInElements") && typeof n.allowCustomizedBuiltInElements == "boolean" && (_.allowCustomizedBuiltInElements = n.allowCustomizedBuiltInElements), N(_), V && (Bt = !1), Dt && (lt = !0), ct && (h = m({}, Qe), T = dt(null), ct.html === !0 && (m(h, Je), m(T, tn)), ct.svg === !0 && (m(h, le), m(T, fe), m(T, Ft)), ct.svgFilters === !0 && (m(h, ce), m(T, fe), m(T, Ft)), ct.mathMl === !0 && (m(h, ue), m(T, en), m(T, Ft))), X.tagCheck = null, X.attributeCheck = null, S(t, "ADD_TAGS") && (typeof t.ADD_TAGS == "function" ? X.tagCheck = t.ADD_TAGS : Q(t.ADD_TAGS) && (h === Ee && (h = L(h)), m(h, t.ADD_TAGS, g))), S(t, "ADD_ATTR") && (typeof t.ADD_ATTR == "function" ? X.attributeCheck = t.ADD_ATTR : Q(t.ADD_ATTR) && (T === Ae && (T = L(T)), m(T, t.ADD_ATTR, g))), S(t, "ADD_URI_SAFE_ATTR") && Q(t.ADD_URI_SAFE_ATTR) && m(Zt, t.ADD_URI_SAFE_ATTR, g), S(t, "FORBID_CONTENTS") && Q(t.FORBID_CONTENTS) && (k === Kt && (k = L(k)), m(k, t.FORBID_CONTENTS, g)), S(t, "ADD_FORBID_CONTENTS") && Q(t.ADD_FORBID_CONTENTS) && (k === Kt && (k = L(k)), m(k, t.ADD_FORBID_CONTENTS, g)), Xt && (h["#text"] = !0), nt && m(h, ["html", "head", "body"]), h.table && (m(h, ["tbody"]), delete At.tbody), t.TRUSTED_TYPES_POLICY) {
+      if (typeof t.TRUSTED_TYPES_POLICY.createHTML != "function")
+        throw it('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+      if (typeof t.TRUSTED_TYPES_POLICY.createScriptURL != "function")
+        throw it('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+      const i = D;
+      D = t.TRUSTED_TYPES_POLICY;
+      try {
+        et = st("");
+      } catch (l) {
+        throw D = i, l;
+      }
+    } else t.TRUSTED_TYPES_POLICY === null ? (D = void 0, et = "") : (D === void 0 && (D = _n()), D && typeof et == "string" && (et = st("")));
+    R && R(t), ft = t;
+  }, Pe = m({}, [...le, ...ce, ...lo]), ve = m({}, [...ue, ...co]), xn = function(t, n, i) {
+    return n.namespaceURI === F ? t === "svg" : n.namespaceURI === Mt ? t === "svg" && (i === "annotation-xml" || te[i]) : !!Pe[t];
+  }, Pn = function(t, n, i) {
+    return n.namespaceURI === F ? t === "math" : n.namespaceURI === xt ? t === "math" && ee[i] : !!ve[t];
+  }, vn = function(t, n, i) {
+    return n.namespaceURI === xt && !ee[i] || n.namespaceURI === Mt && !te[i] ? !1 : !ve[t] && (Ln[t] || !Pe[t]);
+  }, kn = function(t) {
+    let n = $(t);
+    (!n || !n.tagName) && (n = {
+      namespaceURI: ut,
+      tagName: "template"
+    });
+    const i = It(t.tagName), l = It(n.tagName);
+    return Qt[t.namespaceURI] ? t.namespaceURI === xt ? xn(i, n, l) : t.namespaceURI === Mt ? Pn(i, n, l) : t.namespaceURI === F ? vn(i, n, l) : !!(bt === "application/xhtml+xml" && Qt[t.namespaceURI]) : !1;
+  }, K = function(t) {
+    pt(o.removed, {
+      element: t
+    });
+    try {
+      $(t).removeChild(t);
+    } catch {
+      if (W(t), !$(t))
+        throw it("a node selected for removal could not be detached from its tree and cannot be safely returned; refusing to sanitize in place");
+    }
+  }, ke = function(t) {
+    const n = x(t);
+    if (n) {
+      const l = [];
+      Rt(n, (f) => {
+        pt(l, f);
+      }), Rt(l, (f) => {
+        try {
+          W(f);
+        } catch {
+        }
+      });
+    }
+    const i = Ht(t);
+    if (i)
+      for (let l = i.length - 1; l >= 0; --l) {
+        const f = i[l], p = f && f.name;
+        if (typeof p == "string")
+          try {
+            t.removeAttribute(p);
+          } catch {
+          }
+      }
+  }, ot = function(t, n) {
+    try {
+      pt(o.removed, {
+        attribute: n.getAttributeNode(t),
+        from: n
+      });
+    } catch {
+      pt(o.removed, {
+        attribute: null,
+        from: n
+      });
+    }
+    if (n.removeAttribute(t), t === "is")
+      if (lt || Dt)
+        try {
+          K(n);
+        } catch {
+        }
+      else
+        try {
+          n.setAttribute(t, "");
+        } catch {
+        }
+  }, Fn = function(t) {
+    const n = Ht(t);
+    if (n)
+      for (let i = n.length - 1; i >= 0; --i) {
+        const l = n[i], f = l && l.name;
+        if (!(typeof f != "string" || T[g(f)]))
+          try {
+            t.removeAttribute(f);
+          } catch {
+          }
+      }
+  }, Un = function(t) {
+    const n = [t];
+    for (; n.length > 0; ) {
+      const i = n.pop();
+      (C ? C(i) : i.nodeType) === U.element && Fn(i);
+      const f = x(i);
+      if (f)
+        for (let p = f.length - 1; p >= 0; --p)
+          n.push(f[p]);
+    }
+  }, Fe = function(t) {
+    let n = null, i = null;
+    if (qt)
+      t = "<remove></remove>" + t;
+    else {
+      const p = Xe(t, /^[\r\n\t ]+/);
+      i = p && p[0];
+    }
+    bt === "application/xhtml+xml" && ut === F && (t = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + t + "</body></html>");
+    const l = D ? st(t) : t;
+    if (ut === F)
+      try {
+        n = new j().parseFromString(l, bt);
+      } catch {
+      }
+    if (!n || !n.documentElement) {
+      n = Wt.createDocument(ut, "template", null);
+      try {
+        n.documentElement.innerHTML = Jt ? et : l;
+      } catch {
+      }
+    }
+    const f = n.body || n.documentElement;
+    return t && i && f.insertBefore(r.createTextNode(i), f.childNodes[0] || null), ut === F ? En.call(n, nt ? "html" : "body")[0] : nt ? n.documentElement : f;
+  }, Ue = function(t) {
+    return Te.call(
+      t.ownerDocument || t,
+      t,
+      // eslint-disable-next-line no-bitwise
+      w.SHOW_ELEMENT | w.SHOW_COMMENT | w.SHOW_TEXT | w.SHOW_PROCESSING_INSTRUCTION | w.SHOW_CDATA_SECTION,
+      null
+    );
+  }, Pt = function(t) {
+    return t = Nt(t, yn, " "), t = Nt(t, bn, " "), t = Nt(t, Sn, " "), t;
+  }, oe = function(t) {
+    var n;
+    t.normalize();
+    const i = Te.call(
+      t.ownerDocument || t,
+      t,
+      // eslint-disable-next-line no-bitwise
+      w.SHOW_TEXT | w.SHOW_COMMENT | w.SHOW_CDATA_SECTION | w.SHOW_PROCESSING_INSTRUCTION,
+      null
+    );
+    let l = i.nextNode();
+    for (; l; )
+      l.data = Pt(l.data), l = i.nextNode();
+    const f = (n = t.querySelectorAll) === null || n === void 0 ? void 0 : n.call(t, "template");
+    f && Rt(f, (p) => {
+      mt(p.content) && oe(p.content);
+    });
+  }, vt = function(t) {
+    const n = q ? q(t) : null;
+    return typeof n != "string" || g(n) !== "form" ? !1 : typeof t.nodeName != "string" || typeof t.textContent != "string" || typeof t.removeChild != "function" || // Realm-safe NamedNodeMap detection: equality against the cached
+    // prototype getter. Clobbered .attributes (e.g. <input name="attributes">)
+    // makes the direct read diverge from the cached read; a clean form
+    // (same-realm OR foreign-realm) has both reads pointing at the same
+    // canonical NamedNodeMap.
+    t.attributes !== Ht(t) || typeof t.removeAttribute != "function" || typeof t.setAttribute != "function" || typeof t.namespaceURI != "string" || typeof t.insertBefore != "function" || typeof t.hasChildNodes != "function" || // NodeType clobbering probe. Cached Node.prototype.nodeType getter
+    // returns the integer 1 for any Element regardless of realm; direct
+    // read on a clobbered form (e.g. <input name="nodeType">) returns
+    // the named child element. Cheap addition — nodeType is read from
+    // an internal slot, no serialization cost — and removes a residual
+    // clobbering surface used by several mXSS / PI / comment branches
+    // in _sanitizeElements that compare currentNode.nodeType directly.
+    t.nodeType !== C(t) || // HTMLFormElement has [LegacyOverrideBuiltIns]: a descendant named
+    // "childNodes" shadows the prototype getter. Direct reads of
+    // form.childNodes from a clobbered form return the named child
+    // instead of the real NodeList, so any walk that reads it directly
+    // skips the form's real children. Compare the direct read to the
+    // cached Node.prototype getter — when the form's named-property
+    // getter intercepts the read, the two values differ and we flag
+    // the form. This catches every clobbering child type (input,
+    // select, etc.) regardless of whether the named child happens to
+    // carry a numeric .length, which a typeof-based probe would miss
+    // (e.g. HTMLSelectElement.length is a defined unsigned-long).
+    t.childNodes !== x(t);
+  }, mt = function(t) {
+    if (!C || typeof t != "object" || t === null)
+      return !1;
+    try {
+      return C(t) === U.documentFragment;
+    } catch {
+      return !1;
+    }
+  }, St = function(t) {
+    if (!C || typeof t != "object" || t === null)
+      return !1;
+    try {
+      return typeof C(t) == "number";
+    } catch {
+      return !1;
+    }
+  };
+  function B(a, t, n) {
+    a.length !== 0 && Rt(a, (i) => {
+      i.call(o, t, n, ft);
+    });
+  }
+  const zn = function(t, n) {
+    return !!(yt && t.hasChildNodes() && !St(t.firstElementChild) && O(on, t.textContent) && O(on, t.innerHTML) || yt && t.namespaceURI === F && n === "style" && St(t.firstElementChild) || t.nodeType === U.processingInstruction || yt && t.nodeType === U.comment && O(Ao, t.data));
+  }, Hn = function(t, n) {
+    if (!At[n] && Ge(n) && (_.tagNameCheck instanceof RegExp && O(_.tagNameCheck, n) || _.tagNameCheck instanceof Function && _.tagNameCheck(n)))
+      return !1;
+    if (Xt && !k[n]) {
+      const i = $(t), l = x(t);
+      if (l && i) {
+        const f = l.length;
+        for (let p = f - 1; p >= 0; --p) {
+          const b = Vt ? l[p] : zt(l[p], !0);
+          i.insertBefore(b, tt(t));
+        }
+      }
+    }
+    return K(t), !0;
+  }, ze = function(t) {
+    if (B(E.beforeSanitizeElements, t, null), vt(t))
+      return K(t), !0;
+    const n = g(q ? q(t) : t.nodeName);
+    if (B(E.uponSanitizeElement, t, {
+      tagName: n,
+      allowedTags: h
+    }), zn(t, n))
+      return K(t), !0;
+    if (At[n] || !(X.tagCheck instanceof Function && X.tagCheck(n)) && !h[n])
+      return Hn(t, n);
+    if ((C ? C(t) : t.nodeType) === U.element && !kn(t) || (n === "noscript" || n === "noembed" || n === "noframes") && O(yo, t.innerHTML))
+      return K(t), !0;
+    if (V && t.nodeType === U.text) {
+      const l = Pt(t.textContent);
+      t.textContent !== l && (pt(o.removed, {
+        element: t.cloneNode()
+      }), t.textContent = l);
+    }
+    return B(E.afterSanitizeElements, t, null), !1;
+  }, He = function(t, n, i) {
+    if (ye[n] || Re && (n === "id" || n === "name") && (i in r || i in Mn))
+      return !1;
+    const l = T[n] || X.attributeCheck instanceof Function && X.attributeCheck(n, t);
+    if (!(Bt && O(On, n))) {
+      if (!(be && O(Rn, n))) {
+        if (l) {
+          if (!Zt[n]) {
+            if (!O(ge, Nt(i, _e, ""))) {
+              if (!((n === "src" || n === "xlink:href" || n === "href") && t !== "script" && Ve(i, "data:") === 0 && Ie[t])) {
+                if (!(Se && !O(Nn, Nt(i, _e, "")))) {
+                  if (i)
+                    return !1;
+                }
+              }
+            }
+          }
+        } else 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
+          !(Ge(t) && (_.tagNameCheck instanceof RegExp && O(_.tagNameCheck, t) || _.tagNameCheck instanceof Function && _.tagNameCheck(t)) && (_.attributeNameCheck instanceof RegExp && O(_.attributeNameCheck, n) || _.attributeNameCheck instanceof Function && _.attributeNameCheck(n, t)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+          // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+          n === "is" && _.allowCustomizedBuiltInElements && (_.tagNameCheck instanceof RegExp && O(_.tagNameCheck, i) || _.tagNameCheck instanceof Function && _.tagNameCheck(i)))
+        ) return !1;
+      }
+    }
+    return !0;
+  }, Gn = m({}, ["annotation-xml", "color-profile", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "missing-glyph"]), Ge = function(t) {
+    return !Gn[It(t)] && O(wn, t);
+  }, Wn = function(t, n, i, l) {
+    if (D && typeof _t == "object" && typeof _t.getAttributeType == "function" && !i)
+      switch (_t.getAttributeType(t, n)) {
+        case "TrustedHTML":
+          return st(l);
+        case "TrustedScriptURL":
+          return Tn(l);
+      }
+    return l;
+  }, Bn = function(t, n, i, l) {
+    try {
+      i ? t.setAttributeNS(i, n, l) : t.setAttribute(n, l), vt(t) ? K(t) : qe(o.removed);
+    } catch {
+      ot(n, t);
+    }
+  }, We = function(t) {
+    B(E.beforeSanitizeAttributes, t, null);
+    const n = t.attributes;
+    if (!n || vt(t))
+      return;
+    const i = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: !0,
+      allowedAttributes: T,
+      forceKeepAttr: void 0
+    };
+    let l = n.length;
+    const f = g(t.nodeName);
+    for (; l--; ) {
+      const p = n[l], b = p.name, A = p.namespaceURI, M = p.value, P = g(b), ie = M;
+      let I = b === "value" ? ie : eo(ie);
+      if (i.attrName = P, i.attrValue = I, i.keepAttr = !0, i.forceKeepAttr = void 0, B(E.uponSanitizeAttribute, t, i), I = i.attrValue, Ne && (P === "id" || P === "name") && Ve(I, we) !== 0 && (ot(b, t), I = we + I), yt && O(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, I)) {
+        ot(b, t);
+        continue;
+      }
+      if (P === "attributename" && Xe(I, "href")) {
+        ot(b, t);
+        continue;
+      }
+      if (!i.forceKeepAttr) {
+        if (!i.keepAttr) {
+          ot(b, t);
+          continue;
+        }
+        if (!Oe && O(bo, I)) {
+          ot(b, t);
+          continue;
+        }
+        if (V && (I = Pt(I)), !He(f, P, I)) {
+          ot(b, t);
+          continue;
+        }
+        I = Wn(f, P, A, I), I !== ie && Bn(t, b, A, I);
+      }
+    }
+    B(E.afterSanitizeAttributes, t, null);
+  }, kt = function(t) {
+    let n = null;
+    const i = Ue(t);
+    for (B(E.beforeSanitizeShadowDOM, t, null); n = i.nextNode(); )
+      if (B(E.uponSanitizeShadowNode, n, null), ze(n), We(n), mt(n.content) && kt(n.content), (C ? C(n) : n.nodeType) === U.element) {
+        const f = gt(n);
+        mt(f) && (re(f), kt(f));
+      }
+    B(E.afterSanitizeShadowDOM, t, null);
+  }, re = function(t) {
+    const n = [{
+      node: t,
+      shadow: null
+    }];
+    for (; n.length > 0; ) {
+      const i = n.pop();
+      if (i.shadow) {
+        kt(i.shadow);
+        continue;
+      }
+      const l = i.node, p = (C ? C(l) : l.nodeType) === U.element, b = x(l);
+      if (b)
+        for (let A = b.length - 1; A >= 0; --A)
+          n.push({
+            node: b[A],
+            shadow: null
+          });
+      if (p) {
+        const A = q ? q(l) : null;
+        if (typeof A == "string" && g(A) === "template") {
+          const M = l.content;
+          mt(M) && n.push({
+            node: M,
+            shadow: null
+          });
+        }
+      }
+      if (p) {
+        const A = gt(l);
+        mt(A) && n.push({
+          node: null,
+          shadow: A
+        }, {
+          node: A,
+          shadow: null
+        });
+      }
+    }
+  };
+  return o.sanitize = function(a) {
+    let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, n = null, i = null, l = null, f = null;
+    if (Jt = !a, Jt && (a = "<!-->"), typeof a != "string" && !St(a) && (a = ao(a), typeof a != "string"))
+      throw it("dirty is not a string, aborting");
+    if (!o.isSupported)
+      return a;
+    Yt ? (h = jt, T = $t) : ne(t), (E.uponSanitizeElement.length > 0 || E.uponSanitizeAttribute.length > 0) && (h = L(h)), E.uponSanitizeAttribute.length > 0 && (T = L(T)), o.removed = [];
+    const p = Vt && typeof a != "string" && St(a);
+    if (p) {
+      const M = q ? q(a) : a.nodeName;
+      if (typeof M == "string") {
+        const P = g(M);
+        if (!h[P] || At[P])
+          throw it("root node is forbidden and cannot be sanitized in-place");
+      }
+      if (vt(a))
+        throw it("root node is clobbered and cannot be sanitized in-place");
+      try {
+        re(a);
+      } catch (P) {
+        throw ke(a), P;
+      }
+    } else if (St(a))
+      n = Fe("<!---->"), i = n.ownerDocument.importNode(a, !0), i.nodeType === U.element && i.nodeName === "BODY" || i.nodeName === "HTML" ? n = i : n.appendChild(i), re(i);
+    else {
+      if (!lt && !V && !nt && // eslint-disable-next-line unicorn/prefer-includes
+      a.indexOf("<") === -1)
+        return D && Ct ? st(a) : a;
+      if (n = Fe(a), !n)
+        return lt ? null : Ct ? et : "";
+    }
+    n && qt && K(n.firstChild);
+    const b = Ue(p ? a : n);
+    try {
+      for (; l = b.nextNode(); )
+        ze(l), We(l), mt(l.content) && kt(l.content);
+    } catch (M) {
+      throw p && ke(a), M;
+    }
+    if (p)
+      return Rt(o.removed, (M) => {
+        M.element && Un(M.element);
+      }), V && oe(a), a;
+    if (lt) {
+      if (V && oe(n), Dt)
+        for (f = gn.call(n.ownerDocument); n.firstChild; )
+          f.appendChild(n.firstChild);
+      else
+        f = n;
+      return (T.shadowroot || T.shadowrootmode) && (f = An.call(s, f, !0)), f;
+    }
+    let A = nt ? n.outerHTML : n.innerHTML;
+    return nt && h["!doctype"] && n.ownerDocument && n.ownerDocument.doctype && n.ownerDocument.doctype.name && O(go, n.ownerDocument.doctype.name) && (A = "<!DOCTYPE " + n.ownerDocument.doctype.name + `>
+` + A), V && (A = Pt(A)), D && Ct ? st(A) : A;
+  }, o.setConfig = function() {
+    let a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    ne(a), Yt = !0, jt = h, $t = T;
+  }, o.clearConfig = function() {
+    ft = null, Yt = !1, jt = null, $t = null, D = Gt, et = "";
+  }, o.isValidAttribute = function(a, t, n) {
+    ft || ne({});
+    const i = g(a), l = g(t);
+    return He(i, l, n);
+  }, o.addHook = function(a, t) {
+    typeof t == "function" && S(E, a) && pt(E[a], t);
+  }, o.removeHook = function(a, t) {
+    if (S(E, a)) {
+      if (t !== void 0) {
+        const n = Qn(E[a], t);
+        return n === -1 ? void 0 : to(E[a], n, 1)[0];
+      }
+      return qe(E[a]);
+    }
+  }, o.removeHooks = function(a) {
+    S(E, a) && (E[a] = []);
+  }, o.removeAllHooks = function() {
+    E = rn();
+  }, o;
+}
+var Ro = mn();
+function Bo(e) {
+  return Ro.sanitize(e);
+}
+const pn = 320;
+function No(e) {
+  const o = Array.from(e.querySelectorAll("thead th")).map(
+    (u) => u.textContent ?? ""
+  ), r = Array.from(e.querySelectorAll("tbody tr")).map(
+    (u) => Array.from(u.querySelectorAll("td")).map((d) => d.textContent ?? "")
+  );
+  if (o.length < 2 || r.length === 0)
+    return null;
+  const s = r.map((u) => u[0] ?? ""), c = o.slice(1).map((u, d) => ({
+    name: u,
+    values: r.map((v) => Number(v[d + 1] ?? ""))
+  }));
+  return { labels: s, series: c };
+}
+const an = ["#2563eb", "#dc2626", "#16a34a", "#d97706", "#7c3aed"];
+async function wo(e) {
+  const o = No(e);
+  if (!o)
+    return null;
+  const { default: r } = await import("uplot"), s = e.getAttribute("data-kind") ?? "line", u = [o.labels.map((W, tt) => tt), ...o.series.map((W) => W.values)], d = getComputedStyle(e).color || "#1a1a2e", v = "rgba(128, 128, 128, 0.18)", w = {
+    stroke: d,
+    grid: { stroke: v, width: 1 },
+    ticks: { stroke: v, width: 1 }
+  }, H = e.querySelector("table"), j = document.createElement("div");
+  j.className = "alt-chart-canvas", e.prepend(j);
+  const G = {
+    width: j.clientWidth || e.clientWidth || 640,
+    height: pn,
+    scales: { x: { time: !1 } },
+    // A crosshair cursor that highlights the nearest series, and drag to zoom the
+    // x-axis (double-click resets). The legend below the chart tracks the value
+    // under the cursor.
+    cursor: { drag: { x: !0, y: !1 }, focus: { prox: 30 } },
+    axes: [
+      { ...w, values: (W, tt) => tt.map((x) => o.labels[x] ?? "") },
+      { ...w }
+    ],
+    series: [
+      {},
+      ...o.series.map((W, tt) => {
+        var $, gt;
+        const x = an[tt % an.length];
+        return s === "bar" ? { label: W.name, stroke: x, fill: x, paths: (gt = ($ = r.paths).bars) == null ? void 0 : gt.call($, { size: [0.6] }) } : { label: W.name, stroke: x, width: 2, points: { show: !0 } };
+      })
+    ]
+  }, zt = new r(G, u, j);
+  return H == null || H.classList.add("alt-visually-hidden"), zt;
+}
+async function Io(e) {
+  const o = e.querySelector("code"), r = ((o == null ? void 0 : o.textContent) ?? e.textContent ?? "").trim();
+  if (!r)
+    return;
+  const { default: s } = await import("katex"), c = document.createElement("div");
+  c.className = "alt-math-rendered", s.render(r, c, { throwOnError: !1, displayMode: !0 }), e.prepend(c), o == null || o.classList.add("alt-visually-hidden");
+}
+let sn = 0, ln = null;
+function Lo() {
+  return ln ?? (ln = import("mermaid").then(({ default: e }) => (e.initialize({ startOnLoad: !1, securityLevel: "strict" }), e))), ln;
+}
+function Do(e) {
+  const o = e.match(/viewBox="[\d.-]+ [\d.-]+ [\d.-]+ ([\d.]+)"/);
+  return o ? Math.min(Math.max(Math.round(Number(o[1])) + 24, 80), 800) : 320;
+}
+async function Co(e) {
+  var u;
+  const o = (((u = e.querySelector("pre")) == null ? void 0 : u.textContent) ?? e.textContent ?? "").trim();
+  if (!o)
+    return;
+  const r = await Lo();
+  sn += 1;
+  let s;
+  try {
+    ({ svg: s } = await r.render(`altmd-diagram-${String(sn)}`, o));
+  } catch {
+    return;
+  }
+  const c = cn({
+    html: s,
+    allowScripts: !1,
+    height: Do(s),
+    title: "diagram"
+  });
+  e.replaceChildren(c);
+}
+const Mo = [
+  "callout",
+  "tabs",
+  "accordion",
+  "columns",
+  "chart",
+  "math",
+  "table",
+  "diagram",
+  "embed"
+], xo = [...Mo, "tab", "column", "sandbox"];
+class Tt extends HTMLElement {
+  connectedCallback() {
+    this.setAttribute("data-altmd-upgraded", ""), this.enhance();
+  }
+  // Overridden by components that enhance their fallback.
+  enhance() {
+  }
+}
+class Po extends Tt {
+  enhance() {
+    const o = this.ownTabs();
+    if (o.length === 0)
+      return;
+    const r = document.createElement("div");
+    r.className = "alt-tablist", r.setAttribute("role", "tablist"), o.forEach((s, c) => {
+      const u = document.createElement("button");
+      u.type = "button", u.setAttribute("role", "tab"), u.textContent = s.getAttribute("data-title") ?? `Tab ${String(c + 1)}`, u.addEventListener("click", () => {
+        this.select(c);
+      }), r.appendChild(u);
+    }), this.prepend(r), this.select(0);
+  }
+  ownTabs() {
+    return Array.from(this.querySelectorAll("alt-tab")).filter(
+      (o) => o.closest("alt-tabs") === this
+    );
+  }
+  select(o) {
+    this.ownTabs().forEach((s, c) => {
+      s.hidden = c !== o;
+    }), Array.from(this.querySelectorAll(".alt-tablist > button")).forEach((s, c) => {
+      s.setAttribute("aria-selected", c === o ? "true" : "false");
+    });
+  }
+}
+var ht, at, Y, Ut, dn;
+class vo extends Tt {
+  constructor() {
+    super(...arguments);
+    Ot(this, Ut);
+    Ot(this, ht, null);
+    Ot(this, at, null);
+    Ot(this, Y, 0);
+  }
+  enhance() {
+    wo(this).then((r) => {
+      if (!r || !this.isConnected) {
+        r == null || r.destroy();
+        return;
+      }
+      Z(this, ht, r), Ye(this, Ut, dn).call(this, r);
+    }).catch(() => {
+    });
+  }
+  disconnectedCallback() {
+    var r, s;
+    (r = rt(this, at)) == null || r.disconnect(), Z(this, at, null), rt(this, Y) && (cancelAnimationFrame(rt(this, Y)), Z(this, Y, 0)), (s = rt(this, ht)) == null || s.destroy(), Z(this, ht, null);
+  }
+}
+ht = new WeakMap(), at = new WeakMap(), Y = new WeakMap(), Ut = new WeakSet(), /**
+ * Reflow the chart to the container width whenever it changes, so a split or
+ * resized pane never leaves a fixed-width canvas spilling past its column.
+ * uPlot draws to a pixel canvas with no intrinsic responsiveness, so the width
+ * has to be pushed in explicitly.
+ */
+dn = function(r) {
+  const s = this.querySelector(".alt-chart-canvas") ?? this, c = () => {
+    const u = s.clientWidth;
+    u > 0 && Math.abs(u - r.width) > 1 && r.setSize({ width: u, height: pn });
+  };
+  c(), !(typeof ResizeObserver > "u") && (Z(this, at, new ResizeObserver(() => {
+    rt(this, Y) || Z(this, Y, requestAnimationFrame(() => {
+      Z(this, Y, 0), c();
+    }));
+  })), rt(this, at).observe(s));
+};
+class ko extends Tt {
+  enhance() {
+    Io(this).catch(() => {
+    });
+  }
+}
+class Fo extends Tt {
+  enhance() {
+    Co(this).catch(() => {
+    });
+  }
+}
+class Uo extends Tt {
+  enhance() {
+    const o = cn({
+      html: this.innerHTML,
+      allowScripts: !0,
+      title: this.localName
+    });
+    this.replaceChildren(o);
+  }
+}
+function zo(e) {
+  return e === "tabs" ? Po : e === "chart" ? vo : e === "math" ? ko : e === "diagram" ? Fo : e === "sandbox" ? Uo : Tt;
+}
+function Ho(e) {
+  e.querySelectorAll(
+    "li.task-list-item > input[type='checkbox']"
+  ).forEach((r, s) => {
+    r.disabled = !1, r.addEventListener("change", () => {
+      r.dispatchEvent(
+        new CustomEvent("altmd:taskchange", {
+          bubbles: !0,
+          detail: { index: s, checked: r.checked }
+        })
+      );
+    });
+  });
+}
+function hn() {
+  for (const e of xo) {
+    const o = `alt-${e}`;
+    if (customElements.get(o) === void 0) {
+      const r = zo(e);
+      customElements.define(o, class extends r {
+      });
+    }
+  }
+}
+function Go(e, o) {
+  hn(), e.innerHTML = o, Ho(e);
+}
+function Yo(e, o, r) {
+  Go(e, r(o));
+}
+const jo = "0.1.0";
+function $o() {
+  hn();
+}
+export {
+  Tt as AltElement,
+  Mo as V1_COMPONENTS,
+  jo as VERSION,
+  $o as bootstrap,
+  Yn as buildSrcdoc,
+  cn as createSandboxedFrame,
+  Ho as enhanceTaskLists,
+  Go as mount,
+  hn as registerComponents,
+  Yo as renderInto,
+  Bo as sanitizeHtml
+};

package/package.json ADDED Viewed

@@ -0,0 +1,58 @@
+{
+  "name": "@altmd/runtime",
+  "version": "0.1.0",
+  "description": "The zero-build alt-markdown CDN runtime (loads the WASM core, upgrades components).",
+  "license": "MIT",
+  "author": "Daniel Iwugo",
+  "homepage": "https://github.com/elementmerc/alt-markdown#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elementmerc/alt-markdown.git",
+    "directory": "js/packages/runtime"
+  },
+  "bugs": {
+    "url": "https://github.com/elementmerc/alt-markdown/issues"
+  },
+  "keywords": [
+    "markdown",
+    "commonmark",
+    "web-components",
+    "charts",
+    "diagrams",
+    "katex",
+    "mermaid",
+    "zero-build",
+    "alt-markdown"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "dompurify": "^3.4.11"
+  },
+  "peerDependencies": {
+    "katex": "^0.16",
+    "mermaid": "^11",
+    "uplot": "^1.6"
+  },
+  "peerDependenciesMeta": {
+    "katex": { "optional": true },
+    "mermaid": { "optional": true },
+    "uplot": { "optional": true }
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}