@zettelgeist/cli 0.1.0

package/dist/viewer-bundle/main.js

@@ -0,0 +1,4816 @@
+import {
+  showAlert,
+  showConfirmModal,
+  showInputModal
+} from "./chunk-U5T7X4BV.js";
+import "./chunk-DI52DQAC.js";
+
+// src/router.ts
+var Router = class {
+  routes = [];
+  notFoundHandler = async () => {
+    document.getElementById("app").innerHTML = "<p>Not found.</p>";
+  };
+  add(pattern, handler) {
+    const paramNames = [];
+    const regexStr = pattern.replace(/\//g, "\\/").replace(/:([a-zA-Z]+)|\*([a-zA-Z]+)/g, (_, name1, name2) => {
+      const name = name1 ?? name2;
+      paramNames.push(name);
+      return name1 ? "([^/]+)" : "(.+)";
+    });
+    this.routes.push({ pattern: new RegExp("^" + regexStr + "$"), paramNames, handler });
+  }
+  setNotFound(handler) {
+    this.notFoundHandler = handler;
+  }
+  async navigate() {
+    const hash = window.location.hash.slice(1) || "/";
+    if (!hash.startsWith("/spec/")) {
+      try {
+        sessionStorage.setItem("zg:prev-route", `#${hash}`);
+      } catch {
+      }
+    }
+    for (const route of this.routes) {
+      const match = hash.match(route.pattern);
+      if (match) {
+        const params = {};
+        route.paramNames.forEach((name, i) => {
+          params[name] = decodeURIComponent(match[i + 1] ?? "");
+        });
+        await route.handler(params);
+        return;
+      }
+    }
+    await this.notFoundHandler({});
+  }
+  start() {
+    window.addEventListener("hashchange", () => {
+      void this.navigate();
+    });
+    if (document.readyState === "loading") {
+      window.addEventListener("DOMContentLoaded", () => {
+        void this.navigate();
+      }, { once: true });
+    } else {
+      void this.navigate();
+    }
+  }
+};
+
+// src/components/card.ts
+function renderCard(spec) {
+  const card = document.createElement("article");
+  card.className = "zg-card";
+  card.dataset.spec = spec.name;
+  card.dataset.status = spec.status;
+  card.draggable = true;
+  const header = document.createElement("div");
+  header.className = "zg-card-header";
+  const name = document.createElement("h4");
+  name.className = "zg-card-name";
+  name.textContent = spec.name;
+  const editBtn = document.createElement("button");
+  editBtn.type = "button";
+  editBtn.className = "zg-card-edit";
+  editBtn.title = "Edit";
+  editBtn.setAttribute("aria-label", `Edit ${spec.name}`);
+  editBtn.textContent = "\u270E";
+  editBtn.addEventListener("click", async (e) => {
+    e.stopPropagation();
+    const { showEditModal } = await import("./edit-modal-BEGC2AO6.js");
+    const saved = await showEditModal({ spec });
+    if (saved) window.dispatchEvent(new HashChangeEvent("hashchange"));
+  });
+  const delBtn = document.createElement("button");
+  delBtn.type = "button";
+  delBtn.className = "zg-card-delete";
+  delBtn.title = "Delete spec";
+  delBtn.setAttribute("aria-label", `Delete ${spec.name}`);
+  delBtn.textContent = "\u{1F5D1}";
+  delBtn.addEventListener("click", async (e) => {
+    e.stopPropagation();
+    const { showConfirmModal: showConfirmModal2, showAlert: showAlert2 } = await import("./prompt-modal-C4LHI7BS.js");
+    const ok = await showConfirmModal2({
+      title: `Delete "${spec.name}"?`,
+      message: "This removes the entire spec folder from disk and commits the deletion. You can still recover it from git history, but no in-app undo.",
+      confirmLabel: "Delete spec",
+      destructive: true
+    });
+    if (!ok) return;
+    try {
+      await window.zettelgeistBackend.deleteSpec(spec.name);
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    } catch (err) {
+      void showAlert2("Delete failed", err.message);
+    }
+  });
+  header.appendChild(name);
+  header.appendChild(editBtn);
+  header.appendChild(delBtn);
+  const meta = document.createElement("div");
+  meta.className = "zg-card-meta";
+  const progressLabel = document.createElement("span");
+  progressLabel.textContent = spec.progress;
+  meta.appendChild(progressLabel);
+  const { done, total } = parseProgress(spec.progress);
+  if (total > 0) {
+    const bar = document.createElement("div");
+    bar.className = "zg-card-progress";
+    const fill = document.createElement("div");
+    fill.className = "zg-card-progress-bar";
+    fill.style.width = `${Math.round(done / total * 100)}%`;
+    bar.appendChild(fill);
+    meta.appendChild(bar);
+  }
+  card.appendChild(header);
+  card.appendChild(meta);
+  if (spec.pr || spec.branch) {
+    const badges = document.createElement("div");
+    badges.className = "zg-card-badges";
+    if (spec.pr) {
+      const a = document.createElement("a");
+      a.className = "zg-badge zg-badge-pr";
+      a.href = spec.pr;
+      a.target = "_blank";
+      a.rel = "noopener";
+      a.title = spec.pr;
+      a.textContent = prLabel(spec.pr);
+      a.addEventListener("click", (e) => e.stopPropagation());
+      badges.appendChild(a);
+    }
+    if (spec.branch) {
+      const span = document.createElement("span");
+      span.className = "zg-badge zg-badge-branch";
+      span.title = spec.branch;
+      span.textContent = spec.branch;
+      badges.appendChild(span);
+    }
+    card.appendChild(badges);
+  }
+  if (spec.blockedBy) {
+    const blocked = document.createElement("small");
+    blocked.className = "zg-card-blocked";
+    blocked.title = spec.blockedBy;
+    blocked.textContent = `blocked: ${spec.blockedBy}`;
+    card.appendChild(blocked);
+  }
+  card.addEventListener("click", () => {
+    window.location.hash = `#/spec/${encodeURIComponent(spec.name)}`;
+  });
+  card.addEventListener("dragstart", (e) => {
+    if (!e.dataTransfer) return;
+    e.dataTransfer.setData("text/plain", spec.name);
+    e.dataTransfer.setData("application/x-zg-status", spec.status);
+    e.dataTransfer.effectAllowed = "move";
+  });
+  return card;
+}
+function parseProgress(s) {
+  const m = /^(\d+)\s*\/\s*(\d+)$/.exec(s);
+  if (!m) return { done: 0, total: 0 };
+  return { done: Number(m[1]), total: Number(m[2]) };
+}
+function prLabel(url) {
+  const gh = /\/pull\/(\d+)/.exec(url);
+  if (gh) return `PR #${gh[1]}`;
+  return "PR";
+}
+
+// ../../node_modules/.pnpm/dompurify@3.2.0/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(x) {
+    return x;
+  };
+}
+if (!seal) {
+  seal = function seal2(x) {
+    return x;
+  };
+}
+if (!apply) {
+  apply = function apply2(fun, thisValue, args) {
+    return fun.apply(thisValue, args);
+  };
+}
+if (!construct) {
+  construct = function construct2(Func, args) {
+    return new Func(...args);
+  };
+}
+var arrayForEach = unapply(Array.prototype.forEach);
+var arrayPop = unapply(Array.prototype.pop);
+var arrayPush = unapply(Array.prototype.push);
+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) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return apply(func, thisArg, args);
+  };
+}
+function unconstruct(func) {
+  return function() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    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", "section", "select", "shadow", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]);
+var svg$1 = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]);
+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", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]);
+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", "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):|[^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(html3) {
+        return html3;
+      },
+      createScriptURL(scriptUrl) {
+        return scriptUrl;
+      }
+    });
+  } catch (_) {
+    console.warn("TrustedTypes policy " + policyName + " could not be created.");
+    return null;
+  }
+};
+function createDOMPurify() {
+  let window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
+  const DOMPurify = (root) => createDOMPurify(root);
+  DOMPurify.version = "3.2.0";
+  DOMPurify.removed = [];
+  if (!window2 || !window2.document || window2.document.nodeType !== NODE_TYPE.document) {
+    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 = {};
+  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;
+  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) : {};
+    FORBID_ATTR = objectHasOwnProperty(cfg, "FORBID_ATTR") ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};
+    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 (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+        ALLOWED_TAGS = clone(ALLOWED_TAGS);
+      }
+      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+    }
+    if (cfg.ADD_ATTR) {
+      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 (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 (_) {
+      remove(node);
+    }
+  };
+  const _removeAttribute = function _removeAttribute2(name, element) {
+    try {
+      arrayPush(DOMPurify.removed, {
+        attribute: element.getAttributeNode(name),
+        from: element
+      });
+    } catch (_) {
+      arrayPush(DOMPurify.removed, {
+        attribute: null,
+        from: element
+      });
+    }
+    element.removeAttribute(name);
+    if (name === "is" && !ALLOWED_ATTR[name]) {
+      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+        try {
+          _forceRemove(element);
+        } catch (_) {
+        }
+      } else {
+        try {
+          element.setAttribute(name, "");
+        } catch (_) {
+        }
+      }
+    }
+  };
+  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 (_) {
+      }
+    }
+    if (!doc || !doc.documentElement) {
+      doc = implementation.createDocument(NAMESPACE, "template", null);
+      try {
+        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+      } catch (_) {
+      }
+    }
+    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 _executeHook(entryPoint, currentNode, data) {
+    if (!hooks[entryPoint]) {
+      return;
+    }
+    arrayForEach(hooks[entryPoint], (hook) => {
+      hook.call(DOMPurify, currentNode, data, CONFIG);
+    });
+  }
+  const _sanitizeElements = function _sanitizeElements2(currentNode) {
+    let content = null;
+    _executeHook("beforeSanitizeElements", currentNode, null);
+    if (_isClobbered(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    const tagName = transformCaseFunc(currentNode.nodeName);
+    _executeHook("uponSanitizeElement", currentNode, {
+      tagName,
+      allowedTags: ALLOWED_TAGS
+    });
+    if (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 (!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;
+      }
+    }
+    _executeHook("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 (!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)) || // 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) {
+    _executeHook("beforeSanitizeAttributes", currentNode, null);
+    const {
+      attributes
+    } = currentNode;
+    if (!attributes) {
+      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);
+      let value = name === "value" ? attrValue : stringTrim(attrValue);
+      hookEvent.attrName = lcName;
+      hookEvent.attrValue = value;
+      hookEvent.keepAttr = true;
+      hookEvent.forceKeepAttr = void 0;
+      _executeHook("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)/i, value)) {
+        _removeAttribute(name, currentNode);
+        continue;
+      }
+      if (hookEvent.forceKeepAttr) {
+        continue;
+      }
+      _removeAttribute(name, currentNode);
+      if (!hookEvent.keepAttr) {
+        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)) {
+        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;
+            }
+          }
+        }
+      }
+      try {
+        if (namespaceURI) {
+          currentNode.setAttributeNS(namespaceURI, name, value);
+        } else {
+          currentNode.setAttribute(name, value);
+        }
+        if (_isClobbered(currentNode)) {
+          _forceRemove(currentNode);
+        } else {
+          arrayPop(DOMPurify.removed);
+        }
+      } catch (_) {
+      }
+    }
+    _executeHook("afterSanitizeAttributes", currentNode, null);
+  };
+  const _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) {
+    let shadowNode = null;
+    const shadowIterator = _createNodeIterator(fragment);
+    _executeHook("beforeSanitizeShadowDOM", fragment, null);
+    while (shadowNode = shadowIterator.nextNode()) {
+      _executeHook("uponSanitizeShadowNode", shadowNode, null);
+      if (_sanitizeElements(shadowNode)) {
+        continue;
+      }
+      if (shadowNode.content instanceof DocumentFragment) {
+        _sanitizeShadowDOM2(shadowNode.content);
+      }
+      _sanitizeAttributes(shadowNode);
+    }
+    _executeHook("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()) {
+      if (_sanitizeElements(currentNode)) {
+        continue;
+      }
+      if (currentNode.content instanceof DocumentFragment) {
+        _sanitizeShadowDOM(currentNode.content);
+      }
+      _sanitizeAttributes(currentNode);
+    }
+    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(tag2, attr, value) {
+    if (!CONFIG) {
+      _parseConfig({});
+    }
+    const lcTag = transformCaseFunc(tag2);
+    const lcName = transformCaseFunc(attr);
+    return _isValidAttribute(lcTag, lcName, value);
+  };
+  DOMPurify.addHook = function(entryPoint, hookFunction) {
+    if (typeof hookFunction !== "function") {
+      return;
+    }
+    hooks[entryPoint] = hooks[entryPoint] || [];
+    arrayPush(hooks[entryPoint], hookFunction);
+  };
+  DOMPurify.removeHook = function(entryPoint) {
+    if (hooks[entryPoint]) {
+      return arrayPop(hooks[entryPoint]);
+    }
+  };
+  DOMPurify.removeHooks = function(entryPoint) {
+    if (hooks[entryPoint]) {
+      hooks[entryPoint] = [];
+    }
+  };
+  DOMPurify.removeAllHooks = function() {
+    hooks = {};
+  };
+  return DOMPurify;
+}
+var purify = createDOMPurify();
+
+// src/util/sanitize.ts
+var PURIFY_CONFIG = {
+  USE_PROFILES: { html: true, svg: true, svgFilters: true },
+  // Allow <input type="checkbox" disabled> for GFM task-list rendering and
+  // the `task-list-item` / `contains-task-list` classes marked emits.
+  ADD_TAGS: ["input"],
+  ADD_ATTR: ["data-spec", "data-status", "type", "checked", "disabled", "class"],
+  ALLOW_DATA_ATTR: false,
+  KEEP_CONTENT: true
+};
+function sanitizeHtml(html3) {
+  return purify.sanitize(html3, PURIFY_CONFIG);
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  })[c] ?? c);
+}
+
+// src/components/validation-banner.ts
+function renderValidationBanner(errors) {
+  if (errors.length === 0) return null;
+  const banner = document.createElement("details");
+  banner.className = "zg-validation-banner";
+  banner.open = errors.length <= 3;
+  const summary = document.createElement("summary");
+  summary.className = "zg-validation-summary";
+  const icon = document.createElement("span");
+  icon.className = "zg-validation-icon";
+  icon.textContent = "\u26A0";
+  summary.appendChild(icon);
+  const label = document.createElement("span");
+  label.textContent = errors.length === 1 ? "1 spec validation error" : `${errors.length} spec validation errors`;
+  summary.appendChild(label);
+  banner.appendChild(summary);
+  const list2 = document.createElement("ul");
+  list2.className = "zg-validation-list";
+  for (const err of errors) {
+    const li = document.createElement("li");
+    li.className = `zg-validation-item zg-validation-${err.code.toLowerCase()}`;
+    li.innerHTML = `<code>${escapeHtml(err.code)}</code> <strong>${escapeHtml(formatPath(err.path))}</strong>` + (err.detail ? ` \u2014 ${escapeHtml(err.detail)}` : "");
+    list2.appendChild(li);
+  }
+  banner.appendChild(list2);
+  return banner;
+}
+function formatPath(path) {
+  if (typeof path === "string") return path;
+  return path.join(" \u2192 ");
+}
+async function fetchAndRenderValidationBanner() {
+  try {
+    const { errors } = await window.zettelgeistBackend.validateRepo();
+    return renderValidationBanner(errors);
+  } catch {
+    return null;
+  }
+}
+
+// src/views/board.ts
+var COLUMN_ORDER = [
+  "draft",
+  "planned",
+  "in-progress",
+  "in-review",
+  "done",
+  "blocked",
+  "cancelled"
+];
+var COLUMN_LABELS = {
+  "draft": "Draft",
+  "planned": "Planned",
+  "in-progress": "In Progress",
+  "in-review": "In Review",
+  "done": "Done",
+  "blocked": "Blocked",
+  "cancelled": "Cancelled"
+};
+async function renderBoard() {
+  const app = document.getElementById("app");
+  app.innerHTML = "<p>Loading specs\u2026</p>";
+  const backend = window.zettelgeistBackend;
+  let specs;
+  try {
+    specs = await backend.listSpecs();
+  } catch (err) {
+    app.innerHTML = `<p class="zg-error">Failed to load specs: ${escapeHtml(err.message)}</p>`;
+    return;
+  }
+  app.innerHTML = "";
+  const banner = await fetchAndRenderValidationBanner();
+  if (banner) app.appendChild(banner);
+  if (specs.length === 0) {
+    app.appendChild(renderEmptyState());
+    return;
+  }
+  const byStatus = {
+    "draft": [],
+    "planned": [],
+    "in-progress": [],
+    "in-review": [],
+    "done": [],
+    "blocked": [],
+    "cancelled": []
+  };
+  for (const s of specs) byStatus[s.status].push(s);
+  const board = document.createElement("div");
+  board.className = "zg-board";
+  for (const status of COLUMN_ORDER) {
+    const column = document.createElement("section");
+    column.className = "zg-column";
+    column.dataset.status = status;
+    const header = document.createElement("header");
+    header.className = "zg-column-header";
+    const title = document.createElement("h3");
+    title.textContent = COLUMN_LABELS[status];
+    const count = document.createElement("span");
+    count.className = "zg-column-count";
+    count.textContent = String(byStatus[status].length);
+    const addBtn = document.createElement("button");
+    addBtn.type = "button";
+    addBtn.className = "zg-column-add";
+    addBtn.title = `New spec in ${COLUMN_LABELS[status]}`;
+    addBtn.setAttribute("aria-label", `New spec in ${COLUMN_LABELS[status]}`);
+    addBtn.textContent = "+";
+    addBtn.addEventListener("click", () => void createSpecInColumn(status, specs));
+    header.appendChild(title);
+    header.appendChild(count);
+    header.appendChild(addBtn);
+    const cards = document.createElement("div");
+    cards.className = "zg-column-cards";
+    for (const spec of byStatus[status]) {
+      cards.appendChild(renderCard(spec));
+    }
+    column.appendChild(header);
+    column.appendChild(cards);
+    attachDropHandlers(column, status);
+    board.appendChild(column);
+  }
+  app.appendChild(board);
+}
+function templateFor(name, status, blockedBy) {
+  const fmLines = ["---"];
+  fmLines.push(`status: ${status}`);
+  if (status === "blocked" && blockedBy) fmLines.push(`blocked_by: ${JSON.stringify(blockedBy)}`);
+  fmLines.push("depends_on: []");
+  fmLines.push("---");
+  const requirements = `${fmLines.join("\n")}
+# ${name}
+
+## Why
+
+<!-- Why does this spec exist? -->
+
+## Acceptance criteria
+
+- [ ] WHEN <trigger>
+- [ ] THE SYSTEM SHALL <observable behavior>
+
+## Out of scope
+
+- 
+
+## References
+
+- 
+`;
+  const tasks = `- [ ] 1. 
+`;
+  return { requirements, tasks };
+}
+async function createSpecInColumn(status, existing) {
+  const raw = await showInputModal({
+    title: `New spec in "${status}"`,
+    message: 'Lowercase letters, numbers, and dashes. Example: "user-auth".',
+    placeholder: "my-new-spec",
+    confirmLabel: "Create",
+    validate: (v) => {
+      const t = v.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+      if (!t) return "Name is required.";
+      if (existing.some((s) => s.name === t)) return `A spec named "${t}" already exists.`;
+      return null;
+    }
+  });
+  if (raw === null) return;
+  const name = raw.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!name) return;
+  let blockedBy;
+  if (status === "blocked") {
+    const reason = await showInputModal({
+      title: `Why is "${name}" blocked?`,
+      message: "A reason is required for blocked specs.",
+      confirmLabel: "Create",
+      validate: (v) => v.trim() ? null : "Reason is required."
+    });
+    if (reason === null) return;
+    blockedBy = reason.trim();
+  }
+  const { requirements, tasks } = templateFor(name, status, blockedBy);
+  try {
+    const backend = window.zettelgeistBackend;
+    await backend.writeSpecFile(name, "requirements.md", requirements);
+    await backend.writeSpecFile(name, "tasks.md", tasks);
+    window.location.hash = `#/spec/${encodeURIComponent(name)}`;
+  } catch (err) {
+    void showAlert("Error", err.message);
+  }
+}
+function renderEmptyState() {
+  const wrap = document.createElement("div");
+  wrap.className = "zg-empty-state";
+  const title = document.createElement("h2");
+  title.textContent = "No specs yet";
+  wrap.appendChild(title);
+  const blurb = document.createElement("p");
+  blurb.textContent = "A spec is a folder under specs/ with at least one of requirements.md, tasks.md, handoff.md, or lenses/*.md. Create one by hand or ask your agent to.";
+  wrap.appendChild(blurb);
+  const example = document.createElement("pre");
+  example.className = "zg-empty-example";
+  example.textContent = 'specs/my-first-spec/\n  requirements.md   # markdown body (optionally with --- frontmatter ---)\n  tasks.md          # "- [ ] 1. task text" lines\n\n# then:\nzettelgeist regen     # rebuilds specs/INDEX.md\n';
+  wrap.appendChild(example);
+  const hint = document.createElement("p");
+  hint.className = "zg-empty-hint";
+  hint.innerHTML = "Refresh this page once the spec is on disk \u2014 the board will pick it up.";
+  wrap.appendChild(hint);
+  return wrap;
+}
+function attachDropHandlers(column, status) {
+  column.addEventListener("dragover", (e) => {
+    e.preventDefault();
+    column.classList.add("zg-column-drop-target");
+    if (e.dataTransfer) e.dataTransfer.dropEffect = "move";
+  });
+  column.addEventListener("dragleave", () => {
+    column.classList.remove("zg-column-drop-target");
+  });
+  column.addEventListener("drop", async (e) => {
+    e.preventDefault();
+    column.classList.remove("zg-column-drop-target");
+    const specName = e.dataTransfer?.getData("text/plain");
+    if (!specName) return;
+    const sourceStatus = e.dataTransfer?.getData("application/x-zg-status") || "";
+    if (sourceStatus === status) return;
+    let reason;
+    if (status === "blocked" || status === "cancelled") {
+      const { showReasonModal } = await import("./reason-modal-MK34MQ73.js");
+      reason = await showReasonModal({
+        title: status === "blocked" ? "Mark as Blocked" : "Mark as Cancelled",
+        message: `Mark "${specName}" as ${status}.`,
+        reasonRequired: status === "blocked",
+        reasonLabel: status === "blocked" ? "What's blocking it?" : "Reason (optional):",
+        confirmLabel: status === "blocked" ? "Mark Blocked" : "Mark Cancelled"
+      });
+      if (reason === null) return;
+    }
+    try {
+      await window.zettelgeistBackend.setStatus(specName, status, reason || void 0);
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    } catch (err) {
+      void showAlert("Error", err.message);
+    }
+  });
+}
+
+// src/components/tabs.ts
+function renderTabs(tabs, opts = {}) {
+  const wrapper = document.createElement("div");
+  wrapper.className = "zg-tabs";
+  const nav = document.createElement("nav");
+  nav.className = "zg-tab-nav";
+  const content = document.createElement("div");
+  content.className = "zg-tab-content";
+  function activate(id) {
+    const tab = tabs.find((t) => t.id === id);
+    if (!tab) return;
+    nav.querySelectorAll("button").forEach((b) => {
+      b.classList.toggle("active", b.dataset.tab === id);
+    });
+    content.innerHTML = "";
+    content.appendChild(tab.render());
+    opts.onActivate?.(id);
+  }
+  for (const tab of tabs) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.dataset.tab = tab.id;
+    btn.textContent = tab.label;
+    btn.addEventListener("click", () => activate(tab.id));
+    nav.appendChild(btn);
+  }
+  wrapper.appendChild(nav);
+  wrapper.appendChild(content);
+  if (tabs.length > 0) {
+    const initial = opts.initialTabId && tabs.some((t) => t.id === opts.initialTabId) ? opts.initialTabId : tabs[0].id;
+    activate(initial);
+  }
+  return wrapper;
+}
+
+// src/components/task-list.ts
+function renderTaskList(specName, tasks) {
+  const wrap = document.createElement("div");
+  wrap.className = "zg-tasks";
+  const list2 = document.createElement("ul");
+  list2.className = "zg-task-list";
+  if (tasks.length === 0) {
+    const empty = document.createElement("li");
+    const em = document.createElement("em");
+    em.textContent = "No tasks yet \u2014 add the first one below.";
+    empty.appendChild(em);
+    list2.appendChild(empty);
+  } else {
+    for (const task of tasks) list2.appendChild(renderTaskItem(specName, task));
+  }
+  wrap.appendChild(list2);
+  wrap.appendChild(renderAddForm(specName));
+  return wrap;
+}
+function renderTaskItem(specName, task) {
+  const item = document.createElement("li");
+  item.className = "zg-task";
+  item.dataset.index = String(task.index);
+  const checkbox = document.createElement("input");
+  checkbox.type = "checkbox";
+  checkbox.checked = task.checked;
+  checkbox.addEventListener("change", async () => {
+    const backend = window.zettelgeistBackend;
+    try {
+      if (checkbox.checked) await backend.tickTask(specName, task.index);
+      else await backend.untickTask(specName, task.index);
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    } catch (err) {
+      checkbox.checked = !checkbox.checked;
+      void showAlert("Error", err.message);
+    }
+  });
+  const label = document.createElement("label");
+  label.className = "zg-task-label";
+  label.textContent = ` ${task.text}`;
+  label.prepend(checkbox);
+  item.appendChild(label);
+  if (task.tags.length > 0) {
+    const tags = document.createElement("span");
+    tags.className = "zg-task-tags";
+    for (const tag2 of task.tags) {
+      const badge = document.createElement("small");
+      badge.className = "zg-tag";
+      badge.textContent = tag2;
+      tags.appendChild(badge);
+    }
+    item.appendChild(tags);
+  }
+  const actions = document.createElement("span");
+  actions.className = "zg-task-actions";
+  const editBtn = document.createElement("button");
+  editBtn.type = "button";
+  editBtn.className = "zg-task-edit";
+  editBtn.title = "Edit task text";
+  editBtn.setAttribute("aria-label", `Edit task ${task.index}`);
+  editBtn.textContent = "\u270E";
+  editBtn.addEventListener("click", () => startInlineEdit(specName, task, item));
+  const delBtn = document.createElement("button");
+  delBtn.type = "button";
+  delBtn.className = "zg-task-delete";
+  delBtn.title = "Delete task";
+  delBtn.setAttribute("aria-label", `Delete task ${task.index}`);
+  delBtn.textContent = "\u{1F5D1}";
+  delBtn.addEventListener("click", () => deleteTask(specName, task.index));
+  actions.appendChild(editBtn);
+  actions.appendChild(delBtn);
+  item.appendChild(actions);
+  return item;
+}
+function renderAddForm(specName) {
+  const form = document.createElement("form");
+  form.className = "zg-task-add";
+  form.addEventListener("submit", (e) => e.preventDefault());
+  const input = document.createElement("input");
+  input.type = "text";
+  input.className = "zg-task-add-input";
+  input.placeholder = "New task\u2026 (use #human-only / #agent-only / #skip for tags)";
+  input.setAttribute("aria-label", "New task text");
+  const btn = document.createElement("button");
+  btn.type = "submit";
+  btn.className = "zg-task-add-btn";
+  btn.textContent = "Add";
+  const submit = async () => {
+    const text2 = input.value.trim();
+    if (!text2) return;
+    btn.disabled = true;
+    try {
+      await appendTask(specName, text2);
+      input.value = "";
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    } catch (err) {
+      void showAlert("Error", err.message);
+    } finally {
+      btn.disabled = false;
+    }
+  };
+  btn.addEventListener("click", submit);
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      void submit();
+    }
+  });
+  form.appendChild(input);
+  form.appendChild(btn);
+  return form;
+}
+function startInlineEdit(specName, task, item) {
+  const label = item.querySelector(".zg-task-label");
+  if (!label) return;
+  const tagsSuffix = task.tags.length > 0 ? " " + task.tags.join(" ") : "";
+  const original = task.text + tagsSuffix;
+  const input = document.createElement("input");
+  input.type = "text";
+  input.className = "zg-task-edit-input";
+  input.value = original;
+  input.placeholder = "task text  #human-only / #agent-only / #skip";
+  label.style.display = "none";
+  const actions = item.querySelector(".zg-task-actions");
+  if (actions) actions.style.display = "none";
+  const tagsEl = item.querySelector(".zg-task-tags");
+  if (tagsEl) tagsEl.style.display = "none";
+  item.insertBefore(input, label);
+  input.focus();
+  input.select();
+  const finish = async (commit) => {
+    const next = input.value.trim();
+    input.remove();
+    label.style.display = "";
+    if (actions) actions.style.display = "";
+    if (tagsEl) tagsEl.style.display = "";
+    if (!commit || !next || next === original) return;
+    try {
+      await replaceTask(specName, task.index, next);
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    } catch (err) {
+      void showAlert("Error", err.message);
+    }
+  };
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      void finish(true);
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      void finish(false);
+    }
+  });
+  input.addEventListener("blur", () => void finish(true));
+}
+async function readTasksFile(specName) {
+  try {
+    const { content } = await window.zettelgeistBackend.readSpecFile(specName, "tasks.md");
+    return content;
+  } catch {
+    return "";
+  }
+}
+var TASK_LINE = /^([\s>]*[-*+]\s+\[)([ xX])(\]\s+)(.*)$/;
+async function appendTask(specName, text2) {
+  const current = await readTasksFile(specName);
+  const existing = current.split("\n").filter((l) => TASK_LINE.test(l)).length;
+  const nextIndex = existing + 1;
+  const newLine = `- [ ] ${nextIndex}. ${text2}`;
+  const next = current.endsWith("\n") || current === "" ? `${current}${newLine}
+` : `${current}
+${newLine}
+`;
+  await window.zettelgeistBackend.writeSpecFile(specName, "tasks.md", next);
+}
+async function replaceTask(specName, n, text2) {
+  const current = await readTasksFile(specName);
+  const lines = current.split("\n");
+  let count = 0;
+  let mutated = false;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i]?.match(TASK_LINE);
+    if (!m) continue;
+    count++;
+    if (count === n) {
+      const body = m[4];
+      const numPrefix = /^(\d+\.\s+)/.exec(body);
+      const replacement = numPrefix ? numPrefix[1] + text2 : text2;
+      lines[i] = `${m[1]}${m[2]}${m[3]}${replacement}`;
+      mutated = true;
+      break;
+    }
+  }
+  if (!mutated) throw new Error(`no task at index ${n}`);
+  await window.zettelgeistBackend.writeSpecFile(specName, "tasks.md", lines.join("\n"));
+}
+async function deleteTask(specName, n) {
+  const ok = await showConfirmModal({
+    title: `Delete task ${n}?`,
+    message: "This removes the line and renumbers the remaining tasks.",
+    confirmLabel: "Delete",
+    destructive: true
+  });
+  if (!ok) return;
+  try {
+    const current = await readTasksFile(specName);
+    const lines = current.split("\n");
+    const kept = [];
+    let count = 0;
+    let renumber = 0;
+    for (const line of lines) {
+      const m = line.match(TASK_LINE);
+      if (!m) {
+        kept.push(line);
+        continue;
+      }
+      count++;
+      if (count === n) continue;
+      renumber++;
+      const body = m[4];
+      const replaced = body.replace(/^\d+\.\s+/, `${renumber}. `);
+      kept.push(`${m[1]}${m[2]}${m[3]}${replaced}`);
+    }
+    await window.zettelgeistBackend.writeSpecFile(specName, "tasks.md", kept.join("\n"));
+    window.dispatchEvent(new HashChangeEvent("hashchange"));
+  } catch (err) {
+    void showAlert("Error", err.message);
+  }
+}
+
+// src/components/frontmatter-form.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["status", "blocked_by"]);
+var ARRAY_KEYS = /* @__PURE__ */ new Set(["depends_on"]);
+function renderFrontmatterForm(spec) {
+  const container = document.createElement("details");
+  container.className = "zg-frontmatter";
+  container.open = false;
+  const summary = document.createElement("summary");
+  summary.textContent = "Frontmatter";
+  container.appendChild(summary);
+  const editable = Object.entries(spec.frontmatter).filter(([k]) => !FORBIDDEN_KEYS.has(k));
+  if (editable.length === 0 && Object.keys(spec.frontmatter).length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "zg-fm-empty";
+    empty.innerHTML = "<em>No frontmatter set.</em> Use the field below to add one.";
+    container.appendChild(empty);
+  }
+  const form = document.createElement("div");
+  form.className = "zg-fm-form";
+  form.addEventListener("keydown", (e) => {
+    if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+      e.preventDefault();
+      void save();
+    }
+  });
+  const rows = [];
+  for (const [key, value] of editable) rows.push(renderRow(form, key, value));
+  const addBtn = document.createElement("button");
+  addBtn.type = "button";
+  addBtn.className = "zg-fm-add";
+  addBtn.textContent = "+ Add field";
+  addBtn.addEventListener("click", () => {
+    const row = renderRow(form, "", "");
+    rows.push(row);
+    form.insertBefore(row.el, addBtn);
+    row.focusKey();
+  });
+  const status = document.createElement("p");
+  status.className = "zg-fm-status";
+  status.style.display = "none";
+  const saveBtn = document.createElement("button");
+  saveBtn.type = "button";
+  saveBtn.className = "zg-fm-save";
+  saveBtn.textContent = "Save frontmatter";
+  async function save() {
+    saveBtn.disabled = true;
+    try {
+      const original = new Map(editable);
+      const present = /* @__PURE__ */ new Map();
+      for (const r of rows) {
+        const k = r.key;
+        if (!k) continue;
+        present.set(k, r.getValue());
+      }
+      const patch = {};
+      for (const [k, v] of present) patch[k] = v;
+      for (const k of original.keys()) {
+        if (!present.has(k)) patch[k] = null;
+      }
+      if (Object.keys(patch).length === 0) {
+        flashStatus(status, "Nothing to save.", "info");
+        return;
+      }
+      await window.zettelgeistBackend.patchFrontmatter(spec.name, patch);
+      flashStatus(status, "Saved \u2713", "ok");
+    } catch (err) {
+      void showAlert("Save failed", err.message);
+    } finally {
+      saveBtn.disabled = false;
+    }
+  }
+  saveBtn.addEventListener("click", () => void save());
+  form.appendChild(addBtn);
+  const actions = document.createElement("div");
+  actions.className = "zg-fm-actions";
+  actions.appendChild(status);
+  actions.appendChild(saveBtn);
+  container.appendChild(form);
+  container.appendChild(actions);
+  return container;
+}
+function flashStatus(el, text2, kind) {
+  el.textContent = text2;
+  el.dataset.kind = kind;
+  el.style.display = "";
+  el.style.opacity = "1";
+  setTimeout(() => {
+    el.style.transition = "opacity 0.4s";
+    el.style.opacity = "0";
+  }, 1800);
+}
+function renderRow(parent, initialKey, initialValue) {
+  const row = document.createElement("div");
+  row.className = "zg-fm-row";
+  const keyInput = document.createElement("input");
+  keyInput.type = "text";
+  keyInput.className = "zg-fm-key";
+  keyInput.value = initialKey;
+  keyInput.placeholder = "field";
+  const isExisting = initialKey !== "";
+  if (isExisting) keyInput.readOnly = true;
+  const valueEl = makeValueInput(initialKey, initialValue);
+  const removeBtn = document.createElement("button");
+  removeBtn.type = "button";
+  removeBtn.className = "zg-fm-remove";
+  removeBtn.title = "Remove field (will be deleted on save)";
+  removeBtn.textContent = "\u{1F5D1}";
+  removeBtn.addEventListener("click", () => {
+    row.remove();
+  });
+  row.appendChild(keyInput);
+  row.appendChild(valueEl.el);
+  row.appendChild(removeBtn);
+  parent.appendChild(row);
+  return {
+    get key() {
+      return keyInput.value.trim();
+    },
+    el: row,
+    getValue: valueEl.getValue,
+    focusKey: () => keyInput.focus()
+  };
+}
+function makeValueInput(key, value) {
+  if (ARRAY_KEYS.has(key) || Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    const input = document.createElement("input");
+    input.type = "text";
+    input.className = "zg-fm-value";
+    input.placeholder = "comma-separated, e.g. user-auth, billing";
+    input.value = Array.isArray(value) ? value.join(", ") : "";
+    return {
+      el: input,
+      getValue: () => input.value.split(",").map((s) => s.trim()).filter(Boolean)
+    };
+  }
+  if (value === null || value === void 0 || typeof value === "string") {
+    const input = document.createElement("input");
+    input.type = "text";
+    input.className = "zg-fm-value";
+    input.value = typeof value === "string" ? value : "";
+    return {
+      el: input,
+      getValue: () => {
+        const t = input.value.trim();
+        return t === "" ? null : t;
+      }
+    };
+  }
+  if (typeof value === "boolean") {
+    const wrap = document.createElement("label");
+    wrap.className = "zg-fm-value zg-fm-bool";
+    const input = document.createElement("input");
+    input.type = "checkbox";
+    input.checked = value;
+    wrap.appendChild(input);
+    wrap.appendChild(document.createTextNode(value ? "true" : "false"));
+    input.addEventListener("change", () => {
+      wrap.lastChild.textContent = input.checked ? "true" : "false";
+    });
+    return { el: wrap, getValue: () => input.checked };
+  }
+  const ta = document.createElement("textarea");
+  ta.className = "zg-fm-value zg-fm-json";
+  ta.rows = 2;
+  ta.value = JSON.stringify(value);
+  return {
+    el: ta,
+    getValue: () => {
+      try {
+        return JSON.parse(ta.value);
+      } catch {
+        return ta.value;
+      }
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/marked@14.1.4/node_modules/marked/lib/marked.esm.js
+function _getDefaults() {
+  return {
+    async: false,
+    breaks: false,
+    extensions: null,
+    gfm: true,
+    hooks: null,
+    pedantic: false,
+    renderer: null,
+    silent: false,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+var _defaults = _getDefaults();
+function changeDefaults(newDefaults) {
+  _defaults = newDefaults;
+}
+var escapeTest = /[&<>"']/;
+var escapeReplace = new RegExp(escapeTest.source, "g");
+var escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+var escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g");
+var escapeReplacements = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape$1(html3, encode) {
+  if (encode) {
+    if (escapeTest.test(html3)) {
+      return html3.replace(escapeReplace, getEscapeReplacement);
+    }
+  } else {
+    if (escapeTestNoEncode.test(html3)) {
+      return html3.replace(escapeReplaceNoEncode, getEscapeReplacement);
+    }
+  }
+  return html3;
+}
+var caret = /(^|[^\[])\^/g;
+function edit(regex, opt) {
+  let source = typeof regex === "string" ? regex : regex.source;
+  opt = opt || "";
+  const obj = {
+    replace: (name, val) => {
+      let valSource = typeof val === "string" ? val : val.source;
+      valSource = valSource.replace(caret, "$1");
+      source = source.replace(name, valSource);
+      return obj;
+    },
+    getRegex: () => {
+      return new RegExp(source, opt);
+    }
+  };
+  return obj;
+}
+function cleanUrl(href) {
+  try {
+    href = encodeURI(href).replace(/%25/g, "%");
+  } catch {
+    return null;
+  }
+  return href;
+}
+var noopTest = { exec: () => null };
+function splitCells(tableRow, count) {
+  const row = tableRow.replace(/\|/g, (match, offset, str) => {
+    let escaped = false;
+    let curr = offset;
+    while (--curr >= 0 && str[curr] === "\\")
+      escaped = !escaped;
+    if (escaped) {
+      return "|";
+    } else {
+      return " |";
+    }
+  }), cells = row.split(/ \|/);
+  let i = 0;
+  if (!cells[0].trim()) {
+    cells.shift();
+  }
+  if (cells.length > 0 && !cells[cells.length - 1].trim()) {
+    cells.pop();
+  }
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count)
+        cells.push("");
+    }
+  }
+  for (; i < cells.length; i++) {
+    cells[i] = cells[i].trim().replace(/\\\|/g, "|");
+  }
+  return cells;
+}
+function rtrim(str, c, invert) {
+  const l = str.length;
+  if (l === 0) {
+    return "";
+  }
+  let suffLen = 0;
+  while (suffLen < l) {
+    const currChar = str.charAt(l - suffLen - 1);
+    if (currChar === c && !invert) {
+      suffLen++;
+    } else if (currChar !== c && invert) {
+      suffLen++;
+    } else {
+      break;
+    }
+  }
+  return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+  if (str.indexOf(b[1]) === -1) {
+    return -1;
+  }
+  let level = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "\\") {
+      i++;
+    } else if (str[i] === b[0]) {
+      level++;
+    } else if (str[i] === b[1]) {
+      level--;
+      if (level < 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function outputLink(cap, link2, raw, lexer2) {
+  const href = link2.href;
+  const title = link2.title ? escape$1(link2.title) : null;
+  const text2 = cap[1].replace(/\\([\[\]])/g, "$1");
+  if (cap[0].charAt(0) !== "!") {
+    lexer2.state.inLink = true;
+    const token = {
+      type: "link",
+      raw,
+      href,
+      title,
+      text: text2,
+      tokens: lexer2.inlineTokens(text2)
+    };
+    lexer2.state.inLink = false;
+    return token;
+  }
+  return {
+    type: "image",
+    raw,
+    href,
+    title,
+    text: escape$1(text2)
+  };
+}
+function indentCodeCompensation(raw, text2) {
+  const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+  if (matchIndentToCode === null) {
+    return text2;
+  }
+  const indentToCode = matchIndentToCode[1];
+  return text2.split("\n").map((node) => {
+    const matchIndentInNode = node.match(/^\s+/);
+    if (matchIndentInNode === null) {
+      return node;
+    }
+    const [indentInNode] = matchIndentInNode;
+    if (indentInNode.length >= indentToCode.length) {
+      return node.slice(indentToCode.length);
+    }
+    return node;
+  }).join("\n");
+}
+var _Tokenizer = class {
+  options;
+  rules;
+  // set by the lexer
+  lexer;
+  // set by the lexer
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  space(src) {
+    const cap = this.rules.block.newline.exec(src);
+    if (cap && cap[0].length > 0) {
+      return {
+        type: "space",
+        raw: cap[0]
+      };
+    }
+  }
+  code(src) {
+    const cap = this.rules.block.code.exec(src);
+    if (cap) {
+      const text2 = cap[0].replace(/^(?: {1,4}| {0,3}\t)/gm, "");
+      return {
+        type: "code",
+        raw: cap[0],
+        codeBlockStyle: "indented",
+        text: !this.options.pedantic ? rtrim(text2, "\n") : text2
+      };
+    }
+  }
+  fences(src) {
+    const cap = this.rules.block.fences.exec(src);
+    if (cap) {
+      const raw = cap[0];
+      const text2 = indentCodeCompensation(raw, cap[3] || "");
+      return {
+        type: "code",
+        raw,
+        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
+        text: text2
+      };
+    }
+  }
+  heading(src) {
+    const cap = this.rules.block.heading.exec(src);
+    if (cap) {
+      let text2 = cap[2].trim();
+      if (/#$/.test(text2)) {
+        const trimmed = rtrim(text2, "#");
+        if (this.options.pedantic) {
+          text2 = trimmed.trim();
+        } else if (!trimmed || / $/.test(trimmed)) {
+          text2 = trimmed.trim();
+        }
+      }
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[1].length,
+        text: text2,
+        tokens: this.lexer.inline(text2)
+      };
+    }
+  }
+  hr(src) {
+    const cap = this.rules.block.hr.exec(src);
+    if (cap) {
+      return {
+        type: "hr",
+        raw: rtrim(cap[0], "\n")
+      };
+    }
+  }
+  blockquote(src) {
+    const cap = this.rules.block.blockquote.exec(src);
+    if (cap) {
+      let lines = rtrim(cap[0], "\n").split("\n");
+      let raw = "";
+      let text2 = "";
+      const tokens = [];
+      while (lines.length > 0) {
+        let inBlockquote = false;
+        const currentLines = [];
+        let i;
+        for (i = 0; i < lines.length; i++) {
+          if (/^ {0,3}>/.test(lines[i])) {
+            currentLines.push(lines[i]);
+            inBlockquote = true;
+          } else if (!inBlockquote) {
+            currentLines.push(lines[i]);
+          } else {
+            break;
+          }
+        }
+        lines = lines.slice(i);
+        const currentRaw = currentLines.join("\n");
+        const currentText = currentRaw.replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, "\n    $1").replace(/^ {0,3}>[ \t]?/gm, "");
+        raw = raw ? `${raw}
+${currentRaw}` : currentRaw;
+        text2 = text2 ? `${text2}
+${currentText}` : currentText;
+        const top = this.lexer.state.top;
+        this.lexer.state.top = true;
+        this.lexer.blockTokens(currentText, tokens, true);
+        this.lexer.state.top = top;
+        if (lines.length === 0) {
+          break;
+        }
+        const lastToken = tokens[tokens.length - 1];
+        if (lastToken?.type === "code") {
+          break;
+        } else if (lastToken?.type === "blockquote") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + "\n" + lines.join("\n");
+          const newToken = this.blockquote(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;
+          text2 = text2.substring(0, text2.length - oldToken.text.length) + newToken.text;
+          break;
+        } else if (lastToken?.type === "list") {
+          const oldToken = lastToken;
+          const newText = oldToken.raw + "\n" + lines.join("\n");
+          const newToken = this.list(newText);
+          tokens[tokens.length - 1] = newToken;
+          raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
+          text2 = text2.substring(0, text2.length - oldToken.raw.length) + newToken.raw;
+          lines = newText.substring(tokens[tokens.length - 1].raw.length).split("\n");
+          continue;
+        }
+      }
+      return {
+        type: "blockquote",
+        raw,
+        tokens,
+        text: text2
+      };
+    }
+  }
+  list(src) {
+    let cap = this.rules.block.list.exec(src);
+    if (cap) {
+      let bull = cap[1].trim();
+      const isordered = bull.length > 1;
+      const list2 = {
+        type: "list",
+        raw: "",
+        ordered: isordered,
+        start: isordered ? +bull.slice(0, -1) : "",
+        loose: false,
+        items: []
+      };
+      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+      if (this.options.pedantic) {
+        bull = isordered ? bull : "[*+-]";
+      }
+      const itemRegex = new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`);
+      let endsWithBlankLine = false;
+      while (src) {
+        let endEarly = false;
+        let raw = "";
+        let itemContents = "";
+        if (!(cap = itemRegex.exec(src))) {
+          break;
+        }
+        if (this.rules.block.hr.test(src)) {
+          break;
+        }
+        raw = cap[0];
+        src = src.substring(raw.length);
+        let line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length));
+        let nextLine = src.split("\n", 1)[0];
+        let blankLine = !line.trim();
+        let indent = 0;
+        if (this.options.pedantic) {
+          indent = 2;
+          itemContents = line.trimStart();
+        } else if (blankLine) {
+          indent = cap[1].length + 1;
+        } else {
+          indent = cap[2].search(/[^ ]/);
+          indent = indent > 4 ? 1 : indent;
+          itemContents = line.slice(indent);
+          indent += cap[1].length;
+        }
+        if (blankLine && /^[ \t]*$/.test(nextLine)) {
+          raw += nextLine + "\n";
+          src = src.substring(nextLine.length + 1);
+          endEarly = true;
+        }
+        if (!endEarly) {
+          const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`);
+          const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
+          const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
+          const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
+          const htmlBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, "i");
+          while (src) {
+            const rawLine = src.split("\n", 1)[0];
+            let nextLineWithoutTabs;
+            nextLine = rawLine;
+            if (this.options.pedantic) {
+              nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ");
+              nextLineWithoutTabs = nextLine;
+            } else {
+              nextLineWithoutTabs = nextLine.replace(/\t/g, "    ");
+            }
+            if (fencesBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (headingBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (htmlBeginRegex.test(nextLine)) {
+              break;
+            }
+            if (nextBulletRegex.test(nextLine)) {
+              break;
+            }
+            if (hrRegex.test(nextLine)) {
+              break;
+            }
+            if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLine.trim()) {
+              itemContents += "\n" + nextLineWithoutTabs.slice(indent);
+            } else {
+              if (blankLine) {
+                break;
+              }
+              if (line.replace(/\t/g, "    ").search(/[^ ]/) >= 4) {
+                break;
+              }
+              if (fencesBeginRegex.test(line)) {
+                break;
+              }
+              if (headingBeginRegex.test(line)) {
+                break;
+              }
+              if (hrRegex.test(line)) {
+                break;
+              }
+              itemContents += "\n" + nextLine;
+            }
+            if (!blankLine && !nextLine.trim()) {
+              blankLine = true;
+            }
+            raw += rawLine + "\n";
+            src = src.substring(rawLine.length + 1);
+            line = nextLineWithoutTabs.slice(indent);
+          }
+        }
+        if (!list2.loose) {
+          if (endsWithBlankLine) {
+            list2.loose = true;
+          } else if (/\n[ \t]*\n[ \t]*$/.test(raw)) {
+            endsWithBlankLine = true;
+          }
+        }
+        let istask = null;
+        let ischecked;
+        if (this.options.gfm) {
+          istask = /^\[[ xX]\] /.exec(itemContents);
+          if (istask) {
+            ischecked = istask[0] !== "[ ] ";
+            itemContents = itemContents.replace(/^\[[ xX]\] +/, "");
+          }
+        }
+        list2.items.push({
+          type: "list_item",
+          raw,
+          task: !!istask,
+          checked: ischecked,
+          loose: false,
+          text: itemContents,
+          tokens: []
+        });
+        list2.raw += raw;
+      }
+      list2.items[list2.items.length - 1].raw = list2.items[list2.items.length - 1].raw.trimEnd();
+      list2.items[list2.items.length - 1].text = list2.items[list2.items.length - 1].text.trimEnd();
+      list2.raw = list2.raw.trimEnd();
+      for (let i = 0; i < list2.items.length; i++) {
+        this.lexer.state.top = false;
+        list2.items[i].tokens = this.lexer.blockTokens(list2.items[i].text, []);
+        if (!list2.loose) {
+          const spacers = list2.items[i].tokens.filter((t) => t.type === "space");
+          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw));
+          list2.loose = hasMultipleLineBreaks;
+        }
+      }
+      if (list2.loose) {
+        for (let i = 0; i < list2.items.length; i++) {
+          list2.items[i].loose = true;
+        }
+      }
+      return list2;
+    }
+  }
+  html(src) {
+    const cap = this.rules.block.html.exec(src);
+    if (cap) {
+      const token = {
+        type: "html",
+        block: true,
+        raw: cap[0],
+        pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
+        text: cap[0]
+      };
+      return token;
+    }
+  }
+  def(src) {
+    const cap = this.rules.block.def.exec(src);
+    if (cap) {
+      const tag2 = cap[1].toLowerCase().replace(/\s+/g, " ");
+      const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
+      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
+      return {
+        type: "def",
+        tag: tag2,
+        raw: cap[0],
+        href,
+        title
+      };
+    }
+  }
+  table(src) {
+    const cap = this.rules.block.table.exec(src);
+    if (!cap) {
+      return;
+    }
+    if (!/[:|]/.test(cap[2])) {
+      return;
+    }
+    const headers = splitCells(cap[1]);
+    const aligns = cap[2].replace(/^\||\| *$/g, "").split("|");
+    const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [];
+    const item = {
+      type: "table",
+      raw: cap[0],
+      header: [],
+      align: [],
+      rows: []
+    };
+    if (headers.length !== aligns.length) {
+      return;
+    }
+    for (const align of aligns) {
+      if (/^ *-+: *$/.test(align)) {
+        item.align.push("right");
+      } else if (/^ *:-+: *$/.test(align)) {
+        item.align.push("center");
+      } else if (/^ *:-+ *$/.test(align)) {
+        item.align.push("left");
+      } else {
+        item.align.push(null);
+      }
+    }
+    for (let i = 0; i < headers.length; i++) {
+      item.header.push({
+        text: headers[i],
+        tokens: this.lexer.inline(headers[i]),
+        header: true,
+        align: item.align[i]
+      });
+    }
+    for (const row of rows) {
+      item.rows.push(splitCells(row, item.header.length).map((cell, i) => {
+        return {
+          text: cell,
+          tokens: this.lexer.inline(cell),
+          header: false,
+          align: item.align[i]
+        };
+      }));
+    }
+    return item;
+  }
+  lheading(src) {
+    const cap = this.rules.block.lheading.exec(src);
+    if (cap) {
+      return {
+        type: "heading",
+        raw: cap[0],
+        depth: cap[2].charAt(0) === "=" ? 1 : 2,
+        text: cap[1],
+        tokens: this.lexer.inline(cap[1])
+      };
+    }
+  }
+  paragraph(src) {
+    const cap = this.rules.block.paragraph.exec(src);
+    if (cap) {
+      const text2 = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
+      return {
+        type: "paragraph",
+        raw: cap[0],
+        text: text2,
+        tokens: this.lexer.inline(text2)
+      };
+    }
+  }
+  text(src) {
+    const cap = this.rules.block.text.exec(src);
+    if (cap) {
+      return {
+        type: "text",
+        raw: cap[0],
+        text: cap[0],
+        tokens: this.lexer.inline(cap[0])
+      };
+    }
+  }
+  escape(src) {
+    const cap = this.rules.inline.escape.exec(src);
+    if (cap) {
+      return {
+        type: "escape",
+        raw: cap[0],
+        text: escape$1(cap[1])
+      };
+    }
+  }
+  tag(src) {
+    const cap = this.rules.inline.tag.exec(src);
+    if (cap) {
+      if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {
+        this.lexer.state.inLink = true;
+      } else if (this.lexer.state.inLink && /^<\/a>/i.test(cap[0])) {
+        this.lexer.state.inLink = false;
+      }
+      if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        this.lexer.state.inRawBlock = true;
+      } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        this.lexer.state.inRawBlock = false;
+      }
+      return {
+        type: "html",
+        raw: cap[0],
+        inLink: this.lexer.state.inLink,
+        inRawBlock: this.lexer.state.inRawBlock,
+        block: false,
+        text: cap[0]
+      };
+    }
+  }
+  link(src) {
+    const cap = this.rules.inline.link.exec(src);
+    if (cap) {
+      const trimmedUrl = cap[2].trim();
+      if (!this.options.pedantic && /^</.test(trimmedUrl)) {
+        if (!/>$/.test(trimmedUrl)) {
+          return;
+        }
+        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+          return;
+        }
+      } else {
+        const lastParenIndex = findClosingBracket(cap[2], "()");
+        if (lastParenIndex > -1) {
+          const start = cap[0].indexOf("!") === 0 ? 5 : 4;
+          const linkLen = start + cap[1].length + lastParenIndex;
+          cap[2] = cap[2].substring(0, lastParenIndex);
+          cap[0] = cap[0].substring(0, linkLen).trim();
+          cap[3] = "";
+        }
+      }
+      let href = cap[2];
+      let title = "";
+      if (this.options.pedantic) {
+        const link2 = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+        if (link2) {
+          href = link2[1];
+          title = link2[3];
+        }
+      } else {
+        title = cap[3] ? cap[3].slice(1, -1) : "";
+      }
+      href = href.trim();
+      if (/^</.test(href)) {
+        if (this.options.pedantic && !/>$/.test(trimmedUrl)) {
+          href = href.slice(1);
+        } else {
+          href = href.slice(1, -1);
+        }
+      }
+      return outputLink(cap, {
+        href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+        title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
+      }, cap[0], this.lexer);
+    }
+  }
+  reflink(src, links) {
+    let cap;
+    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+      const linkString = (cap[2] || cap[1]).replace(/\s+/g, " ");
+      const link2 = links[linkString.toLowerCase()];
+      if (!link2) {
+        const text2 = cap[0].charAt(0);
+        return {
+          type: "text",
+          raw: text2,
+          text: text2
+        };
+      }
+      return outputLink(cap, link2, cap[0], this.lexer);
+    }
+  }
+  emStrong(src, maskedSrc, prevChar = "") {
+    let match = this.rules.inline.emStrongLDelim.exec(src);
+    if (!match)
+      return;
+    if (match[3] && prevChar.match(/[\p{L}\p{N}]/u))
+      return;
+    const nextChar = match[1] || match[2] || "";
+    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+      const lLength = [...match[0]].length - 1;
+      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
+      const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      endReg.lastIndex = 0;
+      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+      while ((match = endReg.exec(maskedSrc)) != null) {
+        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+        if (!rDelim)
+          continue;
+        rLength = [...rDelim].length;
+        if (match[3] || match[4]) {
+          delimTotal += rLength;
+          continue;
+        } else if (match[5] || match[6]) {
+          if (lLength % 3 && !((lLength + rLength) % 3)) {
+            midDelimTotal += rLength;
+            continue;
+          }
+        }
+        delimTotal -= rLength;
+        if (delimTotal > 0)
+          continue;
+        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+        const lastCharLength = [...match[0]][0].length;
+        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
+        if (Math.min(lLength, rLength) % 2) {
+          const text3 = raw.slice(1, -1);
+          return {
+            type: "em",
+            raw,
+            text: text3,
+            tokens: this.lexer.inlineTokens(text3)
+          };
+        }
+        const text2 = raw.slice(2, -2);
+        return {
+          type: "strong",
+          raw,
+          text: text2,
+          tokens: this.lexer.inlineTokens(text2)
+        };
+      }
+    }
+  }
+  codespan(src) {
+    const cap = this.rules.inline.code.exec(src);
+    if (cap) {
+      let text2 = cap[2].replace(/\n/g, " ");
+      const hasNonSpaceChars = /[^ ]/.test(text2);
+      const hasSpaceCharsOnBothEnds = /^ /.test(text2) && / $/.test(text2);
+      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+        text2 = text2.substring(1, text2.length - 1);
+      }
+      text2 = escape$1(text2, true);
+      return {
+        type: "codespan",
+        raw: cap[0],
+        text: text2
+      };
+    }
+  }
+  br(src) {
+    const cap = this.rules.inline.br.exec(src);
+    if (cap) {
+      return {
+        type: "br",
+        raw: cap[0]
+      };
+    }
+  }
+  del(src) {
+    const cap = this.rules.inline.del.exec(src);
+    if (cap) {
+      return {
+        type: "del",
+        raw: cap[0],
+        text: cap[2],
+        tokens: this.lexer.inlineTokens(cap[2])
+      };
+    }
+  }
+  autolink(src) {
+    const cap = this.rules.inline.autolink.exec(src);
+    if (cap) {
+      let text2, href;
+      if (cap[2] === "@") {
+        text2 = escape$1(cap[1]);
+        href = "mailto:" + text2;
+      } else {
+        text2 = escape$1(cap[1]);
+        href = text2;
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text: text2,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text2,
+            text: text2
+          }
+        ]
+      };
+    }
+  }
+  url(src) {
+    let cap;
+    if (cap = this.rules.inline.url.exec(src)) {
+      let text2, href;
+      if (cap[2] === "@") {
+        text2 = escape$1(cap[0]);
+        href = "mailto:" + text2;
+      } else {
+        let prevCapZero;
+        do {
+          prevCapZero = cap[0];
+          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+        } while (prevCapZero !== cap[0]);
+        text2 = escape$1(cap[0]);
+        if (cap[1] === "www.") {
+          href = "http://" + cap[0];
+        } else {
+          href = cap[0];
+        }
+      }
+      return {
+        type: "link",
+        raw: cap[0],
+        text: text2,
+        href,
+        tokens: [
+          {
+            type: "text",
+            raw: text2,
+            text: text2
+          }
+        ]
+      };
+    }
+  }
+  inlineText(src) {
+    const cap = this.rules.inline.text.exec(src);
+    if (cap) {
+      let text2;
+      if (this.lexer.state.inRawBlock) {
+        text2 = cap[0];
+      } else {
+        text2 = escape$1(cap[0]);
+      }
+      return {
+        type: "text",
+        raw: cap[0],
+        text: text2
+      };
+    }
+  }
+};
+var newline = /^(?:[ \t]*(?:\n|$))+/;
+var blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var bullet = /(?:[*+-]|\d{1,9}[.)])/;
+var lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet).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/).getRegex();
+var _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var blockText = /^[^\n]+/;
+var _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+var def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+var _tag = "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 _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var html2 = edit("^ {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", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var paragraph = edit(_paragraph).replace("hr", hr).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[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+var blockNormal = {
+  blockquote,
+  code: blockCode,
+  def,
+  fences,
+  heading,
+  hr,
+  html: html2,
+  lheading,
+  list,
+  newline,
+  paragraph,
+  table: noopTest,
+  text: blockText
+};
+var gfmTable = edit("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", hr).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[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockGfm = {
+  ...blockNormal,
+  table: gfmTable,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+};
+var blockPedantic = {
+  ...blockNormal,
+  html: edit(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", _comment).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: noopTest,
+  // fences not supported
+  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+  paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+};
+var escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var br = /^( {2,}|\\)\n(?!\s*$)/;
+var inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _punctuation = "\\p{P}\\p{S}";
+var punctuation = edit(/^((?![*_])[\spunctuation])/, "u").replace(/punctuation/g, _punctuation).getRegex();
+var blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
+var emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimAst = edit("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimUnd = edit("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, _punctuation).getRegex();
+var anyPunctuation = edit(/\\([punct])/, "gu").replace(/punct/g, _punctuation).getRegex();
+var autolink = edit(/^<(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 _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+var tag = edit("^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", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+var link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+var nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+var reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+var inlineNormal = {
+  _backpedal: noopTest,
+  // only used for GFM url
+  anyPunctuation,
+  autolink,
+  blockSkip,
+  br,
+  code: inlineCode,
+  del: noopTest,
+  emStrongLDelim,
+  emStrongRDelimAst,
+  emStrongRDelimUnd,
+  escape,
+  link,
+  nolink,
+  punctuation,
+  reflink,
+  reflinkSearch,
+  tag,
+  text: inlineText,
+  url: noopTest
+};
+var inlinePedantic = {
+  ...inlineNormal,
+  link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+  reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+};
+var inlineGfm = {
+  ...inlineNormal,
+  escape: edit(escape).replace("])", "~|])").getRegex(),
+  url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").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~\\]))\1(?=[^~]|$)/,
+  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+};
+var inlineBreaks = {
+  ...inlineGfm,
+  br: edit(br).replace("{2,}", "*").getRegex(),
+  text: edit(inlineGfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+};
+var block = {
+  normal: blockNormal,
+  gfm: blockGfm,
+  pedantic: blockPedantic
+};
+var inline = {
+  normal: inlineNormal,
+  gfm: inlineGfm,
+  breaks: inlineBreaks,
+  pedantic: inlinePedantic
+};
+var _Lexer = class __Lexer {
+  tokens;
+  options;
+  state;
+  tokenizer;
+  inlineQueue;
+  constructor(options2) {
+    this.tokens = [];
+    this.tokens.links = /* @__PURE__ */ Object.create(null);
+    this.options = options2 || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
+    this.tokenizer = this.options.tokenizer;
+    this.tokenizer.options = this.options;
+    this.tokenizer.lexer = this;
+    this.inlineQueue = [];
+    this.state = {
+      inLink: false,
+      inRawBlock: false,
+      top: true
+    };
+    const rules = {
+      block: block.normal,
+      inline: inline.normal
+    };
+    if (this.options.pedantic) {
+      rules.block = block.pedantic;
+      rules.inline = inline.pedantic;
+    } else if (this.options.gfm) {
+      rules.block = block.gfm;
+      if (this.options.breaks) {
+        rules.inline = inline.breaks;
+      } else {
+        rules.inline = inline.gfm;
+      }
+    }
+    this.tokenizer.rules = rules;
+  }
+  /**
+   * Expose Rules
+   */
+  static get rules() {
+    return {
+      block,
+      inline
+    };
+  }
+  /**
+   * Static Lex Method
+   */
+  static lex(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.lex(src);
+  }
+  /**
+   * Static Lex Inline Method
+   */
+  static lexInline(src, options2) {
+    const lexer2 = new __Lexer(options2);
+    return lexer2.inlineTokens(src);
+  }
+  /**
+   * Preprocessing
+   */
+  lex(src) {
+    src = src.replace(/\r\n|\r/g, "\n");
+    this.blockTokens(src, this.tokens);
+    for (let i = 0; i < this.inlineQueue.length; i++) {
+      const next = this.inlineQueue[i];
+      this.inlineTokens(next.src, next.tokens);
+    }
+    this.inlineQueue = [];
+    return this.tokens;
+  }
+  blockTokens(src, tokens = [], lastParagraphClipped = false) {
+    if (this.options.pedantic) {
+      src = src.replace(/\t/g, "    ").replace(/^ +$/gm, "");
+    }
+    let token;
+    let lastToken;
+    let cutSrc;
+    while (src) {
+      if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.space(src)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.length === 1 && tokens.length > 0) {
+          tokens[tokens.length - 1].raw += "\n";
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.code(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.fences(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.heading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.hr(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.blockquote(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.list(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.html(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.def(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.raw;
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else if (!this.tokens.links[token.tag]) {
+          this.tokens.links[token.tag] = {
+            href: token.href,
+            title: token.title
+          };
+        }
+        continue;
+      }
+      if (token = this.tokenizer.table(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.lheading(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      cutSrc = src;
+      if (this.options.extensions && this.options.extensions.startBlock) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
+        lastToken = tokens[tokens.length - 1];
+        if (lastParagraphClipped && lastToken?.type === "paragraph") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        lastParagraphClipped = cutSrc.length !== src.length;
+        src = src.substring(token.raw.length);
+        continue;
+      }
+      if (token = this.tokenizer.text(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && lastToken.type === "text") {
+          lastToken.raw += "\n" + token.raw;
+          lastToken.text += "\n" + token.text;
+          this.inlineQueue.pop();
+          this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    this.state.top = true;
+    return tokens;
+  }
+  inline(src, tokens = []) {
+    this.inlineQueue.push({ src, tokens });
+    return tokens;
+  }
+  /**
+   * Lexing/Compiling
+   */
+  inlineTokens(src, tokens = []) {
+    let token, lastToken, cutSrc;
+    let maskedSrc = src;
+    let match;
+    let keepPrevChar, prevChar;
+    if (this.tokens.links) {
+      const links = Object.keys(this.tokens.links);
+      if (links.length > 0) {
+        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+          if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) {
+            maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+          }
+        }
+      }
+    }
+    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    }
+    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
+      maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    }
+    while (src) {
+      if (!keepPrevChar) {
+        prevChar = "";
+      }
+      keepPrevChar = false;
+      if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => {
+        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+          src = src.substring(token.raw.length);
+          tokens.push(token);
+          return true;
+        }
+        return false;
+      })) {
+        continue;
+      }
+      if (token = this.tokenizer.escape(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.tag(src)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && token.type === "text" && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.link(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+        src = src.substring(token.raw.length);
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && token.type === "text" && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.codespan(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.br(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.del(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (token = this.tokenizer.autolink(src)) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      if (!this.state.inLink && (token = this.tokenizer.url(src))) {
+        src = src.substring(token.raw.length);
+        tokens.push(token);
+        continue;
+      }
+      cutSrc = src;
+      if (this.options.extensions && this.options.extensions.startInline) {
+        let startIndex = Infinity;
+        const tempSrc = src.slice(1);
+        let tempStart;
+        this.options.extensions.startInline.forEach((getStartIndex) => {
+          tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+          if (typeof tempStart === "number" && tempStart >= 0) {
+            startIndex = Math.min(startIndex, tempStart);
+          }
+        });
+        if (startIndex < Infinity && startIndex >= 0) {
+          cutSrc = src.substring(0, startIndex + 1);
+        }
+      }
+      if (token = this.tokenizer.inlineText(cutSrc)) {
+        src = src.substring(token.raw.length);
+        if (token.raw.slice(-1) !== "_") {
+          prevChar = token.raw.slice(-1);
+        }
+        keepPrevChar = true;
+        lastToken = tokens[tokens.length - 1];
+        if (lastToken && lastToken.type === "text") {
+          lastToken.raw += token.raw;
+          lastToken.text += token.text;
+        } else {
+          tokens.push(token);
+        }
+        continue;
+      }
+      if (src) {
+        const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(errMsg);
+          break;
+        } else {
+          throw new Error(errMsg);
+        }
+      }
+    }
+    return tokens;
+  }
+};
+var _Renderer = class {
+  options;
+  parser;
+  // set by the parser
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  space(token) {
+    return "";
+  }
+  code({ text: text2, lang, escaped }) {
+    const langString = (lang || "").match(/^\S*/)?.[0];
+    const code = text2.replace(/\n$/, "") + "\n";
+    if (!langString) {
+      return "<pre><code>" + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+    }
+    return '<pre><code class="language-' + escape$1(langString) + '">' + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+  }
+  blockquote({ tokens }) {
+    const body = this.parser.parse(tokens);
+    return `<blockquote>
+${body}</blockquote>
+`;
+  }
+  html({ text: text2 }) {
+    return text2;
+  }
+  heading({ tokens, depth }) {
+    return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>
+`;
+  }
+  hr(token) {
+    return "<hr>\n";
+  }
+  list(token) {
+    const ordered = token.ordered;
+    const start = token.start;
+    let body = "";
+    for (let j = 0; j < token.items.length; j++) {
+      const item = token.items[j];
+      body += this.listitem(item);
+    }
+    const type = ordered ? "ol" : "ul";
+    const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : "";
+    return "<" + type + startAttr + ">\n" + body + "</" + type + ">\n";
+  }
+  listitem(item) {
+    let itemBody = "";
+    if (item.task) {
+      const checkbox = this.checkbox({ checked: !!item.checked });
+      if (item.loose) {
+        if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
+          item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+          if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
+            item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text;
+          }
+        } else {
+          item.tokens.unshift({
+            type: "text",
+            raw: checkbox + " ",
+            text: checkbox + " "
+          });
+        }
+      } else {
+        itemBody += checkbox + " ";
+      }
+    }
+    itemBody += this.parser.parse(item.tokens, !!item.loose);
+    return `<li>${itemBody}</li>
+`;
+  }
+  checkbox({ checked }) {
+    return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph({ tokens }) {
+    return `<p>${this.parser.parseInline(tokens)}</p>
+`;
+  }
+  table(token) {
+    let header = "";
+    let cell = "";
+    for (let j = 0; j < token.header.length; j++) {
+      cell += this.tablecell(token.header[j]);
+    }
+    header += this.tablerow({ text: cell });
+    let body = "";
+    for (let j = 0; j < token.rows.length; j++) {
+      const row = token.rows[j];
+      cell = "";
+      for (let k = 0; k < row.length; k++) {
+        cell += this.tablecell(row[k]);
+      }
+      body += this.tablerow({ text: cell });
+    }
+    if (body)
+      body = `<tbody>${body}</tbody>`;
+    return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+  }
+  tablerow({ text: text2 }) {
+    return `<tr>
+${text2}</tr>
+`;
+  }
+  tablecell(token) {
+    const content = this.parser.parseInline(token.tokens);
+    const type = token.header ? "th" : "td";
+    const tag2 = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
+    return tag2 + content + `</${type}>
+`;
+  }
+  /**
+   * span level renderer
+   */
+  strong({ tokens }) {
+    return `<strong>${this.parser.parseInline(tokens)}</strong>`;
+  }
+  em({ tokens }) {
+    return `<em>${this.parser.parseInline(tokens)}</em>`;
+  }
+  codespan({ text: text2 }) {
+    return `<code>${text2}</code>`;
+  }
+  br(token) {
+    return "<br>";
+  }
+  del({ tokens }) {
+    return `<del>${this.parser.parseInline(tokens)}</del>`;
+  }
+  link({ href, title, tokens }) {
+    const text2 = this.parser.parseInline(tokens);
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text2;
+    }
+    href = cleanHref;
+    let out = '<a href="' + href + '"';
+    if (title) {
+      out += ' title="' + title + '"';
+    }
+    out += ">" + text2 + "</a>";
+    return out;
+  }
+  image({ href, title, text: text2 }) {
+    const cleanHref = cleanUrl(href);
+    if (cleanHref === null) {
+      return text2;
+    }
+    href = cleanHref;
+    let out = `<img src="${href}" alt="${text2}"`;
+    if (title) {
+      out += ` title="${title}"`;
+    }
+    out += ">";
+    return out;
+  }
+  text(token) {
+    return "tokens" in token && token.tokens ? this.parser.parseInline(token.tokens) : token.text;
+  }
+};
+var _TextRenderer = class {
+  // no need for block level renderers
+  strong({ text: text2 }) {
+    return text2;
+  }
+  em({ text: text2 }) {
+    return text2;
+  }
+  codespan({ text: text2 }) {
+    return text2;
+  }
+  del({ text: text2 }) {
+    return text2;
+  }
+  html({ text: text2 }) {
+    return text2;
+  }
+  text({ text: text2 }) {
+    return text2;
+  }
+  link({ text: text2 }) {
+    return "" + text2;
+  }
+  image({ text: text2 }) {
+    return "" + text2;
+  }
+  br() {
+    return "";
+  }
+};
+var _Parser = class __Parser {
+  options;
+  renderer;
+  textRenderer;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer();
+    this.renderer = this.options.renderer;
+    this.renderer.options = this.options;
+    this.renderer.parser = this;
+    this.textRenderer = new _TextRenderer();
+  }
+  /**
+   * Static Parse Method
+   */
+  static parse(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parse(tokens);
+  }
+  /**
+   * Static Parse Inline Method
+   */
+  static parseInline(tokens, options2) {
+    const parser2 = new __Parser(options2);
+    return parser2.parseInline(tokens);
+  }
+  /**
+   * Parse Loop
+   */
+  parse(tokens, top = true) {
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+        const genericToken = anyToken;
+        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+        if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "space": {
+          out += this.renderer.space(token);
+          continue;
+        }
+        case "hr": {
+          out += this.renderer.hr(token);
+          continue;
+        }
+        case "heading": {
+          out += this.renderer.heading(token);
+          continue;
+        }
+        case "code": {
+          out += this.renderer.code(token);
+          continue;
+        }
+        case "table": {
+          out += this.renderer.table(token);
+          continue;
+        }
+        case "blockquote": {
+          out += this.renderer.blockquote(token);
+          continue;
+        }
+        case "list": {
+          out += this.renderer.list(token);
+          continue;
+        }
+        case "html": {
+          out += this.renderer.html(token);
+          continue;
+        }
+        case "paragraph": {
+          out += this.renderer.paragraph(token);
+          continue;
+        }
+        case "text": {
+          let textToken = token;
+          let body = this.renderer.text(textToken);
+          while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+            textToken = tokens[++i];
+            body += "\n" + this.renderer.text(textToken);
+          }
+          if (top) {
+            out += this.renderer.paragraph({
+              type: "paragraph",
+              raw: body,
+              text: body,
+              tokens: [{ type: "text", raw: body, text: body }]
+            });
+          } else {
+            out += body;
+          }
+          continue;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Parse Inline Tokens
+   */
+  parseInline(tokens, renderer) {
+    renderer = renderer || this.renderer;
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const anyToken = tokens[i];
+      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+        const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
+        if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(anyToken.type)) {
+          out += ret || "";
+          continue;
+        }
+      }
+      const token = anyToken;
+      switch (token.type) {
+        case "escape": {
+          out += renderer.text(token);
+          break;
+        }
+        case "html": {
+          out += renderer.html(token);
+          break;
+        }
+        case "link": {
+          out += renderer.link(token);
+          break;
+        }
+        case "image": {
+          out += renderer.image(token);
+          break;
+        }
+        case "strong": {
+          out += renderer.strong(token);
+          break;
+        }
+        case "em": {
+          out += renderer.em(token);
+          break;
+        }
+        case "codespan": {
+          out += renderer.codespan(token);
+          break;
+        }
+        case "br": {
+          out += renderer.br(token);
+          break;
+        }
+        case "del": {
+          out += renderer.del(token);
+          break;
+        }
+        case "text": {
+          out += renderer.text(token);
+          break;
+        }
+        default: {
+          const errMsg = 'Token with "' + token.type + '" type was not found.';
+          if (this.options.silent) {
+            console.error(errMsg);
+            return "";
+          } else {
+            throw new Error(errMsg);
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+var _Hooks = class {
+  options;
+  block;
+  constructor(options2) {
+    this.options = options2 || _defaults;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set([
+    "preprocess",
+    "postprocess",
+    "processAllTokens"
+  ]);
+  /**
+   * Process markdown before marked
+   */
+  preprocess(markdown) {
+    return markdown;
+  }
+  /**
+   * Process HTML after marked is finished
+   */
+  postprocess(html3) {
+    return html3;
+  }
+  /**
+   * Process all tokens before walk tokens
+   */
+  processAllTokens(tokens) {
+    return tokens;
+  }
+  /**
+   * Provide function to tokenize markdown
+   */
+  provideLexer() {
+    return this.block ? _Lexer.lex : _Lexer.lexInline;
+  }
+  /**
+   * Provide function to parse tokens
+   */
+  provideParser() {
+    return this.block ? _Parser.parse : _Parser.parseInline;
+  }
+};
+var Marked = class {
+  defaults = _getDefaults();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = _Parser;
+  Renderer = _Renderer;
+  TextRenderer = _TextRenderer;
+  Lexer = _Lexer;
+  Tokenizer = _Tokenizer;
+  Hooks = _Hooks;
+  constructor(...args) {
+    this.use(...args);
+  }
+  /**
+   * Run callback for every token
+   */
+  walkTokens(tokens, callback) {
+    let values = [];
+    for (const token of tokens) {
+      values = values.concat(callback.call(this, token));
+      switch (token.type) {
+        case "table": {
+          const tableToken = token;
+          for (const cell of tableToken.header) {
+            values = values.concat(this.walkTokens(cell.tokens, callback));
+          }
+          for (const row of tableToken.rows) {
+            for (const cell of row) {
+              values = values.concat(this.walkTokens(cell.tokens, callback));
+            }
+          }
+          break;
+        }
+        case "list": {
+          const listToken = token;
+          values = values.concat(this.walkTokens(listToken.items, callback));
+          break;
+        }
+        default: {
+          const genericToken = token;
+          if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
+            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+              const tokens2 = genericToken[childTokens].flat(Infinity);
+              values = values.concat(this.walkTokens(tokens2, callback));
+            });
+          } else if (genericToken.tokens) {
+            values = values.concat(this.walkTokens(genericToken.tokens, callback));
+          }
+        }
+      }
+    }
+    return values;
+  }
+  use(...args) {
+    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    args.forEach((pack) => {
+      const opts = { ...pack };
+      opts.async = this.defaults.async || opts.async || false;
+      if (pack.extensions) {
+        pack.extensions.forEach((ext) => {
+          if (!ext.name) {
+            throw new Error("extension name required");
+          }
+          if ("renderer" in ext) {
+            const prevRenderer = extensions.renderers[ext.name];
+            if (prevRenderer) {
+              extensions.renderers[ext.name] = function(...args2) {
+                let ret = ext.renderer.apply(this, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(this, args2);
+                }
+                return ret;
+              };
+            } else {
+              extensions.renderers[ext.name] = ext.renderer;
+            }
+          }
+          if ("tokenizer" in ext) {
+            if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+              throw new Error("extension level must be 'block' or 'inline'");
+            }
+            const extLevel = extensions[ext.level];
+            if (extLevel) {
+              extLevel.unshift(ext.tokenizer);
+            } else {
+              extensions[ext.level] = [ext.tokenizer];
+            }
+            if (ext.start) {
+              if (ext.level === "block") {
+                if (extensions.startBlock) {
+                  extensions.startBlock.push(ext.start);
+                } else {
+                  extensions.startBlock = [ext.start];
+                }
+              } else if (ext.level === "inline") {
+                if (extensions.startInline) {
+                  extensions.startInline.push(ext.start);
+                } else {
+                  extensions.startInline = [ext.start];
+                }
+              }
+            }
+          }
+          if ("childTokens" in ext && ext.childTokens) {
+            extensions.childTokens[ext.name] = ext.childTokens;
+          }
+        });
+        opts.extensions = extensions;
+      }
+      if (pack.renderer) {
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+        for (const prop in pack.renderer) {
+          if (!(prop in renderer)) {
+            throw new Error(`renderer '${prop}' does not exist`);
+          }
+          if (["options", "parser"].includes(prop)) {
+            continue;
+          }
+          const rendererProp = prop;
+          const rendererFunc = pack.renderer[rendererProp];
+          const prevRenderer = renderer[rendererProp];
+          renderer[rendererProp] = (...args2) => {
+            let ret = rendererFunc.apply(renderer, args2);
+            if (ret === false) {
+              ret = prevRenderer.apply(renderer, args2);
+            }
+            return ret || "";
+          };
+        }
+        opts.renderer = renderer;
+      }
+      if (pack.tokenizer) {
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+        for (const prop in pack.tokenizer) {
+          if (!(prop in tokenizer)) {
+            throw new Error(`tokenizer '${prop}' does not exist`);
+          }
+          if (["options", "rules", "lexer"].includes(prop)) {
+            continue;
+          }
+          const tokenizerProp = prop;
+          const tokenizerFunc = pack.tokenizer[tokenizerProp];
+          const prevTokenizer = tokenizer[tokenizerProp];
+          tokenizer[tokenizerProp] = (...args2) => {
+            let ret = tokenizerFunc.apply(tokenizer, args2);
+            if (ret === false) {
+              ret = prevTokenizer.apply(tokenizer, args2);
+            }
+            return ret;
+          };
+        }
+        opts.tokenizer = tokenizer;
+      }
+      if (pack.hooks) {
+        const hooks = this.defaults.hooks || new _Hooks();
+        for (const prop in pack.hooks) {
+          if (!(prop in hooks)) {
+            throw new Error(`hook '${prop}' does not exist`);
+          }
+          if (["options", "block"].includes(prop)) {
+            continue;
+          }
+          const hooksProp = prop;
+          const hooksFunc = pack.hooks[hooksProp];
+          const prevHook = hooks[hooksProp];
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[hooksProp] = (arg) => {
+              if (this.defaults.async) {
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                  return prevHook.call(hooks, ret2);
+                });
+              }
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret);
+            };
+          } else {
+            hooks[hooksProp] = (...args2) => {
+              let ret = hooksFunc.apply(hooks, args2);
+              if (ret === false) {
+                ret = prevHook.apply(hooks, args2);
+              }
+              return ret;
+            };
+          }
+        }
+        opts.hooks = hooks;
+      }
+      if (pack.walkTokens) {
+        const walkTokens2 = this.defaults.walkTokens;
+        const packWalktokens = pack.walkTokens;
+        opts.walkTokens = function(token) {
+          let values = [];
+          values.push(packWalktokens.call(this, token));
+          if (walkTokens2) {
+            values = values.concat(walkTokens2.call(this, token));
+          }
+          return values;
+        };
+      }
+      this.defaults = { ...this.defaults, ...opts };
+    });
+    return this;
+  }
+  setOptions(opt) {
+    this.defaults = { ...this.defaults, ...opt };
+    return this;
+  }
+  lexer(src, options2) {
+    return _Lexer.lex(src, options2 ?? this.defaults);
+  }
+  parser(tokens, options2) {
+    return _Parser.parse(tokens, options2 ?? this.defaults);
+  }
+  parseMarkdown(blockType) {
+    const parse = (src, options2) => {
+      const origOpt = { ...options2 };
+      const opt = { ...this.defaults, ...origOpt };
+      const throwError = this.onError(!!opt.silent, !!opt.async);
+      if (this.defaults.async === true && origOpt.async === false) {
+        return throwError(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 src === "undefined" || src === null) {
+        return throwError(new Error("marked(): input parameter is undefined or null"));
+      }
+      if (typeof src !== "string") {
+        return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
+      }
+      if (opt.hooks) {
+        opt.hooks.options = opt;
+        opt.hooks.block = blockType;
+      }
+      const lexer2 = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
+      const parser2 = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
+      if (opt.async) {
+        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html3) => opt.hooks ? opt.hooks.postprocess(html3) : html3).catch(throwError);
+      }
+      try {
+        if (opt.hooks) {
+          src = opt.hooks.preprocess(src);
+        }
+        let tokens = lexer2(src, opt);
+        if (opt.hooks) {
+          tokens = opt.hooks.processAllTokens(tokens);
+        }
+        if (opt.walkTokens) {
+          this.walkTokens(tokens, opt.walkTokens);
+        }
+        let html3 = parser2(tokens, opt);
+        if (opt.hooks) {
+          html3 = opt.hooks.postprocess(html3);
+        }
+        return html3;
+      } catch (e) {
+        return throwError(e);
+      }
+    };
+    return parse;
+  }
+  onError(silent, async) {
+    return (e) => {
+      e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+      if (silent) {
+        const msg = "<p>An error occurred:</p><pre>" + escape$1(e.message + "", true) + "</pre>";
+        if (async) {
+          return Promise.resolve(msg);
+        }
+        return msg;
+      }
+      if (async) {
+        return Promise.reject(e);
+      }
+      throw e;
+    };
+  }
+};
+var markedInstance = new Marked();
+function marked(src, opt) {
+  return markedInstance.parse(src, opt);
+}
+marked.options = marked.setOptions = function(options2) {
+  markedInstance.setOptions(options2);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.getDefaults = _getDefaults;
+marked.defaults = _defaults;
+marked.use = function(...args) {
+  markedInstance.use(...args);
+  marked.defaults = markedInstance.defaults;
+  changeDefaults(marked.defaults);
+  return marked;
+};
+marked.walkTokens = function(tokens, callback) {
+  return markedInstance.walkTokens(tokens, callback);
+};
+marked.parseInline = markedInstance.parseInline;
+marked.Parser = _Parser;
+marked.parser = _Parser.parse;
+marked.Renderer = _Renderer;
+marked.TextRenderer = _TextRenderer;
+marked.Lexer = _Lexer;
+marked.lexer = _Lexer.lex;
+marked.Tokenizer = _Tokenizer;
+marked.Hooks = _Hooks;
+marked.parse = marked;
+var options = marked.options;
+var setOptions = marked.setOptions;
+var use = marked.use;
+var walkTokens = marked.walkTokens;
+var parseInline = marked.parseInline;
+var parser = _Parser.parse;
+var lexer = _Lexer.lex;
+
+// src/components/markdown-editor.ts
+marked.setOptions({ gfm: true });
+var TASK_LIST_LINE_RE = /^([\s>]*[-*+]\s+\[)([ xX])(\])/;
+function toggleNthTaskLine(body, n, checked) {
+  const lines = body.split("\n");
+  let count = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = TASK_LIST_LINE_RE.exec(line);
+    if (!m) continue;
+    if (count === n) {
+      lines[i] = `${m[1]}${checked ? "x" : " "}${m[3]}${line.slice(m[0].length)}`;
+      return lines.join("\n");
+    }
+    count++;
+  }
+  return null;
+}
+function renderMarkdownEditor(opts) {
+  const container = document.createElement("div");
+  container.className = "zg-md-editor";
+  let currentBody = opts.body ?? "";
+  let mode = "view";
+  let pendingTemplate = null;
+  function render() {
+    container.innerHTML = "";
+    if (mode === "view") {
+      container.appendChild(viewMode());
+    } else {
+      container.appendChild(editMode());
+    }
+  }
+  function enterEditMode(template) {
+    pendingTemplate = template;
+    mode = "edit";
+    render();
+  }
+  function viewMode() {
+    const wrap = document.createElement("div");
+    wrap.className = "zg-md-view";
+    if (currentBody.trim()) {
+      const body = document.createElement("div");
+      body.className = "zg-markdown";
+      body.innerHTML = sanitizeHtml(marked.parse(currentBody));
+      if (opts.interactiveCheckboxes) wireInteractiveCheckboxes(body);
+      opts.postRender?.(body);
+      wrap.appendChild(body);
+      const editBtn = document.createElement("button");
+      editBtn.type = "button";
+      editBtn.className = "zg-md-edit-btn";
+      editBtn.textContent = "\u270E Edit";
+      editBtn.addEventListener("click", () => enterEditMode(null));
+      wrap.appendChild(editBtn);
+    } else {
+      wrap.appendChild(renderEmpty());
+    }
+    return wrap;
+  }
+  function wireInteractiveCheckboxes(body) {
+    const inputs = Array.from(body.querySelectorAll('input[type="checkbox"]'));
+    inputs.forEach((input, idx) => {
+      input.removeAttribute("disabled");
+      input.disabled = false;
+      input.style.cursor = "pointer";
+      input.style.pointerEvents = "auto";
+      async function commit(desired) {
+        const nextBody = toggleNthTaskLine(currentBody, idx, desired);
+        if (nextBody === null) {
+          input.checked = !desired;
+          return;
+        }
+        input.disabled = true;
+        try {
+          await opts.onSave(nextBody);
+          currentBody = nextBody;
+          input.checked = desired;
+        } catch (err) {
+          input.checked = !desired;
+          void showAlert("Save failed", err.message);
+        } finally {
+          input.removeAttribute("disabled");
+        }
+      }
+      input.addEventListener("change", () => void commit(input.checked));
+      const li = input.closest("li");
+      if (li) {
+        li.style.cursor = "pointer";
+        li.addEventListener("click", (e) => {
+          if (e.target instanceof HTMLInputElement) return;
+          if (e.target instanceof HTMLAnchorElement) return;
+          e.preventDefault();
+          const next = !input.checked;
+          input.checked = next;
+          void commit(next);
+        });
+      }
+    });
+  }
+  function renderEmpty() {
+    const empty = document.createElement("div");
+    empty.className = "zg-md-empty";
+    const title = document.createElement("h3");
+    title.textContent = opts.emptyPlaceholder;
+    empty.appendChild(title);
+    if (opts.emptyHint) {
+      const hint = document.createElement("p");
+      hint.className = "zg-md-empty-hint";
+      hint.textContent = opts.emptyHint;
+      empty.appendChild(hint);
+    }
+    const startBtn = document.createElement("button");
+    startBtn.type = "button";
+    startBtn.className = "zg-md-start-btn";
+    startBtn.textContent = opts.startingTemplate ? "\u270E Start writing (with a template)" : "\u270E Start writing";
+    startBtn.addEventListener("click", () => enterEditMode(opts.startingTemplate ?? null));
+    empty.appendChild(startBtn);
+    return empty;
+  }
+  function editMode() {
+    const wrap = document.createElement("div");
+    wrap.className = "zg-md-edit";
+    const textarea = document.createElement("textarea");
+    textarea.className = "zg-md-textarea";
+    const initial = currentBody || pendingTemplate || "";
+    pendingTemplate = null;
+    textarea.value = initial;
+    textarea.rows = Math.max(8, Math.min(30, initial.split("\n").length + 2));
+    wrap.appendChild(textarea);
+    const error = document.createElement("p");
+    error.className = "zg-modal-error";
+    error.style.display = "none";
+    wrap.appendChild(error);
+    const buttons = document.createElement("div");
+    buttons.className = "zg-md-edit-buttons";
+    const cancelBtn = document.createElement("button");
+    cancelBtn.type = "button";
+    cancelBtn.className = "zg-modal-cancel";
+    cancelBtn.textContent = "Cancel";
+    cancelBtn.addEventListener("click", () => {
+      mode = "view";
+      render();
+    });
+    const saveBtn = document.createElement("button");
+    saveBtn.type = "button";
+    saveBtn.className = "zg-modal-confirm";
+    saveBtn.textContent = "Save";
+    saveBtn.addEventListener("click", async () => {
+      const newBody = textarea.value;
+      saveBtn.disabled = true;
+      cancelBtn.disabled = true;
+      try {
+        await opts.onSave(newBody);
+        currentBody = newBody;
+        mode = "view";
+        render();
+      } catch (err) {
+        error.textContent = err.message;
+        error.style.display = "";
+        saveBtn.disabled = false;
+        cancelBtn.disabled = false;
+      }
+    });
+    buttons.appendChild(cancelBtn);
+    buttons.appendChild(saveBtn);
+    wrap.appendChild(buttons);
+    setTimeout(() => textarea.focus(), 0);
+    return wrap;
+  }
+  render();
+  return container;
+}
+function splitFrontmatter(text2) {
+  const m = /^(---\r?\n[\s\S]*?\r?\n---\r?\n?)/.exec(text2);
+  if (!m) return { frontmatter: "", body: text2 };
+  return { frontmatter: m[1], body: text2.slice(m[1].length) };
+}
+
+// src/util/wiki-links.ts
+var WIKILINK_RE = /\[\[([^\]\n]+)\]\]/g;
+var EXCLUDED_TAGS = /* @__PURE__ */ new Set(["CODE", "PRE", "A"]);
+function collectCandidates(node, out) {
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === 3) {
+      const text2 = child.textContent ?? "";
+      if (text2.includes("[[")) out.push(child);
+    } else if (child.nodeType === 1) {
+      const tag2 = child.tagName;
+      if (EXCLUDED_TAGS.has(tag2)) continue;
+      collectCandidates(child, out);
+    }
+  }
+}
+function makeWikiLinkResolver(specNames, docPaths) {
+  const specs = new Set(specNames);
+  const docs = /* @__PURE__ */ new Map();
+  for (const p of docPaths) {
+    const basename = p.replace(/^.*\//, "").replace(/\.md$/, "");
+    docs.set(basename, p);
+  }
+  return (name) => {
+    if (specs.has(name)) return `#/spec/${encodeURIComponent(name)}`;
+    const docPath = docs.get(name);
+    if (docPath) return `#/docs/${encodeURIComponent(docPath)}`;
+    return null;
+  };
+}
+function processWikiLinks(root, resolver) {
+  const targets = [];
+  collectCandidates(root, targets);
+  for (const textNode of targets) {
+    const frag = document.createDocumentFragment();
+    const text2 = textNode.textContent ?? "";
+    let lastIdx = 0;
+    const re = new RegExp(WIKILINK_RE.source, "g");
+    let m;
+    while (m = re.exec(text2)) {
+      if (m.index > lastIdx) {
+        frag.appendChild(document.createTextNode(text2.slice(lastIdx, m.index)));
+      }
+      const name = m[1].trim();
+      const route = resolver(name);
+      const a = document.createElement("a");
+      a.href = route ?? `#/spec/${encodeURIComponent(name)}`;
+      a.textContent = name;
+      a.className = "zg-wikilink" + (route ? "" : " zg-wikilink-missing");
+      if (!route) a.title = `"${name}" doesn't exist yet`;
+      frag.appendChild(a);
+      lastIdx = m.index + m[0].length;
+    }
+    if (lastIdx < text2.length) {
+      frag.appendChild(document.createTextNode(text2.slice(lastIdx)));
+    }
+    textNode.replaceWith(frag);
+  }
+}
+
+// src/views/detail.ts
+async function renderDetail(params) {
+  const app = document.getElementById("app");
+  const name = params.name;
+  if (!name) {
+    app.innerHTML = '<p class="zg-error">Missing spec name in URL.</p>';
+    return;
+  }
+  if (app.children.length === 0 || app.querySelector(".zg-detail") === null) {
+    app.innerHTML = "<p>Loading\u2026</p>";
+  }
+  const backend = window.zettelgeistBackend;
+  let spec;
+  let summary = null;
+  let specNames = [];
+  let docPaths = [];
+  try {
+    spec = await backend.readSpec(name);
+    const [all, docs] = await Promise.all([backend.listSpecs(), backend.listDocs().catch(() => [])]);
+    summary = all.find((s) => s.name === name) ?? null;
+    specNames = all.map((s) => s.name);
+    docPaths = docs.map((d) => d.path);
+  } catch (err) {
+    app.innerHTML = `<p class="zg-error">Failed to load spec "${escapeHtml(name)}": ${escapeHtml(err.message)}</p>`;
+    return;
+  }
+  const resolver = makeWikiLinkResolver(specNames, docPaths);
+  const enrich = (root) => processWikiLinks(root, resolver);
+  const wrapper = document.createElement("article");
+  wrapper.className = "zg-detail";
+  wrapper.appendChild(renderHeader(spec, summary));
+  const tabs = [
+    { id: "requirements", label: "Requirements", render: () => renderRequirementsTab(spec, enrich) },
+    { id: "tasks", label: `Tasks (${spec.tasks.length})`, render: () => renderTasksTab(spec) },
+    { id: "handoff", label: "Handoff", render: () => renderHandoffTab(spec, enrich) }
+  ];
+  if (Object.keys(spec.lenses).length > 0) {
+    tabs.push({ id: "lenses", label: "Lenses", render: () => renderLensesTab(spec, enrich) });
+  }
+  const tabKey = `zg:tab:${spec.name}`;
+  const stored = (() => {
+    try {
+      return sessionStorage.getItem(tabKey);
+    } catch {
+      return null;
+    }
+  })();
+  const tabsOpts = {
+    onActivate: (id) => {
+      try {
+        sessionStorage.setItem(tabKey, id);
+      } catch {
+      }
+    }
+  };
+  if (stored) tabsOpts.initialTabId = stored;
+  wrapper.appendChild(renderTabs(tabs, tabsOpts));
+  app.replaceChildren(wrapper);
+}
+function renderHeader(spec, summary) {
+  const header = document.createElement("header");
+  header.className = "zg-detail-header";
+  const referrer = sessionStorage.getItem("zg:prev-route") ?? "#/";
+  const back = document.createElement("a");
+  back.href = referrer;
+  back.textContent = referrer === "#/graph" ? "\u2190 Back to graph" : "\u2190 Back to board";
+  back.className = "zg-back-link";
+  header.appendChild(back);
+  const titleRow = document.createElement("div");
+  titleRow.className = "zg-detail-title-row";
+  const title = document.createElement("h2");
+  title.textContent = spec.name;
+  titleRow.appendChild(title);
+  if (summary) {
+    const editBtn = document.createElement("button");
+    editBtn.type = "button";
+    editBtn.className = "zg-detail-edit-btn";
+    editBtn.textContent = "\u270E Edit details";
+    editBtn.addEventListener("click", async () => {
+      const { showEditModal } = await import("./edit-modal-BEGC2AO6.js");
+      const saved = await showEditModal({ spec: summary });
+      if (saved) window.dispatchEvent(new HashChangeEvent("hashchange"));
+    });
+    titleRow.appendChild(editBtn);
+  }
+  header.appendChild(titleRow);
+  if (summary) header.appendChild(renderMeta(summary));
+  return header;
+}
+function renderMeta(summary) {
+  const meta = document.createElement("div");
+  meta.className = "zg-detail-meta";
+  const status = document.createElement("span");
+  status.className = `zg-status-pill zg-status-${summary.status}`;
+  status.textContent = summary.status;
+  meta.appendChild(status);
+  const { done, total } = parseProgress2(summary.progress);
+  const progressWrap = document.createElement("span");
+  progressWrap.className = "zg-detail-progress";
+  progressWrap.textContent = `${summary.progress} tasks`;
+  if (total > 0) {
+    const bar = document.createElement("span");
+    bar.className = "zg-detail-progress-bar";
+    const fill = document.createElement("span");
+    fill.className = "zg-detail-progress-fill";
+    fill.style.width = `${Math.round(done / total * 100)}%`;
+    bar.appendChild(fill);
+    progressWrap.appendChild(bar);
+  }
+  meta.appendChild(progressWrap);
+  if (summary.pr) {
+    const a = document.createElement("a");
+    a.className = "zg-badge zg-badge-pr";
+    a.href = summary.pr;
+    a.target = "_blank";
+    a.rel = "noopener";
+    a.textContent = prLabel2(summary.pr);
+    meta.appendChild(a);
+  }
+  if (summary.branch) {
+    const span = document.createElement("span");
+    span.className = "zg-badge zg-badge-branch";
+    span.textContent = summary.branch;
+    meta.appendChild(span);
+  }
+  if (summary.worktree) {
+    const span = document.createElement("span");
+    span.className = "zg-badge zg-badge-worktree";
+    span.title = `worktree: ${summary.worktree}`;
+    span.textContent = `\u{1F4C1} ${summary.worktree}`;
+    meta.appendChild(span);
+  }
+  if (summary.blockedBy) {
+    const span = document.createElement("span");
+    span.className = "zg-badge zg-badge-blocked";
+    span.title = summary.blockedBy;
+    span.textContent = `blocked: ${summary.blockedBy}`;
+    meta.appendChild(span);
+  }
+  return meta;
+}
+function renderRequirementsTab(spec, postRender) {
+  const container = document.createElement("div");
+  container.appendChild(renderFrontmatterForm(spec));
+  container.appendChild(
+    renderMarkdownEditor({
+      body: spec.requirements,
+      emptyPlaceholder: `No requirements yet for "${spec.name}"`,
+      emptyHint: "Write what this spec is for, the acceptance criteria, what's out of scope, and any references. Use `- [ ]` checkboxes for each acceptance criterion.",
+      startingTemplate: REQUIREMENTS_TEMPLATE.replace("{NAME}", spec.name),
+      postRender,
+      interactiveCheckboxes: true,
+      // requirements.md has frontmatter we must preserve on body-only edits.
+      onSave: async (newBody) => {
+        const backend = window.zettelgeistBackend;
+        const file = await backend.readSpecFile(spec.name, "requirements.md").catch(() => ({ content: "" }));
+        const { frontmatter } = splitFrontmatter(file.content);
+        const next = frontmatter + (newBody.startsWith("\n") ? newBody : `
+${newBody}`);
+        await backend.writeSpecFile(spec.name, "requirements.md", next);
+      }
+    })
+  );
+  return container;
+}
+function renderTasksTab(spec) {
+  return renderTaskList(spec.name, spec.tasks);
+}
+function renderHandoffTab(spec, postRender) {
+  return renderMarkdownEditor({
+    body: spec.handoff,
+    emptyPlaceholder: "No handoff notes yet",
+    emptyHint: "When you pause work on this spec, leave a note for the next person (or agent): what you did, what's next, and any open questions.",
+    startingTemplate: HANDOFF_TEMPLATE,
+    postRender,
+    interactiveCheckboxes: true,
+    onSave: async (newBody) => {
+      await window.zettelgeistBackend.writeHandoff(spec.name, newBody);
+    }
+  });
+}
+var REQUIREMENTS_TEMPLATE = `# {NAME}
+
+## Why
+
+<!-- Why does this spec exist? What problem does it solve, for whom? -->
+
+## Acceptance criteria
+
+- [ ] WHEN <trigger>
+- [ ] THE SYSTEM SHALL <observable behavior>
+- [ ] AND <additional behavior>
+
+## Out of scope
+
+- <thing this spec deliberately doesn't cover>
+
+## References
+
+- <link or note>
+`;
+var HANDOFF_TEMPLATE = `## What I did
+
+<!-- Concrete progress: code, decisions, dead ends. -->
+
+## What's next
+
+<!-- The most useful 1\u20133 things the next session should pick up. -->
+
+## Open questions
+
+<!-- Anything ambiguous that needs a human or another agent to weigh in. -->
+`;
+function renderLensesTab(spec, postRender) {
+  const container = document.createElement("div");
+  for (const [name, content] of Object.entries(spec.lenses)) {
+    const heading2 = document.createElement("h3");
+    heading2.textContent = name;
+    container.appendChild(heading2);
+    container.appendChild(
+      renderMarkdownEditor({
+        body: content,
+        emptyPlaceholder: "(empty)",
+        postRender,
+        interactiveCheckboxes: true,
+        onSave: async (newBody) => {
+          await window.zettelgeistBackend.writeSpecFile(spec.name, `lenses/${name}.md`, newBody);
+        }
+      })
+    );
+  }
+  return container;
+}
+function parseProgress2(s) {
+  const m = /^(\d+)\s*\/\s*(\d+)$/.exec(s);
+  if (!m) return { done: 0, total: 0 };
+  return { done: Number(m[1]), total: Number(m[2]) };
+}
+function prLabel2(url) {
+  const gh = /\/pull\/(\d+)/.exec(url);
+  if (gh) return `PR #${gh[1]}`;
+  return "PR";
+}
+
+// src/views/graph.ts
+var mermaidModule = null;
+async function loadMermaid() {
+  if (!mermaidModule) {
+    mermaidModule = await import("./mermaid.core-AEBXU2JK.js");
+  }
+  const mermaid = mermaidModule.default;
+  mermaid.initialize({
+    startOnLoad: false,
+    theme: document.documentElement.getAttribute("data-theme") === "dark" ? "dark" : "default",
+    securityLevel: "strict",
+    // htmlLabels: false → native SVG <text> labels (sanitizer-friendly,
+    // and lets our newline-in-label trick work for "name + progress").
+    flowchart: { htmlLabels: false, curve: "basis" }
+  });
+  return mermaid;
+}
+async function renderGraph() {
+  const app = document.getElementById("app");
+  app.innerHTML = "<p>Loading graph\u2026</p>";
+  const backend = window.zettelgeistBackend;
+  let specs;
+  try {
+    specs = await backend.listSpecs();
+  } catch (err) {
+    app.innerHTML = `<p class="zg-error">Failed to load: ${escapeHtml(err.message)}</p>`;
+    return;
+  }
+  const edges = [];
+  const meta = /* @__PURE__ */ new Map();
+  for (const summary of specs) {
+    try {
+      const spec = await backend.readSpec(summary.name);
+      const deps = spec.frontmatter.depends_on;
+      if (Array.isArray(deps)) {
+        for (const dep of deps) {
+          if (typeof dep === "string" && specs.some((s) => s.name === dep)) {
+            edges.push({ from: summary.name, to: dep });
+          }
+        }
+      }
+      const partOf = typeof spec.frontmatter.part_of === "string" ? spec.frontmatter.part_of : null;
+      meta.set(summary.name, { partOf });
+    } catch {
+      meta.set(summary.name, { partOf: null });
+    }
+  }
+  app.innerHTML = "";
+  const banner = await fetchAndRenderValidationBanner();
+  if (banner) app.appendChild(banner);
+  const wrapper = document.createElement("div");
+  wrapper.className = "zg-graph";
+  const heading2 = document.createElement("div");
+  heading2.className = "zg-graph-header";
+  const h2 = document.createElement("h2");
+  h2.textContent = "Dependency Graph";
+  heading2.appendChild(h2);
+  const sub = document.createElement("p");
+  sub.className = "zg-graph-subtitle";
+  sub.textContent = "Each box is a spec \u2014 its color is the status, the number underneath is task progress. Arrows point from a spec to a spec it depends on. Click any box to open it. Dashed enclosures group specs by their `part_of` field (e.g. an epic or product area).";
+  heading2.appendChild(sub);
+  wrapper.appendChild(heading2);
+  if (specs.length === 0) {
+    const empty = document.createElement("div");
+    empty.className = "zg-empty-state";
+    const h = document.createElement("h3");
+    h.textContent = "No specs to graph";
+    empty.appendChild(h);
+    const p = document.createElement("p");
+    p.textContent = "Once specs exist, depends_on edges between them are rendered here.";
+    empty.appendChild(p);
+    wrapper.appendChild(empty);
+    app.appendChild(wrapper);
+    return;
+  }
+  wrapper.appendChild(renderLegend(specs));
+  const mermaidSrc = renderMermaidSource(specs, edges, meta);
+  const container = document.createElement("div");
+  container.className = "zg-graph-container";
+  wrapper.appendChild(container);
+  app.appendChild(wrapper);
+  document.querySelectorAll('[id^="dzg-graph-svg"], [id^="zg-graph-svg"]').forEach((el) => {
+    if (!container.contains(el)) el.remove();
+  });
+  const renderId = `zg-graph-svg-${Date.now()}`;
+  try {
+    const mermaid = await loadMermaid();
+    const { svg: svg2 } = await mermaid.render(renderId, mermaidSrc);
+    container.innerHTML = svg2;
+    document.querySelectorAll(`#d${renderId}, #${renderId}`).forEach((el) => {
+      if (!container.contains(el)) el.remove();
+    });
+    const idToName = /* @__PURE__ */ new Map();
+    for (const s of specs) idToName.set(nodeId(s.name), s.name);
+    container.querySelectorAll("g.node").forEach((node) => {
+      const id = node.id;
+      const matchedName = [...idToName.entries()].find(([nid]) => id.includes(nid))?.[1];
+      if (!matchedName) return;
+      node.style.cursor = "pointer";
+      node.addEventListener("click", () => {
+        window.location.hash = `#/spec/${encodeURIComponent(matchedName)}`;
+      });
+    });
+  } catch (err) {
+    container.innerHTML = `<pre class="zg-graph-fallback">${escapeMermaidSrcForDisplay(mermaidSrc)}</pre><p class="zg-error">Could not render Mermaid graph: ${escapeHtml(err.message)}. Showing source.</p>`;
+  }
+}
+function renderLegend(specs) {
+  const present = /* @__PURE__ */ new Set();
+  for (const s of specs) present.add(s.status);
+  const legend = document.createElement("div");
+  legend.className = "zg-graph-legend";
+  const items = [
+    { s: "draft", label: "Draft" },
+    { s: "planned", label: "Planned" },
+    { s: "in-progress", label: "In Progress" },
+    { s: "in-review", label: "In Review" },
+    { s: "done", label: "Done" },
+    { s: "blocked", label: "Blocked" },
+    { s: "cancelled", label: "Cancelled" }
+  ];
+  for (const { s, label } of items) {
+    if (!present.has(s)) continue;
+    const item = document.createElement("span");
+    item.className = "zg-legend-item";
+    const swatch = document.createElement("span");
+    swatch.className = `zg-legend-swatch zg-legend-${s}`;
+    item.appendChild(swatch);
+    item.appendChild(document.createTextNode(label));
+    legend.appendChild(item);
+  }
+  return legend;
+}
+function renderMermaidSource(specs, edges, meta) {
+  const groups = /* @__PURE__ */ new Map();
+  const ungrouped = [];
+  for (const s of specs) {
+    const part = meta.get(s.name)?.partOf ?? null;
+    if (!part) {
+      ungrouped.push(s);
+      continue;
+    }
+    if (!groups.has(part)) groups.set(part, []);
+    groups.get(part).push(s);
+  }
+  const lines = ["graph TD"];
+  for (const s of ungrouped) lines.push(`  ${emitNode(s)}`);
+  let sgIdx = 0;
+  const clusterStyles = [];
+  for (const [part, members] of groups) {
+    const sgId = `sg_${sgIdx++}`;
+    lines.push(`  subgraph ${sgId} ["\u{1F4C1} ${escapeForLabel(part)}"]`);
+    for (const s of members) lines.push(`    ${emitNode(s)}`);
+    lines.push("  end");
+    const [fill, stroke] = clusterPalette(part);
+    clusterStyles.push(`style ${sgId} fill:${fill},stroke:${stroke},stroke-dasharray:4 4`);
+  }
+  for (const e of edges) lines.push(`  ${nodeId(e.from)} --> ${nodeId(e.to)}`);
+  const palette = [
+    // [status, fill, stroke, text-color]
+    ["draft", "#f3f4f6", "#9ca3af", "#374151"],
+    ["planned", "#dbeafe", "#60a5fa", "#1e3a8a"],
+    ["in-progress", "#fef3c7", "#f59e0b", "#78350f"],
+    ["in-review", "#ede9fe", "#8b5cf6", "#4c1d95"],
+    ["done", "#d1fae5", "#10b981", "#064e3b"],
+    ["blocked", "#fee2e2", "#c0392b", "#7f1d1d"],
+    ["cancelled", "#f3f4f6", "#7f8c8d", "#374151"]
+  ];
+  for (const [status, fill, stroke, color] of palette) {
+    lines.push(`classDef ${statusClass(status)} fill:${fill},stroke:${stroke},color:${color},stroke-width:1.5px`);
+  }
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const s of specs) {
+    if (!byStatus.has(s.status)) byStatus.set(s.status, []);
+    byStatus.get(s.status).push(nodeId(s.name));
+  }
+  for (const [status, ids] of byStatus) {
+    lines.push(`class ${ids.join(",")} ${statusClass(status)}`);
+  }
+  for (const s of clusterStyles) lines.push(s);
+  return lines.join("\n");
+}
+var CLUSTER_PALETTE = [
+  ["#60a5fa1a", "#60a5fa8c"],
+  // blue
+  ["#f59e0b1a", "#f59e0b8c"],
+  // amber
+  ["#8b5cf61a", "#8b5cf68c"],
+  // violet
+  ["#10b9811a", "#10b9818c"],
+  // emerald
+  ["#ec48991a", "#ec48998c"],
+  // pink
+  ["#f472b61a", "#f472b68c"],
+  // rose
+  ["#38bdf81a", "#38bdf88c"]
+  // sky
+];
+function clusterPalette(name) {
+  let h = 0;
+  for (let i = 0; i < name.length; i++) h = h * 31 + name.charCodeAt(i) | 0;
+  const idx = Math.abs(h) % CLUSTER_PALETTE.length;
+  return CLUSTER_PALETTE[idx];
+}
+function emitNode(s) {
+  const label = `${s.name}\\n${s.progress}`;
+  return `${nodeId(s.name)}["${escapeForLabel(label)}"]`;
+}
+function nodeId(name) {
+  return `n_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+function statusClass(s) {
+  return `s_${s.replace(/-/g, "_")}`;
+}
+function escapeForLabel(s) {
+  return s.replace(/"/g, '\\"');
+}
+function escapeMermaidSrcForDisplay(s) {
+  return s.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c] ?? c);
+}
+
+// src/views/docs.ts
+async function renderDocs(params) {
+  const app = document.getElementById("app");
+  app.innerHTML = "<p>Loading docs\u2026</p>";
+  const backend = window.zettelgeistBackend;
+  let entries2;
+  let specNames = [];
+  try {
+    const [docs, specs] = await Promise.all([
+      backend.listDocs(),
+      backend.listSpecs().catch(() => [])
+    ]);
+    entries2 = docs;
+    specNames = specs.map((s) => s.name);
+  } catch (err) {
+    app.innerHTML = `<p class="zg-error">Failed to list docs: ${escapeHtml(err.message)}</p>`;
+    return;
+  }
+  const resolver = makeWikiLinkResolver(specNames, entries2.map((e) => e.path));
+  const enrich = (root) => processWikiLinks(root, resolver);
+  let selectedPath = params.path ? decodeURIComponent(params.path) : null;
+  if (!selectedPath && entries2.length > 0) {
+    const preferences = ["docs/README.md", "docs/readme.md", "docs/architecture.md", "docs/onboarding.md"];
+    const sorted = [...entries2].sort((a, b) => a.path.localeCompare(b.path));
+    selectedPath = preferences.find((p) => entries2.some((e) => e.path === p)) ?? sorted[0].path;
+  }
+  app.innerHTML = "";
+  const wrapper = document.createElement("div");
+  wrapper.className = "zg-docs";
+  const sidebar = document.createElement("aside");
+  sidebar.className = "zg-docs-sidebar";
+  const title = document.createElement("h3");
+  title.textContent = "Docs";
+  sidebar.appendChild(title);
+  const list2 = document.createElement("ul");
+  list2.className = "zg-docs-list";
+  for (const entry of entries2) {
+    const li = document.createElement("li");
+    li.className = "zg-docs-list-item";
+    const link2 = document.createElement("a");
+    link2.href = `#/docs/${encodeURIComponent(entry.path)}`;
+    link2.textContent = entry.title || entry.path;
+    if (entry.path === selectedPath) {
+      link2.classList.add("active");
+    }
+    li.appendChild(link2);
+    const renameBtn = document.createElement("button");
+    renameBtn.type = "button";
+    renameBtn.className = "zg-docs-rename";
+    renameBtn.title = "Rename";
+    renameBtn.setAttribute("aria-label", `Rename ${entry.path}`);
+    renameBtn.textContent = "\u270E";
+    renameBtn.addEventListener("click", async (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      const next = await showInputModal({
+        title: `Rename ${entry.path}`,
+        message: "Path is relative to the workspace root. Use forward slashes for subfolders.",
+        defaultValue: entry.path,
+        placeholder: "docs/new-name.md",
+        confirmLabel: "Rename",
+        validate: (v) => {
+          const t = v.trim();
+          if (!t) return "Path is required.";
+          if (t === entry.path) return "Pick a different path.";
+          if (!t.endsWith(".md")) return "Path must end in .md";
+          return null;
+        }
+      });
+      if (next === null) return;
+      const trimmed = next.trim();
+      try {
+        const result = await backend.renameDoc(entry.path, trimmed);
+        const wasViewing = entry.path === selectedPath;
+        if (wasViewing) {
+          window.location.hash = `#/docs/${encodeURIComponent(result.newPath)}`;
+        }
+        window.dispatchEvent(new HashChangeEvent("hashchange"));
+      } catch (err) {
+        void showAlert("Rename failed", err.message);
+      }
+    });
+    li.appendChild(renameBtn);
+    list2.appendChild(li);
+  }
+  sidebar.appendChild(list2);
+  const main = document.createElement("article");
+  main.className = "zg-docs-main";
+  if (selectedPath) {
+    try {
+      const doc = await backend.readDoc(selectedPath);
+      main.appendChild(
+        renderMarkdownEditor({
+          body: doc.source,
+          emptyPlaceholder: `${selectedPath} is empty`,
+          emptyHint: "Click below to start writing.",
+          interactiveCheckboxes: true,
+          postRender: enrich,
+          onSave: async (newBody) => {
+            await backend.writeDoc(selectedPath, newBody);
+          }
+        })
+      );
+    } catch (err) {
+      main.innerHTML = `<p class="zg-error">Failed to read doc: ${escapeHtml(err.message)}</p>`;
+    }
+  } else {
+    const empty = document.createElement("div");
+    empty.className = "zg-empty-state";
+    const h = document.createElement("h3");
+    h.textContent = "No docs yet";
+    empty.appendChild(h);
+    const p = document.createElement("p");
+    p.textContent = "Add narrative documentation as markdown files under a `docs/` folder at the repo root. Anything there shows up here.";
+    empty.appendChild(p);
+    main.appendChild(empty);
+  }
+  wrapper.appendChild(sidebar);
+  wrapper.appendChild(main);
+  app.appendChild(wrapper);
+}
+
+// src/main.ts
+var THEME_STORAGE_KEY = "zg.theme";
+function resolveTheme(config) {
+  const stored = (() => {
+    try {
+      return localStorage.getItem(THEME_STORAGE_KEY);
+    } catch {
+      return null;
+    }
+  })();
+  if (stored === "light" || stored === "dark") return stored;
+  const requested = config?.theme ?? "system";
+  if (requested === "light" || requested === "dark") return requested;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function applyTheme(theme) {
+  document.documentElement.setAttribute("data-theme", theme);
+  const btn = document.getElementById("zg-theme-toggle");
+  if (btn) btn.textContent = theme === "dark" ? "\u2600" : "\u263E";
+}
+function setupTheme(config) {
+  let current = resolveTheme(config);
+  applyTheme(current);
+  const mq = window.matchMedia("(prefers-color-scheme: dark)");
+  mq.addEventListener("change", (e) => {
+    try {
+      if (localStorage.getItem(THEME_STORAGE_KEY)) return;
+    } catch {
+    }
+    current = e.matches ? "dark" : "light";
+    applyTheme(current);
+  });
+  const btn = document.getElementById("zg-theme-toggle");
+  if (btn) {
+    btn.addEventListener("click", () => {
+      current = current === "dark" ? "light" : "dark";
+      try {
+        localStorage.setItem(THEME_STORAGE_KEY, current);
+      } catch {
+      }
+      applyTheme(current);
+      window.dispatchEvent(new HashChangeEvent("hashchange"));
+    });
+  }
+}
+async function bootstrap() {
+  const backend = window.zettelgeistBackend;
+  if (!backend) {
+    document.getElementById("app").innerHTML = "<p>Error: <code>window.zettelgeistBackend</code> is not defined. The viewer must be loaded by a host that injects a backend.</p>";
+    throw new Error("window.zettelgeistBackend is not defined");
+  }
+  setupTheme(window.zettelgeistConfig);
+  const router = new Router();
+  router.add("/", renderBoard);
+  router.add("/spec/:name", renderDetail);
+  router.add("/graph", renderGraph);
+  router.add("/docs", renderDocs);
+  router.add("/docs/*path", renderDocs);
+  router.start();
+}
+bootstrap().catch((err) => {
+  console.error("viewer bootstrap failed:", err);
+});
+/*! Bundled license information:
+
+dompurify/dist/purify.es.mjs:
+  (*! @license DOMPurify 3.2.0 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.0/LICENSE *)
+*/
+//# sourceMappingURL=main.js.map