markdown-design-doc-viewer-embed 1.5.3 → 1.5.5

package/index.js

@@ -14587,6 +14587,248 @@ function translatorFor(messages) {
   return (message, ...args) => formatMessage(messages[message] ?? message, ...args);
 }
 
+// src/shared/protocol.ts
+var WEBVIEW_TITLES = {
+  "splitter-title": "Drag to resize, double-click to reset",
+  "hide-warnings-title": "Hide warnings",
+  "toc-title": "Contents",
+  "zoom-title": "Zoom diagram",
+  "zoom-image-title": "Zoom image",
+  "zoom-in-title": "Zoom in",
+  "zoom-out-title": "Zoom out",
+  "zoom-fit-title": "Fit to window",
+  "zoom-close-title": "Close",
+  "diff-added": "{0} added",
+  "diff-changed": "{0} changed",
+  "diff-deleted": "{0} deleted",
+  "diff-no-changes": "No changes",
+  "diff-previous-title": "Previous change",
+  "diff-next-title": "Next change",
+  "diff-close-title": "Stop comparing",
+  "diff-hide-title": "Hide changes",
+  "diff-show-title": "Show changes",
+  "diff-old-diagram": "Diagram before the change"
+};
+
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/array.js
+var ArrayDiff = class extends Diff {
+  tokenize(value) {
+    return value.slice();
+  }
+  join(value) {
+    return value;
+  }
+  removeEmpty(value) {
+    return value;
+  }
+};
+var arrayDiff = new ArrayDiff();
+function diffArrays(oldArr, newArr, options) {
+  return arrayDiff.diff(oldArr, newArr, options);
+}
+
 // node_modules/.pnpm/mdurl@2.1.0/node_modules/mdurl/index.mjs
 var mdurl_exports = {};
 __export(mdurl_exports, {
@@ -19879,265 +20121,6 @@ _defineProperty(MarkdownIt, "ParserInline", ParserInline);
 _defineProperty(MarkdownIt, "StateInline", StateInline);
 var MarkdownItCallable = callable(MarkdownIt);
 
-// node_modules/.pnpm/markdown-it-footnote@4.0.0/node_modules/markdown-it-footnote/index.mjs
-function render_footnote_anchor_name(tokens, idx, options, env) {
-  const n = Number(tokens[idx].meta.id + 1).toString();
-  let prefix = "";
-  if (typeof env.docId === "string") prefix = `-${env.docId}-`;
-  return prefix + n;
-}
-function render_footnote_caption(tokens, idx) {
-  let n = Number(tokens[idx].meta.id + 1).toString();
-  if (tokens[idx].meta.subId > 0) n += `:${tokens[idx].meta.subId}`;
-  return `[${n}]`;
-}
-function render_footnote_ref(tokens, idx, options, env, slf) {
-  const id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
-  const caption = slf.rules.footnote_caption(tokens, idx, options, env, slf);
-  let refid = id;
-  if (tokens[idx].meta.subId > 0) refid += `:${tokens[idx].meta.subId}`;
-  return `<sup class="footnote-ref"><a href="#fn${id}" id="fnref${refid}">${caption}</a></sup>`;
-}
-function render_footnote_block_open(tokens, idx, options) {
-  return (options.xhtmlOut ? '<hr class="footnotes-sep" />\n' : '<hr class="footnotes-sep">\n') + '<section class="footnotes">\n<ol class="footnotes-list">\n';
-}
-function render_footnote_block_close() {
-  return "</ol>\n</section>\n";
-}
-function render_footnote_open(tokens, idx, options, env, slf) {
-  let id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
-  if (tokens[idx].meta.subId > 0) id += `:${tokens[idx].meta.subId}`;
-  return `<li id="fn${id}" class="footnote-item">`;
-}
-function render_footnote_close() {
-  return "</li>\n";
-}
-function render_footnote_anchor(tokens, idx, options, env, slf) {
-  let id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
-  if (tokens[idx].meta.subId > 0) id += `:${tokens[idx].meta.subId}`;
-  return ` <a href="#fnref${id}" class="footnote-backref">\u21A9\uFE0E</a>`;
-}
-function footnote_plugin(md2) {
-  const parseLinkLabel2 = md2.helpers.parseLinkLabel;
-  const isSpace2 = md2.utils.isSpace;
-  md2.renderer.rules.footnote_ref = render_footnote_ref;
-  md2.renderer.rules.footnote_block_open = render_footnote_block_open;
-  md2.renderer.rules.footnote_block_close = render_footnote_block_close;
-  md2.renderer.rules.footnote_open = render_footnote_open;
-  md2.renderer.rules.footnote_close = render_footnote_close;
-  md2.renderer.rules.footnote_anchor = render_footnote_anchor;
-  md2.renderer.rules.footnote_caption = render_footnote_caption;
-  md2.renderer.rules.footnote_anchor_name = render_footnote_anchor_name;
-  function footnote_def(state, startLine, endLine, silent) {
-    const start = state.bMarks[startLine] + state.tShift[startLine];
-    const max = state.eMarks[startLine];
-    if (start + 4 > max) return false;
-    if (state.src.charCodeAt(start) !== 91) return false;
-    if (state.src.charCodeAt(start + 1) !== 94) return false;
-    let pos;
-    for (pos = start + 2; pos < max; pos++) {
-      if (state.src.charCodeAt(pos) === 32) return false;
-      if (state.src.charCodeAt(pos) === 93) {
-        break;
-      }
-    }
-    if (pos === start + 2) return false;
-    if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 58) return false;
-    if (silent) return true;
-    pos++;
-    if (!state.env.footnotes) state.env.footnotes = {};
-    if (!state.env.footnotes.refs) state.env.footnotes.refs = {};
-    const label = state.src.slice(start + 2, pos - 2);
-    state.env.footnotes.refs[`:${label}`] = -1;
-    const token_fref_o = new state.Token("footnote_reference_open", "", 1);
-    token_fref_o.meta = { label };
-    token_fref_o.level = state.level++;
-    state.tokens.push(token_fref_o);
-    const oldBMark = state.bMarks[startLine];
-    const oldTShift = state.tShift[startLine];
-    const oldSCount = state.sCount[startLine];
-    const oldParentType = state.parentType;
-    const posAfterColon = pos;
-    const initial = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);
-    let offset = initial;
-    while (pos < max) {
-      const ch = state.src.charCodeAt(pos);
-      if (isSpace2(ch)) {
-        if (ch === 9) {
-          offset += 4 - offset % 4;
-        } else {
-          offset++;
-        }
-      } else {
-        break;
-      }
-      pos++;
-    }
-    state.tShift[startLine] = pos - posAfterColon;
-    state.sCount[startLine] = offset - initial;
-    state.bMarks[startLine] = posAfterColon;
-    state.blkIndent += 4;
-    state.parentType = "footnote";
-    if (state.sCount[startLine] < state.blkIndent) {
-      state.sCount[startLine] += state.blkIndent;
-    }
-    state.md.block.tokenize(state, startLine, endLine, true);
-    state.parentType = oldParentType;
-    state.blkIndent -= 4;
-    state.tShift[startLine] = oldTShift;
-    state.sCount[startLine] = oldSCount;
-    state.bMarks[startLine] = oldBMark;
-    const token_fref_c = new state.Token("footnote_reference_close", "", -1);
-    token_fref_c.level = --state.level;
-    state.tokens.push(token_fref_c);
-    return true;
-  }
-  function footnote_inline(state, silent) {
-    const max = state.posMax;
-    const start = state.pos;
-    if (start + 2 >= max) return false;
-    if (state.src.charCodeAt(start) !== 94) return false;
-    if (state.src.charCodeAt(start + 1) !== 91) return false;
-    const labelStart = start + 2;
-    const labelEnd = parseLinkLabel2(state, start + 1);
-    if (labelEnd < 0) return false;
-    if (!silent) {
-      if (!state.env.footnotes) state.env.footnotes = {};
-      if (!state.env.footnotes.list) state.env.footnotes.list = [];
-      const footnoteId = state.env.footnotes.list.length;
-      const tokens = [];
-      state.md.inline.parse(
-        state.src.slice(labelStart, labelEnd),
-        state.md,
-        state.env,
-        tokens
-      );
-      const token = state.push("footnote_ref", "", 0);
-      token.meta = { id: footnoteId };
-      state.env.footnotes.list[footnoteId] = {
-        content: state.src.slice(labelStart, labelEnd),
-        tokens
-      };
-    }
-    state.pos = labelEnd + 1;
-    state.posMax = max;
-    return true;
-  }
-  function footnote_ref(state, silent) {
-    const max = state.posMax;
-    const start = state.pos;
-    if (start + 3 > max) return false;
-    if (!state.env.footnotes || !state.env.footnotes.refs) return false;
-    if (state.src.charCodeAt(start) !== 91) return false;
-    if (state.src.charCodeAt(start + 1) !== 94) return false;
-    let pos;
-    for (pos = start + 2; pos < max; pos++) {
-      if (state.src.charCodeAt(pos) === 32) return false;
-      if (state.src.charCodeAt(pos) === 10) return false;
-      if (state.src.charCodeAt(pos) === 93) {
-        break;
-      }
-    }
-    if (pos === start + 2) return false;
-    if (pos >= max) return false;
-    pos++;
-    const label = state.src.slice(start + 2, pos - 1);
-    if (typeof state.env.footnotes.refs[`:${label}`] === "undefined") return false;
-    if (!silent) {
-      if (!state.env.footnotes.list) state.env.footnotes.list = [];
-      let footnoteId;
-      if (state.env.footnotes.refs[`:${label}`] < 0) {
-        footnoteId = state.env.footnotes.list.length;
-        state.env.footnotes.list[footnoteId] = { label, count: 0 };
-        state.env.footnotes.refs[`:${label}`] = footnoteId;
-      } else {
-        footnoteId = state.env.footnotes.refs[`:${label}`];
-      }
-      const footnoteSubId = state.env.footnotes.list[footnoteId].count;
-      state.env.footnotes.list[footnoteId].count++;
-      const token = state.push("footnote_ref", "", 0);
-      token.meta = { id: footnoteId, subId: footnoteSubId, label };
-    }
-    state.pos = pos;
-    state.posMax = max;
-    return true;
-  }
-  function footnote_tail(state) {
-    let tokens;
-    let current;
-    let currentLabel;
-    let insideRef = false;
-    const refTokens = {};
-    if (!state.env.footnotes) {
-      return;
-    }
-    state.tokens = state.tokens.filter(function(tok) {
-      if (tok.type === "footnote_reference_open") {
-        insideRef = true;
-        current = [];
-        currentLabel = tok.meta.label;
-        return false;
-      }
-      if (tok.type === "footnote_reference_close") {
-        insideRef = false;
-        refTokens[":" + currentLabel] = current;
-        return false;
-      }
-      if (insideRef) {
-        current.push(tok);
-      }
-      return !insideRef;
-    });
-    if (!state.env.footnotes.list) {
-      return;
-    }
-    const list2 = state.env.footnotes.list;
-    state.tokens.push(new state.Token("footnote_block_open", "", 1));
-    for (let i = 0, l = list2.length; i < l; i++) {
-      const token_fo = new state.Token("footnote_open", "", 1);
-      token_fo.meta = { id: i, label: list2[i].label };
-      state.tokens.push(token_fo);
-      if (list2[i].tokens) {
-        tokens = [];
-        const token_po = new state.Token("paragraph_open", "p", 1);
-        token_po.block = true;
-        tokens.push(token_po);
-        const token_i = new state.Token("inline", "", 0);
-        token_i.children = list2[i].tokens;
-        token_i.content = list2[i].content;
-        tokens.push(token_i);
-        const token_pc = new state.Token("paragraph_close", "p", -1);
-        token_pc.block = true;
-        tokens.push(token_pc);
-      } else if (list2[i].label) {
-        tokens = refTokens[`:${list2[i].label}`];
-      }
-      if (tokens) state.tokens = state.tokens.concat(tokens);
-      let lastParagraph;
-      if (state.tokens[state.tokens.length - 1].type === "paragraph_close") {
-        lastParagraph = state.tokens.pop();
-      } else {
-        lastParagraph = null;
-      }
-      const t = list2[i].count > 0 ? list2[i].count : 1;
-      for (let j = 0; j < t; j++) {
-        const token_a = new state.Token("footnote_anchor", "", 0);
-        token_a.meta = { id: i, subId: j, label: list2[i].label };
-        state.tokens.push(token_a);
-      }
-      if (lastParagraph) {
-        state.tokens.push(lastParagraph);
-      }
-      state.tokens.push(new state.Token("footnote_close", "", -1));
-    }
-    state.tokens.push(new state.Token("footnote_block_close", "", -1));
-  }
-  md2.block.ruler.before("reference", "footnote_def", footnote_def, { alt: ["paragraph", "reference"] });
-  md2.inline.ruler.after("image", "footnote_inline", footnote_inline);
-  md2.inline.ruler.after("footnote_inline", "footnote_ref", footnote_ref);
-  md2.core.ruler.after("inline", "footnote_tail", footnote_tail);
-}
-
 // src/diagrams/diagramWording.ts
 function diagramWording(kind, t) {
   switch (kind) {
@@ -20519,104 +20502,6 @@ function stripStepNumber(heading2) {
   return void 0;
 }
 
-// src/diagrams/sequenceWrap.ts
-var DEFAULT_MESSAGE_WRAP_WIDTH = 40;
-var WIDE_RE = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦\u{1F300}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
-var NO_START = new Set(Array.from("\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309D\u309E\u30FC\u30A1\u30A3\u30A5\u30A7\u30A9\u30C3\u30E3\u30E5\u30E7\u30EE\u30F5\u30F6\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308E\u3095\u3096\uFF09\u3015\uFF3D\uFF5D\u3009\u300B\u300D\u300F\u3011\u3019\u3017\u301F\u2019\u201D\uFF60\xBB,.:;!?)]}"));
-var NO_END = new Set(Array.from("\uFF08\u3014\uFF3B\uFF5B\u3008\u300A\u300C\u300E\u3010\u3018\u3016\u301D\u2018\u201C\uFF5F\xAB([{"));
-var KEEP_RE = /<br\s*\/?>|#|;|%%|\$\$|^:?(?:no)?wrap:/i;
-var TAG_RE = /<\/?[a-z][a-z0-9]*(?:\s[^>]*)?\/?>/;
-var keepsLabel = (text3) => KEEP_RE.test(text3) || TAG_RE.test(text3);
-var charWidth = (c) => WIDE_RE.test(c) ? 2 : 1;
-var textWidth = (text3) => Array.from(text3).reduce((sum, c) => sum + charWidth(c), 0);
-function canBreakBefore(chars, i) {
-  const before = chars[i - 1];
-  const after = chars[i];
-  if (before === " " || after === " ") {
-    return true;
-  }
-  if (NO_START.has(after) || NO_END.has(before)) {
-    return false;
-  }
-  if (before === "/" && after !== "/") {
-    return true;
-  }
-  return WIDE_RE.test(before) || WIDE_RE.test(after);
-}
-function fillLines(chars, limit) {
-  const lines = [];
-  let start = 0;
-  while (start < chars.length) {
-    while (chars[start] === " ") {
-      start++;
-    }
-    if (start >= chars.length) {
-      break;
-    }
-    let width = 0;
-    let end = start;
-    let lastBreak = -1;
-    while (end < chars.length) {
-      if (end > start && canBreakBefore(chars, end)) {
-        lastBreak = end;
-      }
-      const w = charWidth(chars[end]);
-      if (end > start && width + w > limit) {
-        break;
-      }
-      width += w;
-      end++;
-    }
-    const cut = end < chars.length && lastBreak > start ? lastBreak : end;
-    lines.push(chars.slice(start, cut).join("").trimEnd());
-    start = cut;
-  }
-  return lines;
-}
-function wrapLabel(text3, maxWidth) {
-  const normalized = text3.replace(/\s+/g, " ").trim();
-  const total = textWidth(normalized);
-  if (maxWidth <= 0 || total <= maxWidth) {
-    return [normalized];
-  }
-  const chars = Array.from(normalized);
-  const count = fillLines(chars, maxWidth).length;
-  for (let limit = Math.ceil(total / count); limit < maxWidth; limit++) {
-    const lines = fillLines(chars, limit);
-    if (lines.length <= count) {
-      return lines;
-    }
-  }
-  return fillLines(chars, maxWidth);
-}
-function wrapSequenceMessages(source, maxWidth) {
-  if (!(maxWidth > 0) || !isSequenceDiagram(source)) {
-    return source;
-  }
-  const { messages } = parseSequence(source, 0);
-  const lines = source.split("\n");
-  let changed = false;
-  for (const { line } of messages) {
-    const raw = lines[line];
-    const colon = raw.indexOf(":");
-    const label = raw.slice(colon + 1);
-    const text3 = label.trim();
-    if (keepsLabel(text3) || textWidth(text3) <= maxWidth) {
-      continue;
-    }
-    const lead = /^\s*/.exec(label)[0];
-    const trail = /\s*$/.exec(label)[0];
-    lines[line] = `${raw.slice(0, colon + 1)}${lead}${wrapLabel(text3, maxWidth).join("<br>")}${trail}`;
-    changed = true;
-  }
-  return changed ? lines.join("\n") : source;
-}
-
-// src/markdown/htmlTags.ts
-var RAW_TEXT = "script|style|textarea|title";
-var ATTR_RE = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
-var decodeAttribute = (md2, value) => md2.utils.unescapeAll(value.replace(/\\/g, "\\\\"));
-
 // src/diagrams/diagramNodes.ts
 function readNodes(lines, start, firstLine, rules, reader) {
   const excluded = reader.excluded ?? /* @__PURE__ */ new Set();
@@ -21347,6 +21232,11 @@ function tableWarnings(tokens) {
   return tokens.flatMap((token) => token.meta?.[WARNINGS] ?? []);
 }
 
+// src/markdown/htmlTags.ts
+var RAW_TEXT = "script|style|textarea|title";
+var ATTR_RE = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+var decodeAttribute = (md2, value) => md2.utils.unescapeAll(value.replace(/\\/g, "\\\\"));
+
 // src/markdown/wireframe.ts
 var WIREFRAME_TOKEN = "wireframe";
 var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
@@ -21897,94 +21787,446 @@ function linkParts(diagram, tokens, headings, numberedHeadings, steps, wording,
   }
 }
 
-// node_modules/.pnpm/highlight.js@11.12.0/node_modules/highlight.js/es/common.js
-var import_common = __toESM(require_common(), 1);
-var common_default = import_common.default;
-
-// src/markdown/markdownExtras.ts
-function highlight(code2, lang) {
-  if (!lang || !common_default.getLanguage(lang)) {
-    return "";
-  }
-  try {
-    return common_default.highlight(code2, { language: lang, ignoreIllegals: true }).value;
-  } catch {
-    return "";
-  }
+// node_modules/.pnpm/markdown-it-footnote@4.0.0/node_modules/markdown-it-footnote/index.mjs
+function render_footnote_anchor_name(tokens, idx, options, env) {
+  const n = Number(tokens[idx].meta.id + 1).toString();
+  let prefix = "";
+  if (typeof env.docId === "string") prefix = `-${env.docId}-`;
+  return prefix + n;
 }
-var YAML_KEY_RE = /^(?:"[^"]*"|'[^']*'|[^\s#:"'-][^:]*?)\s*:(?:\s|$)/;
-var unquote2 = (s) => /^(["']).*\1$/.test(s) ? s.slice(1, -1) : s;
-function stripComment(s) {
-  const quoted = /^(["'])(?:(?!\1).)*\1/.exec(s);
-  if (quoted) {
-    return /^\s*(?:#.*)?$/.test(s.slice(quoted[0].length)) ? quoted[0] : s;
-  }
-  const comment = /(?:^|\s)#/.exec(s);
-  return comment ? s.slice(0, comment.index).trimEnd() : s;
+function render_footnote_caption(tokens, idx) {
+  let n = Number(tokens[idx].meta.id + 1).toString();
+  if (tokens[idx].meta.subId > 0) n += `:${tokens[idx].meta.subId}`;
+  return `[${n}]`;
 }
-function parseFrontMatter(yaml) {
-  const entries2 = [];
-  for (const line of yaml.split(/\r?\n/)) {
-    const m = /^\S/.test(line) ? YAML_KEY_RE.exec(line) : null;
-    if (m) {
-      entries2.push({ key: unquote2(m[0].replace(/\s*:\s*$/, "")), rest: stripComment(line.slice(m[0].length).trim()), lines: [] });
-    } else if (entries2.length > 0 && !/^#/.test(line)) {
-      entries2[entries2.length - 1].lines.push(line);
-    }
-  }
-  return entries2.map(({ key, rest, lines }) => {
-    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
-      lines.pop();
-    }
-    const indent = Math.min(...lines.filter((l) => l.trim() !== "").map((l) => /^\s*/.exec(l)[0].length));
-    const body = lines.map((l) => l.slice(indent));
-    let value;
-    if (/^[|>][+-]?\d*$/.test(rest)) {
-      value = body.join(rest.startsWith(">") ? " " : "\n");
-    } else if (rest === "" && body.length > 0 && body.every((l) => /^-(\s|$)/.test(l))) {
-      value = body.map((l) => unquote2(stripComment(l.slice(1).trim()))).join(", ");
-    } else if (body.length === 0 && /^\[.*\]$/.test(rest)) {
-      value = rest.slice(1, -1).split(",").map((item) => unquote2(item.trim())).filter((item) => item !== "").join(", ");
-    } else {
-      value = [unquote2(rest), ...body].filter((l, i) => i > 0 || l !== "").join("\n");
-    }
-    return { key, value };
-  });
+function render_footnote_ref(tokens, idx, options, env, slf) {
+  const id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
+  const caption = slf.rules.footnote_caption(tokens, idx, options, env, slf);
+  let refid = id;
+  if (tokens[idx].meta.subId > 0) refid += `:${tokens[idx].meta.subId}`;
+  return `<sup class="footnote-ref"><a href="#fn${id}" id="fnref${refid}">${caption}</a></sup>`;
 }
-function frontMatterValue(entries2, key) {
-  const value = entries2.find((entry) => entry.key === key)?.value;
-  return value?.trim() ? value : void 0;
+function render_footnote_block_open(tokens, idx, options) {
+  return (options.xhtmlOut ? '<hr class="footnotes-sep" />\n' : '<hr class="footnotes-sep">\n') + '<section class="footnotes">\n<ol class="footnotes-list">\n';
 }
-var DESIGN_DOC_TYPE = "design_doc";
-function isDesignDoc(entries2) {
-  return entries2.find((entry) => entry.key === "type")?.value.trim() === DESIGN_DOC_TYPE;
+function render_footnote_block_close() {
+  return "</ol>\n</section>\n";
 }
-var DESIGN_DOC_META = [
-  { key: "version", label: "Version" },
-  { key: "product", label: "Product" },
-  { key: "status", label: "Status" },
-  { key: "updated", label: "Updated" }
-];
-function frontMatter(md2) {
-  md2.block.ruler.before("table", "seqnotes_front_matter", (state, startLine, endLine, silent) => {
-    const line = (n) => state.src.slice(state.bMarks[n], state.eMarks[n]).trimEnd();
-    if (startLine !== 0 || state.parentType !== "root" || line(0) !== "---" || endLine < 2 || !YAML_KEY_RE.test(line(1))) {
-      return false;
+function render_footnote_open(tokens, idx, options, env, slf) {
+  let id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
+  if (tokens[idx].meta.subId > 0) id += `:${tokens[idx].meta.subId}`;
+  return `<li id="fn${id}" class="footnote-item">`;
+}
+function render_footnote_close() {
+  return "</li>\n";
+}
+function render_footnote_anchor(tokens, idx, options, env, slf) {
+  let id = slf.rules.footnote_anchor_name(tokens, idx, options, env, slf);
+  if (tokens[idx].meta.subId > 0) id += `:${tokens[idx].meta.subId}`;
+  return ` <a href="#fnref${id}" class="footnote-backref">\u21A9\uFE0E</a>`;
+}
+function footnote_plugin(md2) {
+  const parseLinkLabel2 = md2.helpers.parseLinkLabel;
+  const isSpace2 = md2.utils.isSpace;
+  md2.renderer.rules.footnote_ref = render_footnote_ref;
+  md2.renderer.rules.footnote_block_open = render_footnote_block_open;
+  md2.renderer.rules.footnote_block_close = render_footnote_block_close;
+  md2.renderer.rules.footnote_open = render_footnote_open;
+  md2.renderer.rules.footnote_close = render_footnote_close;
+  md2.renderer.rules.footnote_anchor = render_footnote_anchor;
+  md2.renderer.rules.footnote_caption = render_footnote_caption;
+  md2.renderer.rules.footnote_anchor_name = render_footnote_anchor_name;
+  function footnote_def(state, startLine, endLine, silent) {
+    const start = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    if (start + 4 > max) return false;
+    if (state.src.charCodeAt(start) !== 91) return false;
+    if (state.src.charCodeAt(start + 1) !== 94) return false;
+    let pos;
+    for (pos = start + 2; pos < max; pos++) {
+      if (state.src.charCodeAt(pos) === 32) return false;
+      if (state.src.charCodeAt(pos) === 93) {
+        break;
+      }
     }
-    for (let n = 1; n < endLine; n++) {
-      if (line(n) === "---" || line(n) === "...") {
-        if (!silent) {
-          const token = state.push("front_matter", "", 0);
-          token.block = true;
-          token.map = [0, n + 1];
-          token.content = n > 1 ? state.src.slice(state.bMarks[1], state.eMarks[n - 1]) : "";
+    if (pos === start + 2) return false;
+    if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 58) return false;
+    if (silent) return true;
+    pos++;
+    if (!state.env.footnotes) state.env.footnotes = {};
+    if (!state.env.footnotes.refs) state.env.footnotes.refs = {};
+    const label = state.src.slice(start + 2, pos - 2);
+    state.env.footnotes.refs[`:${label}`] = -1;
+    const token_fref_o = new state.Token("footnote_reference_open", "", 1);
+    token_fref_o.meta = { label };
+    token_fref_o.level = state.level++;
+    state.tokens.push(token_fref_o);
+    const oldBMark = state.bMarks[startLine];
+    const oldTShift = state.tShift[startLine];
+    const oldSCount = state.sCount[startLine];
+    const oldParentType = state.parentType;
+    const posAfterColon = pos;
+    const initial = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);
+    let offset = initial;
+    while (pos < max) {
+      const ch = state.src.charCodeAt(pos);
+      if (isSpace2(ch)) {
+        if (ch === 9) {
+          offset += 4 - offset % 4;
+        } else {
+          offset++;
         }
-        state.line = n + 1;
-        return true;
+      } else {
+        break;
       }
+      pos++;
     }
-    return false;
-  });
+    state.tShift[startLine] = pos - posAfterColon;
+    state.sCount[startLine] = offset - initial;
+    state.bMarks[startLine] = posAfterColon;
+    state.blkIndent += 4;
+    state.parentType = "footnote";
+    if (state.sCount[startLine] < state.blkIndent) {
+      state.sCount[startLine] += state.blkIndent;
+    }
+    state.md.block.tokenize(state, startLine, endLine, true);
+    state.parentType = oldParentType;
+    state.blkIndent -= 4;
+    state.tShift[startLine] = oldTShift;
+    state.sCount[startLine] = oldSCount;
+    state.bMarks[startLine] = oldBMark;
+    const token_fref_c = new state.Token("footnote_reference_close", "", -1);
+    token_fref_c.level = --state.level;
+    state.tokens.push(token_fref_c);
+    return true;
+  }
+  function footnote_inline(state, silent) {
+    const max = state.posMax;
+    const start = state.pos;
+    if (start + 2 >= max) return false;
+    if (state.src.charCodeAt(start) !== 94) return false;
+    if (state.src.charCodeAt(start + 1) !== 91) return false;
+    const labelStart = start + 2;
+    const labelEnd = parseLinkLabel2(state, start + 1);
+    if (labelEnd < 0) return false;
+    if (!silent) {
+      if (!state.env.footnotes) state.env.footnotes = {};
+      if (!state.env.footnotes.list) state.env.footnotes.list = [];
+      const footnoteId = state.env.footnotes.list.length;
+      const tokens = [];
+      state.md.inline.parse(
+        state.src.slice(labelStart, labelEnd),
+        state.md,
+        state.env,
+        tokens
+      );
+      const token = state.push("footnote_ref", "", 0);
+      token.meta = { id: footnoteId };
+      state.env.footnotes.list[footnoteId] = {
+        content: state.src.slice(labelStart, labelEnd),
+        tokens
+      };
+    }
+    state.pos = labelEnd + 1;
+    state.posMax = max;
+    return true;
+  }
+  function footnote_ref(state, silent) {
+    const max = state.posMax;
+    const start = state.pos;
+    if (start + 3 > max) return false;
+    if (!state.env.footnotes || !state.env.footnotes.refs) return false;
+    if (state.src.charCodeAt(start) !== 91) return false;
+    if (state.src.charCodeAt(start + 1) !== 94) return false;
+    let pos;
+    for (pos = start + 2; pos < max; pos++) {
+      if (state.src.charCodeAt(pos) === 32) return false;
+      if (state.src.charCodeAt(pos) === 10) return false;
+      if (state.src.charCodeAt(pos) === 93) {
+        break;
+      }
+    }
+    if (pos === start + 2) return false;
+    if (pos >= max) return false;
+    pos++;
+    const label = state.src.slice(start + 2, pos - 1);
+    if (typeof state.env.footnotes.refs[`:${label}`] === "undefined") return false;
+    if (!silent) {
+      if (!state.env.footnotes.list) state.env.footnotes.list = [];
+      let footnoteId;
+      if (state.env.footnotes.refs[`:${label}`] < 0) {
+        footnoteId = state.env.footnotes.list.length;
+        state.env.footnotes.list[footnoteId] = { label, count: 0 };
+        state.env.footnotes.refs[`:${label}`] = footnoteId;
+      } else {
+        footnoteId = state.env.footnotes.refs[`:${label}`];
+      }
+      const footnoteSubId = state.env.footnotes.list[footnoteId].count;
+      state.env.footnotes.list[footnoteId].count++;
+      const token = state.push("footnote_ref", "", 0);
+      token.meta = { id: footnoteId, subId: footnoteSubId, label };
+    }
+    state.pos = pos;
+    state.posMax = max;
+    return true;
+  }
+  function footnote_tail(state) {
+    let tokens;
+    let current;
+    let currentLabel;
+    let insideRef = false;
+    const refTokens = {};
+    if (!state.env.footnotes) {
+      return;
+    }
+    state.tokens = state.tokens.filter(function(tok) {
+      if (tok.type === "footnote_reference_open") {
+        insideRef = true;
+        current = [];
+        currentLabel = tok.meta.label;
+        return false;
+      }
+      if (tok.type === "footnote_reference_close") {
+        insideRef = false;
+        refTokens[":" + currentLabel] = current;
+        return false;
+      }
+      if (insideRef) {
+        current.push(tok);
+      }
+      return !insideRef;
+    });
+    if (!state.env.footnotes.list) {
+      return;
+    }
+    const list2 = state.env.footnotes.list;
+    state.tokens.push(new state.Token("footnote_block_open", "", 1));
+    for (let i = 0, l = list2.length; i < l; i++) {
+      const token_fo = new state.Token("footnote_open", "", 1);
+      token_fo.meta = { id: i, label: list2[i].label };
+      state.tokens.push(token_fo);
+      if (list2[i].tokens) {
+        tokens = [];
+        const token_po = new state.Token("paragraph_open", "p", 1);
+        token_po.block = true;
+        tokens.push(token_po);
+        const token_i = new state.Token("inline", "", 0);
+        token_i.children = list2[i].tokens;
+        token_i.content = list2[i].content;
+        tokens.push(token_i);
+        const token_pc = new state.Token("paragraph_close", "p", -1);
+        token_pc.block = true;
+        tokens.push(token_pc);
+      } else if (list2[i].label) {
+        tokens = refTokens[`:${list2[i].label}`];
+      }
+      if (tokens) state.tokens = state.tokens.concat(tokens);
+      let lastParagraph;
+      if (state.tokens[state.tokens.length - 1].type === "paragraph_close") {
+        lastParagraph = state.tokens.pop();
+      } else {
+        lastParagraph = null;
+      }
+      const t = list2[i].count > 0 ? list2[i].count : 1;
+      for (let j = 0; j < t; j++) {
+        const token_a = new state.Token("footnote_anchor", "", 0);
+        token_a.meta = { id: i, subId: j, label: list2[i].label };
+        state.tokens.push(token_a);
+      }
+      if (lastParagraph) {
+        state.tokens.push(lastParagraph);
+      }
+      state.tokens.push(new state.Token("footnote_close", "", -1));
+    }
+    state.tokens.push(new state.Token("footnote_block_close", "", -1));
+  }
+  md2.block.ruler.before("reference", "footnote_def", footnote_def, { alt: ["paragraph", "reference"] });
+  md2.inline.ruler.after("image", "footnote_inline", footnote_inline);
+  md2.inline.ruler.after("footnote_inline", "footnote_ref", footnote_ref);
+  md2.core.ruler.after("inline", "footnote_tail", footnote_tail);
+}
+
+// src/diagrams/sequenceWrap.ts
+var DEFAULT_MESSAGE_WRAP_WIDTH = 40;
+var WIDE_RE = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦\u{1F300}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
+var NO_START = new Set(Array.from("\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309D\u309E\u30FC\u30A1\u30A3\u30A5\u30A7\u30A9\u30C3\u30E3\u30E5\u30E7\u30EE\u30F5\u30F6\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308E\u3095\u3096\uFF09\u3015\uFF3D\uFF5D\u3009\u300B\u300D\u300F\u3011\u3019\u3017\u301F\u2019\u201D\uFF60\xBB,.:;!?)]}"));
+var NO_END = new Set(Array.from("\uFF08\u3014\uFF3B\uFF5B\u3008\u300A\u300C\u300E\u3010\u3018\u3016\u301D\u2018\u201C\uFF5F\xAB([{"));
+var KEEP_RE = /<br\s*\/?>|#|;|%%|\$\$|^:?(?:no)?wrap:/i;
+var TAG_RE = /<\/?[a-z][a-z0-9]*(?:\s[^>]*)?\/?>/;
+var keepsLabel = (text3) => KEEP_RE.test(text3) || TAG_RE.test(text3);
+var charWidth = (c) => WIDE_RE.test(c) ? 2 : 1;
+var textWidth = (text3) => Array.from(text3).reduce((sum, c) => sum + charWidth(c), 0);
+function canBreakBefore(chars, i) {
+  const before = chars[i - 1];
+  const after = chars[i];
+  if (before === " " || after === " ") {
+    return true;
+  }
+  if (NO_START.has(after) || NO_END.has(before)) {
+    return false;
+  }
+  if (before === "/" && after !== "/") {
+    return true;
+  }
+  return WIDE_RE.test(before) || WIDE_RE.test(after);
+}
+function fillLines(chars, limit) {
+  const lines = [];
+  let start = 0;
+  while (start < chars.length) {
+    while (chars[start] === " ") {
+      start++;
+    }
+    if (start >= chars.length) {
+      break;
+    }
+    let width = 0;
+    let end = start;
+    let lastBreak = -1;
+    while (end < chars.length) {
+      if (end > start && canBreakBefore(chars, end)) {
+        lastBreak = end;
+      }
+      const w = charWidth(chars[end]);
+      if (end > start && width + w > limit) {
+        break;
+      }
+      width += w;
+      end++;
+    }
+    const cut = end < chars.length && lastBreak > start ? lastBreak : end;
+    lines.push(chars.slice(start, cut).join("").trimEnd());
+    start = cut;
+  }
+  return lines;
+}
+function wrapLabel(text3, maxWidth) {
+  const normalized = text3.replace(/\s+/g, " ").trim();
+  const total = textWidth(normalized);
+  if (maxWidth <= 0 || total <= maxWidth) {
+    return [normalized];
+  }
+  const chars = Array.from(normalized);
+  const count = fillLines(chars, maxWidth).length;
+  for (let limit = Math.ceil(total / count); limit < maxWidth; limit++) {
+    const lines = fillLines(chars, limit);
+    if (lines.length <= count) {
+      return lines;
+    }
+  }
+  return fillLines(chars, maxWidth);
+}
+function wrapSequenceMessages(source, maxWidth) {
+  if (!(maxWidth > 0) || !isSequenceDiagram(source)) {
+    return source;
+  }
+  const { messages } = parseSequence(source, 0);
+  const lines = source.split("\n");
+  let changed = false;
+  for (const { line } of messages) {
+    const raw = lines[line];
+    const colon = raw.indexOf(":");
+    const label = raw.slice(colon + 1);
+    const text3 = label.trim();
+    if (keepsLabel(text3) || textWidth(text3) <= maxWidth) {
+      continue;
+    }
+    const lead = /^\s*/.exec(label)[0];
+    const trail = /\s*$/.exec(label)[0];
+    lines[line] = `${raw.slice(0, colon + 1)}${lead}${wrapLabel(text3, maxWidth).join("<br>")}${trail}`;
+    changed = true;
+  }
+  return changed ? lines.join("\n") : source;
+}
+
+// node_modules/.pnpm/highlight.js@11.12.0/node_modules/highlight.js/es/common.js
+var import_common = __toESM(require_common(), 1);
+var common_default = import_common.default;
+
+// src/markdown/markdownExtras.ts
+function highlight(code2, lang) {
+  if (!lang || !common_default.getLanguage(lang)) {
+    return "";
+  }
+  try {
+    return common_default.highlight(code2, { language: lang, ignoreIllegals: true }).value;
+  } catch {
+    return "";
+  }
+}
+var YAML_KEY_RE = /^(?:"[^"]*"|'[^']*'|[^\s#:"'-][^:]*?)\s*:(?:\s|$)/;
+var unquote2 = (s) => /^(["']).*\1$/.test(s) ? s.slice(1, -1) : s;
+function stripComment(s) {
+  const quoted = /^(["'])(?:(?!\1).)*\1/.exec(s);
+  if (quoted) {
+    return /^\s*(?:#.*)?$/.test(s.slice(quoted[0].length)) ? quoted[0] : s;
+  }
+  const comment = /(?:^|\s)#/.exec(s);
+  return comment ? s.slice(0, comment.index).trimEnd() : s;
+}
+function parseFrontMatter(yaml) {
+  const entries2 = [];
+  for (const line of yaml.split(/\r?\n/)) {
+    const m = /^\S/.test(line) ? YAML_KEY_RE.exec(line) : null;
+    if (m) {
+      entries2.push({ key: unquote2(m[0].replace(/\s*:\s*$/, "")), rest: stripComment(line.slice(m[0].length).trim()), lines: [] });
+    } else if (entries2.length > 0 && !/^#/.test(line)) {
+      entries2[entries2.length - 1].lines.push(line);
+    }
+  }
+  return entries2.map(({ key, rest, lines }) => {
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.pop();
+    }
+    const indent = Math.min(...lines.filter((l) => l.trim() !== "").map((l) => /^\s*/.exec(l)[0].length));
+    const body = lines.map((l) => l.slice(indent));
+    let value;
+    if (/^[|>][+-]?\d*$/.test(rest)) {
+      value = body.join(rest.startsWith(">") ? " " : "\n");
+    } else if (rest === "" && body.length > 0 && body.every((l) => /^-(\s|$)/.test(l))) {
+      value = body.map((l) => unquote2(stripComment(l.slice(1).trim()))).join(", ");
+    } else if (body.length === 0 && /^\[.*\]$/.test(rest)) {
+      value = rest.slice(1, -1).split(",").map((item) => unquote2(item.trim())).filter((item) => item !== "").join(", ");
+    } else {
+      value = [unquote2(rest), ...body].filter((l, i) => i > 0 || l !== "").join("\n");
+    }
+    return { key, value };
+  });
+}
+function frontMatterValue(entries2, key) {
+  const value = entries2.find((entry) => entry.key === key)?.value;
+  return value?.trim() ? value : void 0;
+}
+var DESIGN_DOC_TYPE = "design_doc";
+function isDesignDoc(entries2) {
+  return entries2.find((entry) => entry.key === "type")?.value.trim() === DESIGN_DOC_TYPE;
+}
+var DESIGN_DOC_META = [
+  { key: "version", label: "Version" },
+  { key: "product", label: "Product" },
+  { key: "status", label: "Status" },
+  { key: "updated", label: "Updated" }
+];
+function frontMatter(md2) {
+  md2.block.ruler.before("table", "seqnotes_front_matter", (state, startLine, endLine, silent) => {
+    const line = (n) => state.src.slice(state.bMarks[n], state.eMarks[n]).trimEnd();
+    if (startLine !== 0 || state.parentType !== "root" || line(0) !== "---" || endLine < 2 || !YAML_KEY_RE.test(line(1))) {
+      return false;
+    }
+    for (let n = 1; n < endLine; n++) {
+      if (line(n) === "---" || line(n) === "...") {
+        if (!silent) {
+          const token = state.push("front_matter", "", 0);
+          token.block = true;
+          token.map = [0, n + 1];
+          token.content = n > 1 ? state.src.slice(state.bMarks[1], state.eMarks[n - 1]) : "";
+        }
+        state.line = n + 1;
+        return true;
+      }
+    }
+    return false;
+  });
   md2.renderer.rules.front_matter = (tokens, idx, _options, env, self) => {
     const entries2 = env?.frontMatter === false ? [] : parseFrontMatter(tokens[idx].content);
     const escape2 = md2.utils.escapeHtml;
@@ -22278,88 +22520,490 @@ function inRawText(tokens, idx) {
       }
     }
   }
-  return open !== void 0;
+  return open !== void 0;
+}
+function resourceLinks(md2) {
+  const defaultImage = md2.renderer.rules.image;
+  md2.renderer.rules.image = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    const src = token.attrGet("src");
+    if (src && env?.resolveResource) {
+      token.attrSet("src", env.resolveResource(String(src)));
+    }
+    return defaultImage(tokens, idx, options, env, self);
+  };
+  for (const type of ["html_block", "html_inline"]) {
+    const defaultHtml = md2.renderer.rules[type];
+    md2.renderer.rules[type] = (tokens, idx, options, env, self) => {
+      const html2 = defaultHtml(tokens, idx, options, env, self);
+      const resolve = env?.resolveResource;
+      const rendered = tokens[idx].meta?.[RENDERED_HTML] === true;
+      if (!resolve || rendered || type === "html_inline" && inRawText(tokens, idx)) {
+        return html2;
+      }
+      return resolveHtmlImages(md2, html2, resolve);
+    };
+  }
+}
+function createMarkdown() {
+  const md2 = MarkdownItCallable({ html: true, linkify: true });
+  md2.use(footnote_plugin).use(markdownExtras).use(tableOptions).use(wireframes).use(headingIds).use(sourceLines).use(mermaidFence).use(wireframeBlock).use(resourceLinks);
+  return md2;
+}
+function renderDocument(md2, source, env = {}) {
+  return renderTokens(md2, md2.parse(source, env), env);
+}
+function renderTokens(md2, tokens, env) {
+  const t = env.t ?? formatMessage;
+  const { diagrams, warnings: linkWarnings } = linkDiagrams(tokens, t);
+  const warnings = [...linkWarnings, ...tableWarnings(tokens)].sort((a, b) => a.line - b.line);
+  for (const diagram of diagrams) {
+    const fence2 = tokens[diagram.fenceIndex];
+    fence2.meta = { ...fence2.meta, seqNotes: diagram };
+    const wording = diagramWording(diagram.kind, t);
+    for (const index of env.forExport ? [] : diagram.unlinkedHeadings) {
+      tokens[index].attrJoin("class", "seqnotes-unlinked");
+      tokens[index].attrSet("title", wording.unlinkedHeadingTitle);
+      tokens[index].attrSet("data-seqnotes-mark", wording.unlinkedHeadingMark);
+    }
+    for (const row of diagram.rows) {
+      if (row.target) {
+        tokens[row.index].attrSet("data-seqnotes-section", row.target);
+        tokens[row.index].attrJoin("class", "seqnotes-row");
+      } else if (row.unlinked && !env.forExport) {
+        const rows = rowWording(t);
+        tokens[row.index].attrJoin("class", "seqnotes-unlinked");
+        tokens[row.cell].attrSet("title", rows.title);
+        tokens[row.cell].attrSet("data-seqnotes-mark", rows.mark);
+      }
+    }
+  }
+  const render = (slice) => md2.renderer.render(slice, md2.options, env);
+  let html2 = "";
+  if (warnings.length > 0 && !env.forExport) {
+    const key = warnings.map((w) => w.message).join("\n");
+    html2 += `<div class="seqnotes-warnings" data-seqnotes-key="${escapeHtml2(key)}">`;
+    for (const w of warnings) {
+      html2 += `<p data-seqnotes-jump="${w.line}">${escapeHtml2(t("\u26A0 Line {0}: {1}", w.line + 1, w.message))}</p>`;
+    }
+    html2 += "</div>\n";
+  }
+  let pos = 0;
+  for (const diagram of diagrams) {
+    if (!diagram.paired) {
+      continue;
+    }
+    html2 += render(tokens.slice(pos, diagram.fenceIndex));
+    html2 += `<div class="seqnotes-pair${diagram.stacked ? " seqnotes-pair-stacked" : ""}" data-diagram="${diagram.id}">`;
+    html2 += `<div class="seqnotes-seq-col">${render(tokens.slice(diagram.fenceIndex, diagram.fenceIndex + 1))}</div>`;
+    html2 += `<div class="seqnotes-overview-col">${render(tokens.slice(diagram.fenceIndex + 1, diagram.rangeEnd))}</div>`;
+    html2 += "</div>\n";
+    pos = diagram.rangeEnd;
+  }
+  html2 += render(tokens.slice(pos));
+  return html2;
+}
+
+// src/diff/textDiff.ts
+var WORD_RE = /[\p{L}\p{N}_]+|\s+|[^]/gu;
+var UNSPACED_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Thai}]/u;
+function wordSegmenter(lang) {
+  try {
+    return typeof Intl.Segmenter === "function" ? new Intl.Segmenter(lang, { granularity: "word" }) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function splitWords(text3, segmenter2) {
+  const words2 = [];
+  for (const [word] of text3.matchAll(WORD_RE)) {
+    if (word.length > 1 && UNSPACED_RE.test(word)) {
+      if (segmenter2) {
+        for (const { segment } of segmenter2.segment(word)) {
+          words2.push(segment);
+        }
+      } else {
+        words2.push(...word);
+      }
+    } else {
+      words2.push(word);
+    }
+  }
+  return words2;
+}
+var MAX_EDIT_LENGTH = 2e3;
+function diffWordLists(before, after) {
+  return diffArrays(before, after, { maxEditLength: MAX_EDIT_LENGTH })?.map((change) => ({
+    type: change.added ? "added" : change.removed ? "removed" : "equal",
+    tokens: change.value
+  }));
+}
+function groupChanges(changes) {
+  const grouped = [];
+  let removed = [];
+  let added = [];
+  const flush = () => {
+    if (removed.length > 0) {
+      grouped.push({ type: "removed", tokens: removed });
+    }
+    if (added.length > 0) {
+      grouped.push({ type: "added", tokens: added });
+    }
+    removed = [];
+    added = [];
+  };
+  changes.forEach((change, i) => {
+    if (change.type === "removed") {
+      removed.push(...change.tokens);
+    } else if (change.type === "added") {
+      added.push(...change.tokens);
+    } else if ((removed.length > 0 || added.length > 0) && i + 1 < changes.length && change.tokens.join("").trim().length <= 1) {
+      removed.push(...change.tokens);
+      added.push(...change.tokens);
+    } else {
+      flush();
+      grouped.push(change);
+    }
+  });
+  flush();
+  return grouped;
+}
+function similarity(before, after, segmenter2) {
+  if (before === after) {
+    return 1;
+  }
+  const total = before.length + after.length;
+  if (total === 0) {
+    return 1;
+  }
+  let common = 0;
+  for (const change of diffWordLists(splitWords(before, segmenter2), splitWords(after, segmenter2)) ?? []) {
+    if (change.type === "equal") {
+      common += change.tokens.join("").length;
+    }
+  }
+  return 2 * common / total;
+}
+
+// src/diff/diffRender.ts
+var SIMILAR = 0.4;
+var CONTAINERS = /* @__PURE__ */ new Set(["bullet_list_open", "ordered_list_open", "table_open"]);
+var WRAPPED = /* @__PURE__ */ new Set(["fence", "html_block", "front_matter"]);
+var isWrapped = (token) => WRAPPED.has(token.type) && !isMermaidFence(token);
+function isCommentsOnly(html2) {
+  let s = html2.trim();
+  if (!s.startsWith("<!--")) {
+    return false;
+  }
+  while (s.startsWith("<!--")) {
+    const end = s.indexOf("-->", 4);
+    if (end < 0) {
+      return false;
+    }
+    s = s.slice(end + 3).trimStart();
+  }
+  return s === "";
+}
+var LIST_MARKER_RE = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]?/;
+var SPACED = /* @__PURE__ */ new Set(["fence", "mermaid", "code_block", "html_block"]);
+var MAX_COMPARED_PAIRS = 2500;
+function kindOf(token) {
+  if (token.type === "heading_open") {
+    return token.tag;
+  }
+  if (token.type === "fence") {
+    return isMermaidFence(token) ? "mermaid" : "fence";
+  }
+  return token.type;
+}
+function unitsOf(tokens, lines, start, end, level, env) {
+  const units = [];
+  for (let i = start; i < end; ) {
+    const token = tokens[i];
+    if (token.level !== level || token.nesting === -1 || !token.block) {
+      i++;
+      continue;
+    }
+    let close = i;
+    if (token.nesting === 1) {
+      while (close < end && !(tokens[close].level === level && tokens[close].nesting === -1)) {
+        close++;
+      }
+    }
+    if (token.map) {
+      const kind = kindOf(token);
+      let key = lines.slice(token.map[0], token.map[1]).join("\n");
+      if (token.type === "list_item_open") {
+        key = key.replace(LIST_MARKER_RE, "");
+      }
+      key = SPACED.has(kind) ? key.trimEnd() : key.replace(/\s+/g, " ").trim();
+      const hidden = token.type === "html_block" && isCommentsOnly(token.content) || token.type === "front_matter" && env.frontMatter === false;
+      units.push({ start: i, end: close + 1, key, kind, hidden });
+    }
+    i = close + 1;
+  }
+  return units;
 }
-function resourceLinks(md2) {
-  const defaultImage = md2.renderer.rules.image;
-  md2.renderer.rules.image = (tokens, idx, options, env, self) => {
-    const token = tokens[idx];
-    const src = token.attrGet("src");
-    if (src && env?.resolveResource) {
-      token.attrSet("src", env.resolveResource(String(src)));
+function align(before, after, alike) {
+  const ops = [];
+  let removed = [];
+  let added = [];
+  const flush = () => {
+    const pairs = [];
+    const compareText = removed.length * added.length <= MAX_COMPARED_PAIRS;
+    let next = 0;
+    added.forEach((b, j3) => {
+      const i3 = removed.findIndex((a, k) => k >= next && alike(a, b, compareText));
+      if (i3 >= 0) {
+        pairs.push([i3, j3]);
+        next = i3 + 1;
+      }
+    });
+    let i2 = 0;
+    let j2 = 0;
+    for (const [pi, pj] of [...pairs, [removed.length, added.length]]) {
+      while (i2 < pi) {
+        ops.push({ type: "deleted", before: removed[i2++] });
+      }
+      while (j2 < pj) {
+        ops.push({ type: "added", after: added[j2++] });
+      }
+      if (pi < removed.length) {
+        ops.push({ type: "changed", before: removed[pi], after: added[pj] });
+        i2 = pi + 1;
+        j2 = pj + 1;
+      }
     }
-    return defaultImage(tokens, idx, options, env, self);
+    removed = [];
+    added = [];
   };
-  for (const type of ["html_block", "html_inline"]) {
-    const defaultHtml = md2.renderer.rules[type];
-    md2.renderer.rules[type] = (tokens, idx, options, env, self) => {
-      const html2 = defaultHtml(tokens, idx, options, env, self);
-      const resolve = env?.resolveResource;
-      const rendered = tokens[idx].meta?.[RENDERED_HTML] === true;
-      if (!resolve || rendered || type === "html_inline" && inRawText(tokens, idx)) {
-        return html2;
+  let i = 0;
+  let j = 0;
+  for (const change of diffArrays(
+    before.map((u) => u.key),
+    after.map((u) => u.key)
+  )) {
+    if (change.removed) {
+      removed.push(...before.slice(i, i += change.count));
+    } else if (change.added) {
+      added.push(...after.slice(j, j += change.count));
+    } else {
+      flush();
+      for (let k = 0; k < change.count; k++) {
+        ops.push({ type: "equal", before: before[i++], after: after[j++] });
       }
-      return resolveHtmlImages(md2, html2, resolve);
-    };
+    }
   }
-}
-function createMarkdown() {
-  const md2 = MarkdownItCallable({ html: true, linkify: true });
-  md2.use(footnote_plugin).use(markdownExtras).use(tableOptions).use(wireframes).use(headingIds).use(sourceLines).use(mermaidFence).use(wireframeBlock).use(resourceLinks);
-  return md2;
-}
-function renderDocument(md2, source, env = {}) {
-  return renderTokens(md2, md2.parse(source, env), env);
-}
-function renderTokens(md2, tokens, env) {
-  const t = env.t ?? formatMessage;
-  const { diagrams, warnings: linkWarnings } = linkDiagrams(tokens, t);
-  const warnings = [...linkWarnings, ...tableWarnings(tokens)].sort((a, b) => a.line - b.line);
-  for (const diagram of diagrams) {
-    const fence2 = tokens[diagram.fenceIndex];
-    fence2.meta = { ...fence2.meta, seqNotes: diagram };
-    const wording = diagramWording(diagram.kind, t);
-    for (const index of env.forExport ? [] : diagram.unlinkedHeadings) {
-      tokens[index].attrJoin("class", "seqnotes-unlinked");
-      tokens[index].attrSet("title", wording.unlinkedHeadingTitle);
-      tokens[index].attrSet("data-seqnotes-mark", wording.unlinkedHeadingMark);
+  flush();
+  return ops;
+}
+function renderDiff(md2, beforeSource, afterSource, env = {}) {
+  const segmenter2 = wordSegmenter();
+  const beforeEnv = {
+    resolveResource: env.resolveResource,
+    t: env.t,
+    frontMatter: env.frontMatter,
+    headingNumbers: env.headingNumbers,
+    messageWrapWidth: env.messageWrapWidth,
+    wireframes: env.wireframes,
+    forExport: true,
+    docId: "seqnotes-old"
+  };
+  const beforeTokens = md2.parse(beforeSource, beforeEnv);
+  const afterTokens = md2.parse(afterSource, env);
+  for (const token of beforeTokens) {
+    if (token.type === "heading_open" && token.attrs) {
+      token.attrs = token.attrs.filter(([name]) => name !== "id");
+    }
+  }
+  const beforeLines = beforeSource.split(/\r\n?|\n/);
+  const afterLines = afterSource.split(/\r\n?|\n/);
+  const old = [];
+  const stats = { added: 0, changed: 0, deleted: 0 };
+  const inserted = /* @__PURE__ */ new Map();
+  const insert = (index, token) => {
+    inserted.set(index, [...inserted.get(index) ?? [], token]);
+  };
+  const htmlToken = (content, level) => {
+    const token = new MarkdownItCallable.Token("html_block", "", 0);
+    token.content = content;
+    token.block = true;
+    token.level = level;
+    token.meta = { [RENDERED_HTML]: true };
+    return token;
+  };
+  const wrapped = (mark2, html2) => `<div class="seqnotes-diff-block" data-seqnotes-diff="${mark2}">
+${html2}</div>
+`;
+  const renderBefore = (unit) => md2.renderer.render(beforeTokens.slice(unit.start, unit.end), md2.options, beforeEnv);
+  const mark = (unit, value, oldIndex) => {
+    const token = afterTokens[unit.start];
+    if (isWrapped(token)) {
+      const attrs = oldIndex === void 0 ? "" : ` data-seqnotes-diff-old="${oldIndex}"`;
+      insert(unit.start, htmlToken(`<div class="seqnotes-diff-block" data-seqnotes-diff="${value}"${attrs}>
+`, token.level));
+      insert(unit.end, htmlToken("</div>\n", token.level));
+      return;
     }
-    for (const row of diagram.rows) {
-      if (row.target) {
-        tokens[row.index].attrSet("data-seqnotes-section", row.target);
-        tokens[row.index].attrJoin("class", "seqnotes-row");
-      } else if (row.unlinked && !env.forExport) {
-        const rows = rowWording(t);
-        tokens[row.index].attrJoin("class", "seqnotes-unlinked");
-        tokens[row.cell].attrSet("title", rows.title);
-        tokens[row.cell].attrSet("data-seqnotes-mark", rows.mark);
-      }
+    token.attrSet("data-seqnotes-diff", value);
+    if (oldIndex !== void 0) {
+      token.attrSet("data-seqnotes-diff-old", String(oldIndex));
     }
-  }
-  const render = (slice) => md2.renderer.render(slice, md2.options, env);
-  let html2 = "";
-  if (warnings.length > 0 && !env.forExport) {
-    const key = warnings.map((w) => w.message).join("\n");
-    html2 += `<div class="seqnotes-warnings" data-seqnotes-key="${escapeHtml2(key)}">`;
-    for (const w of warnings) {
-      html2 += `<p data-seqnotes-jump="${w.line}">${escapeHtml2(t("\u26A0 Line {0}: {1}", w.line + 1, w.message))}</p>`;
+  };
+  const alike = (a, b, compareText) => a.kind === b.kind && (CONTAINERS.has(a.kind) || a.kind === "mermaid" || compareText && similarity(a.key, b.key, segmenter2) >= SIMILAR);
+  const numberItems = (tokens2, list2, items) => {
+    const start = Number(tokens2[list2.start].attrGet("start") ?? 1);
+    items.forEach((item, i) => tokens2[item.start].attrSet("value", String(start + i)));
+  };
+  const compare = (before, after, level) => {
+    const ops = align(before, after, alike);
+    let deleted = [];
+    const flushDeleted = (index) => {
+      for (const unit of deleted) {
+        const token = beforeTokens[unit.start];
+        let html2;
+        if (isWrapped(token)) {
+          html2 = wrapped("deleted", renderBefore(unit));
+        } else {
+          token.attrSet("data-seqnotes-diff", "deleted");
+          html2 = renderBefore(unit);
+        }
+        insert(index, htmlToken(html2, level));
+        stats.deleted++;
+      }
+      deleted = [];
+    };
+    for (const op of ops) {
+      if (op.type === "deleted") {
+        if (!op.before.hidden) {
+          deleted.push(op.before);
+        }
+        continue;
+      }
+      flushDeleted(op.after.start);
+      if (op.after.hidden) {
+        continue;
+      }
+      if (op.type === "added") {
+        mark(op.after, "added");
+        stats.added++;
+      } else if (op.type === "changed") {
+        const kind = op.after.kind;
+        if (CONTAINERS.has(kind)) {
+          const depth = kind === "table_open" ? 2 : 1;
+          const beforeItems = unitsOf(beforeTokens, beforeLines, op.before.start + 1, op.before.end - 1, level + depth, beforeEnv);
+          const afterItems = unitsOf(afterTokens, afterLines, op.after.start + 1, op.after.end - 1, level + depth, env);
+          if (kind === "ordered_list_open") {
+            numberItems(beforeTokens, op.before, beforeItems);
+            numberItems(afterTokens, op.after, afterItems);
+          }
+          compare(beforeItems, afterItems, level + depth);
+        } else {
+          old.push(renderBefore(op.before));
+          mark(op.after, "changed", old.length - 1);
+          stats.changed++;
+        }
+      }
     }
-    html2 += "</div>\n";
-  }
-  let pos = 0;
-  for (const diagram of diagrams) {
-    if (!diagram.paired) {
-      continue;
+    flushDeleted(after.length > 0 ? after[after.length - 1].end : 0);
+  };
+  compare(unitsOf(beforeTokens, beforeLines, 0, beforeTokens.length, 0, beforeEnv), unitsOf(afterTokens, afterLines, 0, afterTokens.length, 0, env), 0);
+  const tokens = [];
+  for (let i = 0; i <= afterTokens.length; i++) {
+    tokens.push(...inserted.get(i) ?? []);
+    if (i < afterTokens.length) {
+      tokens.push(afterTokens[i]);
     }
-    html2 += render(tokens.slice(pos, diagram.fenceIndex));
-    html2 += `<div class="seqnotes-pair${diagram.stacked ? " seqnotes-pair-stacked" : ""}" data-diagram="${diagram.id}">`;
-    html2 += `<div class="seqnotes-seq-col">${render(tokens.slice(diagram.fenceIndex, diagram.fenceIndex + 1))}</div>`;
-    html2 += `<div class="seqnotes-overview-col">${render(tokens.slice(diagram.fenceIndex + 1, diagram.rangeEnd))}</div>`;
-    html2 += "</div>\n";
-    pos = diagram.rangeEnd;
   }
-  html2 += render(tokens.slice(pos));
-  return html2;
+  return { html: renderTokens(md2, tokens, env), old, stats };
+}
+
+// src/export/exportPage.ts
+var SCHEME_RE2 = /^[a-z][a-z0-9+.-]*:/i;
+var isExternalUrl = (src) => SCHEME_RE2.test(src) || src.startsWith("//") || src.startsWith("#");
+function frontMatterEntries(tokens) {
+  return tokens[0]?.type === "front_matter" ? parseFrontMatter(tokens[0].content) : [];
+}
+function titleOf(tokens, fallback) {
+  const title = frontMatterValue(frontMatterEntries(tokens), "title")?.trim();
+  if (title) {
+    return title;
+  }
+  const h1 = tokens.findIndex((t) => t.type === "heading_open" && t.tag === "h1");
+  return h1 >= 0 && headingText(tokens[h1 + 1]).trim() || fallback;
+}
+function documentTitle(md2, source, fallback) {
+  return titleOf(md2.parse(source, {}), fallback);
+}
+var RESOURCE_PLACEHOLDER = "seqnotes-export-resource:";
+var PLACEHOLDER_RE = new RegExp(`${RESOURCE_PLACEHOLDER}(\\d+)`, "g");
+async function withImages(render, resolveImage) {
+  const images = [];
+  const result = render((src) => {
+    if (isExternalUrl(src)) {
+      return src;
+    }
+    images.push(src);
+    return `${RESOURCE_PLACEHOLDER}${images.length - 1}`;
+  });
+  const resolved = await Promise.all(
+    images.map(async (src) => {
+      const url = await resolveImage(src);
+      const suffix = /[?#].*$/s.exec(src)?.[0] ?? "";
+      return url.startsWith("data:") ? url : url + suffix;
+    })
+  );
+  return { result, resolve: (html2) => html2.replace(PLACEHOLDER_RE, (_, i) => escapeHtml2(resolved[Number(i)])) };
+}
+async function renderForExport(md2, source, env, resolveImage) {
+  const { result, resolve } = await withImages((resolveResource) => renderDocument(md2, source, { ...env, forExport: true, resolveResource }), resolveImage);
+  return resolve(result);
+}
+async function renderDiffForExport(md2, beforeSource, afterSource, env, resolveImage) {
+  const { result, resolve } = await withImages(
+    (resolveResource) => renderDiff(md2, beforeSource, afterSource, { ...env, forExport: true, resolveResource }),
+    resolveImage
+  );
+  return { html: resolve(result.html), old: result.old.map(resolve), stats: result.stats };
+}
+var DIFF_TITLES = ["diff-added", "diff-changed", "diff-deleted", "diff-no-changes", "diff-previous-title", "diff-next-title", "diff-hide-title", "diff-show-title"];
+function exportDiff({ label, stats }, t) {
+  return { label, stats, titles: Object.fromEntries(DIFF_TITLES.map((name) => [`data-seqnotes-${name}`, t(WEBVIEW_TITLES[name])])) };
+}
+function exportPage({ lang, title, body, styles, script, settings, tocTitle, splitterTitle, diff }) {
+  const classes = [
+    "seqnotes-viewer",
+    "seqnotes-export",
+    ...settings.limitContentWidth ? ["seqnotes-limit-width"] : [],
+    ...settings.stickyTableHeader ? ["seqnotes-sticky-table-header"] : [],
+    ...settings.tableTreeHighlight ? ["seqnotes-table-tree-highlight"] : []
+  ];
+  const splitMinWidth = Number.isFinite(Number(settings.splitMinWidth)) ? Number(settings.splitMinWidth) : 1e3;
+  const tocAttrs = settings.toc ? ` data-seqnotes-toc data-seqnotes-toc-title="${escapeHtml2(tocTitle ?? "")}"` : "";
+  const splitterAttrs = splitterTitle ? ` data-seqnotes-splitter-title="${escapeHtml2(splitterTitle)}"` : "";
+  const diffAttrs = diff ? Object.entries({
+    "data-seqnotes-diff-label": diff.label,
+    "data-seqnotes-diff-stats": `${diff.stats.added},${diff.stats.changed},${diff.stats.deleted}`,
+    ...diff.titles
+  }).map(([name, value]) => ` ${name}="${escapeHtml2(value)}"`).join("") : "";
+  return `<!DOCTYPE html>
+<html lang="${escapeHtml2(lang)}">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml2(title)}</title>
+<style>
+${styles.join("\n").replace(/<\/style/gi, "<\\/style")}
+</style>
+</head>
+<body data-seqnotes-theme="light" class="${classes.join(" ")}" data-seqnotes-split-min-width="${splitMinWidth}"${splitterAttrs}${tocAttrs}${diffAttrs}>
+<div id="seqnotes-root" class="seqnotes-viewer-root">${body}</div>
+<script>
+${script.replace(/<\/script/gi, "<\\/script")}
+<\/script>
+</body>
+</html>
+`;
 }
 
 // node_modules/.pnpm/dompurify@3.4.17/node_modules/dompurify/dist/purify.es.mjs
@@ -24001,710 +24645,426 @@ function createDOMPurify() {
     const realTagName = getNodeName ? getNodeName(element) : null;
     if (typeof realTagName !== "string") return false;
     if (transformCaseFunc(realTagName) !== "form") return false;
-    return typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || element.attributes !== getAttributes(element) || typeof element.removeAttribute !== "function" || typeof element.removeAttributeNode !== "function" || typeof element.getAttributeNode !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function" || element.nodeType !== getNodeType(element) || element.childNodes !== getChildNodes(element);
-  };
-  const _isDocumentFragment = function _isDocumentFragment2(value) {
-    if (!getNodeType || typeof value !== "object" || value === null) return false;
-    try {
-      return getNodeType(value) === NODE_TYPE.documentFragment;
-    } catch (_) {
-      return false;
-    }
-  };
-  const _isNode = function _isNode2(value) {
-    if (!getNodeType || typeof value !== "object" || value === null) return false;
-    try {
-      return typeof getNodeType(value) === "number";
-    } catch (_) {
-      return false;
-    }
-  };
-  function _executeHooks(hooks2, currentNode, data) {
-    if (hooks2.length === 0) return;
-    arrayForEach(hooks2, (hook) => {
-      hook.call(DOMPurify, currentNode, data, CONFIG);
-    });
-  }
-  const _isUnsafeNode = function _isUnsafeNode2(currentNode, tagName) {
-    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.innerHTML)) return true;
-    if (SAFE_FOR_XML && LITERAL_TEXT_ELEMENTS[tagName] && _readNodeType(currentNode) === NODE_TYPE.element && _readNamespaceURI(currentNode) === HTML_NAMESPACE && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent))) return true;
-    if (currentNode.nodeType === NODE_TYPE.processingInstruction) return true;
-    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, currentNode.data)) return true;
-    return false;
-  };
-  const _matchesNameCheck = function _matchesNameCheck2(check, name) {
-    if (check instanceof RegExp) return regExpTest(check, name);
-    if (check instanceof Function) {
-      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) args[_key - 2] = arguments[_key];
-      return Boolean(check(name, ...args));
-    }
-    return false;
-  };
-  const _sanitizeDisallowedNode = function _sanitizeDisallowedNode2(currentNode, tagName, root) {
-    if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
-    if (KEEP_CONTENT && !FORBID_CONTENTS[tagName] && !FORBID_CONTENTS[stringToLowerCase(tagName)]) {
-      const parentNode = getParentNode(currentNode);
-      const childNodes = getChildNodes(currentNode);
-      if (childNodes && parentNode) {
-        const childCount = childNodes.length;
-        for (let i = childCount - 1; i >= 0; --i) {
-          const hoisted = currentNode === root ? cloneNode(childNodes[i], true) : childNodes[i];
-          parentNode.insertBefore(hoisted, getNextSibling(currentNode));
-        }
-      }
-    }
-    _forceRemove(currentNode);
-    return true;
-  };
-  const _forkSharedAllowlist = function _forkSharedAllowlist2(hookList, set, defaultSet, setConfigSet) {
-    if (hookList.length === 0) return set;
-    return set === defaultSet || set === setConfigSet ? clone(set) : set;
-  };
-  const _handleHookDetachedNode = function _handleHookDetachedNode2(currentNode, root) {
-    if (currentNode === root || getParentNode(currentNode) !== null) return false;
-    if (IN_PLACE) _neutralizeSubtree(currentNode);
-    return true;
-  };
-  const _sanitizeElements = function _sanitizeElements2(currentNode, root) {
-    _markVisited(currentNode);
-    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
-    if (_handleHookDetachedNode(currentNode, root)) return true;
-    if (_isClobbered(currentNode)) {
-      _forceRemove(currentNode);
-      return true;
-    }
-    const tagName = transformCaseFunc(_readNodeName(currentNode));
-    ALLOWED_TAGS = _forkSharedAllowlist(hooks.uponSanitizeElement, ALLOWED_TAGS, DEFAULT_ALLOWED_TAGS, SET_CONFIG_ALLOWED_TAGS);
-    _executeHooks(hooks.uponSanitizeElement, currentNode, {
-      tagName,
-      allowedTags: ALLOWED_TAGS
-    });
-    if (_handleHookDetachedNode(currentNode, root)) return true;
-    if (_isUnsafeNode(currentNode, tagName)) {
-      _forceRemove(currentNode);
-      return true;
-    }
-    if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
-      const removed = _sanitizeDisallowedNode(currentNode, tagName, root);
-      if (removed === false) {
-        _executeHooks(hooks.afterSanitizeElements, currentNode, null);
-        if (_handleHookDetachedNode(currentNode, root)) return true;
-      }
-      return removed;
-    }
-    if (_readNodeType(currentNode) === NODE_TYPE.element && !_checkValidNamespace(currentNode)) {
-      _forceRemove(currentNode);
-      return true;
-    }
-    if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(FALLBACK_TAG_CLOSE, currentNode.innerHTML)) {
-      _forceRemove(currentNode);
-      return true;
-    }
-    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
-      const content = _stripTemplateExpressions(currentNode.textContent);
-      if (currentNode.textContent !== content) {
-        arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
-        currentNode.textContent = content;
-      }
-    }
-    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
-    return _handleHookDetachedNode(currentNode, root);
-  };
-  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
-    if (FORBID_ATTR[lcName]) return false;
-    if (_isPatchLinkageAttribute(lcName, lcTag)) return false;
-    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) return false;
-    const nameIsPermitted = ALLOWED_ATTR[lcName] || EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag);
-    if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$1, lcName)) return true;
-    if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) return true;
-    if (!nameIsPermitted) return _isBasicCustomElement(lcTag) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName, lcTag) || lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value);
-    if (URI_SAFE_ATTRIBUTES[lcName]) return true;
-    if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) return true;
-    if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) return true;
-    if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) return true;
-    return !value;
-  };
-  const RESERVED_CUSTOM_ELEMENT_NAMES = addToSet({}, [
-    "annotation-xml",
-    "color-profile",
-    "font-face",
-    "font-face-format",
-    "font-face-name",
-    "font-face-src",
-    "font-face-uri",
-    "missing-glyph"
-  ]);
-  const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
-    return !RESERVED_CUSTOM_ELEMENT_NAMES[stringToLowerCase(tagName)] && regExpTest(CUSTOM_ELEMENT$1, tagName);
+    return typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || element.attributes !== getAttributes(element) || typeof element.removeAttribute !== "function" || typeof element.removeAttributeNode !== "function" || typeof element.getAttributeNode !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function" || element.nodeType !== getNodeType(element) || element.childNodes !== getChildNodes(element);
   };
-  const _applyTrustedTypesToAttribute = function _applyTrustedTypesToAttribute2(lcTag, lcName, namespaceURI, value) {
-    if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function" && !namespaceURI) switch (trustedTypes.getAttributeType(lcTag, lcName)) {
-      case "TrustedHTML":
-        return _createTrustedHTML(value);
-      case "TrustedScriptURL":
-        return _createTrustedScriptURL(value);
+  const _isDocumentFragment = function _isDocumentFragment2(value) {
+    if (!getNodeType || typeof value !== "object" || value === null) return false;
+    try {
+      return getNodeType(value) === NODE_TYPE.documentFragment;
+    } catch (_) {
+      return false;
     }
-    return value;
   };
-  const _setAttributeValue = function _setAttributeValue2(currentNode, name, namespaceURI, value) {
+  const _isNode = function _isNode2(value) {
+    if (!getNodeType || typeof value !== "object" || value === null) return false;
     try {
-      if (namespaceURI) currentNode.setAttributeNS(namespaceURI, name, value);
-      else currentNode.setAttribute(name, value);
-      if (_isClobbered(currentNode)) {
-        _forceRemove(currentNode);
-        return false;
-      }
-      return true;
+      return typeof getNodeType(value) === "number";
     } catch (_) {
-      _removeAttribute(name, currentNode);
       return false;
     }
   };
-  const _isUnsafeAttributeValue = function _isUnsafeAttributeValue2(name, value) {
-    if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) return true;
-    return stringToLowerCase(name) === "attributename" && stringMatch(value, "href") !== null;
+  function _executeHooks(hooks2, currentNode, data) {
+    if (hooks2.length === 0) return;
+    arrayForEach(hooks2, (hook) => {
+      hook.call(DOMPurify, currentNode, data, CONFIG);
+    });
+  }
+  const _isUnsafeNode = function _isUnsafeNode2(currentNode, tagName) {
+    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.innerHTML)) return true;
+    if (SAFE_FOR_XML && LITERAL_TEXT_ELEMENTS[tagName] && _readNodeType(currentNode) === NODE_TYPE.element && _readNamespaceURI(currentNode) === HTML_NAMESPACE && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent))) return true;
+    if (currentNode.nodeType === NODE_TYPE.processingInstruction) return true;
+    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, currentNode.data)) return true;
+    return false;
   };
-  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode, root) {
-    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
-    if (_handleHookDetachedNode(currentNode, root)) return;
-    const attributes = currentNode.attributes;
-    if (!attributes || _isClobbered(currentNode)) return;
-    ALLOWED_ATTR = _forkSharedAllowlist(hooks.uponSanitizeAttribute, ALLOWED_ATTR, DEFAULT_ALLOWED_ATTR, SET_CONFIG_ALLOWED_ATTR);
-    const hookEvent = {
-      attrName: "",
-      attrValue: "",
-      keepAttr: true,
-      allowedAttributes: ALLOWED_ATTR,
-      forceKeepAttr: void 0
-    };
-    let l = attributes.length;
-    const lcTag = transformCaseFunc(currentNode.nodeName);
-    while (l--) {
-      const attr = attributes[l];
-      const name = attr.name, namespaceURI = attr.namespaceURI, attrValue = attr.value;
-      const lcName = transformCaseFunc(name);
-      const initValue = attrValue;
-      let value = name === "value" ? initValue : stringTrim(initValue);
-      let recreatedNamedProp = false;
-      hookEvent.attrName = lcName;
-      hookEvent.attrValue = value;
-      hookEvent.keepAttr = true;
-      hookEvent.forceKeepAttr = void 0;
-      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
-      value = hookEvent.attrValue;
-      if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name") && stringIndexOf(value, SANITIZE_NAMED_PROPS_PREFIX) !== 0) {
-        _removeAttribute(name, currentNode, attr);
-        value = SANITIZE_NAMED_PROPS_PREFIX + value;
-        recreatedNamedProp = true;
-      }
-      if (_isUnsafeAttributeValue(name, value)) {
-        _removeAttribute(name, currentNode, attr);
-        continue;
-      }
-      if (hookEvent.forceKeepAttr) continue;
-      if (!hookEvent.keepAttr) {
-        _removeAttribute(name, currentNode, attr);
-        continue;
-      }
-      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value)) {
-        _removeAttribute(name, currentNode, attr);
-        continue;
-      }
-      if (SAFE_FOR_TEMPLATES) value = _stripTemplateExpressions(value);
-      if (!_isValidAttribute(lcTag, lcName, value)) {
-        _removeAttribute(name, currentNode, attr);
-        continue;
-      }
-      value = _applyTrustedTypesToAttribute(lcTag, lcName, namespaceURI, value);
-      if (value !== initValue) {
-        if (_setAttributeValue(currentNode, name, namespaceURI, value) && recreatedNamedProp) arrayPop(DOMPurify.removed);
-      }
+  const _matchesNameCheck = function _matchesNameCheck2(check, name) {
+    if (check instanceof RegExp) return regExpTest(check, name);
+    if (check instanceof Function) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) args[_key - 2] = arguments[_key];
+      return Boolean(check(name, ...args));
     }
-    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
-    _handleHookDetachedNode(currentNode, root);
+    return false;
   };
-  const _sanitizeShadowDOM2 = function _sanitizeShadowDOM(fragment) {
-    let shadowNode = null;
-    const shadowIterator = _createNodeIterator(fragment);
-    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
-    while (shadowNode = shadowIterator.nextNode()) {
-      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
-      _sanitizeElements(shadowNode, fragment);
-      _sanitizeAttributes(shadowNode, fragment);
-      if (_isDocumentFragment(shadowNode.content)) _sanitizeShadowDOM2(shadowNode.content);
-      if (_readNodeType(shadowNode) === NODE_TYPE.element) {
-        const innerSr = getShadowRoot(shadowNode);
-        if (_isDocumentFragment(innerSr)) {
-          _sanitizeAttachedShadowRoots(innerSr);
-          _sanitizeShadowDOM2(innerSr);
+  const _sanitizeDisallowedNode = function _sanitizeDisallowedNode2(currentNode, tagName, root) {
+    if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
+    if (KEEP_CONTENT && !FORBID_CONTENTS[tagName] && !FORBID_CONTENTS[stringToLowerCase(tagName)]) {
+      const parentNode = getParentNode(currentNode);
+      const childNodes = getChildNodes(currentNode);
+      if (childNodes && parentNode) {
+        const childCount = childNodes.length;
+        for (let i = childCount - 1; i >= 0; --i) {
+          const hoisted = currentNode === root ? cloneNode(childNodes[i], true) : childNodes[i];
+          parentNode.insertBefore(hoisted, getNextSibling(currentNode));
         }
       }
     }
-    if (SAFE_FOR_TEMPLATES) _scrubOwnCharacterData(fragment);
-    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+    _forceRemove(currentNode);
+    return true;
   };
-  const _sanitizeAttachedShadowRoots = function _sanitizeAttachedShadowRoots2(root) {
-    const stack = [{
-      node: root,
-      shadow: null
-    }];
-    while (stack.length > 0) {
-      const item = stack.pop();
-      if (item.shadow) {
-        _sanitizeShadowDOM2(item.shadow);
-        continue;
-      }
-      const node = item.node;
-      const isElement = _readNodeType(node) === NODE_TYPE.element;
-      const childNodes = getChildNodes(node);
-      if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push({
-        node: childNodes[i],
-        shadow: null
-      });
-      if (isElement) {
-        const rootName = getNodeName ? getNodeName(node) : null;
-        if (typeof rootName === "string" && transformCaseFunc(rootName) === "template") {
-          const content = node.content;
-          if (_isDocumentFragment(content)) stack.push({
-            node: content,
-            shadow: null
-          });
-        }
-      }
-      if (isElement) {
-        const sr = getShadowRoot(node);
-        if (_isDocumentFragment(sr)) stack.push({
-          node: null,
-          shadow: sr
-        }, {
-          node: sr,
-          shadow: null
-        });
-      }
-    }
+  const _forkSharedAllowlist = function _forkSharedAllowlist2(hookList, set, defaultSet, setConfigSet) {
+    if (hookList.length === 0) return set;
+    return set === defaultSet || set === setConfigSet ? clone(set) : set;
   };
-  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)) {
-      dirty = stringifyValue(dirty);
-      if (typeof dirty !== "string") throw typeErrorCreate("dirty is not a string, aborting");
-    }
-    if (!DOMPurify.isSupported) return dirty;
-    if (SET_CONFIG) {
-      ALLOWED_TAGS = SET_CONFIG_ALLOWED_TAGS;
-      ALLOWED_ATTR = SET_CONFIG_ALLOWED_ATTR;
-    } else _parseConfig(cfg);
-    if (hooks.uponSanitizeElement.length > 0 || hooks.uponSanitizeAttribute.length > 0) ALLOWED_TAGS = clone(ALLOWED_TAGS);
-    if (hooks.uponSanitizeAttribute.length > 0) ALLOWED_ATTR = clone(ALLOWED_ATTR);
-    DOMPurify.removed = [];
-    const inPlace = IN_PLACE && typeof dirty !== "string" && _isNode(dirty);
-    let inPlaceNodes = [];
-    const outerVisited = IN_PLACE_VISITED;
-    if (inPlace) {
-      _neutralizePatchLinkage(dirty);
-      const nn = _readNodeName(dirty);
-      if (typeof nn === "string") {
-        const tagName = transformCaseFunc(nn);
-        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
-          _neutralizeRoot(dirty);
-          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
-        }
-      }
-      if (_isClobbered(dirty)) {
-        _neutralizeRoot(dirty);
-        throw typeErrorCreate("root node is clobbered and cannot be sanitized in-place");
-      }
-      inPlaceNodes = _collectLiveNodes(dirty);
-      IN_PLACE_VISITED = setCreate();
-    } else if (_isNode(dirty)) {
-      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);
-      _sanitizeAttachedShadowRoots(body);
-    } else {
-      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(dirty) : dirty;
-      body = _initDocument(dirty);
-      if (!body) return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
+  const _handleHookDetachedNode = function _handleHookDetachedNode2(currentNode, root) {
+    if (currentNode === root || getParentNode(currentNode) !== null) return false;
+    if (IN_PLACE) _neutralizeSubtree(currentNode);
+    return true;
+  };
+  const _sanitizeElements = function _sanitizeElements2(currentNode, root) {
+    _markVisited(currentNode);
+    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+    if (_handleHookDetachedNode(currentNode, root)) return true;
+    if (_isClobbered(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
     }
-    if (body && FORCE_BODY) _forceRemove(body.firstChild);
-    const walkRoot = inPlace ? dirty : body;
-    try {
-      if (inPlace) _sanitizeAttachedShadowRoots(dirty);
-      const nodeIterator = _createNodeIterator(walkRoot);
-      while (currentNode = nodeIterator.nextNode()) {
-        _sanitizeElements(currentNode, walkRoot);
-        _sanitizeAttributes(currentNode, walkRoot);
-        if (_isDocumentFragment(currentNode.content)) _sanitizeShadowDOM2(currentNode.content);
-      }
-      if (inPlace) _sanitizeUnvisitedNodes(dirty, inPlaceNodes);
-    } catch (error2) {
-      if (inPlace) {
-        _neutralizeRoot(dirty);
-        _neutralizeDiscarded(dirty, inPlaceNodes);
+    const tagName = transformCaseFunc(_readNodeName(currentNode));
+    ALLOWED_TAGS = _forkSharedAllowlist(hooks.uponSanitizeElement, ALLOWED_TAGS, DEFAULT_ALLOWED_TAGS, SET_CONFIG_ALLOWED_TAGS);
+    _executeHooks(hooks.uponSanitizeElement, currentNode, {
+      tagName,
+      allowedTags: ALLOWED_TAGS
+    });
+    if (_handleHookDetachedNode(currentNode, root)) return true;
+    if (_isUnsafeNode(currentNode, tagName)) {
+      _forceRemove(currentNode);
+      return true;
+    }
+    if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
+      const removed = _sanitizeDisallowedNode(currentNode, tagName, root);
+      if (removed === false) {
+        _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+        if (_handleHookDetachedNode(currentNode, root)) return true;
       }
-      throw error2;
-    } finally {
-      IN_PLACE_VISITED = outerVisited;
+      return removed;
     }
-    if (inPlace) {
-      if (_neutralizeDiscarded(dirty, inPlaceNodes)) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
-      if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(dirty);
-      return dirty;
+    if (_readNodeType(currentNode) === NODE_TYPE.element && !_checkValidNamespace(currentNode)) {
+      _forceRemove(currentNode);
+      return true;
     }
-    if (RETURN_DOM) {
-      if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(body);
-      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;
+    if ((tagName === "noscript" || tagName === "noembed" || tagName === "noframes") && regExpTest(FALLBACK_TAG_CLOSE, currentNode.innerHTML)) {
+      _forceRemove(currentNode);
+      return true;
     }
-    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) serializedHTML = _stripTemplateExpressions(serializedHTML);
-    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(serializedHTML) : serializedHTML;
-  };
-  DOMPurify.setConfig = function() {
-    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    _parseConfig(cfg);
-    SET_CONFIG = true;
-    SET_CONFIG_ALLOWED_TAGS = ALLOWED_TAGS;
-    SET_CONFIG_ALLOWED_ATTR = ALLOWED_ATTR;
-  };
-  DOMPurify.clearConfig = function() {
-    CONFIG = null;
-    SET_CONFIG = false;
-    SET_CONFIG_ALLOWED_TAGS = null;
-    SET_CONFIG_ALLOWED_ATTR = null;
-    trustedTypesPolicy = defaultTrustedTypesPolicy;
-    emptyHTML = "";
+    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+      const content = _stripTemplateExpressions(currentNode.textContent);
+      if (currentNode.textContent !== content) {
+        arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+        currentNode.textContent = content;
+      }
+    }
+    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+    return _handleHookDetachedNode(currentNode, root);
   };
-  DOMPurify.isValidAttribute = function(tag, attr, value) {
-    if (!CONFIG) _parseConfig({});
-    const lcTag = transformCaseFunc(tag);
-    const lcName = transformCaseFunc(attr);
-    if (typeof value === "string" && (_isUnsafeAttributeValue(attr, value) || !ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value))) return false;
-    return _isValidAttribute(lcTag, lcName, value);
+  const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
+    if (FORBID_ATTR[lcName]) return false;
+    if (_isPatchLinkageAttribute(lcName, lcTag)) return false;
+    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) return false;
+    const nameIsPermitted = ALLOWED_ATTR[lcName] || EXTRA_ELEMENT_HANDLING.attributeCheck instanceof Function && EXTRA_ELEMENT_HANDLING.attributeCheck(lcName, lcTag);
+    if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$1, lcName)) return true;
+    if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) return true;
+    if (!nameIsPermitted) return _isBasicCustomElement(lcTag) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName, lcTag) || lcName === "is" && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value);
+    if (URI_SAFE_ATTRIBUTES[lcName]) return true;
+    if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) return true;
+    if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) return true;
+    if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, ""))) return true;
+    return !value;
   };
-  DOMPurify.addHook = function(entryPoint, hookFunction) {
-    if (typeof hookFunction !== "function") return;
-    if (!objectHasOwnProperty(hooks, entryPoint)) return;
-    arrayPush(hooks[entryPoint], hookFunction);
+  const RESERVED_CUSTOM_ELEMENT_NAMES = addToSet({}, [
+    "annotation-xml",
+    "color-profile",
+    "font-face",
+    "font-face-format",
+    "font-face-name",
+    "font-face-src",
+    "font-face-uri",
+    "missing-glyph"
+  ]);
+  const _isBasicCustomElement = function _isBasicCustomElement2(tagName) {
+    return !RESERVED_CUSTOM_ELEMENT_NAMES[stringToLowerCase(tagName)] && regExpTest(CUSTOM_ELEMENT$1, tagName);
   };
-  DOMPurify.removeHook = function(entryPoint, hookFunction) {
-    if (!objectHasOwnProperty(hooks, entryPoint)) return;
-    if (hookFunction !== void 0) {
-      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
-      return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
+  const _applyTrustedTypesToAttribute = function _applyTrustedTypesToAttribute2(lcTag, lcName, namespaceURI, value) {
+    if (trustedTypesPolicy && typeof trustedTypes === "object" && typeof trustedTypes.getAttributeType === "function" && !namespaceURI) switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+      case "TrustedHTML":
+        return _createTrustedHTML(value);
+      case "TrustedScriptURL":
+        return _createTrustedScriptURL(value);
     }
-    return arrayPop(hooks[entryPoint]);
+    return value;
   };
-  DOMPurify.removeHooks = function(entryPoint) {
-    if (!objectHasOwnProperty(hooks, entryPoint)) return;
-    hooks[entryPoint] = [];
+  const _setAttributeValue = function _setAttributeValue2(currentNode, name, namespaceURI, value) {
+    try {
+      if (namespaceURI) currentNode.setAttributeNS(namespaceURI, name, value);
+      else currentNode.setAttribute(name, value);
+      if (_isClobbered(currentNode)) {
+        _forceRemove(currentNode);
+        return false;
+      }
+      return true;
+    } catch (_) {
+      _removeAttribute(name, currentNode);
+      return false;
+    }
   };
-  DOMPurify.removeAllHooks = function() {
-    hooks = _createHooksMap();
+  const _isUnsafeAttributeValue = function _isUnsafeAttributeValue2(name, value) {
+    if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) return true;
+    return stringToLowerCase(name) === "attributename" && stringMatch(value, "href") !== null;
   };
-  return DOMPurify;
-}
-var purify_default = createDOMPurify();
-
-// webview/preview.ts
-import mermaid from "mermaid";
-
-// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/base.js
-var Diff = class {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return void 0;
-      } else {
-        return value;
-      }
+  const _sanitizeAttributes = function _sanitizeAttributes2(currentNode, root) {
+    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+    if (_handleHookDetachedNode(currentNode, root)) return;
+    const attributes = currentNode.attributes;
+    if (!attributes || _isClobbered(currentNode)) return;
+    ALLOWED_ATTR = _forkSharedAllowlist(hooks.uponSanitizeAttribute, ALLOWED_ATTR, DEFAULT_ALLOWED_ATTR, SET_CONFIG_ALLOWED_ATTR);
+    const hookEvent = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: true,
+      allowedAttributes: ALLOWED_ATTR,
+      forceKeepAttr: void 0
     };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
+    let l = attributes.length;
+    const lcTag = transformCaseFunc(currentNode.nodeName);
+    while (l--) {
+      const attr = attributes[l];
+      const name = attr.name, namespaceURI = attr.namespaceURI, attrValue = attr.value;
+      const lcName = transformCaseFunc(name);
+      const initValue = attrValue;
+      let value = name === "value" ? initValue : stringTrim(initValue);
+      let recreatedNamedProp = false;
+      hookEvent.attrName = lcName;
+      hookEvent.attrValue = value;
+      hookEvent.keepAttr = true;
+      hookEvent.forceKeepAttr = void 0;
+      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+      value = hookEvent.attrValue;
+      if (SANITIZE_NAMED_PROPS && (lcName === "id" || lcName === "name") && stringIndexOf(value, SANITIZE_NAMED_PROPS_PREFIX) !== 0) {
+        _removeAttribute(name, currentNode, attr);
+        value = SANITIZE_NAMED_PROPS_PREFIX + value;
+        recreatedNamedProp = true;
+      }
+      if (_isUnsafeAttributeValue(name, value)) {
+        _removeAttribute(name, currentNode, attr);
+        continue;
+      }
+      if (hookEvent.forceKeepAttr) continue;
+      if (!hookEvent.keepAttr) {
+        _removeAttribute(name, currentNode, attr);
+        continue;
+      }
+      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value)) {
+        _removeAttribute(name, currentNode, attr);
+        continue;
       }
-      editLength++;
-    };
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(void 0);
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
+      if (SAFE_FOR_TEMPLATES) value = _stripTemplateExpressions(value);
+      if (!_isValidAttribute(lcTag, lcName, value)) {
+        _removeAttribute(name, currentNode, attr);
+        continue;
       }
-    }
-  }
-  addToPath(path, added, removed, oldPosInc, options) {
-    const last = path.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      value = _applyTrustedTypesToAttribute(lcTag, lcName, namespaceURI, value);
+      if (value !== initValue) {
+        if (_setAttributeValue(currentNode, name, namespaceURI, value) && recreatedNamedProp) arrayPop(DOMPurify.removed);
       }
     }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
+    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+    _handleHookDetachedNode(currentNode, root);
+  };
+  const _sanitizeShadowDOM2 = function _sanitizeShadowDOM(fragment) {
+    let shadowNode = null;
+    const shadowIterator = _createNodeIterator(fragment);
+    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+    while (shadowNode = shadowIterator.nextNode()) {
+      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+      _sanitizeElements(shadowNode, fragment);
+      _sanitizeAttributes(shadowNode, fragment);
+      if (_isDocumentFragment(shadowNode.content)) _sanitizeShadowDOM2(shadowNode.content);
+      if (_readNodeType(shadowNode) === NODE_TYPE.element) {
+        const innerSr = getShadowRoot(shadowNode);
+        if (_isDocumentFragment(innerSr)) {
+          _sanitizeAttachedShadowRoots(innerSr);
+          _sanitizeShadowDOM2(innerSr);
+        }
       }
     }
-    return ret;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(value, options) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (; componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
+    if (SAFE_FOR_TEMPLATES) _scrubOwnCharacterData(fragment);
+    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+  };
+  const _sanitizeAttachedShadowRoots = function _sanitizeAttachedShadowRoots2(root) {
+    const stack = [{
+      node: root,
+      shadow: null
+    }];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (item.shadow) {
+        _sanitizeShadowDOM2(item.shadow);
+        continue;
+      }
+      const node = item.node;
+      const isElement = _readNodeType(node) === NODE_TYPE.element;
+      const childNodes = getChildNodes(node);
+      if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push({
+        node: childNodes[i],
+        shadow: null
+      });
+      if (isElement) {
+        const rootName = getNodeName ? getNodeName(node) : null;
+        if (typeof rootName === "string" && transformCaseFunc(rootName) === "template") {
+          const content = node.content;
+          if (_isDocumentFragment(content)) stack.push({
+            node: content,
+            shadow: null
           });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
         }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
+      }
+      if (isElement) {
+        const sr = getShadowRoot(node);
+        if (_isDocumentFragment(sr)) stack.push({
+          node: null,
+          shadow: sr
+        }, {
+          node: sr,
+          shadow: null
+        });
       }
     }
-    return components;
-  }
-};
-
-// node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/array.js
-var ArrayDiff = class extends Diff {
-  tokenize(value) {
-    return value.slice();
-  }
-  join(value) {
-    return value;
-  }
-  removeEmpty(value) {
-    return value;
-  }
-};
-var arrayDiff = new ArrayDiff();
-function diffArrays(oldArr, newArr, options) {
-  return arrayDiff.diff(oldArr, newArr, options);
-}
-
-// src/diff/textDiff.ts
-var WORD_RE = /[\p{L}\p{N}_]+|\s+|[^]/gu;
-var UNSPACED_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Thai}]/u;
-function wordSegmenter(lang) {
-  try {
-    return typeof Intl.Segmenter === "function" ? new Intl.Segmenter(lang, { granularity: "word" }) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function splitWords(text3, segmenter2) {
-  const words2 = [];
-  for (const [word] of text3.matchAll(WORD_RE)) {
-    if (word.length > 1 && UNSPACED_RE.test(word)) {
-      if (segmenter2) {
-        for (const { segment } of segmenter2.segment(word)) {
-          words2.push(segment);
+  };
+  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)) {
+      dirty = stringifyValue(dirty);
+      if (typeof dirty !== "string") throw typeErrorCreate("dirty is not a string, aborting");
+    }
+    if (!DOMPurify.isSupported) return dirty;
+    if (SET_CONFIG) {
+      ALLOWED_TAGS = SET_CONFIG_ALLOWED_TAGS;
+      ALLOWED_ATTR = SET_CONFIG_ALLOWED_ATTR;
+    } else _parseConfig(cfg);
+    if (hooks.uponSanitizeElement.length > 0 || hooks.uponSanitizeAttribute.length > 0) ALLOWED_TAGS = clone(ALLOWED_TAGS);
+    if (hooks.uponSanitizeAttribute.length > 0) ALLOWED_ATTR = clone(ALLOWED_ATTR);
+    DOMPurify.removed = [];
+    const inPlace = IN_PLACE && typeof dirty !== "string" && _isNode(dirty);
+    let inPlaceNodes = [];
+    const outerVisited = IN_PLACE_VISITED;
+    if (inPlace) {
+      _neutralizePatchLinkage(dirty);
+      const nn = _readNodeName(dirty);
+      if (typeof nn === "string") {
+        const tagName = transformCaseFunc(nn);
+        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+          _neutralizeRoot(dirty);
+          throw typeErrorCreate("root node is forbidden and cannot be sanitized in-place");
         }
-      } else {
-        words2.push(...word);
       }
+      if (_isClobbered(dirty)) {
+        _neutralizeRoot(dirty);
+        throw typeErrorCreate("root node is clobbered and cannot be sanitized in-place");
+      }
+      inPlaceNodes = _collectLiveNodes(dirty);
+      IN_PLACE_VISITED = setCreate();
+    } else if (_isNode(dirty)) {
+      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);
+      _sanitizeAttachedShadowRoots(body);
     } else {
-      words2.push(word);
+      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(dirty) : dirty;
+      body = _initDocument(dirty);
+      if (!body) return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : "";
     }
-  }
-  return words2;
-}
-var MAX_EDIT_LENGTH = 2e3;
-function diffWordLists(before, after) {
-  return diffArrays(before, after, { maxEditLength: MAX_EDIT_LENGTH })?.map((change) => ({
-    type: change.added ? "added" : change.removed ? "removed" : "equal",
-    tokens: change.value
-  }));
-}
-function groupChanges(changes) {
-  const grouped = [];
-  let removed = [];
-  let added = [];
-  const flush = () => {
-    if (removed.length > 0) {
-      grouped.push({ type: "removed", tokens: removed });
+    if (body && FORCE_BODY) _forceRemove(body.firstChild);
+    const walkRoot = inPlace ? dirty : body;
+    try {
+      if (inPlace) _sanitizeAttachedShadowRoots(dirty);
+      const nodeIterator = _createNodeIterator(walkRoot);
+      while (currentNode = nodeIterator.nextNode()) {
+        _sanitizeElements(currentNode, walkRoot);
+        _sanitizeAttributes(currentNode, walkRoot);
+        if (_isDocumentFragment(currentNode.content)) _sanitizeShadowDOM2(currentNode.content);
+      }
+      if (inPlace) _sanitizeUnvisitedNodes(dirty, inPlaceNodes);
+    } catch (error2) {
+      if (inPlace) {
+        _neutralizeRoot(dirty);
+        _neutralizeDiscarded(dirty, inPlaceNodes);
+      }
+      throw error2;
+    } finally {
+      IN_PLACE_VISITED = outerVisited;
     }
-    if (added.length > 0) {
-      grouped.push({ type: "added", tokens: added });
+    if (inPlace) {
+      if (_neutralizeDiscarded(dirty, inPlaceNodes)) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
+      if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(dirty);
+      return dirty;
     }
-    removed = [];
-    added = [];
+    if (RETURN_DOM) {
+      if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(body);
+      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) serializedHTML = _stripTemplateExpressions(serializedHTML);
+    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? _createTrustedHTML(serializedHTML) : serializedHTML;
   };
-  changes.forEach((change, i) => {
-    if (change.type === "removed") {
-      removed.push(...change.tokens);
-    } else if (change.type === "added") {
-      added.push(...change.tokens);
-    } else if ((removed.length > 0 || added.length > 0) && i + 1 < changes.length && change.tokens.join("").trim().length <= 1) {
-      removed.push(...change.tokens);
-      added.push(...change.tokens);
-    } else {
-      flush();
-      grouped.push(change);
+  DOMPurify.setConfig = function() {
+    let cfg = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _parseConfig(cfg);
+    SET_CONFIG = true;
+    SET_CONFIG_ALLOWED_TAGS = ALLOWED_TAGS;
+    SET_CONFIG_ALLOWED_ATTR = ALLOWED_ATTR;
+  };
+  DOMPurify.clearConfig = function() {
+    CONFIG = null;
+    SET_CONFIG = false;
+    SET_CONFIG_ALLOWED_TAGS = null;
+    SET_CONFIG_ALLOWED_ATTR = null;
+    trustedTypesPolicy = defaultTrustedTypesPolicy;
+    emptyHTML = "";
+  };
+  DOMPurify.isValidAttribute = function(tag, attr, value) {
+    if (!CONFIG) _parseConfig({});
+    const lcTag = transformCaseFunc(tag);
+    const lcName = transformCaseFunc(attr);
+    if (typeof value === "string" && (_isUnsafeAttributeValue(attr, value) || !ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value))) return false;
+    return _isValidAttribute(lcTag, lcName, value);
+  };
+  DOMPurify.addHook = function(entryPoint, hookFunction) {
+    if (typeof hookFunction !== "function") return;
+    if (!objectHasOwnProperty(hooks, entryPoint)) return;
+    arrayPush(hooks[entryPoint], hookFunction);
+  };
+  DOMPurify.removeHook = function(entryPoint, hookFunction) {
+    if (!objectHasOwnProperty(hooks, entryPoint)) return;
+    if (hookFunction !== void 0) {
+      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index === -1 ? void 0 : arraySplice(hooks[entryPoint], index, 1)[0];
     }
-  });
-  flush();
-  return grouped;
+    return arrayPop(hooks[entryPoint]);
+  };
+  DOMPurify.removeHooks = function(entryPoint) {
+    if (!objectHasOwnProperty(hooks, entryPoint)) return;
+    hooks[entryPoint] = [];
+  };
+  DOMPurify.removeAllHooks = function() {
+    hooks = _createHooksMap();
+  };
+  return DOMPurify;
 }
+var purify_default = createDOMPurify();
+
+// webview/preview.ts
+import mermaid from "mermaid";
 
 // webview/diff.ts
 var segmenter;
@@ -24927,7 +25287,12 @@ function setupDiffBar(root, action, { container, titles, scroll }) {
     clearTimeout(focusTimer);
     focusTimer = setTimeout(() => target.classList.remove("seqnotes-diff-focus"), FOCUS_MS);
   }
+  function setLabel(text3) {
+    label.textContent = text3;
+    label.title = text3;
+  }
   return {
+    setLabel,
     show(diff) {
       bar.hidden = !diff;
       current = void 0;
@@ -24935,8 +25300,7 @@ function setupDiffBar(root, action, { container, titles, scroll }) {
       if (!diff) {
         return;
       }
-      label.textContent = diff.label;
-      label.title = diff.label;
+      setLabel(diff.label);
       const { added, changed, deleted } = diff.stats;
       const items = [
         ["added", added, titles.seqnotesDiffAdded],
@@ -26673,7 +27037,7 @@ ${source}`;
       }
     });
     setUpWarnings();
-    diffBar.show(diff);
+    diffBar.show(lastDiff);
     layoutWireframes(root);
     addZoomButtons();
     markZoomableImages();
@@ -27313,32 +27677,15 @@ ${source}`;
     el.classList.remove("seqnotes-wide", "seqnotes-limit-width", "seqnotes-sticky-table-header", "seqnotes-table-tree-highlight");
     el.style.removeProperty("--seqnotes-split");
   }
-  return { handle, destroy };
+  function relabelDiff(label) {
+    if (lastDiff) {
+      lastDiff = { ...lastDiff, label };
+      diffBar.setLabel(label);
+    }
+  }
+  return { handle, destroy, relabelDiff };
 }
 
-// src/shared/protocol.ts
-var WEBVIEW_TITLES = {
-  "splitter-title": "Drag to resize, double-click to reset",
-  "hide-warnings-title": "Hide warnings",
-  "toc-title": "Contents",
-  "zoom-title": "Zoom diagram",
-  "zoom-image-title": "Zoom image",
-  "zoom-in-title": "Zoom in",
-  "zoom-out-title": "Zoom out",
-  "zoom-fit-title": "Fit to window",
-  "zoom-close-title": "Close",
-  "diff-added": "{0} added",
-  "diff-changed": "{0} changed",
-  "diff-deleted": "{0} deleted",
-  "diff-no-changes": "No changes",
-  "diff-previous-title": "Previous change",
-  "diff-next-title": "Next change",
-  "diff-close-title": "Stop comparing",
-  "diff-hide-title": "Hide changes",
-  "diff-show-title": "Show changes",
-  "diff-old-diagram": "Diagram before the change"
-};
-
 // webview/viewerContext.ts
 function elementScrollHost(scroller) {
   const host = {
@@ -27395,6 +27742,110 @@ function writeTitles(el, t) {
   }
 }
 
+// src/export/exportIndex.ts
+function documentInfo(md2, source, fallback, frontMatter2 = true) {
+  const tokens = md2.parse(source, {});
+  const entries2 = frontMatterEntries(tokens);
+  const meta = {};
+  for (const { key } of frontMatter2 ? DESIGN_DOC_META : []) {
+    const value = frontMatterValue(entries2, key)?.trim();
+    if (value !== void 0) {
+      meta[key] = value;
+    }
+  }
+  return { title: titleOf(tokens, fallback), meta, designDoc: isDesignDoc(entries2) };
+}
+function compareFolders(a, b) {
+  const as = a === "" ? [] : a.split("/");
+  const bs = b === "" ? [] : b.split("/");
+  for (let i = 0; i < Math.min(as.length, bs.length); i++) {
+    const order = as[i].localeCompare(bs[i]);
+    if (order !== 0) {
+      return order;
+    }
+  }
+  return as.length - bs.length;
+}
+var NO_DESIGN_DOCS = "There are no design docs (Markdown files with type: design_doc in their front matter).";
+function changesCell(changes, t) {
+  const { added, changed, deleted } = changes.stats;
+  const total = added + changed + deleted;
+  let content;
+  if (changes.isNew) {
+    content = `<span class="seqnotes-index-new">${escapeHtml2(t("New"))}</span>`;
+  } else if (total === 0) {
+    content = `<span class="seqnotes-index-unchanged">${escapeHtml2(t("No changes"))}</span>`;
+  } else {
+    const counts = [
+      ["added", added, "{0} added"],
+      ["changed", changed, "{0} changed"],
+      ["deleted", deleted, "{0} deleted"]
+    ];
+    content = '<span class="seqnotes-diff-counts">' + counts.filter(([, count]) => count > 0).map(([kind, count, text3]) => `<span class="seqnotes-diff-count" data-kind="${kind}">${escapeHtml2(t(text3, count))}</span>`).join("") + "</span>";
+  }
+  return `<td class="seqnotes-index-changes" data-seqnotes-sort="${changes.isNew ? Number.MAX_SAFE_INTEGER : total}">${content}</td>`;
+}
+function groupByFolder(entries2, keepOrder = false) {
+  const unique = [...new Set(entries2.map((entry) => entry.folder))];
+  const folders = keepOrder ? unique : unique.sort(compareFolders);
+  return folders.map((folder) => {
+    const rows = entries2.filter((entry) => entry.folder === folder);
+    return { folder, entries: keepOrder ? rows : rows.sort((a, b) => a.file.localeCompare(b.file)) };
+  });
+}
+function indexBody(title, entries2, t, { empty = "", fileLabel, filterPlaceholder, keepOrder = false } = {}) {
+  const columns = DESIGN_DOC_META.filter(({ key }) => entries2.some((entry) => key in entry.meta));
+  const changes = entries2.some((entry) => entry.changes !== void 0);
+  const headers = [
+    { key: "title", label: t("Title") },
+    { key: "file", label: fileLabel ?? t("File") },
+    ...columns.map(({ key, label }) => ({ key, label: t(label) })),
+    ...changes ? [{ key: "changes", label: t("Changes") }] : []
+  ];
+  const head = "<thead><tr>" + headers.map(({ key, label }) => `<th data-seqnotes-column="${key}">${escapeHtml2(label)}</th>`).join("") + "</tr></thead>\n";
+  const row = (entry) => `<tr><td class="seqnotes-index-title"><a href="${escapeHtml2(entry.href)}">${escapeHtml2(entry.title)}</a></td><td class="seqnotes-index-file">${escapeHtml2(entry.file)}</td>` + columns.map(({ key }) => {
+    const value = entry.meta[key];
+    return `<td class="seqnotes-index-${key}">${value === void 0 ? "" : `<span>${escapeHtml2(value)}</span>`}</td>`;
+  }).join("") + (!changes ? "" : entry.changes ? changesCell(entry.changes, t) : '<td class="seqnotes-index-changes"></td>') + "</tr>\n";
+  const tables = groupByFolder(entries2, keepOrder).map(
+    ({ folder, entries: rows }) => (folder === "" ? "" : `<h2>${escapeHtml2(folder)}/</h2>
+`) + `<table>
+${head}<tbody>
+${rows.map(row).join("")}</tbody>
+</table>
+`
+  );
+  const texts = {
+    "filter-label": t("Filter"),
+    "filter-placeholder": filterPlaceholder ?? t("Filter by title, file name or metadata"),
+    // `{0}` documents shown of `{1}`, filled in by the script.
+    count: t("{0} of {1} documents"),
+    "no-match": t("No documents match the filter."),
+    "sort-title": t("Sort by this column")
+  };
+  const attrs = Object.entries(texts).map(([key, text3]) => ` data-seqnotes-${key}="${escapeHtml2(text3)}"`).join("");
+  const body = entries2.length === 0 ? `<p class="seqnotes-index-empty">${escapeHtml2(empty)}</p>
+` : tables.join("");
+  return `<div class="seqnotes-index"${attrs}>
+<h1>${escapeHtml2(title)}</h1>
+${body}</div>`;
+}
+
+// embed/designDocList.ts
+function designDocListHtml(md2, content, t) {
+  const entries2 = content.documents.map((doc) => {
+    const file = doc.file ?? "";
+    const info = documentInfo(md2, doc.markdown, file || doc.href);
+    return { title: doc.title ?? info.title, meta: info.meta, href: doc.href, folder: doc.folder ?? "", file };
+  });
+  return indexBody(content.title ?? t("Design Docs"), entries2, t, {
+    empty: content.empty ?? t(NO_DESIGN_DOCS),
+    fileLabel: content.fileLabel,
+    filterPlaceholder: content.filterPlaceholder,
+    keepOrder: content.keepOrder
+  });
+}
+
 // embed/viewer.ts
 function openLinkInNewTab(href) {
   if (/^(?:https?|mailto):/i.test(href)) {
@@ -27403,6 +27854,12 @@ function openLinkInNewTab(href) {
 }
 var md = createMarkdown();
 var viewers = 0;
+function langOf(lang) {
+  return lang ?? (navigator.language.toLowerCase().startsWith("ja") ? "ja" : "en");
+}
+function translator(lang) {
+  return lang === "ja" ? translatorFor(bundle_l10n_ja_default) : formatMessage;
+}
 function resolveUrl(path, baseUrl) {
   try {
     return new URL(path, baseUrl).href;
@@ -27424,14 +27881,28 @@ function fetchFrom(baseUrl) {
     }
   };
 }
-var CONTENT_OPTIONS = ["markdown", "baseUrl", "readFile", "resolveResource", "frontMatter", "headingNumbers", "messageWrapWidth"];
+async function readWireframes(markdown, { readFile, baseUrl }) {
+  const read = readFile ?? (baseUrl === void 0 ? void 0 : fetchFrom(baseUrl));
+  if (!read) {
+    return void 0;
+  }
+  return loadWireframes(md, wireframeSources(md.parse(markdown, {})), (path) => Promise.resolve().then(() => read(path)).catch(() => void 0));
+}
+function viewerContent(markdown, env, compareWith, compareLabel) {
+  if (compareWith === void 0) {
+    return { html: renderDocument(md, markdown, env) };
+  }
+  const result = renderDiff(md, compareWith, markdown, env);
+  return { html: result.html, diff: diffView(result, compareLabel) };
+}
+function diffView({ old, stats }, compareLabel) {
+  return { label: compareLabel ?? "", old, stats };
+}
+var CONTENT_OPTIONS = ["markdown", "baseUrl", "readFile", "resolveResource", "frontMatter", "headingNumbers", "messageWrapWidth", "compareWith"];
 var VIEW_OPTIONS = ["documentId", "splitMinWidth", "toc", "diagramLook", "limitContentWidth", "stickyTableHeader", "tableTreeHighlight"];
-function createViewer(container, options) {
-  let current = { ...options };
-  const lang = options.lang ?? (navigator.language.toLowerCase().startsWith("ja") ? "ja" : "en");
-  const t = lang === "ja" ? translatorFor(bundle_l10n_ja_default) : formatMessage;
+function mountViewer(container, lang, t, options, className = "") {
   const el = document.createElement("div");
-  el.className = "seqnotes-viewer seqnotes-embedded";
+  el.className = `seqnotes-viewer seqnotes-embedded ${className}`.trim();
   el.lang = lang;
   el.dataset.seqnotesTheme = "auto";
   writeTitles(el, t);
@@ -27450,9 +27921,11 @@ function createViewer(container, options) {
   let state;
   const post = (message) => {
     if (message.type === "openLink") {
-      (current.onOpenLink ?? openLinkInNewTab)(message.href);
+      (options().onOpenLink ?? openLinkInNewTab)(message.href);
     } else if (message.type === "revealLine") {
-      current.onRevealLine?.(message.line);
+      options().onRevealLine?.(message.line);
+    } else if (message.type === "closeDiff") {
+      options().onCloseDiff?.();
     }
   };
   const preview = createPreview({
@@ -27466,21 +27939,51 @@ function createViewer(container, options) {
   });
   const systemDark = window.matchMedia("(prefers-color-scheme: dark)");
   const applyTheme = () => {
-    const dark = current.theme === "dark" || current.theme !== "light" && systemDark.matches;
+    const { theme } = options();
+    const dark = theme === "dark" || theme !== "light" && systemDark.matches;
     el.classList.toggle("vscode-dark", dark);
     el.classList.toggle("vscode-light", !dark);
   };
   systemDark.addEventListener("change", applyTheme);
   applyTheme();
+  return {
+    preview,
+    applyTheme,
+    destroy() {
+      preview.destroy();
+      systemDark.removeEventListener("change", applyTheme);
+      stopSizing();
+      el.remove();
+    }
+  };
+}
+function createViewer(container, options) {
+  let current = { ...options };
+  const lang = langOf(options.lang);
+  const t = translator(lang);
   let destroyed = false;
   let resolveReady;
   const ready = new Promise((resolve) => resolveReady = resolve);
   let html2;
+  let diff;
+  let wireframesRead;
   let rendering = Promise.resolve();
   let pending = false;
   let renders = 0;
   let shown = 0;
-  async function show(rendered) {
+  let dismissed;
+  const closeDiff = () => {
+    if (current.onCloseDiff) {
+      current.onCloseDiff();
+    } else if (!destroyed && current.compareWith !== void 0 && current.compareWith !== dismissed) {
+      dismissed = current.compareWith;
+      if (!pending) {
+        rendering = render(true);
+      }
+    }
+  };
+  const { preview, applyTheme, destroy: unmount } = mountViewer(container, lang, t, () => ({ ...current, onCloseDiff: closeDiff }));
+  async function show(rendered, differences) {
     const seq = ++shown;
     await preview.handle({
       type: "update",
@@ -27494,26 +27997,32 @@ function createViewer(container, options) {
       theme: "auto",
       limitContentWidth: current.limitContentWidth ?? true,
       stickyTableHeader: current.stickyTableHeader ?? true,
-      tableTreeHighlight: current.tableTreeHighlight ?? true
+      tableTreeHighlight: current.tableTreeHighlight ?? true,
+      ...differences ? { diff: differences } : {}
     });
     if (seq === shown) {
       resolveReady();
     }
   }
-  async function render() {
+  async function render(sameWireframes = false) {
     const seq = ++renders;
     pending = true;
     const { markdown, baseUrl } = current;
-    const read = current.readFile ?? (baseUrl === void 0 ? void 0 : fetchFrom(baseUrl));
     const resolveResource = current.resolveResource ?? (baseUrl === void 0 ? void 0 : (src) => resolveUrl(src, baseUrl) ?? src);
-    const readFile = read && ((path) => Promise.resolve().then(() => read(path)).catch(() => void 0));
-    const wireframes2 = readFile ? await loadWireframes(md, wireframeSources(md.parse(markdown, {})), readFile) : void 0;
+    const wireframes2 = sameWireframes && wireframesRead ? wireframesRead.files : await readWireframes(markdown, current);
     if (destroyed || seq !== renders) {
       return;
     }
     pending = false;
-    html2 = renderDocument(md, markdown, { t, frontMatter: current.frontMatter, headingNumbers: current.headingNumbers, messageWrapWidth: current.messageWrapWidth, wireframes: wireframes2, resolveResource });
-    await show(html2);
+    wireframesRead = { files: wireframes2 };
+    const compareWith = current.compareWith === dismissed ? void 0 : current.compareWith;
+    ({ html: html2, diff } = viewerContent(
+      markdown,
+      { t, frontMatter: current.frontMatter, headingNumbers: current.headingNumbers, messageWrapWidth: current.messageWrapWidth, wireframes: wireframes2, resolveResource },
+      compareWith,
+      current.compareLabel
+    ));
+    await show(html2, diff);
   }
   rendering = render();
   return {
@@ -27525,6 +28034,9 @@ function createViewer(container, options) {
       const previous = current;
       current = { ...current, ...changes, lang: current.lang };
       applyTheme();
+      if (current.compareWith !== previous.compareWith) {
+        dismissed = void 0;
+      }
       if (html2 === void 0 || CONTENT_OPTIONS.some((name) => current[name] !== previous[name])) {
         rendering = render();
         return rendering;
@@ -27532,9 +28044,13 @@ function createViewer(container, options) {
       if (pending) {
         return rendering;
       }
+      if (diff !== void 0 && current.compareLabel !== previous.compareLabel) {
+        diff = diffView(diff, current.compareLabel);
+        preview.relabelDiff(diff.label);
+      }
       const revealing = (options2) => options2.onRevealLine !== void 0;
       if (VIEW_OPTIONS.some((name) => current[name] !== previous[name]) || revealing(current) !== revealing(previous)) {
-        return show(html2);
+        return show(html2, diff);
       }
       return Promise.resolve();
     },
@@ -27549,17 +28065,174 @@ function createViewer(container, options) {
         return;
       }
       destroyed = true;
-      preview.destroy();
-      systemDark.removeEventListener("change", applyTheme);
-      stopSizing();
-      el.remove();
+      unmount();
+      resolveReady();
+    }
+  };
+}
+var LIST_URI = "seqnotes-design-doc-list";
+var LIST_CONTENT_OPTIONS = ["documents", "title", "fileLabel", "filterPlaceholder", "empty", "keepOrder"];
+var SCRIPT_SCHEMES = /* @__PURE__ */ new Set(["javascript:", "data:", "vbscript:"]);
+function openLinkInPage(href) {
+  let url;
+  try {
+    url = new URL(href, document.baseURI);
+  } catch {
+    return;
+  }
+  if (!SCRIPT_SCHEMES.has(url.protocol)) {
+    window.location.assign(url.href);
+  }
+}
+function createDesignDocList(container, options) {
+  let current = { ...options };
+  const lang = langOf(options.lang);
+  const t = translator(lang);
+  const { preview, applyTheme, destroy: unmount } = mountViewer(
+    container,
+    lang,
+    t,
+    () => ({ ...current, onOpenLink: current.onOpenLink ?? openLinkInPage }),
+    "seqnotes-embedded-list"
+  );
+  let destroyed = false;
+  let resolveReady;
+  const ready = new Promise((resolve) => resolveReady = resolve);
+  let html2 = designDocListHtml(md, current, t);
+  let shown = 0;
+  async function show() {
+    if (destroyed) {
+      return;
+    }
+    const seq = ++shown;
+    await preview.handle({
+      type: "update",
+      uri: LIST_URI,
+      html: html2,
+      splitMinWidth: 1e3,
+      syncEditor: false,
+      toc: false,
+      diagramLook: "neo",
+      theme: "auto",
+      limitContentWidth: current.limitContentWidth ?? true,
+      stickyTableHeader: false,
+      tableTreeHighlight: false
+    });
+    if (seq === shown) {
+      resolveReady();
+    }
+  }
+  void show();
+  return {
+    ready,
+    update(changes) {
+      if (destroyed) {
+        return Promise.resolve();
+      }
+      const previous = current;
+      current = { ...current, ...changes, lang: current.lang };
+      applyTheme();
+      if (LIST_CONTENT_OPTIONS.some((name) => current[name] !== previous[name])) {
+        html2 = designDocListHtml(md, current, t);
+      }
+      return show();
+    },
+    destroy() {
+      if (destroyed) {
+        return;
+      }
+      destroyed = true;
+      unmount();
       resolveReady();
     }
   };
 }
+var exportCount = 0;
+async function renderExportBody(html2, t, diagramLook, diff) {
+  const el = document.createElement("div");
+  el.className = "seqnotes-viewer seqnotes-embedded vscode-light";
+  el.dataset.seqnotesTheme = "light";
+  el.setAttribute("aria-hidden", "true");
+  el.style.cssText = "position: fixed; top: 0; left: 0; width: 0; height: 0; overflow: hidden; visibility: hidden; pointer-events: none;";
+  writeTitles(el, t);
+  const root = document.createElement("div");
+  root.className = "seqnotes-viewer-root";
+  el.append(root);
+  document.body.append(el);
+  let state;
+  let preview;
+  try {
+    const exported = new Promise((resolve) => {
+      preview = createPreview({
+        el,
+        root,
+        scroll: elementScrollHost(root),
+        idPrefix: `seqnotes-export-${++exportCount}`,
+        post: (message) => message.type === "exported" && resolve(message),
+        getState: () => state,
+        setState: (next) => state = next
+      });
+    });
+    await preview.handle({ type: "export", id: 1, html: html2, diagramLook, ...diff ? { diff } : {} });
+    const { body, error: error2 } = await exported;
+    if (body === void 0) {
+      throw new Error(error2 ?? "The diagrams could not be rendered.");
+    }
+    return body;
+  } finally {
+    preview?.destroy();
+    el.remove();
+  }
+}
+async function exportDocument(options, assets) {
+  const lang = langOf(options.lang);
+  const t = translator(lang);
+  const { markdown, baseUrl } = options;
+  const wireframes2 = await readWireframes(markdown, options);
+  const resolveImage = options.resolveImage ?? ((path) => baseUrl === void 0 ? path : resolveUrl(path, baseUrl) ?? path);
+  const image2 = (src) => {
+    const [path] = src.split(/[?#]/, 1);
+    return Promise.resolve().then(() => resolveImage(path)).then(
+      (url) => typeof url === "string" ? url : path,
+      () => path
+    );
+  };
+  const env = { t, frontMatter: options.frontMatter, headingNumbers: options.headingNumbers, messageWrapWidth: options.messageWrapWidth, wireframes: wireframes2 };
+  let html2;
+  let diff;
+  if (options.compareWith !== void 0) {
+    const result = await renderDiffForExport(md, options.compareWith, markdown, env, image2);
+    html2 = result.html;
+    diff = diffView(result, options.compareLabel);
+  } else {
+    html2 = await renderForExport(md, markdown, env, image2);
+  }
+  const body = await renderExportBody(html2, t, options.diagramLook ?? "neo", diff);
+  return exportPage({
+    lang,
+    title: documentTitle(md, markdown, options.title ?? ""),
+    body,
+    styles: assets.styles,
+    script: assets.script,
+    settings: {
+      limitContentWidth: options.limitContentWidth ?? true,
+      stickyTableHeader: options.stickyTableHeader ?? true,
+      tableTreeHighlight: options.tableTreeHighlight ?? true,
+      splitMinWidth: options.splitMinWidth ?? 1e3,
+      toc: options.toc ?? true
+    },
+    tocTitle: t(WEBVIEW_TITLES["toc-title"]),
+    splitterTitle: t(WEBVIEW_TITLES["splitter-title"]),
+    ...diff ? { diff: exportDiff(diff, t) } : {}
+  });
+}
 export {
+  createDesignDocList,
   createViewer,
-  openLinkInNewTab
+  exportDocument,
+  openLinkInNewTab,
+  openLinkInPage,
+  viewerContent
 };
 /*! Bundled license information: