@ai-react-markdown/engine 2.3.0

package/dist/index.dev.cjs

@@ -0,0 +1,4150 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_PAYLOAD: () => DEFAULT_PAYLOAD,
+  DEF_LINE_START_RE: () => DEF_LINE_START_RE,
+  PIPELINE_STAGES: () => PIPELINE_STAGES,
+  SENTINEL_FN_CONTENT: () => SENTINEL_FN_CONTENT,
+  SENTINEL_LINK_URL: () => SENTINEL_LINK_URL,
+  SMOOTH_STREAM_PACING_PRESETS: () => SMOOTH_STREAM_PACING_PRESETS,
+  STAGE_MEASURE_PREFIX: () => STAGE_MEASURE_PREFIX,
+  advanceIncrementalParse: () => advanceIncrementalParse,
+  attributeHastChildren: () => attributeHastChildren,
+  buildCoreRehypePlugins: () => buildCoreRehypePlugins,
+  buildCoreRemarkPlugins: () => buildCoreRemarkPlugins,
+  buildCoreRemarkRehypeOptions: () => buildCoreRemarkRehypeOptions,
+  buildCrossChunkHandlers: () => buildCrossChunkHandlers,
+  buildPhantomSuffix: () => buildPhantomSuffix,
+  buildTransform: () => buildTransform,
+  codePointSnapshots: () => codePointSnapshots,
+  collectDefLabels: () => collectDefLabels,
+  computeFreezeBoundary: () => computeFreezeBoundary,
+  createDefLabelScanner: () => createDefLabelScanner,
+  createFile: () => createFile,
+  createIncrementalLatexPreprocessor: () => createIncrementalLatexPreprocessor,
+  createProcessor: () => createProcessor,
+  createRegistry: () => createRegistry,
+  createRemendPreprocessor: () => createRemendPreprocessor,
+  createSmoothStreamController: () => createSmoothStreamController,
+  defaultEnginePlugins: () => defaultEnginePlugins,
+  defaultUrlTransform: () => defaultUrlTransform,
+  definitionList: () => definitionList,
+  extendSanitizeSchema: () => extendSanitizeSchema,
+  extractContributions: () => extractContributions,
+  extractDefBodiesFromHast: () => extractDefBodiesFromHast,
+  getEnginePluginInternals: () => getEnginePluginInternals,
+  highlight: () => highlight,
+  isFootnoteSection: () => isFootnoteSection,
+  lastRegionStart: () => lastRegionStart,
+  measureStage: () => measureStage,
+  mergeClassNameAllowlist: () => mergeClassNameAllowlist,
+  normalizeForMatch: () => normalizeForMatch,
+  normalizeId: () => normalizeId,
+  pangu: () => pangu,
+  parseStage: () => parseStage,
+  preprocessAIMDContent: () => preprocessAIMDContent,
+  preprocessLaTeX: () => preprocessLaTeX,
+  rehypeFooterAdorn: () => rehypeFooterAdorn,
+  rehypeRebaseHashLinks: () => rehypeRebaseHashLinks_default,
+  removeComments: () => removeComments,
+  sanitizeCrossChunkUrl: () => sanitizeCrossChunkUrl,
+  sanitizeSchema: () => sanitizeSchema,
+  shortenDocumentId: () => shortenDocumentId,
+  smartypants: () => smartypants,
+  sourceIdFromFootnoteLiId: () => sourceIdFromFootnoteLiId,
+  splitByProtectedRegions: () => splitByProtectedRegions,
+  subscribeStageTimings: () => subscribeStageTimings,
+  transformStage: () => transformStage,
+  withDefs: () => withDefs
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/fixtures/scenarios.ts
+var DEFAULT_BLOCKS = [
+  "# Stress payload\n\n",
+  "Streaming markdown with mixed token boundaries \u2014 code, math, tables, admonitions \u2014 all incomplete during transit.\n\n",
+  "```ts\nconst fib = (n: number): number => (n < 2 ? n : fib(n - 1) + fib(n - 2));\nconst result = Array.from({ length: 12 }, (_, i) => fib(i));\n```\n\n",
+  "$$\n\\int_0^\\infty e^{-x^2}\\,dx = \\frac{\\sqrt{\\pi}}{2}\n$$\n\n",
+  "Inline math like $E = mc^2$ and $\\frac{a}{b}$ keeps appearing.\n\n",
+  "| Lang | Year | Stable |\n| --- | --- | --- |\n| JavaScript | 1995 | yes |\n| TypeScript | 2012 | yes |\n| Rust | 2010 | yes |\n\n",
+  "> The hard part is **incomplete tokens** \u2014 code fences, LaTeX delimiters, table rows mid-emission.\n\n",
+  "- bullet one with `inline code`\n- bullet two with [link](https://example.com)\n- bullet three closes the test payload.\n"
+];
+var DEFAULT_PAYLOAD = DEFAULT_BLOCKS.join("");
+var DEFS_TAIL = 'References[^n1] appear mid-prose[^n2], along with [reference links][spec] and [another one][gfm].\n\n[^n1]: First footnote body with `code` and a [link](https://example.com/fn).\n[^n2]: Second footnote body, plain text.\n\n[spec]: https://spec.commonmark.org\n[gfm]: https://github.github.com/gfm/ "GFM spec"\n';
+function withDefs(payload) {
+  const sep = payload.endsWith("\n\n") ? "" : payload.endsWith("\n") ? "\n" : "\n\n";
+  return payload + sep + DEFS_TAIL;
+}
+
+// src/components/markdown/processor.ts
+var import_devlop = require("devlop");
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+var import_remark_rehype = __toESM(require("remark-rehype"), 1);
+var import_unified = require("unified");
+var import_vfile = require("vfile");
+var emptyPlugins = [];
+var emptyRemarkRehypeOptions = { allowDangerousHtml: true };
+function createProcessor(options) {
+  const rehypePlugins = options.rehypePlugins || emptyPlugins;
+  const remarkPlugins = options.remarkPlugins || emptyPlugins;
+  const remarkRehypeOptions = options.remarkRehypeOptions ? { ...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions } : emptyRemarkRehypeOptions;
+  return (0, import_unified.unified)().use(import_remark_parse.default).use(remarkPlugins).use(import_remark_rehype.default, remarkRehypeOptions).use(rehypePlugins);
+}
+function createFile(options) {
+  const children = options.children || "";
+  const file = new import_vfile.VFile();
+  if (typeof children === "string") {
+    file.value = children;
+  } else {
+    (0, import_devlop.unreachable)("Unexpected value `" + String(children) + "` for `children` prop, expected `string`");
+  }
+  return file;
+}
+
+// src/components/markdown/stages.ts
+var import_devlop2 = require("devlop");
+var changelog = "https://github.com/remarkjs/react-markdown/blob/main/changelog.md";
+var deprecations = [
+  { from: "astPlugins", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "allowDangerousHtml", id: "remove-buggy-html-in-markdown-parser" },
+  {
+    from: "allowNode",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowElement"
+  },
+  {
+    from: "allowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowedElements"
+  },
+  { from: "className", id: "remove-classname" },
+  {
+    from: "disallowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "disallowedElements"
+  },
+  { from: "escapeHtml", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "includeElementIndex", id: "#remove-includeelementindex" },
+  {
+    from: "includeNodeIndex",
+    id: "change-includenodeindex-to-includeelementindex"
+  },
+  { from: "linkTarget", id: "remove-linktarget" },
+  { from: "plugins", id: "change-plugins-to-remarkplugins", to: "remarkPlugins" },
+  { from: "rawSourcePos", id: "#remove-rawsourcepos" },
+  { from: "renderers", id: "change-renderers-to-components", to: "components" },
+  { from: "source", id: "change-source-to-children", to: "children" },
+  { from: "sourcePos", id: "#remove-sourcepos" },
+  { from: "transformImageUri", id: "#add-urltransform", to: "urlTransform" },
+  { from: "transformLinkUri", id: "#add-urltransform", to: "urlTransform" }
+];
+function validateOptions(options) {
+  for (const deprecation of deprecations) {
+    if (Object.hasOwn(options, deprecation.from)) {
+      (0, import_devlop2.unreachable)(
+        "Unexpected `" + deprecation.from + "` prop, " + (deprecation.to ? "use `" + deprecation.to + "` instead" : "remove it") + " (see <" + changelog + "#" + deprecation.id + "> for more info)"
+      );
+    }
+  }
+  if (options.allowedElements && options.disallowedElements) {
+    (0, import_devlop2.unreachable)("Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other");
+  }
+}
+function parseStage(options) {
+  validateOptions(options);
+  const processor2 = createProcessor(options);
+  const file = createFile(options);
+  const mdast = processor2.parse(file);
+  return { processor: processor2, file, mdast };
+}
+function transformStage(parsed) {
+  return parsed.processor.runSync(parsed.mdast, parsed.file);
+}
+
+// src/components/markdown/transform.ts
+var import_html_url_attributes = require("html-url-attributes");
+function buildTransform(ctx) {
+  return function transform(node, index, parent) {
+    if (node.type === "raw" && parent && typeof index === "number") {
+      if (ctx.skipHtml) {
+        parent.children.splice(index, 1);
+      } else {
+        parent.children[index] = { type: "text", value: node.value };
+      }
+      return index;
+    }
+    if (node.type === "element") {
+      const element = node;
+      let key;
+      const properties = element.properties ?? {};
+      for (key in import_html_url_attributes.urlAttributes) {
+        if (Object.hasOwn(import_html_url_attributes.urlAttributes, key) && Object.hasOwn(properties, key)) {
+          const test = import_html_url_attributes.urlAttributes[key];
+          if (test === null || test.includes(element.tagName)) {
+            const stash = element.data?.originalUrls;
+            const hasStash = stash !== void 0 && key in stash;
+            const original = hasStash ? stash[key] : properties[key];
+            const transformed = ctx.urlTransform(String(original || ""), key, element);
+            if (!hasStash && transformed !== original) {
+              const data = element.data ??= {};
+              (data.originalUrls ??= {})[key] = original;
+            }
+            properties[key] = transformed;
+          }
+        }
+      }
+      element.properties = properties;
+    }
+    if (node.type === "element") {
+      const element = node;
+      let remove = ctx.allowedElements ? !ctx.allowedElements.includes(element.tagName) : ctx.disallowedElements ? ctx.disallowedElements.includes(element.tagName) : false;
+      if (!remove && ctx.allowElement && typeof index === "number") {
+        remove = !ctx.allowElement(element, index, parent);
+      }
+      if (remove && parent && typeof index === "number") {
+        if (ctx.unwrapDisallowed && element.children) {
+          parent.children.splice(index, 1, ...element.children);
+        } else {
+          parent.children.splice(index, 1);
+        }
+        return index;
+      }
+    }
+    return void 0;
+  };
+}
+
+// src/components/markdown/urlTransform.ts
+var safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
+var defaultUrlTransform = (value) => {
+  const colon = value.indexOf(":");
+  const questionMark = value.indexOf("?");
+  const numberSign = value.indexOf("#");
+  const slash = value.indexOf("/");
+  if (
+    // No protocol → relative.
+    colon === -1 || // First colon is after `/`, `?`, or `#` → not a protocol.
+    slash !== -1 && colon > slash || questionMark !== -1 && colon > questionMark || numberSign !== -1 && colon > numberSign || // Allowed protocol.
+    safeProtocol.test(value.slice(0, colon))
+  ) {
+    return value;
+  }
+  return "";
+};
+
+// src/components/incrementalParse/computeFreezeBoundary.ts
+var import_micromark_util_html_tag_name = require("micromark-util-html-tag-name");
+var import_micromark_util_normalize_identifier = require("micromark-util-normalize-identifier");
+var TYPE6_NAMES = new Set(import_micromark_util_html_tag_name.htmlBlockNames);
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var LIST_MARKER_RE = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:[ \t]|$)/;
+var FOOTNOTE_DEF_RE = /^ {0,3}\[\^[^\]]*\]:/;
+var DEF_LIST_DD_RE = /^ {0,3}:[ \t]/;
+var DEF_RE = /^ {0,3}\[((?:[^[\]\\]|\\.)+)\]:/;
+var FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+var MATH_RUN_RE = /^ {0,3}(\$\$+)/;
+var TAG_OR_COMMENT_RE = /<(\/?)([A-Za-z][A-Za-z0-9-]*)(?=[\s/>])([^>]*)>|<!--|-->/g;
+var TRUNCATED_TAG_RE = /<(\/?)([A-Za-z][A-Za-z0-9-]*)([^<>]*)$/;
+var REF_RE = /!?\[((?:[^[\]\\]|\\.)*)\]/g;
+var BACKTICK_RUN_RE = /`+/g;
+function computeIndent(text) {
+  let indent = 0;
+  for (const ch of text) {
+    if (ch === " ") indent += 1;
+    else if (ch === "	") indent += 4 - indent % 4;
+    else break;
+  }
+  return indent;
+}
+function normalizeLabel(label) {
+  const collapsed = label.trim().replace(/[ \t\r\n]+/g, " ");
+  return collapsed ? (0, import_micromark_util_normalize_identifier.normalizeIdentifier)(collapsed) : "";
+}
+function canBecomeDdLine(text, confirmed) {
+  let i = 0;
+  while (i < text.length && text[i] === " ") i += 1;
+  if (i > 3) return false;
+  if (i === text.length) return !confirmed;
+  if (text[i] !== ":") return false;
+  if (i + 1 === text.length) return !confirmed;
+  return text[i + 1] === " " || text[i + 1] === "	";
+}
+function maskIntraLineCodeSpans(text, carryOpen) {
+  BACKTICK_RUN_RE.lastIndex = 0;
+  const runs = [];
+  let m;
+  while ((m = BACKTICK_RUN_RE.exec(text)) !== null) runs.push({ index: m.index, length: m[0].length });
+  if (runs.length === 0) return { masked: carryOpen ? null : text, unpaired: false };
+  const spans = [];
+  let unpaired = false;
+  for (let i = 0; i < runs.length; i++) {
+    const opener = runs[i];
+    let matched = -1;
+    for (let j = i + 1; j < runs.length; j++) {
+      if (runs[j].length === opener.length) {
+        matched = j;
+        break;
+      }
+    }
+    if (matched === -1) {
+      unpaired = true;
+      continue;
+    }
+    spans.push([opener.index, runs[matched].index + runs[matched].length]);
+    i = matched;
+  }
+  if (carryOpen || unpaired) return { masked: null, unpaired };
+  if (spans.length === 0) return { masked: text, unpaired: false };
+  let out = "";
+  let cursor = 0;
+  for (const [from, to] of spans) {
+    out += text.slice(cursor, from) + " ".repeat(to - from);
+    cursor = to;
+  }
+  out += text.slice(cursor);
+  return { masked: out, unpaired: false };
+}
+function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
+  return {
+    defListEnabled,
+    mathFlow,
+    referenceTaint,
+    confirmedOffset: 0,
+    candidates: [],
+    defs: /* @__PURE__ */ new Map(),
+    footnoteDefs: /* @__PURE__ */ new Map(),
+    unresolvedRefs: [],
+    tagBalance: /* @__PURE__ */ new Map(),
+    openTotal: 0,
+    commentOpen: false,
+    piOpen: false,
+    declOpen: false,
+    cdataOpen: false,
+    inFence: false,
+    fenceChar: "",
+    fenceLen: 0,
+    inMath: false,
+    mathFenceLen: 0,
+    blankRun: 0,
+    lastBlankStart: -1,
+    hazardVerdict: false,
+    prevLineBlank: true,
+    // doc start counts as a block start
+    prevLineWasText: false,
+    prevLineWasValidDef: false,
+    paragraphHasUnpairedRun: false,
+    htmlFlowSinceBlank: false,
+    htmlSeamPending: false,
+    phasePoisonedAt: Infinity
+  };
+}
+function isPlausibleLinkDefRest(rest) {
+  const t = rest.trim();
+  if (t === "") return false;
+  let destEnd;
+  if (t.startsWith("<")) {
+    const close = t.indexOf(">");
+    if (close === -1) return false;
+    destEnd = close + 1;
+  } else {
+    const ws = t.search(/[ \t]/);
+    destEnd = ws === -1 ? t.length : ws;
+  }
+  const after = t.slice(destEnd).trim();
+  if (after === "") return true;
+  const opener = after[0];
+  if (opener !== '"' && opener !== "'" && opener !== "(") return false;
+  const closer = opener === "(" ? ")" : opener;
+  for (let i = 1; i < after.length; i++) {
+    if (after[i] === "\\") {
+      i += 1;
+      continue;
+    }
+    if (after[i] === closer) return after.slice(i + 1).trim() === "";
+  }
+  return false;
+}
+function classifyBlockStart(text, indent, defListEnabled) {
+  if (indent >= 4) return true;
+  if (LIST_MARKER_RE.test(text) || FOOTNOTE_DEF_RE.test(text)) return true;
+  if (defListEnabled && DEF_LIST_DD_RE.test(text)) return true;
+  if (indent === 0) return false;
+  return null;
+}
+function computeFreezeBoundary(text, options, resume) {
+  const mathFlow = options.mathFlow ?? true;
+  const referenceTaint = options.referenceTaint ?? true;
+  const cp = resume && resume.defListEnabled === options.defListEnabled && resume.mathFlow === mathFlow && resume.referenceTaint === referenceTaint && resume.confirmedOffset <= text.length ? resume : freshCheckpoint(options.defListEnabled, mathFlow, referenceTaint);
+  let start = cp.confirmedOffset;
+  let tailLine = null;
+  while (start < text.length) {
+    let end = text.indexOf("\n", start);
+    if (end === -1) end = text.length;
+    const confirmed = end < text.length;
+    const lineText = text.slice(start, end);
+    const ln = {
+      start,
+      end,
+      text: lineText,
+      blank: confirmed && lineText.trim() === "",
+      indent: computeIndent(lineText)
+    };
+    if (!confirmed) {
+      tailLine = ln;
+      break;
+    }
+    processConfirmedLine(cp, ln, text);
+    cp.confirmedOffset = end + 1;
+    start = end + 1;
+  }
+  if (cp.unresolvedRefs.length > 0) {
+    const settled = (defEnd) => cp.lastBlankStart >= defEnd;
+    cp.unresolvedRefs = cp.unresolvedRefs.filter((ref) => {
+      const table = ref.footnote ? cp.footnoteDefs : cp.defs;
+      const defEnd = table.get(ref.label);
+      return defEnd === void 0 || !settled(defEnd);
+    });
+  }
+  let earliestUnresolved = Infinity;
+  for (const ref of cp.unresolvedRefs) earliestUnresolved = Math.min(earliestUnresolved, ref.offset);
+  const defListSettled = (c) => {
+    if (!options.defListEnabled || c.blankRun >= 2) return true;
+    if (c.defListSettled !== null) return c.defListSettled;
+    if (tailLine) return !canBecomeDdLine(tailLine.text, false);
+    return false;
+  };
+  let boundary = 0;
+  for (let i = cp.candidates.length - 1; i >= 0; i--) {
+    const c = cp.candidates[i];
+    if (!c.htmlBalanced || c.hazard || c.seamRisk) continue;
+    if (c.offset > cp.phasePoisonedAt) continue;
+    if (c.offset > earliestUnresolved) continue;
+    if (!defListSettled(c)) continue;
+    boundary = c.offset;
+    break;
+  }
+  return { boundary, checkpoint: cp };
+}
+function processConfirmedLine(cp, ln, text) {
+  const newest = cp.candidates[cp.candidates.length - 1];
+  if (newest && newest.defListSettled === null) {
+    newest.defListSettled = ln.blank ? true : !canBecomeDdLine(ln.text, true);
+  }
+  const isBlockStart = cp.prevLineBlank;
+  if (cp.htmlSeamPending && !ln.blank && !cp.htmlFlowSinceBlank && !(cp.commentOpen || cp.piOpen || cp.declOpen || cp.cdataOpen)) {
+    const defShapedLine = DEF_RE.test(ln.text) || FOOTNOTE_DEF_RE.test(ln.text);
+    const commentOnly = ln.text.replace(/<!--[\s\S]*?-->/g, " ").replace(/<!--[\s\S]*$/, " ").trim() === "";
+    if (!defShapedLine && !commentOnly) {
+      cp.htmlSeamPending = false;
+    }
+  }
+  const applyTag = (tag, closing) => {
+    if (closing) {
+      const count = cp.tagBalance.get(tag) ?? 0;
+      if (count > 0) {
+        cp.tagBalance.set(tag, count - 1);
+        cp.openTotal -= 1;
+      }
+    } else {
+      cp.tagBalance.set(tag, (cp.tagBalance.get(tag) ?? 0) + 1);
+      cp.openTotal += 1;
+    }
+  };
+  const commentOpenAtLineStart = cp.commentOpen;
+  const rawOpenAtLineStart = cp.commentOpen || cp.piOpen || cp.declOpen || cp.cdataOpen;
+  if (cp.inFence) {
+    const close = FENCE_RE.exec(ln.text);
+    if (close && close[1][0] === cp.fenceChar && close[1].length >= cp.fenceLen && ln.text.trim() === close[1]) {
+      cp.inFence = false;
+      cp.fenceChar = "";
+      cp.fenceLen = 0;
+    }
+    cp.blankRun = 0;
+    cp.paragraphHasUnpairedRun = false;
+    cp.prevLineBlank = false;
+    cp.prevLineWasText = false;
+    cp.prevLineWasValidDef = false;
+    return;
+  }
+  if (!cp.inMath && !rawOpenAtLineStart) {
+    const open = FENCE_RE.exec(ln.text);
+    const bogusInfo = open !== null && open[1][0] === "`" && ln.text.slice(ln.text.indexOf(open[1]) + open[1].length).includes("`");
+    if (open && !bogusInfo && cp.htmlFlowSinceBlank) {
+      cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+    } else if (open && !bogusInfo) {
+      if (isBlockStart) {
+        const verdict = classifyBlockStart(ln.text, ln.indent, cp.defListEnabled);
+        if (verdict !== null) cp.hazardVerdict = verdict;
+      }
+      cp.inFence = true;
+      cp.fenceChar = open[1][0];
+      cp.fenceLen = open[1].length;
+      cp.blankRun = 0;
+      cp.paragraphHasUnpairedRun = false;
+      cp.prevLineBlank = false;
+      cp.prevLineWasText = false;
+      cp.prevLineWasValidDef = false;
+      return;
+    }
+  }
+  if (cp.inMath) {
+    const close = MATH_RUN_RE.exec(ln.text);
+    if (close && close[1].length >= cp.mathFenceLen && ln.text.trim() === close[1]) {
+      cp.inMath = false;
+      cp.mathFenceLen = 0;
+    }
+    cp.blankRun = 0;
+    cp.paragraphHasUnpairedRun = false;
+    cp.prevLineBlank = false;
+    cp.prevLineWasText = false;
+    cp.prevLineWasValidDef = false;
+    return;
+  }
+  const mathRun = cp.mathFlow && !rawOpenAtLineStart ? MATH_RUN_RE.exec(ln.text) : null;
+  if (mathRun) {
+    const rest = ln.text.slice(ln.text.indexOf(mathRun[1]) + mathRun[1].length);
+    if (!rest.includes("$")) {
+      if (cp.htmlFlowSinceBlank) {
+        cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+      } else {
+        if (isBlockStart) {
+          const verdict = classifyBlockStart(ln.text, ln.indent, cp.defListEnabled);
+          if (verdict !== null) cp.hazardVerdict = verdict;
+        }
+        cp.inMath = true;
+        cp.mathFenceLen = mathRun[1].length;
+        cp.blankRun = 0;
+        cp.paragraphHasUnpairedRun = false;
+        cp.prevLineBlank = false;
+        cp.prevLineWasText = false;
+        cp.prevLineWasValidDef = false;
+        return;
+      }
+    }
+  }
+  if (ln.blank) {
+    cp.blankRun += 1;
+    cp.lastBlankStart = ln.start;
+    cp.candidates.push({
+      offset: Math.min(ln.end + 1, text.length),
+      blankRun: cp.blankRun,
+      htmlBalanced: cp.openTotal === 0 && !cp.commentOpen && !cp.piOpen && !cp.declOpen && !cp.cdataOpen,
+      hazard: cp.hazardVerdict,
+      seamRisk: cp.htmlSeamPending,
+      defListSettled: null
+    });
+    cp.paragraphHasUnpairedRun = false;
+    cp.htmlFlowSinceBlank = false;
+    cp.prevLineBlank = true;
+    cp.prevLineWasText = false;
+    cp.prevLineWasValidDef = false;
+    return;
+  }
+  if (isBlockStart) {
+    const verdict = classifyBlockStart(ln.text, ln.indent, cp.defListEnabled);
+    if (verdict !== null) cp.hazardVerdict = verdict;
+  } else if (LIST_MARKER_RE.test(ln.text) || FOOTNOTE_DEF_RE.test(ln.text) || cp.defListEnabled && DEF_LIST_DD_RE.test(ln.text) || ln.indent >= 4) {
+    cp.hazardVerdict = true;
+  }
+  const tagStart = ln.indent <= 3 ? /^<\/?([A-Za-z][A-Za-z0-9-]*)/.exec(ln.text.trimStart()) : null;
+  if (tagStart) {
+    cp.htmlFlowSinceBlank = true;
+    if (!TYPE6_NAMES.has(tagStart[1].toLowerCase())) cp.hazardVerdict = true;
+  }
+  const inRawText = cp.htmlFlowSinceBlank || rawOpenAtLineStart;
+  const { masked, unpaired } = inRawText ? { masked: null, unpaired: false } : maskIntraLineCodeSpans(ln.text, cp.paragraphHasUnpairedRun);
+  if (unpaired) cp.paragraphHasUnpairedRun = true;
+  const scanText = masked ?? ln.text;
+  const defShaped = inRawText ? null : DEF_RE.exec(scanText);
+  const def = defShaped !== null && (defShaped[1].startsWith("^") || isPlausibleLinkDefRest(scanText.slice(defShaped.index + defShaped[0].length))) ? defShaped : null;
+  const defLineStart = isBlockStart || !cp.prevLineWasText || cp.prevLineWasValidDef;
+  const validDef = def !== null && defLineStart;
+  if (validDef) {
+    const label = def[1];
+    if (label.startsWith("^")) {
+      const key = normalizeLabel(label.slice(1));
+      if (key && !cp.footnoteDefs.has(key)) cp.footnoteDefs.set(key, ln.end);
+    } else {
+      const key = normalizeLabel(label);
+      if (key && !cp.defs.has(key)) cp.defs.set(key, ln.end);
+    }
+  }
+  if (cp.referenceTaint && scanText.includes("[")) {
+    const defBracket = validDef ? def.index + def[0].indexOf("[") : -1;
+    REF_RE.lastIndex = 0;
+    let m;
+    while ((m = REF_RE.exec(scanText)) !== null) {
+      const follow = scanText[m.index + m[0].length];
+      if (follow === "(") continue;
+      if (follow === ":" && m.index === defBracket) continue;
+      const inner = m[1];
+      let label;
+      let footnote = false;
+      if (inner.startsWith("^")) {
+        footnote = true;
+        label = normalizeLabel(inner.slice(1));
+      } else if (follow === "[") {
+        const explicit = /^\[((?:[^[\]\\]|\\.)*)\]/.exec(scanText.slice(m.index + m[0].length));
+        label = normalizeLabel(explicit && explicit[1] ? explicit[1] : inner);
+      } else {
+        label = normalizeLabel(inner);
+      }
+      if (!label) continue;
+      cp.unresolvedRefs.push({ offset: ln.start + m.index, label, footnote });
+    }
+  }
+  const rawOpenAtStart = cp.piOpen || cp.declOpen || cp.cdataOpen;
+  const rawSpans = [];
+  let pos = 0;
+  while (pos < scanText.length) {
+    if (cp.piOpen) {
+      const c = scanText.indexOf("?>", pos);
+      if (c === -1) {
+        rawSpans.push([pos, scanText.length]);
+        break;
+      }
+      rawSpans.push([pos, c + 2]);
+      cp.piOpen = false;
+      pos = c + 2;
+      continue;
+    }
+    if (cp.cdataOpen) {
+      const c = scanText.indexOf("]]>", pos);
+      if (c === -1) {
+        rawSpans.push([pos, scanText.length]);
+        break;
+      }
+      rawSpans.push([pos, c + 3]);
+      cp.cdataOpen = false;
+      pos = c + 3;
+      continue;
+    }
+    if (cp.declOpen) {
+      const c = scanText.indexOf(">", pos);
+      if (c === -1) {
+        rawSpans.push([pos, scanText.length]);
+        break;
+      }
+      rawSpans.push([pos, c + 1]);
+      cp.declOpen = false;
+      pos = c + 1;
+      continue;
+    }
+    const pi = scanText.indexOf("<?", pos);
+    const cd = scanText.indexOf("<![CDATA[", pos);
+    const dm = scanText.slice(pos).search(/<![A-Za-z]/);
+    const decl = dm === -1 ? -1 : pos + dm;
+    const starts = [pi, cd, decl].filter((x) => x !== -1);
+    if (starts.length === 0) break;
+    const first = Math.min(...starts);
+    if (first === cd) {
+      rawSpans.push([cd, cd + 9]);
+      cp.cdataOpen = true;
+      pos = cd + 9;
+    } else if (first === pi) {
+      rawSpans.push([pi, pi + 2]);
+      cp.piOpen = true;
+      pos = pi + 2;
+    } else {
+      rawSpans.push([decl, decl + 2]);
+      cp.declOpen = true;
+      pos = decl + 2;
+    }
+  }
+  const rawOpenAtEnd = cp.piOpen || cp.declOpen || cp.cdataOpen;
+  if (!rawOpenAtStart && !rawOpenAtEnd) {
+    TAG_OR_COMMENT_RE.lastIndex = 0;
+    let m;
+    let lastCommentOpenerIdx = -1;
+    while ((m = TAG_OR_COMMENT_RE.exec(scanText)) !== null) {
+      if (m[0] === "<!--") {
+        cp.commentOpen = true;
+        lastCommentOpenerIdx = m.index;
+        continue;
+      }
+      if (m[0] === "-->") {
+        cp.commentOpen = false;
+        continue;
+      }
+      if (cp.commentOpen) continue;
+      const closing = m[1] === "/";
+      const tag = m[2].toLowerCase();
+      const selfClosing = m[3] !== void 0 && /\/\s*$/.test(m[3]);
+      if (VOID_TAGS.has(tag) || selfClosing) continue;
+      applyTag(tag, closing);
+    }
+    if (cp.commentOpen && lastCommentOpenerIdx !== -1 && !inRawText) {
+      if (scanText.slice(0, lastCommentOpenerIdx).trim() !== "") {
+        cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + lastCommentOpenerIdx);
+      }
+    }
+    if (!cp.commentOpen) {
+      const lastLt = scanText.lastIndexOf("<");
+      if (lastLt !== -1 && !scanText.includes(">", lastLt)) {
+        const m2 = TRUNCATED_TAG_RE.exec(scanText.slice(lastLt));
+        if (m2) {
+          const closing = m2[1] === "/";
+          const tag = m2[2].toLowerCase();
+          if (!VOID_TAGS.has(tag)) applyTag(tag, closing);
+        }
+      }
+    }
+  }
+  if (inRawText && cp.openTotal === 0) {
+    let residue = scanText;
+    for (const [from, to] of rawSpans) {
+      residue = residue.slice(0, from) + " ".repeat(to - from) + residue.slice(to);
+    }
+    residue = residue.replace(/<!--[\s\S]*?-->/g, " ");
+    if (commentOpenAtLineStart) {
+      residue = residue.includes("-->") ? residue.replace(/[\s\S]*?-->/, " ") : "";
+    }
+    residue = residue.replace(TAG_OR_COMMENT_RE, "");
+    if (residue.trim() !== "") {
+      cp.htmlSeamPending = true;
+    }
+  }
+  cp.blankRun = 0;
+  cp.prevLineBlank = false;
+  cp.prevLineWasText = true;
+  cp.prevLineWasValidDef = validDef && !def[1].startsWith("^");
+}
+
+// src/components/hastPredicates.ts
+function isFootnoteSection(node) {
+  if (node.tagName !== "section") return false;
+  const props = node.properties;
+  return props?.dataFootnotes !== void 0;
+}
+
+// src/components/incrementalParse/attributeHastChildren.ts
+function attributeHastChildren(mdast, hast, stopAt = Infinity) {
+  const mdastStarts = [];
+  for (const child of mdast.children) {
+    const off = child.position?.start?.offset;
+    if (off !== void 0) mdastStarts.push(off);
+  }
+  let cursor = 0;
+  let mdastIdx = 0;
+  const out = [];
+  for (let i = 0; i < hast.children.length; i++) {
+    const attr = attributeOne(hast.children[i], hast.children[i + 1]);
+    out.push(attr);
+    if (attr >= stopAt) break;
+  }
+  return out;
+  function attributeOne(child, next) {
+    const start = child.position?.start?.offset;
+    const end = child.position?.end?.offset;
+    if (start !== void 0 && start !== null) {
+      cursor = Math.max(cursor, end ?? start);
+      return start;
+    }
+    if (child.type === "element" && isFootnoteSection(child)) return Infinity;
+    if (child.type === "text" && next?.type === "element" && isFootnoteSection(next)) return Infinity;
+    while (mdastIdx < mdastStarts.length && mdastStarts[mdastIdx] < cursor) mdastIdx += 1;
+    return mdastIdx < mdastStarts.length ? mdastStarts[mdastIdx] : cursor;
+  }
+}
+
+// src/components/incrementalParse/spliceParse.ts
+function collectPrefixInjection(mdast, content, boundary, resume) {
+  const resumeValid = resume != null && resume.boundary <= boundary;
+  if (resumeValid && resume.uninjectable) return { events: resume.events, uninjectable: true };
+  const resumeAt = resumeValid ? resume.boundary : 0;
+  const events = resumeAt > 0 ? cloneEventsForAppend(resume.events) : [];
+  let uninjectable = false;
+  let cacheable = true;
+  const pushRef = (token) => {
+    const last = events[events.length - 1];
+    if (last && last.kind === "refs") last.tokens.push(token);
+    else events.push({ kind: "refs", tokens: [token] });
+  };
+  const visit6 = (node, nested) => {
+    const type = node.type;
+    if (type === "definition") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start !== void 0 && end !== void 0 && start < boundary) {
+        const slice = content.slice(start, end);
+        if (nested && slice.includes("\n")) uninjectable = true;
+        else events.push({ kind: "def", source: slice });
+      }
+      return;
+    }
+    if (type === "footnoteDefinition") {
+      const start = node.position?.start;
+      const end = node.position?.end?.offset;
+      if (start?.offset === void 0 || end === void 0 || start.offset >= boundary) return;
+      if (nested) {
+        uninjectable = true;
+        return;
+      }
+      const lineStart = start.offset - (start.column - 1);
+      events.push({
+        kind: "footnoteDef",
+        source: content.slice(lineStart, end),
+        origStart: lineStart,
+        origLine: start.line
+      });
+      return;
+    }
+    if (type === "footnoteReference") {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (start === void 0 || end === void 0) {
+        uninjectable = true;
+        return;
+      }
+      pushRef(content.slice(start, end));
+      return;
+    }
+    const children = node.children;
+    if (children) {
+      for (const child of children) visit6(child, true);
+    }
+  };
+  for (const child of mdast.children) {
+    const start = child.position?.start?.offset;
+    if (start === void 0) {
+      if (resumeAt > 0) return collectPrefixInjection(mdast, content, boundary, null);
+      cacheable = false;
+      visit6(child, false);
+      continue;
+    }
+    if (start >= boundary) break;
+    if (start < resumeAt) continue;
+    visit6(child, false);
+  }
+  return { events, uninjectable, cacheable };
+}
+function cloneEventsForAppend(events) {
+  const out = events.slice();
+  const last = out[out.length - 1];
+  if (last && last.kind === "refs") out[out.length - 1] = { kind: "refs", tokens: last.tokens.slice() };
+  return out;
+}
+var TERMINATOR_LABEL = "__aimd_injection_terminator__";
+var INJECTION_TERMINATOR = `[${TERMINATOR_LABEL}]: __aimd_sentinel_link__`;
+function tailMentionsTerminator(tailSource) {
+  return tailSource.includes(`[${TERMINATOR_LABEL}`);
+}
+function buildInjectionPrefix(events) {
+  if (events.length === 0) return { text: "", segments: [] };
+  let text = "";
+  let line = 1;
+  const segments = [];
+  for (const event of events) {
+    if (text.length > 0) {
+      text += "\n\n";
+      line += 2;
+    }
+    const injStart = text.length;
+    const source = event.kind === "refs" ? event.tokens.join(" ") : event.source;
+    if (event.kind === "footnoteDef") {
+      segments.push({
+        injStart,
+        injEnd: injStart + source.length,
+        offsetDelta: event.origStart - injStart,
+        lineDelta: event.origLine - line
+      });
+    }
+    text += source;
+    line += countNewlines(source);
+  }
+  return { text: `${text}
+
+${INJECTION_TERMINATOR}
+
+`, segments };
+}
+function rebaseTree(node, offsetDelta, lineDelta) {
+  rebaseTreeDual(node, EMPTY_SEGMENTS, offsetDelta, lineDelta);
+}
+var EMPTY_SEGMENTS = [];
+function rebaseTreeDual(node, segments, offsetDelta, lineDelta) {
+  const maxEnd = segments.length > 0 ? segments[segments.length - 1].injEnd : -1;
+  rebaseDualWalk(node, segments, maxEnd, offsetDelta, lineDelta);
+}
+function rebaseDualWalk(node, segments, maxEnd, offsetDelta, lineDelta) {
+  const position = node.position;
+  if (position) {
+    for (const point of [position.start, position.end]) {
+      const seg = point.offset !== void 0 && point.offset <= maxEnd ? segments.find((s) => point.offset >= s.injStart && point.offset <= s.injEnd) : void 0;
+      if (seg) {
+        point.offset += seg.offsetDelta;
+        point.line += seg.lineDelta;
+      } else {
+        if (point.offset !== void 0) point.offset += offsetDelta;
+        point.line += lineDelta;
+      }
+    }
+  }
+  const children = node.children;
+  if (children) {
+    for (const child of children) rebaseDualWalk(child, segments, maxEnd, offsetDelta, lineDelta);
+  }
+}
+function spliceTrees(input) {
+  const { prevMdast, prevHast, tailMdast, tailHast, content, boundary, injectionPrefix, injectedSegments } = input;
+  const injectedLen = injectionPrefix.length;
+  const injectedLines = countNewlines(injectionPrefix);
+  const prefixLines = countNewlines(content, boundary);
+  const offsetDelta = boundary - injectedLen;
+  const lineDelta = prefixLines - injectedLines;
+  const prefixMdast = [];
+  for (const child of prevMdast.children) {
+    const start = child.position?.start?.offset;
+    if (start !== void 0 && start < boundary) prefixMdast.push(child);
+  }
+  const attrs = attributeHastChildren(prevMdast, prevHast, boundary);
+  const cutRegion = [];
+  for (let i = 0; i < prevHast.children.length; i++) {
+    if (attrs[i] < boundary) {
+      const node2 = prevHast.children[i];
+      const end = node2.position?.end?.offset;
+      if (end !== void 0 && end > boundary) return null;
+      if (isTrailingLiteralText(node2)) {
+        const prev = i > 0 ? prevHast.children[i - 1] : void 0;
+        if (!prev || prev.type !== "element" || prev.position === void 0) return null;
+      }
+      cutRegion.push(node2);
+      continue;
+    }
+    const node = prevHast.children[i];
+    if (i > 0 && attrs[i - 1] < boundary && prevHast.children[i - 1].type === "element" && isTrailingLiteralText(node)) {
+      cutRegion.push(node);
+      break;
+    }
+    for (let j = i; j < prevHast.children.length; j++) {
+      const look = prevHast.children[j];
+      if (look.type === "element" || look.position !== void 0) break;
+      if (isTrailingLiteralText(look)) return null;
+    }
+    break;
+  }
+  const tailMdastChildren = tailMdast.children.filter((child) => {
+    const start = child.position?.start?.offset;
+    return !(start !== void 0 && start < injectedLen);
+  });
+  const tailWrapVisible = tailMdastChildren.some((child) => !isWrapInvisible(child));
+  const aligned = alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible);
+  if (aligned === null) return null;
+  const hastChildren = aligned.children;
+  const interiorFinalLiteral = aligned.interiorFinalLiteral;
+  const stripResult = stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible);
+  if (stripResult === null) return null;
+  const strippedTailHast = stripResult.rest;
+  for (const child of tailMdastChildren) rebaseTree(child, offsetDelta, lineDelta);
+  for (const child of strippedTailHast) rebaseTreeDual(child, injectedSegments, offsetDelta, lineDelta);
+  const mdastChildren = prefixMdast.concat(tailMdastChildren);
+  const seamMergeVerdict = stripResult.remnantMerged ?? tailLeadingTextIsHoist(tailMdastChildren, strippedTailHast);
+  if (seamMergeVerdict === null) return null;
+  const seamMergeAllowed = seamMergeVerdict;
+  let firstTailChild = true;
+  for (const child of strippedTailHast) {
+    const tailEnd = hastChildren[hastChildren.length - 1];
+    if (firstTailChild && child.type === "text" && child.position !== void 0) {
+      return null;
+    }
+    if (firstTailChild && tailEnd && tailEnd.type === "text" && child.type === "text" && child.position === void 0) {
+      if (interiorFinalLiteral && tailEnd.value.trim() !== "") {
+        if (seamMergeAllowed) return null;
+        firstTailChild = false;
+        hastChildren.push(child);
+        continue;
+      }
+      const literalSeam = tailEnd.value.trim() !== "" && !tailWrapVisible;
+      if (seamMergeAllowed || literalSeam) {
+        hastChildren[hastChildren.length - 1] = { type: "text", value: tailEnd.value + child.value };
+        firstTailChild = false;
+        continue;
+      }
+    }
+    firstTailChild = false;
+    hastChildren.push(child);
+  }
+  if (!hastChildren.some((child) => child.position !== void 0)) return null;
+  const docStart = { line: 1, column: 1, offset: 0 };
+  const mdastRootPosition = tailMdast.position ? { start: docStart, end: rebasePoint(tailMdast.position.end, offsetDelta, lineDelta) } : prevMdast.position;
+  const hastRootPosition = mdastRootPosition;
+  const mdast = { type: "root", children: mdastChildren };
+  if (mdastRootPosition) mdast.position = mdastRootPosition;
+  const hast = { type: "root", children: hastChildren };
+  if (hastRootPosition) hast.position = hastRootPosition;
+  if (prevHast.data !== void 0) hast.data = prevHast.data;
+  return { mdast, hast };
+}
+function rebasePoint(point, offsetDelta, lineDelta) {
+  return {
+    line: point.line + lineDelta,
+    column: point.column,
+    offset: point.offset !== void 0 ? point.offset + offsetDelta : void 0
+  };
+}
+function isWrapInvisible(node) {
+  return node.type === "definition" || node.type === "footnoteDefinition";
+}
+function alignPrefixCut(prefixMdast, cutRegion, tailWrapVisible) {
+  const visibles = prefixMdast.filter((c) => !isWrapInvisible(c));
+  const out = [];
+  let sepBuffer = [];
+  let pairIdx = -1;
+  let sawContent = false;
+  let literalCredit = 0;
+  for (const node of cutRegion) {
+    if (isSeparatorText(node)) {
+      sepBuffer.push(node);
+      continue;
+    }
+    const start = node.position?.start?.offset;
+    const paired = pairIdx >= 0 ? visibles[pairIdx] : void 0;
+    if (sawContent && start !== void 0 && paired && paired.position?.start?.offset !== void 0 && paired.position?.end?.offset !== void 0 && start >= paired.position.start.offset && start < paired.position.end.offset) {
+      if (sepBuffer.length !== 0) return null;
+      out.push(node);
+      continue;
+    }
+    if (sawContent && isTrailingLiteralText(node)) {
+      if (sepBuffer.length !== 0) return null;
+      out.push(node);
+      literalCredit += countTrailingNewlines(node.value);
+      continue;
+    }
+    let nextIdx;
+    if (!sawContent && start !== void 0) {
+      nextIdx = -1;
+      for (let j = 0; j <= sepBuffer.length && j < visibles.length; j++) {
+        const vStart = visibles[j].position?.start?.offset;
+        const vEnd = visibles[j].position?.end?.offset;
+        if (vStart !== void 0 && vEnd !== void 0 && start >= vStart && start < vEnd) {
+          nextIdx = j;
+          break;
+        }
+      }
+      if (nextIdx === -1) return null;
+      const excess = sepBuffer.length - nextIdx;
+      if (excess > (nextIdx === 0 ? 1 : 0)) return null;
+    } else {
+      const stripped = sawContent ? sepBuffer.length + literalCredit - 1 : sepBuffer.length;
+      if (stripped < 0) return null;
+      nextIdx = pairIdx + 1 + stripped;
+      const candidate = visibles[nextIdx];
+      if (!candidate) return null;
+      if (start !== void 0) {
+        const cStart = candidate.position?.start?.offset;
+        const cEnd = candidate.position?.end?.offset;
+        if (cStart === void 0 || cEnd === void 0 || start < cStart || start >= cEnd) return null;
+      }
+    }
+    out.push(...sepBuffer, node);
+    sepBuffer = [];
+    literalCredit = 0;
+    pairIdx = nextIdx;
+    sawContent = true;
+  }
+  const trailingStripped = visibles.length - (pairIdx + 1);
+  const trailingGaps = sawContent ? trailingStripped : Math.max(0, visibles.length - 1);
+  const seam = visibles.length > 0 && tailWrapVisible ? 1 : 0;
+  const last = out[out.length - 1];
+  const lastIsLiteral = last !== void 0 && last.type === "text" && last.value.trim() !== "";
+  const litOwnerEnd = pairIdx >= 0 ? visibles[pairIdx].position?.end?.offset : void 0;
+  const litEnd = lastIsLiteral ? last.position?.end?.offset : void 0;
+  if (lastIsLiteral && last.position !== void 0 && (litEnd === void 0 || litOwnerEnd === void 0)) {
+    return null;
+  }
+  if (litEnd !== void 0 && litOwnerEnd !== void 0 && litEnd > litOwnerEnd) {
+    return null;
+  }
+  const interiorFinalLiteral = lastIsLiteral && litEnd !== void 0 && litOwnerEnd !== void 0 && litEnd < litOwnerEnd;
+  if (lastIsLiteral && !interiorFinalLiteral) {
+    if (trailingGaps > 0 || sepBuffer.length > 0) return null;
+    const body = last.value.replace(/\n+$/, "");
+    if (last.position !== void 0 && body !== last.value) {
+      return null;
+    }
+    if (seam > 0) {
+      out[out.length - 1] = { type: "text", value: `${body}
+` };
+    } else if (last.position !== void 0) {
+    } else {
+      const prevEl = out.length >= 2 ? out[out.length - 2] : void 0;
+      const owner = pairIdx >= 0 ? visibles[pairIdx] : void 0;
+      const start = prevEl?.type === "element" ? prevEl.position?.end : void 0;
+      const end = owner?.position?.end;
+      if (!start || !end) return null;
+      out[out.length - 1] = { type: "text", value: body, position: { start, end } };
+    }
+    return { children: out, interiorFinalLiteral: false };
+  }
+  if (sepBuffer.some((s) => s.type !== "text" || s.value !== "\n")) return null;
+  if (literalCredit > 0) return null;
+  const lastPaired = pairIdx >= 0 ? visibles[pairIdx] : void 0;
+  if (lastPaired && lastPaired.type === "html") {
+    const v = lastPaired.value;
+    const lastLt = v.lastIndexOf("<");
+    if (lastLt !== -1 && /^<[!?]/.test(v.slice(lastLt))) return null;
+  }
+  if (sepBuffer.length !== trailingGaps && sepBuffer.length !== trailingGaps + 1) return null;
+  for (let i = 0; i < trailingGaps + seam; i++) {
+    out.push({ type: "text", value: "\n" });
+  }
+  return { children: out, interiorFinalLiteral };
+}
+function stripInjectedHast(tailMdast, tailHast, injectedLen, tailWrapVisible) {
+  if (injectedLen === 0) return { rest: tailHast.children.slice(), remnantMerged: null };
+  const injectedVisibleCount = tailMdast.children.filter((c) => {
+    const start = c.position?.start?.offset;
+    return start !== void 0 && start < injectedLen && !isWrapInvisible(c);
+  }).length;
+  if (injectedVisibleCount === 0) return { rest: tailHast.children.slice(), remnantMerged: null };
+  const children = tailHast.children;
+  let idx = 0;
+  let consumed = 0;
+  while (idx < children.length && consumed < injectedVisibleCount) {
+    const node = children[idx];
+    if (isSeparatorText(node)) {
+      idx += 1;
+      continue;
+    }
+    const start = node.position?.start?.offset;
+    if (start === void 0 || start >= injectedLen) return null;
+    consumed += 1;
+    idx += 1;
+  }
+  if (consumed < injectedVisibleCount) return null;
+  let remnant = "";
+  let remnantMerged = null;
+  if (tailWrapVisible) {
+    const gap = children[idx];
+    if (!gap || !isSeparatorText(gap)) return null;
+    remnant = gap.value.slice(1);
+    remnantMerged = remnant !== "";
+    idx += 1;
+  }
+  const rest = children.slice(idx);
+  if (remnant !== "") rest.unshift({ type: "text", value: remnant });
+  return { rest, remnantMerged };
+}
+function tailLeadingTextIsHoist(tailMdastChildren, tailHastChildren) {
+  const firstText = tailHastChildren[0];
+  if (!firstText || !isSeparatorText(firstText)) return false;
+  const firstVisible = tailMdastChildren.find((c) => !isWrapInvisible(c));
+  if (!firstVisible) return false;
+  const firstContent = tailHastChildren.find((c) => !isSeparatorText(c));
+  if (firstContent) {
+    const start = firstContent.position?.start?.offset;
+    const vStart = firstVisible.position?.start?.offset;
+    const vEnd = firstVisible.position?.end?.offset;
+    if (start !== void 0 && vStart !== void 0 && vEnd !== void 0) {
+      if (start >= vStart && start < vEnd) return true;
+    }
+  }
+  if (firstVisible.type === "math") return false;
+  if (firstVisible.type === "html" && isCompleteRawConstruct(firstVisible.value)) return false;
+  return null;
+}
+function isCompleteRawConstruct(value) {
+  const v = value.trim();
+  return v.startsWith("<!--") && v.endsWith("-->") || v.startsWith("<?") && v.endsWith("?>") || v.startsWith("<![CDATA[") && v.endsWith("]]>") || /^<![A-Za-z]/.test(v) && v.endsWith(">");
+}
+function isSeparatorText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() === "";
+}
+function isTrailingLiteralText(node) {
+  return node.type === "text" && node.position === void 0 && node.value.trim() !== "";
+}
+function countTrailingNewlines(value) {
+  let n = 0;
+  for (let i = value.length - 1; i >= 0 && value[i] === "\n"; i--) n += 1;
+  return n;
+}
+function countNewlines(text, end = text.length) {
+  let count = 0;
+  for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
+  return count;
+}
+
+// src/components/incrementalParse/advanceIncrementalParse.ts
+var identityMeasure = (_stage, fn) => fn();
+function depsKeyEqual(a, b) {
+  return a.length === b.length && a.every((value, i) => value === b[i]);
+}
+function runPipeline(source, options) {
+  const measure = options.measure ?? identityMeasure;
+  const parsed = measure(
+    "parse",
+    () => parseStage({
+      children: source,
+      remarkPlugins: options.remarkPlugins,
+      rehypePlugins: options.rehypePlugins,
+      remarkRehypeOptions: options.remarkRehypeOptions
+    })
+  );
+  const hast = measure("transform", () => transformStage(parsed));
+  return { mdast: parsed.mdast, hast };
+}
+function advanceIncrementalParse(prev, content, options) {
+  const measure = options.measure ?? identityMeasure;
+  const phantomSuffix = options.phantomSuffix ?? "";
+  const sameDeps = prev !== null && depsKeyEqual(prev.depsKey, options.depsKey);
+  if (sameDeps && content === prev.content && phantomSuffix === prev.phantomSuffix) {
+    return {
+      mdast: prev.mdast,
+      hast: prev.hast,
+      usedIncremental: true,
+      boundary: prev.stableBoundary,
+      nextState: prev
+    };
+  }
+  const appendOnly = sameDeps && content.startsWith(prev.content);
+  const scan = measure(
+    "scan",
+    () => computeFreezeBoundary(content, { defListEnabled: options.defListEnabled }, appendOnly ? prev.scanCheckpoint : null)
+  );
+  const freshBoundary = scan.boundary;
+  let injectionPlan = appendOnly ? prev.injectionPlan : null;
+  const finish = (mdast, hast, usedIncremental, boundary2) => ({
+    mdast,
+    hast,
+    usedIncremental,
+    boundary: boundary2,
+    nextState: {
+      content,
+      phantomSuffix,
+      mdast,
+      hast,
+      stableBoundary: freshBoundary,
+      scanCheckpoint: scan.checkpoint,
+      injectionPlan,
+      depsKey: options.depsKey
+    }
+  });
+  const fullPath = () => {
+    const { mdast, hast } = runPipeline(content + phantomSuffix, options);
+    return finish(mdast, hast, false, 0);
+  };
+  if (!appendOnly) return fullPath();
+  const boundary = Math.min(freshBoundary, prev.stableBoundary);
+  if (boundary <= 0) return fullPath();
+  for (const child of prev.mdast.children) {
+    const start = child.position?.start?.offset;
+    const end = child.position?.end?.offset;
+    if (start !== void 0 && end !== void 0 && start < boundary && end > boundary) {
+      return fullPath();
+    }
+  }
+  const tailAndSuffix = content.slice(boundary) + phantomSuffix;
+  if (tailMentionsTerminator(tailAndSuffix)) return fullPath();
+  const plan = collectPrefixInjection(prev.mdast, prev.content, boundary, injectionPlan);
+  if (plan.cacheable !== false) {
+    injectionPlan = { boundary, events: plan.events, uninjectable: plan.uninjectable };
+  }
+  if (plan.uninjectable) return fullPath();
+  const injection = buildInjectionPrefix(plan.events);
+  const tailSource = injection.text + tailAndSuffix;
+  const tail = runPipeline(tailSource, options);
+  const spliced = spliceTrees({
+    prevMdast: prev.mdast,
+    prevHast: prev.hast,
+    tailMdast: tail.mdast,
+    tailHast: tail.hast,
+    content,
+    boundary,
+    injectionPrefix: injection.text,
+    injectedSegments: injection.segments
+  });
+  if (spliced === null) return fullPath();
+  return finish(spliced.mdast, spliced.hast, true, boundary);
+}
+
+// src/components/incrementalParse/codePointSnapshots.ts
+function codePointSnapshots(payload, chunkSize) {
+  const codePoints = Array.from(payload);
+  const snapshots = [];
+  for (let i = chunkSize; i < codePoints.length; i += chunkSize) {
+    snapshots.push(codePoints.slice(0, i).join(""));
+  }
+  snapshots.push(payload);
+  return snapshots;
+}
+
+// src/components/collectDefLabels.ts
+var import_unified2 = require("unified");
+var import_remark_parse2 = __toESM(require("remark-parse"), 1);
+var import_remark_gfm = __toESM(require("remark-gfm"), 1);
+var import_unist_util_visit = require("unist-util-visit");
+
+// src/components/normalizeId.ts
+function normalizeId(s) {
+  return s.replace(/\s+/g, " ").toUpperCase();
+}
+function normalizeForMatch(s) {
+  return s.replace(/\\(.)/g, "$1").replace(/\s+/g, " ").toUpperCase();
+}
+
+// src/components/collectDefLabels.ts
+var SCANNER_BOUNDARY_PROFILE = { defListEnabled: false, mathFlow: false, referenceTaint: false };
+function buildProcessor() {
+  return (0, import_unified2.unified)().use(import_remark_parse2.default).use(import_remark_gfm.default);
+}
+var _processor = null;
+function processor() {
+  if (!_processor) _processor = buildProcessor();
+  return _processor;
+}
+function collectDefLabels(source) {
+  if (!source) {
+    return { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() };
+  }
+  const mdast = processor().parse(source);
+  const footnoteLabels = /* @__PURE__ */ new Set();
+  const linkLabels = /* @__PURE__ */ new Set();
+  (0, import_unist_util_visit.visit)(mdast, (node) => {
+    if (node.type === "footnoteDefinition" && "identifier" in node) {
+      footnoteLabels.add(normalizeId(node.identifier));
+    } else if (node.type === "definition" && "identifier" in node) {
+      linkLabels.add(normalizeId(node.identifier));
+    }
+  });
+  return { footnoteLabels, linkLabels };
+}
+var setsEqual = (a, b) => {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
+};
+var BLANK_LINE_RE = /\r?\n[ \t]*\r?\n/g;
+function lastRegionStart(source) {
+  BLANK_LINE_RE.lastIndex = 0;
+  let start = 0;
+  for (let m = BLANK_LINE_RE.exec(source); m !== null; m = BLANK_LINE_RE.exec(source)) {
+    start = m.index + m[0].length;
+  }
+  return start;
+}
+var DEF_LINE_START_RE = /^[ \t>*+\d.)-]*\[(?:[^\]\\]|\\[\s\S])*\]:/m;
+function createDefLabelScanner(parse = collectDefLabels) {
+  let prevSource = null;
+  let prevLabels = null;
+  let frozenEnd = 0;
+  let frozenFootnotes = /* @__PURE__ */ new Set();
+  let frozenLinks = /* @__PURE__ */ new Set();
+  let checkpoint = null;
+  const resetFrozen = () => {
+    frozenEnd = 0;
+    frozenFootnotes = /* @__PURE__ */ new Set();
+    frozenLinks = /* @__PURE__ */ new Set();
+    checkpoint = null;
+  };
+  return {
+    scan(source) {
+      let isAppend = false;
+      if (prevSource !== null && prevLabels !== null) {
+        if (source === prevSource) return prevLabels;
+        if (source.startsWith(prevSource)) {
+          isAppend = true;
+          const regionStart = lastRegionStart(prevSource);
+          const region = prevSource.slice(regionStart) + source.slice(prevSource.length);
+          if (!DEF_LINE_START_RE.test(region)) {
+            prevSource = source;
+            return prevLabels;
+          }
+        }
+      }
+      if (!isAppend && prevSource !== null) resetFrozen();
+      const scanResult = computeFreezeBoundary(source, SCANNER_BOUNDARY_PROFILE, isAppend ? checkpoint : null);
+      checkpoint = scanResult.checkpoint;
+      const boundary = Math.max(scanResult.boundary, frozenEnd);
+      if (boundary > frozenEnd) {
+        const slice = source.slice(frozenEnd, boundary);
+        if (DEF_LINE_START_RE.test(slice)) {
+          const sliceLabels = parse(slice);
+          for (const label of sliceLabels.footnoteLabels) frozenFootnotes.add(label);
+          for (const label of sliceLabels.linkLabels) frozenLinks.add(label);
+        }
+        frozenEnd = boundary;
+      }
+      const tailSource = source.slice(frozenEnd);
+      const tail = DEF_LINE_START_RE.test(tailSource) ? parse(tailSource) : { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() };
+      const next = {
+        footnoteLabels: /* @__PURE__ */ new Set([...frozenFootnotes, ...tail.footnoteLabels]),
+        linkLabels: /* @__PURE__ */ new Set([...frozenLinks, ...tail.linkLabels])
+      };
+      if (prevLabels !== null && setsEqual(next.footnoteLabels, prevLabels.footnoteLabels) && setsEqual(next.linkLabels, prevLabels.linkLabels)) {
+        prevSource = source;
+        return prevLabels;
+      }
+      prevSource = source;
+      prevLabels = next;
+      return next;
+    }
+  };
+}
+
+// src/components/extractDefBodiesFromHast.ts
+var import_unist_util_visit2 = require("unist-util-visit");
+var FN_LI_ID_RE = /(?:^|-)user-content-fn-(.+)$/;
+function sourceIdFromFootnoteLiId(idProp, clobberPrefix) {
+  let raw = null;
+  if (clobberPrefix !== void 0) {
+    const exactPrefix = `${clobberPrefix}fn-`;
+    if (idProp.startsWith(exactPrefix)) raw = idProp.slice(exactPrefix.length);
+  }
+  if (raw === null) {
+    const m = idProp.match(FN_LI_ID_RE);
+    raw = m ? m[1] : null;
+  }
+  if (raw === null) return null;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    if (true) {
+      console.warn(
+        `[ai-react-markdown] Malformed percent-encoding in footnote id "${raw}"; its body may be missing from the aggregated footnote footer.`
+      );
+    }
+    return raw;
+  }
+}
+function isBackrefAnchor(c) {
+  if (c.type !== "element") return false;
+  const el = c;
+  if (el.tagName !== "a") return false;
+  return Boolean(el.properties && "dataFootnoteBackref" in el.properties);
+}
+function isWhitespaceText(c) {
+  if (c.type !== "text") return false;
+  return /^\s*$/.test(c.value);
+}
+function lastMeaningfulIdx(children) {
+  for (let i = children.length - 1; i >= 0; i--) {
+    if (!isWhitespaceText(children[i])) return i;
+  }
+  return -1;
+}
+function dropTrailingBackrefs(children) {
+  let trailingWsStart = children.length;
+  while (trailingWsStart > 0 && isWhitespaceText(children[trailingWsStart - 1])) {
+    trailingWsStart--;
+  }
+  let scan = trailingWsStart;
+  let peeledAny = false;
+  while (scan > 0) {
+    const t = children[scan - 1];
+    if (!isBackrefAnchor(t)) break;
+    peeledAny = true;
+    scan -= 1;
+    if (scan > 0 && children[scan - 1].type === "text" && children[scan - 1].value === " ") {
+      scan -= 1;
+    }
+  }
+  if (!peeledAny) return children;
+  const trailing = children.slice(trailingWsStart);
+  if (scan > 0) {
+    const last = children[scan - 1];
+    if (last.type === "text") {
+      const v = last.value;
+      if (v.endsWith(" ") && !/^\s*$/.test(v)) {
+        return [...children.slice(0, scan - 1), { ...last, value: v.slice(0, -1) }, ...trailing];
+      }
+    }
+  }
+  return [...children.slice(0, scan), ...trailing];
+}
+function stripBackrefs(liChildren) {
+  if (liChildren.length === 0) return liChildren;
+  const lastIdx = lastMeaningfulIdx(liChildren);
+  if (lastIdx < 0) return liChildren;
+  const last = liChildren[lastIdx];
+  if (isBackrefAnchor(last)) {
+    return dropTrailingBackrefs(liChildren);
+  }
+  if (last.type === "element" && last.tagName === "p") {
+    const p = last;
+    const newPChildren = dropTrailingBackrefs(p.children);
+    if (newPChildren === p.children) return liChildren;
+    return liChildren.map((c, i) => i === lastIdx ? { ...p, children: newPChildren } : c);
+  }
+  return liChildren;
+}
+function stripLocalOccurrenceFromFootnoteSups(children) {
+  let changed = false;
+  const out = [];
+  for (const c of children) {
+    if (c.type === "element") {
+      const el = c;
+      let nextEl = el;
+      if (el.tagName === "footnote-sup" && el.properties && "localOccurrence" in el.properties) {
+        const { localOccurrence: _drop, ...rest } = el.properties;
+        nextEl = { ...el, properties: rest };
+        changed = true;
+      }
+      const newChildren = stripLocalOccurrenceFromFootnoteSups(nextEl.children);
+      if (newChildren !== nextEl.children) {
+        nextEl = { ...nextEl, children: newChildren };
+        changed = true;
+      }
+      out.push(nextEl);
+    } else {
+      out.push(c);
+    }
+  }
+  return changed ? out : children;
+}
+function extractDefBodiesFromHast(hast, clobberPrefix) {
+  const out = /* @__PURE__ */ new Map();
+  (0, import_unist_util_visit2.visit)(hast, "element", (sectionNode) => {
+    const sec = sectionNode;
+    if (sec.tagName !== "section") return;
+    if (!(sec.properties && "dataFootnotes" in sec.properties)) return;
+    (0, import_unist_util_visit2.visit)(sec, "element", (liNode) => {
+      const li = liNode;
+      if (li.tagName !== "li") return;
+      const idProp = li.properties?.id;
+      if (typeof idProp !== "string") return;
+      const sourceId = sourceIdFromFootnoteLiId(idProp, clobberPrefix);
+      if (sourceId === null) return;
+      const normalized = normalizeId(sourceId);
+      const stripped = stripBackrefs(li.children);
+      out.set(normalized, stripLocalOccurrenceFromFootnoteSups(stripped));
+    });
+    return import_unist_util_visit2.SKIP;
+  });
+  return out;
+}
+
+// src/components/extractContributions.ts
+var import_unist_util_visit3 = require("unist-util-visit");
+
+// src/components/remarkInjectPhantomDefs.ts
+var SENTINEL_LINK_URL = "__aimd_sentinel_link__";
+var SENTINEL_FN_CONTENT = "__aimd_sentinel_fn__";
+function buildPhantomSuffix(phantoms) {
+  if (phantoms.missingFootnotes.size === 0 && phantoms.missingLinks.size === 0) {
+    return "";
+  }
+  let suffix = "\n\n";
+  for (const label of phantoms.missingLinks) {
+    suffix += `[${label}]: ${SENTINEL_LINK_URL}
+`;
+  }
+  for (const label of phantoms.missingFootnotes) {
+    suffix += `[^${label}]: ${SENTINEL_FN_CONTENT}
+`;
+  }
+  return suffix;
+}
+
+// src/components/extractContributions.ts
+function fakeAnchorElement(url) {
+  return { type: "element", tagName: "a", properties: { href: url }, children: [] };
+}
+function sanitizeDefUrl(url, urlTransform) {
+  if (!urlTransform) return url;
+  const result = urlTransform(url, "href", fakeAnchorElement(url));
+  return result == null ? "" : String(result);
+}
+function* extractContributions(mdast, options = {}) {
+  const phantomFn = options.phantomFootnoteLabels;
+  const urlTransform = options.urlTransform;
+  const out = [];
+  (0, import_unist_util_visit3.visit)(mdast, (n) => {
+    if (n.type === "footnoteReference") {
+      out.push({
+        kind: "ref",
+        refKind: "footnote",
+        label: normalizeId(n.identifier)
+      });
+    } else if (n.type === "linkReference") {
+      const r = n;
+      out.push({ kind: "ref", refKind: "link", label: normalizeId(r.identifier), referenceType: r.referenceType });
+    } else if (n.type === "imageReference") {
+      const r = n;
+      out.push({ kind: "ref", refKind: "image", label: normalizeId(r.identifier), referenceType: r.referenceType });
+    } else if (n.type === "footnoteDefinition") {
+      const d = n;
+      const label = normalizeId(d.identifier);
+      if (phantomFn?.has(label)) return import_unist_util_visit3.SKIP;
+      const content = JSON.stringify(d.children ?? []);
+      out.push({ kind: "fnDef", label, sourceIdentifier: d.identifier, content });
+      return import_unist_util_visit3.SKIP;
+    } else if (n.type === "definition") {
+      const d = n;
+      if (d.url === SENTINEL_LINK_URL) return;
+      out.push({
+        kind: "linkDef",
+        label: normalizeId(d.identifier),
+        url: sanitizeDefUrl(d.url, urlTransform),
+        title: d.title
+      });
+    }
+  });
+  for (const c of out) yield c;
+}
+
+// src/components/documentRegistry.ts
+function createRegistry(onEmpty) {
+  const reg = {
+    chunkOrder: [],
+    chunkData: /* @__PURE__ */ new Map(),
+    labelSet: { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() },
+    version: 0,
+    _reactIdMap: /* @__PURE__ */ new Map(),
+    _subscribers: /* @__PURE__ */ new Set(),
+    _notifyScheduled: false,
+    allocateSymbol(reactId) {
+      const existing = this._reactIdMap.get(reactId);
+      if (existing) {
+        existing.refcount++;
+        return existing.symbol;
+      }
+      const sym = Symbol(reactId);
+      this._reactIdMap.set(reactId, { symbol: sym, refcount: 1 });
+      this.chunkOrder.push(sym);
+      this._notify();
+      return sym;
+    },
+    registerChunk(reactId, footnotes, links) {
+      const sym = this.allocateSymbol(reactId);
+      this.contributeLabels(sym, footnotes, links);
+      return sym;
+    },
+    releaseSymbol(reactId) {
+      const entry = this._reactIdMap.get(reactId);
+      if (!entry) return;
+      entry.refcount--;
+      if (entry.refcount === 0) {
+        queueMicrotask(() => {
+          const latest = this._reactIdMap.get(reactId);
+          if (latest && latest.refcount === 0) {
+            this._reactIdMap.delete(reactId);
+            const idx = this.chunkOrder.indexOf(entry.symbol);
+            if (idx !== -1) this.chunkOrder.splice(idx, 1);
+            this.chunkData.delete(entry.symbol);
+            const nextFn = /* @__PURE__ */ new Set();
+            const nextLink = /* @__PURE__ */ new Set();
+            for (const cd of this.chunkData.values()) {
+              for (const l of cd.ownFootnoteLabels) nextFn.add(l);
+              for (const l of cd.ownLinkLabels) nextLink.add(l);
+            }
+            this.labelSet.footnoteLabels = nextFn;
+            this.labelSet.linkLabels = nextLink;
+            this._notify();
+            if (this.chunkOrder.length === 0 && this.chunkData.size === 0 && onEmpty) {
+              onEmpty();
+            }
+          }
+        });
+      }
+    },
+    contributeLabels(symbol, footnotes, links) {
+      const data = this.chunkData.get(symbol);
+      if (data) {
+        data.ownFootnoteLabels = footnotes;
+        data.ownLinkLabels = links;
+      } else {
+        this.chunkData.set(symbol, {
+          refs: [],
+          defs: /* @__PURE__ */ new Map(),
+          linkDefs: /* @__PURE__ */ new Map(),
+          ownFootnoteLabels: footnotes,
+          ownLinkLabels: links
+        });
+      }
+      const newFn = /* @__PURE__ */ new Set();
+      const newLink = /* @__PURE__ */ new Set();
+      for (const cd of this.chunkData.values()) {
+        for (const l of cd.ownFootnoteLabels) newFn.add(l);
+        for (const l of cd.ownLinkLabels) newLink.add(l);
+      }
+      this.labelSet.footnoteLabels = newFn;
+      this.labelSet.linkLabels = newLink;
+      this._notify();
+    },
+    contributeChunkData(symbol, data) {
+      this.chunkData.set(symbol, data);
+      this.labelSet.footnoteLabels = /* @__PURE__ */ new Set();
+      this.labelSet.linkLabels = /* @__PURE__ */ new Set();
+      for (const cd of this.chunkData.values()) {
+        for (const l of cd.ownFootnoteLabels) this.labelSet.footnoteLabels.add(l);
+        for (const l of cd.ownLinkLabels) this.labelSet.linkLabels.add(l);
+      }
+      this._notify();
+    },
+    subscribe(cb) {
+      this._subscribers.add(cb);
+      return () => {
+        this._subscribers.delete(cb);
+      };
+    },
+    canonicalFootnoteFor(label) {
+      const id = normalizeId(label);
+      for (const sym of this.chunkOrder) {
+        const data = this.chunkData.get(sym);
+        if (data?.defs.has(id)) return sym;
+      }
+      return null;
+    },
+    canonicalLinkFor(label) {
+      const id = normalizeId(label);
+      for (const sym of this.chunkOrder) {
+        const data = this.chunkData.get(sym);
+        if (data?.linkDefs.has(id)) return sym;
+      }
+      return null;
+    },
+    globalNumber(label) {
+      const id = normalizeId(label);
+      let n = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (const sym of this.chunkOrder) {
+        const data = this.chunkData.get(sym);
+        if (!data) continue;
+        for (const ref of data.refs) {
+          if (ref.kind !== "footnote") continue;
+          if (!seen.has(ref.label)) {
+            seen.add(ref.label);
+            n++;
+            if (ref.label === id) return n;
+          }
+        }
+      }
+      return null;
+    },
+    resolveLinkDef(label) {
+      const sym = this.canonicalLinkFor(label);
+      if (!sym) return null;
+      return this.chunkData.get(sym)?.linkDefs.get(normalizeId(label)) ?? null;
+    },
+    getRefsForLabel(label) {
+      const id = normalizeId(label);
+      let n = 0;
+      for (const sym of this.chunkOrder) {
+        const data = this.chunkData.get(sym);
+        if (!data) continue;
+        for (const ref of data.refs) {
+          if (ref.kind === "footnote" && ref.label === id) n++;
+        }
+      }
+      return n;
+    },
+    globalOccurrenceForRef(chunkSym, label, localOccurrence) {
+      const id = normalizeId(label);
+      let global2 = 0;
+      for (const sym of this.chunkOrder) {
+        const data = this.chunkData.get(sym);
+        if (!data) continue;
+        let localCount = 0;
+        for (const ref of data.refs) {
+          if (ref.kind !== "footnote") continue;
+          if (ref.label !== id) continue;
+          localCount++;
+          global2++;
+          if (sym === chunkSym && localCount === localOccurrence) return global2;
+        }
+      }
+      return null;
+    },
+    _notify() {
+      this.version++;
+      if (this._notifyScheduled) return;
+      this._notifyScheduled = true;
+      queueMicrotask(() => {
+        this._notifyScheduled = false;
+        for (const cb of [...this._subscribers]) cb();
+      });
+    }
+  };
+  return reg;
+}
+
+// src/components/pluginChain.ts
+var import_rehype_katex = __toESM(require("rehype-katex"), 1);
+var import_rehype_raw = __toESM(require("rehype-raw"), 1);
+var import_rehype_unwrap_images = __toESM(require("rehype-unwrap-images"), 1);
+var import_rehype_sanitize = __toESM(require("rehype-sanitize"), 1);
+var import_remark_breaks = __toESM(require("remark-breaks"), 1);
+var import_remark_cjk_friendly = __toESM(require("remark-cjk-friendly"), 1);
+var import_remark_cjk_friendly_gfm_strikethrough = __toESM(require("remark-cjk-friendly-gfm-strikethrough"), 1);
+var import_remark_emoji = __toESM(require("remark-emoji"), 1);
+var import_remark_gfm2 = __toESM(require("remark-gfm"), 1);
+var import_remark_math = __toESM(require("remark-math"), 1);
+var import_remark_definition_list = require("remark-definition-list");
+var import_remark_mark_highlight = require("@ai-react-markdown/remark-mark-highlight");
+var import_remark_squeeze_paragraphs = __toESM(require("remark-squeeze-paragraphs"), 1);
+var import_remark_smartypants = __toESM(require("remark-smartypants"), 1);
+var import_remark_pangu = __toESM(require("remark-pangu"), 1);
+var import_remark_remove_comments = __toESM(require("remark-remove-comments"), 1);
+
+// src/components/rehypeRebaseHashLinks.ts
+var import_unist_util_visit4 = require("unist-util-visit");
+var DEFAULT_PREFIX = "user-content-";
+var rehypeRebaseHashLinks = (options) => {
+  const prefix = options?.prefix ?? DEFAULT_PREFIX;
+  const hashPrefix = "#" + prefix;
+  return (tree) => {
+    (0, import_unist_util_visit4.visit)(tree, "element", (node) => {
+      if (node.tagName !== "a") return;
+      const href = node.properties?.href;
+      if (typeof href !== "string" || !href.startsWith("#")) return;
+      if (href.startsWith(hashPrefix)) return;
+      node.properties.href = hashPrefix + href.slice(1);
+    });
+  };
+};
+var rehypeRebaseHashLinks_default = rehypeRebaseHashLinks;
+
+// src/components/rehypeFooterAdorn.ts
+var import_unist_util_visit5 = require("unist-util-visit");
+var FOOTNOTE_LABEL_ID_RE = /(?:^|-)footnote-label$/;
+function isFootnoteLabelH2(node) {
+  if (node.type !== "element") return false;
+  const el = node;
+  if (el.tagName !== "h2") return false;
+  const id = el.properties?.id;
+  return typeof id === "string" && FOOTNOTE_LABEL_ID_RE.test(id);
+}
+function isHr(node) {
+  if (node.type !== "element") return false;
+  return node.tagName === "hr";
+}
+function rehypeFooterAdorn() {
+  return (tree) => {
+    (0, import_unist_util_visit5.visit)(tree, "element", (n) => {
+      const el = n;
+      if (el.tagName !== "section") return;
+      if (!(el.properties && "dataFootnotes" in el.properties)) return;
+      const filtered = el.children.filter((c) => !isFootnoteLabelH2(c));
+      if (!filtered.some(isHr)) {
+        const hr = {
+          type: "element",
+          tagName: "hr",
+          properties: {},
+          children: []
+        };
+        filtered.unshift(hr);
+      }
+      el.children = filtered;
+      if (!el.properties) el.properties = {};
+      if (!("ariaLabel" in el.properties)) {
+        el.properties.ariaLabel = "Footnotes";
+      }
+    });
+  };
+}
+
+// src/components/pluginChain.ts
+var EXTRA_SYNTAX_CHAIN = [
+  ["highlight", import_remark_mark_highlight.remarkMark],
+  ["definitionList", import_remark_definition_list.remarkDefinitionList]
+];
+var DISPLAY_OPTIMIZE_CHAIN = [
+  ["removeComments", import_remark_remove_comments.default],
+  ["smartypants", import_remark_smartypants.default],
+  ["pangu", import_remark_pangu.default]
+];
+function buildCoreRemarkPlugins(enginePlugins) {
+  const selected = new Set(enginePlugins.map((plugin) => plugin.name));
+  return [
+    // --- Core plugins (always active) ---
+    import_remark_gfm2.default,
+    [
+      import_remark_math.default,
+      {
+        // Disable single-dollar inline math to avoid conflicts with currency
+        // signs and other dollar usages; the preprocessor converts $...$ to $$...$$.
+        singleDollarTextMath: false
+      }
+    ],
+    // --- Selectable extra syntax plugins (canonical table order) ---
+    ...EXTRA_SYNTAX_CHAIN.filter(([name]) => selected.has(name)).map(([, plugin]) => plugin),
+    // --- Formatting & normalization ---
+    import_remark_breaks.default,
+    import_remark_emoji.default,
+    import_remark_squeeze_paragraphs.default,
+    import_remark_cjk_friendly.default,
+    import_remark_cjk_friendly_gfm_strikethrough.default,
+    // --- Selectable display optimizations (canonical table order) ---
+    ...DISPLAY_OPTIMIZE_CHAIN.filter(([name]) => selected.has(name)).map(([, plugin]) => plugin)
+  ];
+}
+function buildCoreRehypePlugins(sanitizeSchema2, clobberPrefix) {
+  return [
+    // Allow raw HTML through so rehype-sanitize can handle it.
+    [import_rehype_raw.default, { passThrough: [] }],
+    // Sanitize HTML while allowing <mark> (highlight), KaTeX class names,
+    // and any extra protocols the caller permitted via the `sanitizeSchema`
+    // prop. Override `clobberPrefix` with the instance-scoped value — the
+    // spread order is intentional: our prefix wins over any caller-supplied
+    // prefix on the schema.
+    [import_rehype_sanitize.default, { ...sanitizeSchema2, clobberPrefix }],
+    // Normalize the auto-generated `<section data-footnotes>`: strip the
+    // sr-only `<h2>Footnotes</h2>` label and prepend `<hr>`. Keeps standalone
+    // single-doc rendering visually consistent with the cross-chunk aggregate
+    // footer (which builds the same shape from scratch).
+    rehypeFooterAdorn,
+    // Re-prefix intra-document hash hrefs so they match the ids that
+    // rehype-sanitize just clobbered. Must use the SAME prefix as the schema
+    // above.
+    [rehypeRebaseHashLinks_default, { prefix: clobberPrefix }],
+    import_rehype_katex.default,
+    import_rehype_unwrap_images.default
+  ];
+}
+function buildCoreRemarkRehypeOptions(enableDefinitionList) {
+  return {
+    allowDangerousHtml: true,
+    // Suppress mdast-util-to-hast's `user-content-` prefix on footnote
+    // ids/hrefs; rehype-sanitize will apply the same prefix downstream
+    // and `rehypeRebaseHashLinks` mirrors it onto matching hash hrefs.
+    // Without this, ids would end up double-prefixed
+    // (`user-content-user-content-fn-x`).
+    clobberPrefix: "",
+    handlers: {
+      // Inject definition-list HAST handlers when the extension is active.
+      ...enableDefinitionList ? import_remark_definition_list.defListHastHandlers : {}
+    }
+  };
+}
+
+// src/components/customMdastHandlers.ts
+function buildCrossChunkHandlers() {
+  return {
+    footnoteDefinition: (state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      if (s.options.phantomFootnoteLabels.has(id)) {
+        return void 0;
+      }
+      if (s.options.preserveOrphan && !s.footnoteOrder.includes(id)) {
+        s.footnoteOrder.push(id);
+      }
+      return void 0;
+    },
+    linkReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const resolved = s.definitionById.has(id);
+      if (!resolved) {
+        return void 0;
+      }
+      return {
+        type: "element",
+        tagName: "cross-chunk-link",
+        properties: {
+          // `label` is the ORIGINAL source text (mdast's `label` field), NOT
+          // the normalized `identifier`. The placeholder uses it to construct
+          // hrefs that line up with mdast-util-to-hast's default `<li id>`
+          // which also preserves source case. Registry lookups normalize
+          // internally, so cross-chunk case-insensitive matching still works.
+          label: node.label ?? node.identifier,
+          referenceType: node.referenceType,
+          documentId: s.options.documentId
+        },
+        children: s.all(node)
+      };
+    }),
+    imageReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const resolved = s.definitionById.has(id);
+      if (!resolved) return void 0;
+      return {
+        type: "element",
+        tagName: "cross-chunk-image",
+        properties: {
+          label: node.label ?? node.identifier,
+          referenceType: node.referenceType,
+          alt: node.alt ?? "",
+          documentId: s.options.documentId
+        },
+        children: []
+      };
+    }),
+    footnoteReference: ((state, node) => {
+      const s = state;
+      const id = normalizeId(node.identifier);
+      const localOccurrence = (s.footnoteCounts.get(id) ?? 0) + 1;
+      s.footnoteCounts.set(id, localOccurrence);
+      if (s.options.phantomFootnoteLabels.has(id)) {
+        return {
+          type: "element",
+          tagName: "footnote-sup",
+          properties: {
+            label: node.identifier,
+            localOccurrence,
+            documentId: s.options.documentId
+          },
+          children: []
+        };
+      }
+      if (!s.footnoteOrder.includes(id)) s.footnoteOrder.push(id);
+      return {
+        type: "element",
+        tagName: "footnote-sup",
+        properties: {
+          label: node.identifier,
+          localOccurrence,
+          documentId: s.options.documentId
+        },
+        children: []
+      };
+    })
+  };
+}
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new ListCache_default();
+  this.size = 0;
+}
+var stackClear_default = stackClear;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var stackDelete_default = stackDelete;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var stackGet_default = stackGet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var stackHas_default = stackHas;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isMasked.js
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+})();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Map.js
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache_default) {
+    var pairs = data.__data__;
+    if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var stackSet_default = stackSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear_default;
+Stack.prototype["delete"] = stackDelete_default;
+Stack.prototype.get = stackGet_default;
+Stack.prototype.has = stackHas_default;
+Stack.prototype.set = stackSet_default;
+var Stack_default = Stack;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_arrayEach.js
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+var arrayEach_default = arrayEach;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_defineProperty.js
+var defineProperty = (function() {
+  try {
+    var func = getNative_default(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+})();
+var defineProperty_default = defineProperty;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty_default) {
+    defineProperty_default(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var baseAssignValue_default = baseAssignValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assignValue.js
+var objectProto6 = Object.prototype;
+var hasOwnProperty5 = objectProto6.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty5.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue_default(object, key, value);
+  }
+}
+var assignValue_default = assignValue;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyObject.js
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue_default(object, key, newValue);
+    } else {
+      assignValue_default(object, key, newValue);
+    }
+  }
+  return object;
+}
+var copyObject_default = copyObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var baseTimes_default = baseTimes;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
+}
+var baseIsArguments_default = baseIsArguments;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isArguments.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty6 = objectProto7.hasOwnProperty;
+var propertyIsEnumerable = objectProto7.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? root_default.Buffer : void 0;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var isIndex_default = isIndex;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
+}
+var baseIsTypedArray_default = baseIsTypedArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var baseUnary_default = baseUnary;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nodeUtil.js
+var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && freeGlobal_default.process;
+var nodeUtil = (function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+})();
+var nodeUtil_default = nodeUtil;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto8 = Object.prototype;
+var hasOwnProperty7 = objectProto8.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty7.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var arrayLikeKeys_default = arrayLikeKeys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isPrototype.js
+var objectProto9 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto9;
+  return value === proto;
+}
+var isPrototype_default = isPrototype;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = overArg_default(Object.keys, Object);
+var nativeKeys_default = nativeKeys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseKeys.js
+var objectProto10 = Object.prototype;
+var hasOwnProperty8 = objectProto10.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype_default(object)) {
+    return nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty8.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeys_default = baseKeys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object) : baseKeys_default(object);
+}
+var keys_default = keys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssign.js
+function baseAssign(object, source) {
+  return object && copyObject_default(source, keys_default(source), object);
+}
+var baseAssign_default = baseAssign;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nativeKeysIn.js
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var nativeKeysIn_default = nativeKeysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseKeysIn.js
+var objectProto11 = Object.prototype;
+var hasOwnProperty9 = objectProto11.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject_default(object)) {
+    return nativeKeysIn_default(object);
+  }
+  var isProto = isPrototype_default(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty9.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeysIn_default = baseKeysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/keysIn.js
+function keysIn(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object, true) : baseKeysIn_default(object);
+}
+var keysIn_default = keysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssignIn.js
+function baseAssignIn(object, source) {
+  return object && copyObject_default(source, keysIn_default(source), object);
+}
+var baseAssignIn_default = baseAssignIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneBuffer.js
+var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3;
+var Buffer3 = moduleExports3 ? root_default.Buffer : void 0;
+var allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+var cloneBuffer_default = cloneBuffer;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyArray.js
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var copyArray_default = copyArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var arrayFilter_default = arrayFilter;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default = stubArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getSymbols.js
+var objectProto12 = Object.prototype;
+var propertyIsEnumerable2 = objectProto12.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable2.call(object, symbol);
+  });
+};
+var getSymbols_default = getSymbols;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copySymbols.js
+function copySymbols(source, object) {
+  return copyObject_default(source, getSymbols_default(source), object);
+}
+var copySymbols_default = copySymbols;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var arrayPush_default = arrayPush;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getPrototype.js
+var getPrototype = overArg_default(Object.getPrototypeOf, Object);
+var getPrototype_default = getPrototype;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getSymbolsIn.js
+var nativeGetSymbols2 = Object.getOwnPropertySymbols;
+var getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush_default(result, getSymbols_default(object));
+    object = getPrototype_default(object);
+  }
+  return result;
+};
+var getSymbolsIn_default = getSymbolsIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copySymbolsIn.js
+function copySymbolsIn(source, object) {
+  return copyObject_default(source, getSymbolsIn_default(source), object);
+}
+var copySymbolsIn_default = copySymbolsIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : arrayPush_default(result, symbolsFunc(object));
+}
+var baseGetAllKeys_default = baseGetAllKeys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return baseGetAllKeys_default(object, keys_default, getSymbols_default);
+}
+var getAllKeys_default = getAllKeys;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getAllKeysIn.js
+function getAllKeysIn(object) {
+  return baseGetAllKeys_default(object, keysIn_default, getSymbolsIn_default);
+}
+var getAllKeysIn_default = getAllKeysIn;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_DataView.js
+var DataView = getNative_default(root_default, "DataView");
+var DataView_default = DataView;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Promise.js
+var Promise2 = getNative_default(root_default, "Promise");
+var Promise_default = Promise2;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Set.js
+var Set2 = getNative_default(root_default, "Set");
+var Set_default = Set2;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_WeakMap.js
+var WeakMap = getNative_default(root_default, "WeakMap");
+var WeakMap_default = WeakMap;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getTag.js
+var mapTag2 = "[object Map]";
+var objectTag2 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag2 = "[object Set]";
+var weakMapTag2 = "[object WeakMap]";
+var dataViewTag2 = "[object DataView]";
+var dataViewCtorString = toSource_default(DataView_default);
+var mapCtorString = toSource_default(Map_default);
+var promiseCtorString = toSource_default(Promise_default);
+var setCtorString = toSource_default(Set_default);
+var weakMapCtorString = toSource_default(WeakMap_default);
+var getTag = baseGetTag_default;
+if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
+  getTag = function(value) {
+    var result = baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag2;
+        case mapCtorString:
+          return mapTag2;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag2;
+        case weakMapCtorString:
+          return weakMapTag2;
+      }
+    }
+    return result;
+  };
+}
+var getTag_default = getTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneArray.js
+var objectProto13 = Object.prototype;
+var hasOwnProperty10 = objectProto13.hasOwnProperty;
+function initCloneArray(array) {
+  var length = array.length, result = new array.constructor(length);
+  if (length && typeof array[0] == "string" && hasOwnProperty10.call(array, "index")) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+var initCloneArray_default = initCloneArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_Uint8Array.js
+var Uint8Array2 = root_default.Uint8Array;
+var Uint8Array_default = Uint8Array2;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneArrayBuffer.js
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer));
+  return result;
+}
+var cloneArrayBuffer_default = cloneArrayBuffer;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneDataView.js
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var cloneDataView_default = cloneDataView;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneRegExp.js
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var cloneRegExp_default = cloneRegExp;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneSymbol.js
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+var cloneSymbol_default = cloneSymbol;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneTypedArray.js
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var cloneTypedArray_default = cloneTypedArray;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneByTag.js
+var boolTag2 = "[object Boolean]";
+var dateTag2 = "[object Date]";
+var mapTag3 = "[object Map]";
+var numberTag2 = "[object Number]";
+var regexpTag2 = "[object RegExp]";
+var setTag3 = "[object Set]";
+var stringTag2 = "[object String]";
+var symbolTag = "[object Symbol]";
+var arrayBufferTag2 = "[object ArrayBuffer]";
+var dataViewTag3 = "[object DataView]";
+var float32Tag2 = "[object Float32Array]";
+var float64Tag2 = "[object Float64Array]";
+var int8Tag2 = "[object Int8Array]";
+var int16Tag2 = "[object Int16Array]";
+var int32Tag2 = "[object Int32Array]";
+var uint8Tag2 = "[object Uint8Array]";
+var uint8ClampedTag2 = "[object Uint8ClampedArray]";
+var uint16Tag2 = "[object Uint16Array]";
+var uint32Tag2 = "[object Uint32Array]";
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag2:
+      return cloneArrayBuffer_default(object);
+    case boolTag2:
+    case dateTag2:
+      return new Ctor(+object);
+    case dataViewTag3:
+      return cloneDataView_default(object, isDeep);
+    case float32Tag2:
+    case float64Tag2:
+    case int8Tag2:
+    case int16Tag2:
+    case int32Tag2:
+    case uint8Tag2:
+    case uint8ClampedTag2:
+    case uint16Tag2:
+    case uint32Tag2:
+      return cloneTypedArray_default(object, isDeep);
+    case mapTag3:
+      return new Ctor();
+    case numberTag2:
+    case stringTag2:
+      return new Ctor(object);
+    case regexpTag2:
+      return cloneRegExp_default(object);
+    case setTag3:
+      return new Ctor();
+    case symbolTag:
+      return cloneSymbol_default(object);
+  }
+}
+var initCloneByTag_default = initCloneByTag;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseCreate.js
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ (function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject_default(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+})();
+var baseCreate_default = baseCreate;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneObject.js
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
+}
+var initCloneObject_default = initCloneObject;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsMap.js
+var mapTag4 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike_default(value) && getTag_default(value) == mapTag4;
+}
+var baseIsMap_default = baseIsMap;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isMap.js
+var nodeIsMap = nodeUtil_default && nodeUtil_default.isMap;
+var isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default;
+var isMap_default = isMap;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsSet.js
+var setTag4 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike_default(value) && getTag_default(value) == setTag4;
+}
+var baseIsSet_default = baseIsSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isSet.js
+var nodeIsSet = nodeUtil_default && nodeUtil_default.isSet;
+var isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default;
+var isSet_default = isSet;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseClone.js
+var CLONE_DEEP_FLAG = 1;
+var CLONE_FLAT_FLAG = 2;
+var CLONE_SYMBOLS_FLAG = 4;
+var argsTag3 = "[object Arguments]";
+var arrayTag2 = "[object Array]";
+var boolTag3 = "[object Boolean]";
+var dateTag3 = "[object Date]";
+var errorTag2 = "[object Error]";
+var funcTag3 = "[object Function]";
+var genTag2 = "[object GeneratorFunction]";
+var mapTag5 = "[object Map]";
+var numberTag3 = "[object Number]";
+var objectTag3 = "[object Object]";
+var regexpTag3 = "[object RegExp]";
+var setTag5 = "[object Set]";
+var stringTag3 = "[object String]";
+var symbolTag2 = "[object Symbol]";
+var weakMapTag3 = "[object WeakMap]";
+var arrayBufferTag3 = "[object ArrayBuffer]";
+var dataViewTag4 = "[object DataView]";
+var float32Tag3 = "[object Float32Array]";
+var float64Tag3 = "[object Float64Array]";
+var int8Tag3 = "[object Int8Array]";
+var int16Tag3 = "[object Int16Array]";
+var int32Tag3 = "[object Int32Array]";
+var uint8Tag3 = "[object Uint8Array]";
+var uint8ClampedTag3 = "[object Uint8ClampedArray]";
+var uint16Tag3 = "[object Uint16Array]";
+var uint32Tag3 = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag3] = cloneableTags[arrayTag2] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag3] = cloneableTags[float64Tag3] = cloneableTags[int8Tag3] = cloneableTags[int16Tag3] = cloneableTags[int32Tag3] = cloneableTags[mapTag5] = cloneableTags[numberTag3] = cloneableTags[objectTag3] = cloneableTags[regexpTag3] = cloneableTags[setTag5] = cloneableTags[stringTag3] = cloneableTags[symbolTag2] = cloneableTags[uint8Tag3] = cloneableTags[uint8ClampedTag3] = cloneableTags[uint16Tag3] = cloneableTags[uint32Tag3] = true;
+cloneableTags[errorTag2] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false;
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject_default(value)) {
+    return value;
+  }
+  var isArr = isArray_default(value);
+  if (isArr) {
+    result = initCloneArray_default(value);
+    if (!isDeep) {
+      return copyArray_default(value, result);
+    }
+  } else {
+    var tag = getTag_default(value), isFunc = tag == funcTag3 || tag == genTag2;
+    if (isBuffer_default(value)) {
+      return cloneBuffer_default(value, isDeep);
+    }
+    if (tag == objectTag3 || tag == argsTag3 || isFunc && !object) {
+      result = isFlat || isFunc ? {} : initCloneObject_default(value);
+      if (!isDeep) {
+        return isFlat ? copySymbolsIn_default(value, baseAssignIn_default(result, value)) : copySymbols_default(value, baseAssign_default(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag_default(value, tag, isDeep);
+    }
+  }
+  stack || (stack = new Stack_default());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet_default(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap_default(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = isFull ? isFlat ? getAllKeysIn_default : getAllKeys_default : isFlat ? keysIn_default : keys_default;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach_default(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue_default(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+var baseClone_default = baseClone;
+
+// ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/cloneDeep.js
+var CLONE_DEEP_FLAG2 = 1;
+var CLONE_SYMBOLS_FLAG2 = 4;
+function cloneDeep(value) {
+  return baseClone_default(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG2);
+}
+var cloneDeep_default = cloneDeep;
+
+// src/components/sanitizeSchema.ts
+var import_rehype_sanitize2 = require("rehype-sanitize");
+function mergeClassNameAllowlist(existing, extraClassNames) {
+  const entries = existing ? [...existing] : [];
+  const idx = entries.findIndex(
+    (entry) => typeof entry === "string" ? entry === "className" : entry[0] === "className"
+  );
+  if (idx === -1) {
+    return [...entries, ["className", ...extraClassNames]];
+  }
+  const current = entries[idx];
+  const merged = typeof current === "string" ? ["className", ...extraClassNames] : [...current, ...extraClassNames];
+  entries[idx] = merged;
+  return entries;
+}
+var crossChunkTags = ["cross-chunk-link", "cross-chunk-image", "footnote-sup"];
+var sanitizeSchema = cloneDeep_default({
+  ...import_rehype_sanitize2.defaultSchema,
+  tagNames: [...import_rehype_sanitize2.defaultSchema.tagNames || [], "mark", ...crossChunkTags],
+  attributes: {
+    ...import_rehype_sanitize2.defaultSchema.attributes,
+    code: mergeClassNameAllowlist(import_rehype_sanitize2.defaultSchema.attributes?.code, ["math-inline", "math-display"]),
+    "cross-chunk-link": ["label", "referenceType", "documentId"],
+    "cross-chunk-image": ["label", "referenceType", "documentId", "alt"],
+    "footnote-sup": ["label", "localOccurrence", "documentId"]
+  }
+});
+
+// src/components/crossChunkUrlSanitize.ts
+function fakeElement(tagName, key, url) {
+  return { type: "element", tagName, properties: { [key]: url }, children: [] };
+}
+function isRelative(url, colon) {
+  if (colon === -1) return true;
+  const slash = url.indexOf("/");
+  const questionMark = url.indexOf("?");
+  const numberSign = url.indexOf("#");
+  if (slash !== -1 && colon > slash) return true;
+  if (questionMark !== -1 && colon > questionMark) return true;
+  if (numberSign !== -1 && colon > numberSign) return true;
+  return false;
+}
+function isProtocolAllowed(url, allowed) {
+  const colon = url.indexOf(":");
+  if (isRelative(url, colon)) return true;
+  const protocol = url.slice(0, colon);
+  return allowed.some((p) => p === protocol);
+}
+function sanitizeCrossChunkUrl(rawUrl, key, tagName, urlTransform, schema) {
+  const transformed = urlTransform(rawUrl, key, fakeElement(tagName, key, rawUrl));
+  if (transformed == null) return "";
+  const stringUrl = String(transformed);
+  if (stringUrl === "") return "";
+  const callerProtocols = schema.protocols;
+  const allowed = callerProtocols === void 0 || callerProtocols === null ? sanitizeSchema.protocols?.[key] : callerProtocols[key];
+  if (!allowed || allowed.length === 0) return stringUrl;
+  return isProtocolAllowed(stringUrl, allowed) ? stringUrl : "";
+}
+
+// src/plugins/defs.ts
+function getEnginePluginInternals(plugin) {
+  const candidate = plugin;
+  return candidate != null && candidate["~sealed"] === "ai-react-markdown/engine-plugin" && candidate.stage != null ? candidate : null;
+}
+
+// src/plugins/catalog.ts
+var seal = (name, stage) => Object.freeze({
+  name,
+  "~sealed": "ai-react-markdown/engine-plugin",
+  stage
+});
+var highlight = seal("highlight", "extraSyntax");
+var definitionList = seal("definitionList", "extraSyntax");
+var removeComments = seal("removeComments", "displayOptimize");
+var smartypants = seal("smartypants", "displayOptimize");
+var pangu = seal("pangu", "displayOptimize");
+var defaultEnginePlugins = Object.freeze([
+  highlight,
+  definitionList,
+  removeComments,
+  smartypants,
+  pangu
+]);
+
+// src/components/shortenDocumentId.ts
+var BASE62_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function toBase62(n) {
+  if (n === 0) return BASE62_ALPHABET[0];
+  let v = n >>> 0;
+  let out = "";
+  while (v > 0) {
+    out = BASE62_ALPHABET[v % 62] + out;
+    v = Math.floor(v / 62);
+  }
+  return out;
+}
+function rotl32(x, r) {
+  return (x << r | x >>> 32 - r) >>> 0;
+}
+var C1 = 3432918353;
+var C2 = 461845907;
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
+function murmur3_32(s, seed = 0) {
+  const bytes = UTF8_ENCODER.encode(s);
+  const len = bytes.length;
+  let h1 = seed >>> 0;
+  const nblocks = len >>> 2;
+  for (let i = 0; i < nblocks; i++) {
+    const b = i * 4;
+    let k1 = bytes[b] | bytes[b + 1] << 8 | bytes[b + 2] << 16 | bytes[b + 3] << 24;
+    k1 = Math.imul(k1, C1);
+    k1 = rotl32(k1, 15);
+    k1 = Math.imul(k1, C2);
+    h1 ^= k1;
+    h1 = rotl32(h1, 13);
+    h1 = Math.imul(h1, 5) + 3864292196 >>> 0;
+  }
+  const tail = nblocks * 4;
+  const rem = len & 3;
+  if (rem > 0) {
+    let k1 = 0;
+    if (rem === 3) k1 ^= bytes[tail + 2] << 16;
+    if (rem >= 2) k1 ^= bytes[tail + 1] << 8;
+    k1 ^= bytes[tail];
+    k1 = Math.imul(k1, C1);
+    k1 = rotl32(k1, 15);
+    k1 = Math.imul(k1, C2);
+    h1 ^= k1;
+  }
+  h1 ^= len;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function shortenDocumentId(id, threshold = 16) {
+  if (id.length <= threshold) return id;
+  return toBase62(murmur3_32(id));
+}
+
+// src/components/devStageTimings.ts
+var PIPELINE_STAGES = ["scan", "parse", "transform", "build", "render"];
+var STAGE_MEASURE_PREFIX = "ai-markdown:stage:";
+var STAGE_NAMES = Object.fromEntries(
+  PIPELINE_STAGES.map((stage) => [stage, `${STAGE_MEASURE_PREFIX}${stage}`])
+);
+var ENABLED = (() => {
+  if (typeof performance === "undefined" || typeof performance.measure !== "function") {
+    return false;
+  }
+  try {
+    const probe = `${STAGE_MEASURE_PREFIX}probe`;
+    performance.measure(probe, { start: 0, end: 0 });
+    performance.clearMeasures?.(probe);
+    return true;
+  } catch {
+    return false;
+  }
+})();
+var stageListeners = /* @__PURE__ */ new Set();
+function subscribeStageTimings(listener) {
+  stageListeners.add(listener);
+  return () => {
+    stageListeners.delete(listener);
+  };
+}
+function measureStage(stage, fn, instanceId) {
+  if (!ENABLED) return fn();
+  const start = performance.now();
+  const result = fn();
+  const end = performance.now();
+  for (const listener of stageListeners) listener(stage, end - start, instanceId);
+  performance.measure(STAGE_NAMES[stage], { start, end });
+  return result;
+}
+
+// src/components/extendSanitizeSchema.ts
+function extendSanitizeSchema(modifier) {
+  const draft = cloneDeep_default(sanitizeSchema);
+  const result = modifier(draft);
+  return result ?? draft;
+}
+
+// src/components/smoothStream/controller.ts
+var SMOOTH_STREAM_PACING_PRESETS = Object.freeze({
+  smooth: Object.freeze({
+    bufferFactor: 1.7,
+    correctionTauMs: 280,
+    emaTauMs: 2600,
+    minCharsPerSecond: 4,
+    drainMs: 320
+  }),
+  balanced: Object.freeze({
+    bufferFactor: 1,
+    correctionTauMs: 180,
+    emaTauMs: 1800,
+    minCharsPerSecond: 6,
+    drainMs: 240
+  }),
+  responsive: Object.freeze({
+    bufferFactor: 0.45,
+    correctionTauMs: 110,
+    emaTauMs: 1100,
+    minCharsPerSecond: 10,
+    drainMs: 150
+  })
+});
+var MAX_TARGET_BUFFER_MS = 1200;
+var defaultNow = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
+var defaultSchedule = (cb) => {
+  if (typeof requestAnimationFrame === "function") {
+    const id2 = requestAnimationFrame(() => cb());
+    return () => cancelAnimationFrame(id2);
+  }
+  const id = setTimeout(cb, 16);
+  return () => clearTimeout(id);
+};
+var finiteOr = (value, fallback) => value !== void 0 && Number.isFinite(value) ? value : fallback;
+var segmenter = typeof Intl !== "undefined" && typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : void 0;
+var graphemeEnds = (text, base) => {
+  const ends = [];
+  if (segmenter) {
+    for (const part of segmenter.segment(text)) {
+      ends.push(base + part.index + part.segment.length);
+    }
+  } else {
+    let offset = base;
+    for (const cp of text) {
+      offset += cp.length;
+      ends.push(offset);
+    }
+  }
+  return ends;
+};
+var createSmoothStreamController = (options = {}) => {
+  const now = options.now ?? defaultNow;
+  const schedule = options.schedule ?? defaultSchedule;
+  let source = "";
+  let visibleEnd = 0;
+  let pending = [];
+  let tentativeEnd = 0;
+  let finished = false;
+  let drainDeadlineAt;
+  let initialized = false;
+  let visibleCache = "";
+  let credit = 0;
+  let lastTickAt = 0;
+  let cancelFrame;
+  let disposed = false;
+  let rateEma;
+  let intervalEma;
+  let lastArrivalAt;
+  const listeners = /* @__PURE__ */ new Set();
+  const resolveParams = () => {
+    const preset = SMOOTH_STREAM_PACING_PRESETS[options.pacing] ?? SMOOTH_STREAM_PACING_PRESETS.balanced;
+    return {
+      bufferFactor: finiteOr(options.bufferFactor, preset.bufferFactor),
+      correctionTauMs: finiteOr(options.correctionTauMs, preset.correctionTauMs),
+      emaTauMs: finiteOr(options.emaTauMs, preset.emaTauMs),
+      minCharsPerSecond: finiteOr(options.minCharsPerSecond, preset.minCharsPerSecond),
+      drainMs: finiteOr(options.drainMs, preset.drainMs)
+    };
+  };
+  const recordArrival = (t, added) => {
+    if (added <= 0) return;
+    if (lastArrivalAt === void 0) {
+      lastArrivalAt = t;
+      return;
+    }
+    const gap = Math.max(1, t - lastArrivalAt);
+    lastArrivalAt = t;
+    const tau = Math.max(1, resolveParams().emaTauMs);
+    if (gap > tau) return;
+    const alpha = 1 - Math.exp(-gap / tau);
+    const instantRate = added * 1e3 / gap;
+    rateEma = (rateEma ?? 0) + alpha * (instantRate - (rateEma ?? 0));
+    intervalEma = (intervalEma ?? 0) + alpha * (gap - (intervalEma ?? 0));
+  };
+  const notify = () => {
+    visibleCache = source.slice(0, visibleEnd);
+    for (const listener of [...listeners]) listener();
+  };
+  const cancelScheduled = () => {
+    cancelFrame?.();
+    cancelFrame = void 0;
+  };
+  const ensureScheduled = () => {
+    if (disposed || cancelFrame || pending.length === 0) return;
+    lastTickAt = now();
+    credit = 0;
+    cancelFrame = schedule(tick);
+  };
+  const tick = () => {
+    cancelFrame = void 0;
+    if (disposed) return;
+    const t = now();
+    const dt = Math.max(0, t - lastTickAt);
+    lastTickAt = t;
+    const params = resolveParams();
+    let rate;
+    if (finished && drainDeadlineAt !== void 0) {
+      rate = Math.max(params.minCharsPerSecond, pending.length * 1e3 / Math.max(1, drainDeadlineAt - t));
+    } else if (rateEma !== void 0 && intervalEma !== void 0) {
+      const targetBuffer = Math.max(
+        1,
+        Math.min(params.bufferFactor * rateEma * (intervalEma / 1e3), rateEma * MAX_TARGET_BUFFER_MS / 1e3)
+      );
+      rate = Math.max(
+        params.minCharsPerSecond,
+        rateEma + (pending.length - targetBuffer) * 1e3 / Math.max(1, params.correctionTauMs)
+      );
+    } else {
+      rate = Math.max(params.minCharsPerSecond, pending.length * 1e3 / Math.max(1, params.correctionTauMs));
+    }
+    credit += rate * dt / 1e3;
+    const reveal = Math.min(Math.floor(credit), pending.length);
+    if (reveal > 0) {
+      visibleEnd = pending[reveal - 1];
+      pending = pending.slice(reveal);
+      credit = pending.length > 0 ? credit - reveal : 0;
+      notify();
+    }
+    if (!disposed && !cancelFrame && pending.length > 0) cancelFrame = schedule(tick);
+  };
+  const resegmentTail = () => {
+    const from = pending.length > 0 ? pending[pending.length - 1] : visibleEnd;
+    const ends = graphemeEnds(source.slice(from), from);
+    if (ends.length === 0) {
+      tentativeEnd = from;
+      return;
+    }
+    tentativeEnd = ends[ends.length - 1];
+    const confirmedEnds = finished ? ends : ends.slice(0, -1);
+    for (const end of confirmedEnds) pending.push(end);
+  };
+  const snap = (next) => {
+    disposed = false;
+    initialized = true;
+    finished = false;
+    drainDeadlineAt = void 0;
+    rateEma = void 0;
+    intervalEma = void 0;
+    lastArrivalAt = void 0;
+    source = next;
+    visibleEnd = next.length;
+    tentativeEnd = next.length;
+    pending = [];
+    credit = 0;
+    cancelScheduled();
+    if (visibleCache !== next) notify();
+  };
+  const revive = () => {
+    if (!disposed) return;
+    disposed = false;
+    ensureScheduled();
+  };
+  return {
+    update(next) {
+      revive();
+      if (initialized && next === source) return;
+      if (!initialized || !next.startsWith(source)) {
+        snap(next);
+        return;
+      }
+      finished = false;
+      drainDeadlineAt = void 0;
+      const previousLength = source.length;
+      source = next;
+      resegmentTail();
+      recordArrival(now(), next.length - previousLength);
+      ensureScheduled();
+    },
+    finish() {
+      revive();
+      if (finished) return;
+      finished = true;
+      lastArrivalAt = void 0;
+      drainDeadlineAt = now() + resolveParams().drainMs;
+      if (tentativeEnd > (pending.length > 0 ? pending[pending.length - 1] : visibleEnd)) {
+        pending.push(tentativeEnd);
+      }
+      ensureScheduled();
+    },
+    snap,
+    flush() {
+      disposed = false;
+      if (visibleEnd === source.length) return;
+      visibleEnd = source.length;
+      tentativeEnd = source.length;
+      pending = [];
+      credit = 0;
+      cancelScheduled();
+      notify();
+    },
+    subscribe(listener) {
+      revive();
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getVisible: () => visibleCache,
+    isDrained: () => visibleEnd === source.length,
+    dispose() {
+      disposed = true;
+      cancelScheduled();
+      listeners.clear();
+    }
+  };
+};
+
+// src/preprocessors/latex.ts
+function getRepeatedMarkerLength(content, start, marker) {
+  let end = start;
+  while (end < content.length && content[end] === marker) {
+    end += 1;
+  }
+  return end - start;
+}
+var HTML_TAG_REGEX = /<\/?(span|div|p|br|hr|img|a|em|strong|b|i|u|s|sub|sup|code|pre|table|tr|td|th|thead|tbody|tfoot|ul|ol|li|dl|dt|dd|h[1-6]|blockquote|details|summary|figure|figcaption|section|article|aside|nav|header|footer|main|mark|del|ins|small|abbr|cite|dfn|kbd|samp|var|ruby|rt|rp|bdo|wbr|input|button|select|textarea|label|fieldset|legend|output|iframe|video|audio|source|canvas|svg|math|time)(?:\s[^>]*)?\/?>/iy;
+var LITERAL_CONTENT_TAGS = /* @__PURE__ */ new Set(["code", "pre", "kbd", "samp", "math", "svg"]);
+var LITERAL_CONTENT_CLOSE_REGEX = {
+  code: /<\/code\s*>/gi,
+  pre: /<\/pre\s*>/gi,
+  kbd: /<\/kbd\s*>/gi,
+  samp: /<\/samp\s*>/gi,
+  math: /<\/math\s*>/gi,
+  svg: /<\/svg\s*>/gi
+};
+function isAtLineStart(content, pos) {
+  let i = pos - 1;
+  let spaces = 0;
+  while (i >= 0 && content[i] === " ") {
+    spaces++;
+    if (spaces > 3) return false;
+    i--;
+  }
+  return i < 0 || content[i] === "\n" || content[i] === "\r";
+}
+function findClosingBacktickRun(content, start, n) {
+  let i = start;
+  while (i < content.length) {
+    if (content[i] === "`") {
+      const runLen = getRepeatedMarkerLength(content, i, "`");
+      if (runLen === n) return i;
+      i += runLen;
+    } else {
+      i += 1;
+    }
+  }
+  return -1;
+}
+function splitByProtectedRegions(content) {
+  const segments = [];
+  let lastIndex = 0;
+  let multilineStart = -1;
+  let multilineFenceMarker = null;
+  let multilineFenceLength = 0;
+  function pushProtected(start, end) {
+    if (start > lastIndex) {
+      segments.push({ text: content.substring(lastIndex, start), isCode: false });
+    }
+    segments.push({ text: content.substring(start, end), isCode: true });
+    lastIndex = end;
+  }
+  let i = 0;
+  while (i < content.length) {
+    const char = content[i];
+    if (multilineStart !== -1) {
+      if (char === multilineFenceMarker) {
+        const runLen = getRepeatedMarkerLength(content, i, multilineFenceMarker);
+        if (runLen >= multilineFenceLength && isAtLineStart(content, i)) {
+          pushProtected(multilineStart, i + runLen);
+          multilineStart = -1;
+          multilineFenceMarker = null;
+          multilineFenceLength = 0;
+          i += runLen;
+          continue;
+        }
+        i += runLen;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    if (char === "`" || char === "~") {
+      const runLen = getRepeatedMarkerLength(content, i, char);
+      if (runLen >= 3 && isAtLineStart(content, i)) {
+        multilineStart = i;
+        multilineFenceMarker = char;
+        multilineFenceLength = runLen;
+        i += runLen;
+        continue;
+      }
+      if (char === "`") {
+        const closeIdx = findClosingBacktickRun(content, i + runLen, runLen);
+        if (closeIdx !== -1) {
+          pushProtected(i, closeIdx + runLen);
+          i = closeIdx + runLen;
+          continue;
+        }
+      }
+      i += runLen;
+      continue;
+    }
+    if (char === "<") {
+      HTML_TAG_REGEX.lastIndex = i;
+      const tagMatch = HTML_TAG_REGEX.exec(content);
+      if (tagMatch) {
+        let endIndex = i + tagMatch[0].length;
+        const tagName = tagMatch[1].toLowerCase();
+        const isOpeningPairedTag = content[i + 1] !== "/" && !tagMatch[0].endsWith("/>") && LITERAL_CONTENT_TAGS.has(tagName);
+        if (isOpeningPairedTag) {
+          const closeRegex = LITERAL_CONTENT_CLOSE_REGEX[tagName];
+          closeRegex.lastIndex = endIndex;
+          const closeMatch = closeRegex.exec(content);
+          if (closeMatch) {
+            endIndex = closeMatch.index + closeMatch[0].length;
+          } else {
+            endIndex = content.length;
+          }
+        }
+        pushProtected(i, endIndex);
+        i = endIndex;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  if (multilineStart !== -1) {
+    pushProtected(multilineStart, content.length);
+  }
+  if (lastIndex < content.length) {
+    segments.push({ text: content.substring(lastIndex), isCode: false });
+  }
+  return segments;
+}
+function escapeMhchemCommands(text) {
+  return text.replaceAll("$\\ce{", "$\\\\ce{").replaceAll("$\\pu{", "$\\\\pu{");
+}
+var CURRENCY_REGEX = /(?<![\\$])\$(?!\$)(?=\d+(?:,\d{3})*(?:\.\d+)?(?:[KMBkmb])?(?:\s|$|[^a-zA-Z\d]))/g;
+var NO_ESCAPED_DOLLAR_REGEX = /(?<![\\$])\$(?!\$)/g;
+var DELIMITERS_REGEX = /(?<!!)\\\[([\S\s]*?[^\\])\\](?!\()|\\\((.*?)\\\)/g;
+var ARRAY_COL_SPEC_OR_PIPE_REGEX = /(\\begin\{(?:array|tabular[x*]?)\}\{[^}]*\})|(?<!\\)\|/g;
+var LATEX_BLOCK_REGEX = /\$\$([\S\s]*?)\$\$|(?<![\\$])\$(?!\$)((?:[^$\n]|\\\$)*?)(?<![\\`])\$(?!\$)/g;
+var TEXT_COMMAND = "\\text{";
+var SINGLE_DOLLAR_REGEX = /(?<![\\$])\$(?!\$)((?:[^$\n]|\\[$])+?)(?<!\\)(?<!`)\$(?!\$)/g;
+function escapeCurrencyDollarSigns(text) {
+  const parts = [];
+  let lastIndex = 0;
+  const currencyMatches = Array.from(text.matchAll(CURRENCY_REGEX));
+  let currentLineProcessed = "";
+  for (let i = 0; i < currencyMatches.length; i++) {
+    const match = currencyMatches[i];
+    const segment = text.substring(lastIndex, match.index);
+    parts.push(segment);
+    const newlineIdx = Math.max(segment.lastIndexOf("\n"), segment.lastIndexOf("\r"));
+    if (newlineIdx !== -1) {
+      currentLineProcessed = segment.substring(newlineIdx + 1);
+    } else {
+      currentLineProcessed += segment;
+    }
+    let needEscape = true;
+    let restBeforeNextMatchOrEnd = "";
+    if (i < currencyMatches.length - 1) {
+      const nextMatch = currencyMatches[i + 1];
+      if (nextMatch.index - match.index > 1) {
+        restBeforeNextMatchOrEnd = text.substring(match.index + 1, nextMatch.index);
+      }
+    } else {
+      restBeforeNextMatchOrEnd = text.substring(match.index + 1);
+    }
+    const firstLineBeforeNextMatch = restBeforeNextMatchOrEnd.split(/\r\n|\r|\n/g)[0];
+    if (Array.from(firstLineBeforeNextMatch.matchAll(NO_ESCAPED_DOLLAR_REGEX)).length % 2 !== 0) {
+      const wholeLineBeforeNextMatchWithoutCurrentDollar = currentLineProcessed + firstLineBeforeNextMatch;
+      if (Array.from(wholeLineBeforeNextMatchWithoutCurrentDollar.matchAll(NO_ESCAPED_DOLLAR_REGEX)).length % 2 !== 0) {
+        needEscape = false;
+      }
+    }
+    const replacement = needEscape ? "\\$" : "$";
+    parts.push(replacement);
+    currentLineProcessed += replacement;
+    lastIndex = match.index + 1;
+  }
+  parts.push(text.substring(lastIndex));
+  return parts.join("");
+}
+function convertLatexDelimiters(text) {
+  return text.replaceAll(
+    DELIMITERS_REGEX,
+    (match, squareBracket, roundBracket) => {
+      if (squareBracket !== void 0) {
+        return `$$${squareBracket}$$`;
+      } else if (roundBracket !== void 0) {
+        return `$${roundBracket}$`;
+      }
+      return match;
+    }
+  );
+}
+var replaceUnescapedPipes = (formula) => (
+  // Use \vert{} so the control sequence terminates before the next token.
+  // Preserve `|` inside \begin{array}{...} / \begin{tabular}{...} column specifiers.
+  formula.replaceAll(
+    ARRAY_COL_SPEC_OR_PIPE_REGEX,
+    (match, colSpec) => colSpec !== void 0 ? match : "\\vert{}"
+  )
+);
+function escapeLatexPipes(text) {
+  return text.replaceAll(LATEX_BLOCK_REGEX, (match, display, inline) => {
+    if (display !== void 0) return `$$${replaceUnescapedPipes(display)}$$`;
+    if (inline !== void 0) return `$${replaceUnescapedPipes(inline)}$`;
+    return match;
+  });
+}
+function isEscapedByBackslashRun(text, pos) {
+  let count = 0;
+  let j = pos - 1;
+  while (j >= 0 && text[j] === "\\") {
+    count++;
+    j--;
+  }
+  return count % 2 === 1;
+}
+function findUnclosedDelimiterStart(text, mode) {
+  let unclosedStart = -1;
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "$" && i + 1 < text.length && text[i + 1] === "$" && !isEscapedByBackslashRun(text, i)) {
+      unclosedStart = unclosedStart === -1 ? i : -1;
+      i += 2;
+    } else if (mode === "both" && text[i] === "$" && !isEscapedByBackslashRun(text, i) && (i + 1 >= text.length || text[i + 1] !== "$")) {
+      unclosedStart = unclosedStart === -1 ? i : -1;
+      i += 1;
+    } else {
+      i += 1;
+    }
+  }
+  return unclosedStart;
+}
+function escapeLatexPipesInUnclosed(text) {
+  const unclosedStart = findUnclosedDelimiterStart(text, "both");
+  if (unclosedStart === -1) return text;
+  const before = text.substring(0, unclosedStart);
+  const delimLen = text[unclosedStart + 1] === "$" ? 2 : 1;
+  const delim = text.substring(unclosedStart, unclosedStart + delimLen);
+  const tail = text.substring(unclosedStart + delimLen);
+  return before + delim + replaceUnescapedPipes(tail);
+}
+function truncateUnclosedLatexBlock(text) {
+  const unclosedStart = findUnclosedDelimiterStart(text, "double-only");
+  if (unclosedStart === -1) return text;
+  return text.substring(0, unclosedStart).trimEnd();
+}
+function escapeTextUnderscores(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf(TEXT_COMMAND, i);
+    if (start === -1) {
+      out += text.substring(i);
+      return out;
+    }
+    out += text.substring(i, start);
+    const bodyStart = start + TEXT_COMMAND.length;
+    let depth = 1;
+    let j = bodyStart;
+    while (j < text.length && depth > 0) {
+      const c = text[j];
+      if (c === "\\" && j + 1 < text.length) {
+        j += 2;
+        continue;
+      }
+      if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth !== 0) {
+      out += text.substring(start);
+      return out;
+    }
+    const body = text.substring(bodyStart, j);
+    const escapedBody = body.replaceAll(/(?<!\\)_/g, "\\_");
+    out += `\\text{${escapedBody}}`;
+    i = j + 1;
+  }
+  return out;
+}
+function convertSingleToDoubleDollar(text) {
+  return text.replaceAll(SINGLE_DOLLAR_REGEX, (_match, content) => `$$${content}$$`);
+}
+function preprocessLaTeX(str) {
+  if (!hasLatexTrigger(str)) return str;
+  const segments = splitByProtectedRegions(str);
+  const result = segments.map((segment) => {
+    if (segment.isCode) return segment.text;
+    let text = segment.text;
+    text = escapeMhchemCommands(text);
+    text = escapeCurrencyDollarSigns(text);
+    text = convertLatexDelimiters(text);
+    text = escapeLatexPipes(text);
+    text = escapeLatexPipesInUnclosed(text);
+    text = escapeTextUnderscores(text);
+    text = convertSingleToDoubleDollar(text);
+    text = truncateUnclosedLatexBlock(text);
+    return text;
+  });
+  return result.join("");
+}
+function hasLatexTrigger(str) {
+  return str.includes("$") || str.includes("\\[") || str.includes("\\(");
+}
+function hasUnclosedTextCommand(text) {
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf(TEXT_COMMAND, i);
+    if (start === -1) return false;
+    let depth = 1;
+    let j = start + TEXT_COMMAND.length;
+    while (j < text.length && depth > 0) {
+      const c = text[j];
+      if (c === "\\" && j + 1 < text.length) {
+        j += 2;
+        continue;
+      }
+      if (c === "{") depth++;
+      else if (c === "}") depth--;
+      j++;
+    }
+    if (depth !== 0) return true;
+    i = j;
+  }
+  return false;
+}
+var RESIDUAL_OPEN_BRACKET_RE = /(?<!!)\\\[/;
+function processSliceInstrumented(slice) {
+  const segments = splitByProtectedRegions(slice);
+  let out = "";
+  let quiescent = true;
+  let truncatedAtSeamStart = false;
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index];
+    if (segment.isCode) {
+      out += segment.text;
+      continue;
+    }
+    let text = segment.text;
+    text = escapeMhchemCommands(text);
+    text = escapeCurrencyDollarSigns(text);
+    text = convertLatexDelimiters(text);
+    if (RESIDUAL_OPEN_BRACKET_RE.test(text)) quiescent = false;
+    text = escapeLatexPipes(text);
+    if (findUnclosedDelimiterStart(text, "both") !== -1) quiescent = false;
+    text = escapeLatexPipesInUnclosed(text);
+    if (hasUnclosedTextCommand(text)) quiescent = false;
+    text = escapeTextUnderscores(text);
+    text = convertSingleToDoubleDollar(text);
+    const unclosedDouble = findUnclosedDelimiterStart(text, "double-only");
+    if (unclosedDouble !== -1) {
+      quiescent = false;
+      if (index === 0 && text.slice(0, unclosedDouble).trim() === "") {
+        truncatedAtSeamStart = true;
+      }
+    }
+    text = truncateUnclosedLatexBlock(text);
+    out += text;
+  }
+  return { out, quiescent, truncatedAtSeamStart };
+}
+function findRawSafeCut(active) {
+  const segments = splitByProtectedRegions(active);
+  let offset = 0;
+  let lastCut = -1;
+  let backtickHazard = false;
+  let latentLt = false;
+  for (const segment of segments) {
+    if (segment.isCode) {
+      if (segment.text.includes(">")) latentLt = false;
+      offset += segment.text.length;
+      continue;
+    }
+    const text = segment.text;
+    let lineStart = 0;
+    while (lineStart <= text.length) {
+      const nl = text.indexOf("\n", lineStart);
+      const lineEnd = nl === -1 ? text.length : nl;
+      for (let i = lineStart; i < lineEnd; i++) {
+        const ch = text[i];
+        if (ch === "`") backtickHazard = true;
+        else if (ch === ">") latentLt = false;
+        else if (ch === "<") {
+          const next = text[i + 1];
+          if (next !== void 0 && (next === "/" || /[A-Za-z]/.test(next))) latentLt = true;
+        }
+      }
+      if (nl === -1) break;
+      if (!backtickHazard && !latentLt) lastCut = offset + nl + 1;
+      lineStart = nl + 1;
+    }
+    offset += text.length;
+  }
+  return lastCut;
+}
+var DEFAULT_FREEZE_ATTEMPT_THRESHOLD = 512;
+function createIncrementalLatexPreprocessor(options) {
+  const freezeThreshold = options?.freezeThreshold ?? DEFAULT_FREEZE_ATTEMPT_THRESHOLD;
+  let prevSource = "";
+  let prevOutput = "";
+  let frozenSrcEnd = 0;
+  let frozenOut = "";
+  let triggered = false;
+  return function incrementalPreprocessLaTeX(source) {
+    if (source === prevSource) return prevOutput;
+    const isAppend = source.length > prevSource.length && source.startsWith(prevSource);
+    if (!isAppend) {
+      frozenSrcEnd = 0;
+      frozenOut = "";
+      triggered = false;
+    }
+    if (!triggered) {
+      const checkFrom = isAppend ? Math.max(0, prevSource.length - 1) : 0;
+      if (!hasLatexTrigger(source.slice(checkFrom))) {
+        prevSource = source;
+        prevOutput = source;
+        return source;
+      }
+      triggered = true;
+    }
+    let active = source.slice(frozenSrcEnd);
+    if (active.length > freezeThreshold) {
+      const cut = findRawSafeCut(active);
+      if (cut > 0) {
+        const candidate = processSliceInstrumented(active.slice(0, cut));
+        if (candidate.quiescent) {
+          frozenOut += candidate.out;
+          frozenSrcEnd += cut;
+          active = source.slice(frozenSrcEnd);
+        }
+      }
+    }
+    const tail = processSliceInstrumented(active);
+    const head = tail.truncatedAtSeamStart ? frozenOut.replace(/\s+$/, "") : frozenOut;
+    const out = head + tail.out;
+    prevSource = source;
+    prevOutput = out;
+    return out;
+  };
+}
+
+// src/preprocessors/index.ts
+function applyPreprocessors(value, ...fns) {
+  return fns.reduce((result, fn) => fn(result), value);
+}
+var defaultExtraPreprocessors = [];
+function preprocessAIMDContent(content, extraPreprocessors = defaultExtraPreprocessors, latexPreprocessor = preprocessLaTeX) {
+  return applyPreprocessors(content, latexPreprocessor, ...extraPreprocessors);
+}
+
+// src/preprocessors/remend.ts
+var import_remend = __toESM(require("remend"), 1);
+function createRemendPreprocessor(options) {
+  return (content) => (0, import_remend.default)(content, {
+    linkMode: "text-only",
+    ...options,
+    katex: false,
+    inlineKatex: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PAYLOAD,
+  DEF_LINE_START_RE,
+  PIPELINE_STAGES,
+  SENTINEL_FN_CONTENT,
+  SENTINEL_LINK_URL,
+  SMOOTH_STREAM_PACING_PRESETS,
+  STAGE_MEASURE_PREFIX,
+  advanceIncrementalParse,
+  attributeHastChildren,
+  buildCoreRehypePlugins,
+  buildCoreRemarkPlugins,
+  buildCoreRemarkRehypeOptions,
+  buildCrossChunkHandlers,
+  buildPhantomSuffix,
+  buildTransform,
+  codePointSnapshots,
+  collectDefLabels,
+  computeFreezeBoundary,
+  createDefLabelScanner,
+  createFile,
+  createIncrementalLatexPreprocessor,
+  createProcessor,
+  createRegistry,
+  createRemendPreprocessor,
+  createSmoothStreamController,
+  defaultEnginePlugins,
+  defaultUrlTransform,
+  definitionList,
+  extendSanitizeSchema,
+  extractContributions,
+  extractDefBodiesFromHast,
+  getEnginePluginInternals,
+  highlight,
+  isFootnoteSection,
+  lastRegionStart,
+  measureStage,
+  mergeClassNameAllowlist,
+  normalizeForMatch,
+  normalizeId,
+  pangu,
+  parseStage,
+  preprocessAIMDContent,
+  preprocessLaTeX,
+  rehypeFooterAdorn,
+  rehypeRebaseHashLinks,
+  removeComments,
+  sanitizeCrossChunkUrl,
+  sanitizeSchema,
+  shortenDocumentId,
+  smartypants,
+  sourceIdFromFootnoteLiId,
+  splitByProtectedRegions,
+  subscribeStageTimings,
+  transformStage,
+  withDefs
+});
+//# sourceMappingURL=index.dev.cjs.map