@ai-react-markdown/engine 2.4.3 → 2.5.0

package/dist/index.js

@@ -176,6 +176,74 @@ var defaultUrlTransform = (value) => {
 import { htmlBlockNames } from "micromark-util-html-tag-name";
 import { normalizeIdentifier } from "micromark-util-normalize-identifier";
 var TYPE6_NAMES = new Set(htmlBlockNames);
+var TABLE_PART_NAMES = /* @__PURE__ */ new Set(["td", "th", "tr", "tbody", "thead", "tfoot", "caption", "col", "colgroup"]);
+var HTML_BREAKOUT_TAGS = /* @__PURE__ */ new Set([
+  "b",
+  "big",
+  "blockquote",
+  "body",
+  "br",
+  "center",
+  "code",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "hr",
+  "i",
+  "img",
+  "li",
+  "listing",
+  "menu",
+  "meta",
+  "nobr",
+  "ol",
+  "p",
+  "pre",
+  "ruby",
+  "s",
+  "small",
+  "span",
+  "strong",
+  "strike",
+  "sub",
+  "sup",
+  "table",
+  "tt",
+  "u",
+  "ul",
+  "var"
+]);
+var HTML_INTEGRATION_POINTS = ["foreignobject", "desc", "mi", "mo", "mn", "ms", "mtext", "annotation-xml"];
+var TYPE1_NAMES = /* @__PURE__ */ new Set(["script", "pre", "style", "textarea"]);
+var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "textarea",
+  "title",
+  "xmp",
+  "iframe",
+  "noembed",
+  "noframes",
+  // NOT `noscript`: hast-util-raw constructs parse5 with
+  // `scriptingEnabled: false`, under which `<noscript>` content is ordinary
+  // HTML — modelling it as raw text ignored a `<b>` inside and under-blocked
+  // (oracle review of the r2 batch; regression caught before release).
+  "plaintext"
+]);
+var TYPE6_START_RE = /^<\/?([A-Za-z][A-Za-z0-9-]*)(?:[ \t\r]|\/?>|$)/;
+var TYPE1_START_RE = /^<(script|pre|style|textarea)(?:[ \t\r]|>|$)/i;
+var TYPE7_LINE_RE = /^(?:<[A-Za-z][A-Za-z0-9-]*(?:[ \t\r][^>]*|\/)?>|<\/[A-Za-z][A-Za-z0-9-]*[ \t\r]*>)[ \t\r]*$/;
+var t7Name = (line) => /^<\/?([A-Za-z][A-Za-z0-9-]*)/.exec(line)[1];
 var VOID_TAGS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -199,7 +267,35 @@ 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 TRUNCATED_TAG_RE = /<(\/?)([A-Za-z][A-Za-z0-9-]*)([^>]*)$/;
+var TAG_START_LT_RE = /<\/?[A-Za-z]/g;
+function scanTagAttrs(text, from, to, out) {
+  let st = out.state;
+  for (let i = from; i < to; i++) {
+    const c = text[i];
+    if (st === '"' || st === "'") {
+      if (c === st) st = "outside";
+      continue;
+    }
+    const ws = c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f";
+    if (st === "afterEq") {
+      if (ws) continue;
+      if (c === '"' || c === "'") st = c;
+      else if (c === ">") return i;
+      else st = "unquoted";
+      continue;
+    }
+    if (st === "unquoted") {
+      if (ws) st = "outside";
+      else if (c === ">") return i;
+      continue;
+    }
+    if (c === "=") st = "afterEq";
+    else if (c === ">") return i;
+  }
+  out.state = st;
+  return -1;
+}
 var REF_RE = /!?\[((?:[^[\]\\]|\\.)*)\]/g;
 var BACKTICK_RUN_RE = /`+/g;
 var MD_BLANK_RE = /^[ \t\r]*$/;
@@ -294,6 +390,8 @@ function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
     openTotal: 0,
     commentOpen: false,
     piOpen: false,
+    bogusOpen: false,
+    rawTextOpen: null,
     declOpen: false,
     cdataOpen: false,
     inFence: false,
@@ -314,7 +412,12 @@ function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
     htmlFlowSinceBlank: false,
     htmlSeamPending: false,
     phasePoisonedAt: Infinity,
-    pendingTruncatedTags: []
+    pendingTruncatedTags: [],
+    pendingTruncatedCloses: [],
+    tagAcrossLines: false,
+    tagAcrossLinesIndent: 0,
+    tagAcrossLinesState: "outside",
+    htmlFlowReal: false
   };
 }
 function isPlausibleLinkDefRest(rest) {
@@ -413,11 +516,21 @@ function computeFreezeBoundary(text, options, resume) {
   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 rawLine = text.slice(start, end);
-    const lineText = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    let end = text.length;
+    let textEnd = text.length;
+    {
+      const nl = text.indexOf("\n", start);
+      const cr = text.indexOf("\r", start);
+      if (cr !== -1 && (nl === -1 || cr < nl)) {
+        textEnd = cr;
+        end = text.charCodeAt(cr + 1) === 10 ? cr + 1 : cr;
+      } else if (nl !== -1) {
+        textEnd = nl;
+        end = nl;
+      }
+    }
+    const confirmed = end < text.length && !(end === text.length - 1 && text.charCodeAt(end) === 13);
+    const lineText = text.slice(start, textEnd);
     const ln = {
       start,
       end,
@@ -509,14 +622,33 @@ function processConfirmedLine(cp, ln, text) {
     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)) {
+  if (cp.htmlSeamPending && !ln.blank && !cp.htmlFlowSinceBlank && !(cp.commentOpen || cp.piOpen || cp.declOpen || cp.cdataOpen || cp.bogusOpen)) {
     const defShapedLine = DEF_RE.test(ln.text) || FOOTNOTE_DEF_RE.test(ln.text);
     const commentOnly = ln.text.replace(/<!--[\s\S]*?-->/g, " ").replace(/<!--[\s\S]*$/, " ").replace(/[ \t\r]/g, "") === "";
     if (!defShapedLine && !commentOnly) {
       cp.htmlSeamPending = false;
     }
   }
+  const inForeignContent = () => (cp.tagBalance.get("svg") ?? 0) > 0 || (cp.tagBalance.get("math") ?? 0) > 0;
+  const honoursSelfClosing = (tag) => {
+    if (tag === "svg" || tag === "math") return true;
+    if (!inForeignContent() || HTML_BREAKOUT_TAGS.has(tag)) return false;
+    for (const ip of HTML_INTEGRATION_POINTS) if ((cp.tagBalance.get(ip) ?? 0) > 0) return false;
+    return true;
+  };
+  const htmlRulesApply = () => {
+    if (!inForeignContent()) return true;
+    for (const ip of HTML_INTEGRATION_POINTS) if ((cp.tagBalance.get(ip) ?? 0) > 0) return true;
+    return false;
+  };
   const applyTag = (tag, closing) => {
+    if (cp.rawTextOpen !== null) {
+      if (!(closing && tag === cp.rawTextOpen)) return;
+      cp.rawTextOpen = null;
+    } else if (!closing && RAW_TEXT_ELEMENTS.has(tag) && htmlRulesApply()) {
+      cp.rawTextOpen = tag;
+      if (tag === "plaintext") cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+    }
     if (closing) {
       const count = cp.tagBalance.get(tag) ?? 0;
       if (count > 0) {
@@ -529,7 +661,7 @@ function processConfirmedLine(cp, ln, text) {
     }
   };
   const commentOpenAtLineStart = cp.commentOpen;
-  const rawOpenAtLineStart = cp.commentOpen || cp.piOpen || cp.declOpen || cp.cdataOpen;
+  const rawOpenAtLineStart = cp.commentOpen || cp.piOpen || cp.declOpen || cp.cdataOpen || cp.bogusOpen;
   if (cp.inFence) {
     const close = FENCE_RE.exec(ln.text);
     if (close && close[1][0] === cp.fenceChar && close[1].length >= cp.fenceLen && isMdBlank(ln.text.slice(close[0].length))) {
@@ -611,12 +743,22 @@ function processConfirmedLine(cp, ln, text) {
       for (const tag of cp.pendingTruncatedTags) applyTag(tag, true);
       cp.pendingTruncatedTags = [];
     }
+    cp.pendingTruncatedCloses = [];
+    if (cp.tagAcrossLines && (cp.tagAcrossLinesState === '"' || cp.tagAcrossLinesState === "'")) {
+      cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+    }
+    cp.tagAcrossLines = false;
+    cp.tagAcrossLinesState = "outside";
+    if (cp.bogusOpen) {
+      cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+      cp.bogusOpen = false;
+    }
     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,
+      htmlBalanced: cp.openTotal === 0 && !cp.commentOpen && !cp.piOpen && !cp.declOpen && !cp.cdataOpen && !cp.bogusOpen,
       hazard: cp.hazardVerdict,
       seamRisk: cp.htmlSeamPending,
       defListSettled: null
@@ -624,6 +766,7 @@ function processConfirmedLine(cp, ln, text) {
     cp.paragraphHasUnpairedRun = false;
     cp.openBracket = null;
     cp.htmlFlowSinceBlank = false;
+    cp.htmlFlowReal = false;
     cp.prevLineBlank = true;
     cp.prevLineWasText = false;
     cp.prevLineWasValidDef = false;
@@ -639,6 +782,16 @@ function processConfirmedLine(cp, ln, text) {
   if (tagStart) {
     cp.htmlFlowSinceBlank = true;
     if (!TYPE6_NAMES.has(tagStart[1].toLowerCase())) cp.hazardVerdict = true;
+    if (!cp.htmlFlowReal) {
+      const t = mdTrimStart(ln.text);
+      const t6 = TYPE6_START_RE.exec(t);
+      const t7 = TYPE7_LINE_RE.exec(t);
+      if (t6 !== null && TYPE6_NAMES.has(t6[1].toLowerCase()) || TYPE1_START_RE.test(t) || // Type 7 cannot interrupt a paragraph, and excludes the raw-text
+      // names (those are type 1 as start tags, paragraph as end tags).
+      t7 !== null && !cp.prevLineWasText && !TYPE1_NAMES.has(t7Name(t).toLowerCase())) {
+        cp.htmlFlowReal = true;
+      }
+    }
   }
   const inRawText = cp.htmlFlowSinceBlank || rawOpenAtLineStart;
   const rawFlowStart = ln.indent <= 3 && /^<(?:!--|\?|![A-Za-z]|!\[CDATA\[)/.test(mdTrimStart(ln.text));
@@ -737,7 +890,7 @@ ${cont(scanText)}` };
       pos = c + 3;
       continue;
     }
-    if (cp.declOpen) {
+    if (cp.declOpen || cp.bogusOpen) {
       const c = scanText.indexOf(">", pos);
       if (c === -1) {
         rawSpans.push([pos, scanText.length]);
@@ -745,6 +898,7 @@ ${cont(scanText)}` };
       }
       rawSpans.push([pos, c + 1]);
       cp.declOpen = false;
+      cp.bogusOpen = false;
       pos = c + 1;
       continue;
     }
@@ -752,10 +906,16 @@ ${cont(scanText)}` };
     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);
+    const bm = cp.htmlFlowReal ? scanText.slice(pos).search(/<!(?!--|[A-Za-z]|\[CDATA\[)|<\/(?![A-Za-z])/) : -1;
+    const bogus = bm === -1 ? -1 : pos + bm;
+    const starts = [pi, cd, decl, bogus].filter((x) => x !== -1);
     if (starts.length === 0) break;
     const first = Math.min(...starts);
-    if (first === cd) {
+    if (first === bogus) {
+      rawSpans.push([bogus, bogus + 2]);
+      cp.bogusOpen = true;
+      pos = bogus + 2;
+    } else if (first === cd) {
       rawSpans.push([cd, cd + 9]);
       cp.cdataOpen = true;
       pos = cd + 9;
@@ -779,11 +939,30 @@ ${cont(scanText)}` };
   for (const [from, to] of rawSpans) {
     tagText = tagText.slice(0, from) + " ".repeat(to - from) + tagText.slice(to);
   }
-  {
+  let skipTagScan = false;
+  if (cp.tagAcrossLines) {
+    if (ln.indent < cp.tagAcrossLinesIndent) poisonRawDivergence();
+    const attrs = { state: cp.tagAcrossLinesState };
+    const gt = scanTagAttrs(ln.text, 0, ln.text.length, attrs);
+    if (gt === -1) {
+      scanTagAttrs("\n", 0, 1, attrs);
+      cp.tagAcrossLinesState = attrs.state;
+      skipTagScan = true;
+    } else {
+      for (const tag of cp.pendingTruncatedCloses) applyTag(tag, true);
+      cp.pendingTruncatedCloses = [];
+      cp.tagAcrossLines = false;
+      cp.tagAcrossLinesState = "outside";
+      tagText = " ".repeat(gt + 1) + tagText.slice(gt + 1);
+    }
+  }
+  let tagHandledAsTruncated = false;
+  if (!skipTagScan) {
     TAG_OR_COMMENT_RE.lastIndex = 0;
     let m;
     let lastCommentOpenerIdx = -1;
     while ((m = TAG_OR_COMMENT_RE.exec(tagText)) !== null) {
+      if (cp.rawTextOpen !== null && (m[0] === "<!--" || m[0] === "-->" || m[0] === "--!>")) continue;
       if (m[0] === "<!--") {
         const next = tagText.slice(m.index + 4, m.index + 6);
         if (cp.commentOpen) {
@@ -809,8 +988,32 @@ ${cont(scanText)}` };
       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;
+      if (TABLE_PART_NAMES.has(tag)) cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + m.index);
+      let attrs = m[3] ?? "";
+      if (cp.htmlFlowReal && (cp.rawTextOpen === null || closing && tag === cp.rawTextOpen)) {
+        const attrStart = m.index + 1 + (closing ? 1 : 0) + m[2].length;
+        const st = { state: "outside" };
+        const gt = scanTagAttrs(tagText, attrStart, tagText.length, st);
+        if (gt === -1) {
+          if (!VOID_TAGS.has(tag)) {
+            if (closing) cp.pendingTruncatedCloses.push(tag);
+            else applyTag(tag, false);
+          }
+          scanTagAttrs("\n", 0, 1, st);
+          cp.tagAcrossLines = true;
+          cp.tagAcrossLinesIndent = ln.indent;
+          cp.tagAcrossLinesState = st.state;
+          tagHandledAsTruncated = true;
+          break;
+        }
+        if (gt + 1 !== m.index + m[0].length) {
+          attrs = tagText.slice(attrStart, gt);
+          TAG_OR_COMMENT_RE.lastIndex = gt + 1;
+        }
+      }
+      if (closing && !cp.htmlFlowReal && !/^\s*$/.test(attrs)) continue;
+      const selfClosing = /\/\s*$/.test(attrs);
+      if (VOID_TAGS.has(tag) || selfClosing && honoursSelfClosing(tag)) continue;
       applyTag(tag, closing);
     }
     if (cp.commentOpen && lastCommentOpenerIdx !== -1 && !inRawText) {
@@ -829,22 +1032,44 @@ ${cont(scanText)}` };
         if (startMasked || wholeVisible || inRaw(mr.index) || cp.commentOpen) continue;
         const closing = mr[1] === "/";
         const tag = mr[2].toLowerCase();
+        if (TABLE_PART_NAMES.has(tag)) cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + mr.index);
+        if (closing && mr[3] !== void 0 && !/^\s*$/.test(mr[3])) continue;
         const selfClosing = mr[3] !== void 0 && /\/\s*$/.test(mr[3]);
-        if (VOID_TAGS.has(tag) || selfClosing) continue;
+        if (VOID_TAGS.has(tag) || selfClosing && honoursSelfClosing(tag)) continue;
         applyTag(tag, closing);
       }
     }
     if (cp.pendingTruncatedTags.length > 0 && ln.text.includes(">")) {
+      if (cp.pendingTruncatedTags.some((t) => TABLE_PART_NAMES.has(t))) {
+        cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start);
+      }
       cp.pendingTruncatedTags = [];
     }
-    if (!cp.commentOpen) {
-      const lastLt = tagText.lastIndexOf("<");
+    if (!cp.commentOpen && !tagHandledAsTruncated) {
+      let lastLt = -1;
+      TAG_START_LT_RE.lastIndex = 0;
+      for (let ms = TAG_START_LT_RE.exec(tagText); ms !== null; ms = TAG_START_LT_RE.exec(tagText)) {
+        lastLt = ms.index;
+        TAG_START_LT_RE.lastIndex = ms.index + 1;
+      }
       if (lastLt !== -1 && !tagText.includes(">", lastLt)) {
         const m2 = TRUNCATED_TAG_RE.exec(tagText.slice(lastLt));
         if (m2) {
           const closing = m2[1] === "/";
           const tag = m2[2].toLowerCase();
-          if (!VOID_TAGS.has(tag)) {
+          if (TABLE_PART_NAMES.has(tag) && cp.htmlFlowReal) {
+            cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + lastLt);
+          }
+          if (cp.htmlFlowReal) {
+            cp.tagAcrossLines = true;
+            cp.tagAcrossLinesIndent = ln.indent;
+            const attrs = { state: "outside" };
+            scanTagAttrs(m2[3] + "\n", 0, m2[3].length + 1, attrs);
+            cp.tagAcrossLinesState = attrs.state;
+          }
+          if (closing) {
+            if (!VOID_TAGS.has(tag) && cp.htmlFlowReal) cp.pendingTruncatedCloses.push(tag);
+          } else if (!VOID_TAGS.has(tag)) {
             applyTag(tag, closing);
             const rawLastLt = ln.text.lastIndexOf("<");
             const rawTruncated = rawLastLt !== -1 && !ln.text.includes(">", rawLastLt);
@@ -1387,6 +1612,9 @@ function countTrailingNewlines(value) {
 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;
+  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
+    if (text.charCodeAt(i + 1) !== 10) count += 1;
+  }
   return count;
 }
 
@@ -1506,7 +1734,7 @@ function normalizeId(s) {
   return normalizeIdentifier3(s);
 }
 function normalizeForMatch(s) {
-  return normalizeIdentifier3(s.replace(/\\(.)/g, "$1"));
+  return normalizeIdentifier3(s);
 }
 
 // src/components/collectDefLabels.ts
@@ -1824,22 +2052,68 @@ function createRegistry(onEmpty) {
     labelSet: { footnoteLabels: /* @__PURE__ */ new Set(), linkLabels: /* @__PURE__ */ new Set() },
     version: 0,
     _reactIdMap: /* @__PURE__ */ new Map(),
+    /** Symbol → its `documentIndex`, for chunks that supplied one. */
+    _chunkIndex: /* @__PURE__ */ new Map(),
     _subscribers: /* @__PURE__ */ new Set(),
     _notifyScheduled: false,
-    allocateSymbol(reactId) {
+    allocateSymbol(reactId, rawDocumentIndex) {
+      const documentIndex = rawDocumentIndex !== void 0 && Number.isFinite(rawDocumentIndex) ? rawDocumentIndex : void 0;
+      if (false) {
+        console.warn(
+          `[ai-react-markdown] documentIndex must be a finite number \u2014 received ${String(rawDocumentIndex)}; ignoring it for this chunk.`
+        );
+      }
       const existing = this._reactIdMap.get(reactId);
       if (existing) {
         existing.refcount++;
+        const moved = documentIndex !== void 0 ? this._chunkIndex.get(existing.symbol) !== documentIndex : this._chunkIndex.has(existing.symbol);
+        if (moved) {
+          const at = this.chunkOrder.indexOf(existing.symbol);
+          if (at !== -1) this.chunkOrder.splice(at, 1);
+          this._placeChunk(existing.symbol, documentIndex);
+          this._notify();
+        }
         return existing.symbol;
       }
       const sym = Symbol(reactId);
       this._reactIdMap.set(reactId, { symbol: sym, refcount: 1 });
-      this.chunkOrder.push(sym);
+      this._placeChunk(sym, documentIndex);
       this._notify();
       return sym;
     },
-    registerChunk(reactId, footnotes, links) {
-      const sym = this.allocateSymbol(reactId);
+    /** Put `sym` into `chunkOrder` at its document position. Without an index
+     *  it goes last (mount order — the historical behaviour); with one it
+     *  sorts before the first chunk that sits later, where a chunk WITHOUT an
+     *  index counts as "later" so an indexed chunk never lands behind one
+     *  whose position is unknown. */
+    _placeChunk(sym, documentIndex) {
+      if (false) {
+        const anyIndexed = documentIndex !== void 0 || this.chunkOrder.some((s) => this._chunkIndex.has(s));
+        const anyPlain = documentIndex === void 0 || this.chunkOrder.some((s) => !this._chunkIndex.has(s));
+        if (anyIndexed && anyPlain) {
+          console.warn(
+            "[ai-react-markdown] Some chunks of this document supply `documentIndex` and some do not. Indexed chunks always sort ahead of un-indexed ones, so footnote numbering and aggregate-footer placement will not follow document order. Pass `documentIndex` to every chunk, or to none."
+          );
+        }
+      }
+      if (documentIndex === void 0) {
+        this._chunkIndex.delete(sym);
+        this.chunkOrder.push(sym);
+        return;
+      }
+      this._chunkIndex.set(sym, documentIndex);
+      let at = this.chunkOrder.length;
+      for (let i = 0; i < this.chunkOrder.length; i++) {
+        const other = this._chunkIndex.get(this.chunkOrder[i]);
+        if (other === void 0 || other > documentIndex) {
+          at = i;
+          break;
+        }
+      }
+      this.chunkOrder.splice(at, 0, sym);
+    },
+    registerChunk(reactId, footnotes, links, documentIndex) {
+      const sym = this.allocateSymbol(reactId, documentIndex);
       this.contributeLabels(sym, footnotes, links);
       return sym;
     },
@@ -1862,6 +2136,7 @@ function createRegistry(onEmpty) {
             this._reactIdMap.delete(reactId);
             const idx = this.chunkOrder.indexOf(entry.symbol);
             if (idx !== -1) this.chunkOrder.splice(idx, 1);
+            this._chunkIndex.delete(entry.symbol);
             this.chunkData.delete(entry.symbol);
             const nextFn = /* @__PURE__ */ new Set();
             const nextLink = /* @__PURE__ */ new Set();
@@ -3488,17 +3763,28 @@ function mergeClassNameAllowlist(existing, extraClassNames) {
   return entries;
 }
 var crossChunkTags = ["cross-chunk-link", "cross-chunk-image", "footnote-sup"];
-var sanitizeSchema = cloneDeep_default({
-  ...defaultSchema,
-  tagNames: [...defaultSchema.tagNames || [], "mark", ...crossChunkTags],
-  attributes: {
-    ...defaultSchema.attributes,
-    code: mergeClassNameAllowlist(defaultSchema.attributes?.code, ["math-inline", "math-display"]),
-    "cross-chunk-link": ["label", "referenceType", "documentId", "localUrl", "localTitle"],
-    "cross-chunk-image": ["label", "referenceType", "documentId", "alt", "localUrl", "localTitle"],
-    "footnote-sup": ["label", "localOccurrence", "localNumber", "documentId"]
-  }
-});
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const key of Object.keys(value)) deepFreeze(value[key]);
+  }
+  return value;
+}
+var STRIPPED_TAGS = ["script", "style", "title", "textarea", "noframes", "noembed", "xmp", "iframe", "plaintext"];
+var sanitizeSchema = deepFreeze(
+  cloneDeep_default({
+    ...defaultSchema,
+    tagNames: [...defaultSchema.tagNames || [], "mark", ...crossChunkTags],
+    attributes: {
+      ...defaultSchema.attributes,
+      code: mergeClassNameAllowlist(defaultSchema.attributes?.code, ["math-inline", "math-display"]),
+      "cross-chunk-link": ["label", "referenceType", "documentId", "localUrl", "localTitle"],
+      "cross-chunk-image": ["label", "referenceType", "documentId", "alt", "localUrl", "localTitle"],
+      "footnote-sup": ["label", "localOccurrence", "localNumber", "documentId"]
+    },
+    strip: [.../* @__PURE__ */ new Set([...defaultSchema.strip || [], ...STRIPPED_TAGS])]
+  })
+);
 
 // src/components/crossChunkUrlSanitize.ts
 function fakeElement(tagName, key, url) {
@@ -3809,7 +4095,12 @@ var createSmoothStreamController = (options = {}) => {
       return;
     }
     tentativeEnd = ends[ends.length - 1];
-    const confirmedEnds = finished ? ends : ends.slice(0, -1);
+    let hold = 1;
+    if (!finished && ends.length > 1) {
+      const last = source.charCodeAt(source.length - 1);
+      if (last >= 55296 && last <= 56319) hold = 2;
+    }
+    const confirmedEnds = finished ? ends : ends.slice(0, -hold);
     for (const end of confirmedEnds) pending.push(end);
   };
   const snap = (next) => {
@@ -3932,10 +4223,17 @@ function lineIndentBefore(content, pos) {
 function findClosingBacktickRun(content, start, n) {
   let i = start;
   while (i < content.length) {
-    if (content[i] === "`") {
+    const ch = content[i];
+    if (ch === "`") {
       const runLen = getRepeatedMarkerLength(content, i, "`");
       if (runLen === n) return i;
       i += runLen;
+    } else if (ch === "\n" || ch === "\r") {
+      let j = i + 1;
+      if (ch === "\r" && content[j] === "\n") j += 1;
+      while (j < content.length && (content[j] === " " || content[j] === "	")) j += 1;
+      if (j >= content.length || content[j] === "\n" || content[j] === "\r") return -1;
+      i += 1;
     } else {
       i += 1;
     }
@@ -4035,47 +4333,85 @@ 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 EVEN_BACKSLASHES = String.raw`(?<=(?:^|[^\\])(?:\\\\)*)`;
+var LATEX_BLOCK_REGEX = new RegExp(
+  String.raw`${EVEN_BACKSLASHES}\$\$([\S\s]*?)${EVEN_BACKSLASHES}\$\$|(?<![\\$])\$(?!\$)((?:[^$\n]|\\\$)*?)(?<![\\` + "`" + String.raw`])\$(?!\$)`,
+  "g"
+);
 var TEXT_COMMAND = "\\text{";
 var SINGLE_DOLLAR_REGEX = /(?<![\\$])\$(?!\$)((?:[^$\n]|\\[$])+?)(?<!\\)(?<!`)\$(?!\$)/g;
+function countBareDollars(str, from, to, prev, next) {
+  let n = 0;
+  for (let j = from; j < to; j++) {
+    if (str.charCodeAt(j) !== 36) continue;
+    const before = j > from ? str[j - 1] : prev;
+    const after = j + 1 < to ? str[j + 1] : next;
+    if (before !== "\\" && before !== "$" && after !== "$") n += 1;
+  }
+  return n;
+}
 function escapeCurrencyDollarSigns(text) {
   const parts = [];
   let lastIndex = 0;
   const currencyMatches = Array.from(text.matchAll(CURRENCY_REGEX));
   let currentLineProcessed = "";
+  let currentLineDollars = 0;
+  const appendToLine = (piece) => {
+    if (piece.length === 0) return;
+    const prevLast = currentLineProcessed.length > 0 ? currentLineProcessed[currentLineProcessed.length - 1] : "";
+    const prevBeforeLast = currentLineProcessed.length > 1 ? currentLineProcessed[currentLineProcessed.length - 2] : "";
+    const prevLastCounted = prevLast === "$" && prevBeforeLast !== "\\" && prevBeforeLast !== "$";
+    if (prevLastCounted && piece[0] === "$") currentLineDollars -= 1;
+    currentLineDollars += countBareDollars(piece, 0, piece.length, prevLast, "");
+    currentLineProcessed += piece;
+  };
+  const resetLine = (rest) => {
+    currentLineProcessed = "";
+    currentLineDollars = 0;
+    appendToLine(rest);
+  };
   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);
+      resetLine(segment.substring(newlineIdx + 1));
     } else {
-      currentLineProcessed += segment;
+      appendToLine(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);
+    const restStart = match.index + 1;
+    const restEnd = i < currencyMatches.length - 1 ? currencyMatches[i + 1].index : text.length;
+    let firstLineBeforeNextMatch = "";
+    if (restEnd - restStart > 0) {
+      let eol = restEnd;
+      for (let k = restStart; k < restEnd; k++) {
+        const c = text.charCodeAt(k);
+        if (c === 10 || c === 13) {
+          eol = k;
+          break;
+        }
       }
-    } else {
-      restBeforeNextMatchOrEnd = text.substring(match.index + 1);
+      firstLineBeforeNextMatch = text.substring(restStart, eol);
     }
-    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 restDollars = countBareDollars(firstLineBeforeNextMatch, 0, firstLineBeforeNextMatch.length, "", "");
+    if (restDollars % 2 !== 0) {
+      const L = currentLineProcessed;
+      const lLast = L.length > 0 ? L[L.length - 1] : "";
+      const lBeforeLast = L.length > 1 ? L[L.length - 2] : "";
+      const lLastCounted = lLast === "$" && lBeforeLast !== "\\" && lBeforeLast !== "$";
+      const f0 = firstLineBeforeNextMatch[0];
+      let whole = currentLineDollars + restDollars;
+      if (lLastCounted && f0 === "$") whole -= 1;
+      if (f0 === "$" && (lLast === "\\" || lLast === "$") && firstLineBeforeNextMatch[1] !== "$") whole -= 1;
+      if (whole % 2 !== 0) needEscape = false;
     }
     const replacement = needEscape ? "\\$" : "$";
     parts.push(replacement);
-    currentLineProcessed += replacement;
+    appendToLine(replacement);
     lastIndex = match.index + 1;
   }
   parts.push(text.substring(lastIndex));
@@ -4143,8 +4479,7 @@ function escapeLatexPipesInUnclosed(text) {
   const tail = text.substring(unclosedStart + delimLen);
   return before + delim + replaceUnescapedPipes(tail);
 }
-function truncateUnclosedLatexBlock(text) {
-  const unclosedStart = findUnclosedDelimiterStart(text, "double-only");
+function truncateUnclosedLatexBlock(text, unclosedStart = findUnclosedDelimiterStart(text, "double-only")) {
   if (unclosedStart === -1) return text;
   return text.substring(0, unclosedStart).trimEnd();
 }
@@ -4232,39 +4567,50 @@ function hasUnclosedTextCommand(text) {
   return false;
 }
 var RESIDUAL_OPEN_BRACKET_RE = /(?<!!)\\\[/;
-function processSliceInstrumented(slice) {
+var LEADING_DOUBLE_DOLLAR_RE = /^\s*\$\$/;
+function processSliceInstrumented(slice, probe = true) {
   const segments = splitByProtectedRegions(slice);
-  let out = "";
+  const parts = [];
   let quiescent = true;
   let truncatedAtSeamStart = false;
   for (let index = 0; index < segments.length; index++) {
     const segment = segments[index];
     if (segment.isCode) {
-      out += segment.text;
+      parts.push(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;
+    if (probe && RESIDUAL_OPEN_BRACKET_RE.test(text)) quiescent = false;
     text = escapeLatexPipes(text);
-    if (findUnclosedDelimiterStart(text, "both") !== -1) quiescent = false;
+    if (probe && findUnclosedDelimiterStart(text, "both") !== -1) quiescent = false;
     text = escapeLatexPipesInUnclosed(text);
-    if (hasUnclosedTextCommand(text)) quiescent = false;
+    if (probe && 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;
+    let unclosedDouble;
+    if (probe || index === 0 && LEADING_DOUBLE_DOLLAR_RE.test(text)) {
+      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;
+    text = truncateUnclosedLatexBlock(text, unclosedDouble);
+    parts.push(text);
   }
-  return { out, quiescent, truncatedAtSeamStart };
+  return { out: parts.join(""), quiescent, truncatedAtSeamStart };
+}
+function isBlankRawLine(text, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = text.charCodeAt(i);
+    if (c !== 32 && c !== 9 && c !== 13) return false;
+  }
+  return true;
 }
 function findRawSafeCut(active) {
   const segments = splitByProtectedRegions(active);
@@ -4279,10 +4625,12 @@ function findRawSafeCut(active) {
       continue;
     }
     const text = segment.text;
+    let atLineStart = offset === 0 || active.charCodeAt(offset - 1) === 10;
     let lineStart = 0;
     while (lineStart <= text.length) {
       const nl = text.indexOf("\n", lineStart);
       const lineEnd = nl === -1 ? text.length : nl;
+      if (atLineStart && nl !== -1 && isBlankRawLine(text, lineStart, lineEnd)) backtickHazard = false;
       for (let i = lineStart; i < lineEnd; i++) {
         const ch = text[i];
         if (ch === "`") backtickHazard = true;
@@ -4295,6 +4643,7 @@ function findRawSafeCut(active) {
       if (nl === -1) break;
       if (!backtickHazard && !latentLt) lastCut = offset + nl + 1;
       lineStart = nl + 1;
+      atLineStart = true;
     }
     offset += text.length;
   }
@@ -4303,11 +4652,14 @@ function findRawSafeCut(active) {
 var DEFAULT_FREEZE_ATTEMPT_THRESHOLD = 512;
 function createIncrementalLatexPreprocessor(options) {
   const freezeThreshold = options?.freezeThreshold ?? DEFAULT_FREEZE_ATTEMPT_THRESHOLD;
+  const onAttempt = options?.onAttempt;
+  const backoff = options?.backoff ?? true;
   let prevSource = "";
   let prevOutput = "";
   let frozenSrcEnd = 0;
   let frozenOut = "";
   let triggered = false;
+  let nextAttemptLen = 0;
   return function incrementalPreprocessLaTeX(source) {
     if (source === prevSource) return prevOutput;
     const isAppend = source.length > prevSource.length && source.startsWith(prevSource);
@@ -4315,6 +4667,7 @@ function createIncrementalLatexPreprocessor(options) {
       frozenSrcEnd = 0;
       frozenOut = "";
       triggered = false;
+      nextAttemptLen = 0;
     }
     if (!triggered) {
       const checkFrom = isAppend ? Math.max(0, prevSource.length - 1) : 0;
@@ -4326,18 +4679,26 @@ function createIncrementalLatexPreprocessor(options) {
       triggered = true;
     }
     let active = source.slice(frozenSrcEnd);
-    if (active.length > freezeThreshold) {
+    if (active.length > freezeThreshold && active.length >= nextAttemptLen) {
+      const activeLength = active.length;
+      let advanced = false;
+      let frozenBytes = 0;
+      const freeze = (cut2, slice) => {
+        frozenOut += slice.out;
+        frozenSrcEnd += cut2;
+        active = source.slice(frozenSrcEnd);
+        advanced = true;
+        frozenBytes = cut2;
+      };
       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);
-        }
+        if (candidate.quiescent) freeze(cut, candidate);
       }
+      nextAttemptLen = advanced || !backoff ? 0 : active.length * 2;
+      onAttempt?.({ activeLength, frozenBytes });
     }
-    const tail = processSliceInstrumented(active);
+    const tail = processSliceInstrumented(active, false);
     const head = tail.truncatedAtSeamStart ? frozenOut.replace(/\s+$/, "") : frozenOut;
     const out = head + tail.out;
     prevSource = source;
@@ -4367,7 +4728,6 @@ function createRemendPreprocessor(options) {
 }
 export {
   DEFAULT_PAYLOAD,
-  DEF_LINE_START_RE,
   PIPELINE_STAGES,
   SENTINEL_FN_CONTENT,
   SENTINEL_LINK_URL,
@@ -4402,7 +4762,6 @@ export {
   hasLoneSurrogate,
   highlight,
   isFootnoteSection,
-  lastRegionStart,
   measureStage,
   mergeClassNameAllowlist,
   normalizeForMatch,