@ai-matrx/rich-content 0.0.0-stage → 0.2.2

package/dist/markdown-core/math/vendor/rehype-katex.js

@@ -0,0 +1,83 @@
+import { fromHtmlIsomorphic } from "hast-util-from-html-isomorphic";
+import { toText } from "hast-util-to-text";
+import katex from "katex";
+import { SKIP, visitParents } from "unist-util-visit-parents";
+const emptyOptions = {};
+const emptyClasses = [];
+function rehypeKatex(options) {
+  const settings = options || emptyOptions;
+  return function(tree, file) {
+    visitParents(tree, "element", function(element, parents) {
+      const classes = Array.isArray(element.properties.className) ? element.properties.className : emptyClasses;
+      const languageMath = classes.includes("language-math");
+      const mathDisplay = classes.includes("math-display");
+      const mathInline = classes.includes("math-inline");
+      let displayMode = mathDisplay;
+      if (!languageMath && !mathDisplay && !mathInline) {
+        return;
+      }
+      let parent = parents[parents.length - 1];
+      let scope = element;
+      if (element.tagName === "code" && languageMath && parent && parent.type === "element" && parent.tagName === "pre") {
+        scope = parent;
+        parent = parents[parents.length - 2];
+        displayMode = true;
+      }
+      if (!parent) return;
+      const value = toText(scope, { whitespace: "pre" });
+      let result;
+      try {
+        result = katex.renderToString(value, {
+          ...settings,
+          displayMode,
+          throwOnError: true
+        });
+      } catch (error) {
+        const cause = (
+          /** @type {Error} */
+          error
+        );
+        const ruleId = cause.name.toLowerCase();
+        file.message("Could not render math with KaTeX", {
+          ancestors: [...parents, element],
+          cause,
+          place: element.position,
+          ruleId,
+          source: "rehype-katex"
+        });
+        try {
+          result = katex.renderToString(value, {
+            ...settings,
+            displayMode,
+            strict: "ignore",
+            throwOnError: false
+          });
+        } catch {
+          result = [
+            {
+              type: "element",
+              tagName: "span",
+              properties: {
+                className: ["katex-error"],
+                style: "color:" + (settings.errorColor || "#cc0000"),
+                title: String(error)
+              },
+              children: [{ type: "text", value }]
+            }
+          ];
+        }
+      }
+      if (typeof result === "string") {
+        const root = fromHtmlIsomorphic(result, { fragment: true });
+        result = /** @type {Array<ElementContent>} */
+        root.children;
+      }
+      const index = parent.children.indexOf(scope);
+      parent.children.splice(index, 1, ...result);
+      return SKIP;
+    });
+  };
+}
+export {
+  rehypeKatex as default
+};

package/dist/markdown-core/math/vendor/remark-math.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Add support for math.
+ *
+ * @param {Readonly<Options> | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export default function remarkMath(options: any): void;

package/dist/markdown-core/math/vendor/remark-math.js

@@ -0,0 +1,20 @@
+import { mathFromMarkdown, mathToMarkdown } from "mdast-util-math";
+import { math } from "./micromark-math-syntax.js";
+const emptyOptions = {};
+function remarkMath(options) {
+  const self = (
+    /** @type {Processor} */
+    this
+  );
+  const settings = options || emptyOptions;
+  const data = self.data();
+  const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+  const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(math(settings));
+  fromMarkdownExtensions.push(mathFromMarkdown());
+  toMarkdownExtensions.push(mathToMarkdown(settings));
+}
+export {
+  remarkMath as default
+};

package/dist/markdown-core/math-normalizer.d.ts

@@ -0,0 +1,57 @@
+/** remark-math options for EVERY math-capable renderer. */
+export declare const REMARK_MATH_OPTIONS: {
+    readonly singleDollarTextMath: false;
+};
+/** rehype-katex options for EVERY math-capable renderer. */
+export declare const REHYPE_KATEX_OPTIONS: {
+    readonly strict: "ignore";
+    /** No command (`\href`, `\url`, `\includegraphics`, `\htmlClass`…) is trusted. */
+    readonly trust: false;
+    /** Largest size any user-given length may take, in em (`\rule{1000em}` → 10em). */
+    readonly maxSize: 10;
+    /** Macro expansions per formula before KaTeX stops (a `\def` loop ends here). */
+    readonly maxExpand: 500;
+};
+/**
+ * Exactly `text.replace(/OPEN((?:(?!\n[ \t]*\n)[\s\S])*?)CLOSE/g, fn)` for a
+ * two-character `open`/`close` (`\[`/`\]`, `\(`/`\)`), in linear time — the
+ * regex re-scanned to the next blank line from every unclosed opener (round
+ * 11, F1). A span never crosses a blank line (a line of only spaces/tabs).
+ */
+export declare function replaceDelimitedWithinParagraph(text: string, open: string, close: string, fn: (match: string, inner: string, offset: number) => string): string;
+/**
+ * THE escaped-bracket rule: a closed `\[ … \]` is display math only when its
+ * content is real TeX and the `\[` does not index an identifier. Everything
+ * else — citations `\[1\]`, dates, task boxes `- \[x\]`, `arr\[i\]`,
+ * `\[bracket\]` — is CommonMark's escaped brackets, literal text
+ * (verify-RC-B4 R3-2). The rule's home is `@ai-matrx/content-ir`
+ * `isEscapedBracketMath` (aidream 094594d3a1, shared vectors
+ * `escaped-bracket-vectors.json`); this is its exact copy until that release
+ * is installed here — then import it and delete this.
+ */
+export declare function isEscapedBracketMath(content: string, before: string | undefined): boolean;
+/**
+ * Normalize every LLM/author math delimiter to the one form remark-math
+ * (with `REMARK_MATH_OPTIONS`) parses. Idempotent on already-normalized text.
+ */
+export declare function normalizeMathDelimiters(markdown: string): string;
+/** Markdown source that renders `tex` as one display-math block. */
+export declare function displayMathSource(tex: string): string;
+/** One piece of normalized markdown: prose, code (fence or span), or math. */
+export interface MathSpanPiece {
+    kind: "text" | "code" | "math";
+    /** The source bytes of this piece (for math, including the `$$` delimiters). */
+    text: string;
+    /** Math only: the TeX between the delimiters. */
+    tex?: string;
+    /** Math only: a display block (`$$` on their own lines) vs inline. */
+    display?: boolean;
+}
+/**
+ * Split markdown into prose / code / math pieces AFTER normalizing it to the
+ * one dialect — the same boundaries every renderer uses, so a consumer that
+ * must turn math into something else (a document exporter drawing formulas)
+ * never re-derives them. Concatenating every `text` reproduces the normalized
+ * source.
+ */
+export declare function splitMathSpans(markdown: string): MathSpanPiece[];

package/dist/markdown-core/math-normalizer.js

@@ -0,0 +1,315 @@
+import { fenceLineKinds, findCodeRanges, isSingleDollarMath, singleDollarAfter } from "@ai-matrx/content-ir/source";
+const REMARK_MATH_OPTIONS = { singleDollarTextMath: false };
+const REHYPE_KATEX_OPTIONS = {
+  strict: "ignore",
+  // SAFETY LIMITS — math is rendered from anyone's text (shared notes,
+  // public pages), so it must not be able to inflate or script the page
+  // (verifier F3, 2026-09-25; guard __tests__/katex-limits.test.tsx):
+  /** No command (`\href`, `\url`, `\includegraphics`, `\htmlClass`…) is trusted. */
+  trust: false,
+  /** Largest size any user-given length may take, in em (`\rule{1000em}` → 10em). */
+  maxSize: 10,
+  /** Macro expansions per formula before KaTeX stops (a `\def` loop ends here). */
+  maxExpand: 500
+};
+function segment(md) {
+  const out = [];
+  let buf = "";
+  const flushText = () => {
+    if (buf) out.push({ text: buf, protected: false });
+    buf = "";
+  };
+  const pushProtected = (text) => {
+    flushText();
+    out.push({ text, protected: true });
+  };
+  const lines = md.split(/(?<=\n)/);
+  const kinds = fenceLineKinds(md);
+  let i = 0;
+  const blocks = [];
+  let textRun = "";
+  while (i < lines.length) {
+    const line = lines[i];
+    if (kinds[i] === "open") {
+      let fence = line;
+      i += 1;
+      while (i < lines.length && (kinds[i] === "body" || kinds[i] === "close")) {
+        const closes = kinds[i] === "close";
+        fence += lines[i];
+        i += 1;
+        if (closes) break;
+      }
+      if (textRun) blocks.push({ text: textRun, protected: false });
+      textRun = "";
+      blocks.push({ text: fence, protected: true });
+      continue;
+    }
+    textRun += line;
+    i += 1;
+  }
+  if (textRun) blocks.push({ text: textRun, protected: false });
+  for (const block of blocks) {
+    if (block.protected) {
+      pushProtected(block.text);
+      continue;
+    }
+    const s = block.text;
+    const spans = findCodeRanges(s).filter((r) => r.kind === "span");
+    let nextSpan = 0;
+    let j = 0;
+    while (j < s.length) {
+      while (nextSpan < spans.length && spans[nextSpan].start < j) nextSpan += 1;
+      const span = spans[nextSpan];
+      if (span && span.start === j) {
+        pushProtected(s.slice(span.start, span.end));
+        j = span.end;
+        nextSpan += 1;
+        continue;
+      }
+      const ch = s[j];
+      if (ch === "\\" && j + 1 < s.length) {
+        buf += ch + s[j + 1];
+        j += 2;
+        continue;
+      }
+      if (ch === "`") {
+        let n = 0;
+        while (s[j + n] === "`") n += 1;
+        buf += s.slice(j, j + n);
+        j += n;
+        continue;
+      }
+      if (ch === "$" && s[j + 1] === "$") {
+        const close = s.indexOf("$$", j + 2);
+        if (close === -1) {
+          buf += "$$";
+          j += 2;
+          continue;
+        }
+        flushText();
+        out.push({ text: s.slice(j, close + 2), protected: true, math: true });
+        j = close + 2;
+        continue;
+      }
+      buf += ch;
+      j += 1;
+    }
+    flushText();
+  }
+  return out;
+}
+function convertSingleDollar(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\" && i + 1 < text.length) {
+      out += ch + text[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "$" && text[i + 1] === "$") {
+      const close = text.indexOf("$$", i + 2);
+      const end = close === -1 ? i + 2 : close + 2;
+      out += text.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "$") {
+      let close = -1;
+      for (let k = i + 1; k < text.length; k += 1) {
+        const c = text[k];
+        if (c === "\n") break;
+        if (c === "\\") {
+          k += 1;
+          continue;
+        }
+        if (c === "$") {
+          close = k;
+          break;
+        }
+      }
+      if (close !== -1 && text[close + 1] !== "$") {
+        const content = text.slice(i + 1, close);
+        if (isSingleDollarMath(content, singleDollarAfter(text, close))) {
+          out += `$$${content}$$`;
+          i = close + 1;
+          continue;
+        }
+      }
+      out += ch;
+      i += 1;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+function outsideMath(text, fn) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const open = text.indexOf("$$", i);
+    if (open === -1) break;
+    const close = text.indexOf("$$", open + 2);
+    if (close === -1) break;
+    out += fn(text.slice(i, open)) + text.slice(open, close + 2);
+    i = close + 2;
+  }
+  return out + fn(text.slice(i));
+}
+function convertBracketDisplay(text) {
+  return outsideMath(text, convertBracketDisplayInProse);
+}
+function convertBracketDisplayInProse(text) {
+  return replaceBracketSpans(text, (match, content) => {
+    const trimmed = content.trim();
+    if (content.includes("$") || /[A-Za-z]:\\/.test(content)) return match;
+    if (/\\[A-Za-z]/.test(content) && (content.includes("\n") || content.length >= 3)) {
+      return `
+
+$$
+${trimmed}
+$$
+
+`;
+    }
+    const multiline = match.startsWith("[\n") || match.startsWith("[ \n");
+    if (multiline && trimmed.length >= 3) {
+      const hasMathOperators = /[+\-=×÷*/]/.test(trimmed);
+      const hasProseWords = /\b(note|step|example|optional|the|is|are|was|were|for|with|this|that)\b/i.test(
+        trimmed
+      );
+      const mathLikeRatio = (trimmed.match(/[0-9+\-=×÷*/()xy\s]/g) || []).length / trimmed.length;
+      if (hasMathOperators && !hasProseWords && mathLikeRatio > 0.6) {
+        return `
+
+$$
+${trimmed}
+$$
+
+`;
+      }
+    }
+    return match;
+  });
+}
+function forwardFinder(find) {
+  let askedFrom = -1;
+  let answer = -1;
+  return (from) => {
+    if (askedFrom >= 0 && from >= askedFrom && (answer === -1 || answer >= from)) return answer;
+    askedFrom = from;
+    answer = find(from);
+    return answer;
+  };
+}
+const isRegexWhitespace = (ch) => /\s/.test(ch);
+function replaceBracketSpans(text, fn) {
+  if (!text.includes("[")) return text;
+  const nextClose = forwardFinder((from) => {
+    for (let at = text.indexOf("]", from); at !== -1; at = text.indexOf("]", at + 1)) {
+      const after = text[at + 1];
+      if (after !== "(" && after !== "[" && after !== ":") return at;
+    }
+    return -1;
+  });
+  let out = "";
+  let copied = 0;
+  for (let open = text.indexOf("["); open !== -1; ) {
+    const close = nextClose(open + 1);
+    if (close === -1) break;
+    let a = open + 1;
+    while (a < close && isRegexWhitespace(text[a])) a++;
+    let b = close;
+    while (b > a && isRegexWhitespace(text[b - 1])) b--;
+    out += text.slice(copied, open) + fn(text.slice(open, close + 1), text.slice(a, b));
+    copied = close + 1;
+    open = text.indexOf("[", copied);
+  }
+  return copied === 0 ? text : out + text.slice(copied);
+}
+function replaceDelimitedWithinParagraph(text, open, close, fn) {
+  if (!text.includes(open)) return text;
+  const nextClose = forwardFinder((from) => text.indexOf(close, from));
+  const blank = /\n[ \t]*\n/g;
+  const nextBlank = forwardFinder((from) => {
+    blank.lastIndex = from;
+    const m = blank.exec(text);
+    return m ? m.index : -1;
+  });
+  let out = "";
+  let copied = 0;
+  for (let at = text.indexOf(open); at !== -1; ) {
+    const start = at + open.length;
+    const end = nextClose(start);
+    if (end === -1) break;
+    const gap = nextBlank(start);
+    if (gap !== -1 && gap < end) {
+      at = text.indexOf(open, at + 1);
+      continue;
+    }
+    out += text.slice(copied, at) + fn(text.slice(at, end + close.length), text.slice(start, end), at);
+    copied = end + close.length;
+    at = text.indexOf(open, copied);
+  }
+  return copied === 0 ? text : out + text.slice(copied);
+}
+const BRACKET_TEX_SIGNAL = /\\[A-Za-z]+|[\^{}=<>+]|_\{|(?:^|[^A-Za-z0-9])[A-Za-z]_[A-Za-z0-9](?![A-Za-z0-9])/;
+function isEscapedBracketMath(content, before) {
+  if (!content.trim()) return false;
+  if (before !== void 0 && /[A-Za-z0-9_)\]]/.test(before)) return false;
+  return BRACKET_TEX_SIGNAL.test(content);
+}
+function normalizeText(text) {
+  let t = text;
+  const whole = t;
+  t = replaceDelimitedWithinParagraph(
+    t,
+    "\\[",
+    "\\]",
+    (match, tex, offset) => isEscapedBracketMath(tex, offset > 0 ? whole[offset - 1] : void 0) ? `
+
+$$
+${tex.trim()}
+$$
+
+` : match
+  );
+  t = replaceDelimitedWithinParagraph(t, "\\(", "\\)", (_m, tex) => `$$${tex.trim()}$$`);
+  t = convertSingleDollar(t);
+  t = convertBracketDisplay(t);
+  return t;
+}
+function normalizeMathDelimiters(markdown) {
+  if (!markdown || !/[\\$[]/.test(markdown)) return markdown;
+  return segment(markdown).map((s) => s.protected ? s.text : normalizeText(s.text)).join("");
+}
+function displayMathSource(tex) {
+  return `$$
+${tex.trim()}
+$$`;
+}
+function splitMathSpans(markdown) {
+  return segment(normalizeMathDelimiters(markdown)).map((seg) => {
+    if (!seg.protected) return { kind: "text", text: seg.text };
+    if (!seg.math) return { kind: "code", text: seg.text };
+    const inner = seg.text.slice(2, -2);
+    return {
+      kind: "math",
+      text: seg.text,
+      tex: inner.trim(),
+      display: /^[ \t]*\n/.test(inner)
+    };
+  });
+}
+export {
+  REHYPE_KATEX_OPTIONS,
+  REMARK_MATH_OPTIONS,
+  displayMathSource,
+  isEscapedBracketMath,
+  normalizeMathDelimiters,
+  replaceDelimitedWithinParagraph,
+  splitMathSpans
+};

package/dist/markdown-core/plain-title.d.ts

@@ -0,0 +1,2 @@
+/** Moved to the chat package (chat-package-move P14); kept for its many app importers. */
+export * from "../utils/plain-title.js";

package/dist/markdown-core/plain-title.js

@@ -0,0 +1 @@
+export * from "../utils/plain-title.js";

package/dist/markdown-core/stream-heal.d.ts

@@ -0,0 +1,2 @@
+/** Heal a streaming markdown prefix so it renders gracefully. Streaming only. */
+export declare function healStreamingMarkdown(source: string): string;

package/dist/markdown-core/stream-heal.js

@@ -0,0 +1,184 @@
+import remend, {
+  isWithinCodeBlock,
+  isWithinMathBlock
+} from "remend";
+import { looksLikeOpenInlineMath, singleDollarMathEnd } from "@ai-matrx/content-ir/source";
+import { SYNTAX_STREAM_HANDLERS } from "./syntax/stream-heal-syntax.js";
+import { replaceReferenceUses, trailingBracketedTail, trimTrailingSpaceTab } from "./syntax/linear-scan.js";
+import {
+  isGfmDelimiterRow,
+  rowCells,
+  startsLikeTableRow,
+  trailingTableStart
+} from "../display/markdown-classification/processors/utils/gfm-table-lines.js";
+const TRAILING_REFERENCE_DEFINITION = /(^|\n) {0,3}\[[^\]\n]+\]:[^\n]*$/;
+const pendingReferenceDefinition = {
+  name: "matrx-pending-reference-definition",
+  priority: 5,
+  handle: (text) => {
+    const match = TRAILING_REFERENCE_DEFINITION.exec(text);
+    if (!match) return text;
+    const lineStart = match.index + match[1].length;
+    if (isWithinCodeBlock(text, lineStart)) return text;
+    return text.slice(0, lineStart);
+  }
+};
+const DEFINITION_LABEL = /^ {0,3}\[([^\]\n]+)\]:/gm;
+const pendingReferenceUses = {
+  name: "matrx-pending-reference-uses",
+  priority: 6,
+  handle: (text) => {
+    const defined = /* @__PURE__ */ new Set();
+    for (const m of text.matchAll(DEFINITION_LABEL)) {
+      if (!isWithinCodeBlock(text, m.index)) defined.add(normalizeLabel(m[1]));
+    }
+    return replaceReferenceUses(
+      text,
+      (whole, bang, label, id, offset) => {
+        if (defined.has(normalizeLabel(id))) return whole;
+        if (isWithinCodeBlock(text, offset) || isInsideInlineCode(text, offset)) {
+          return whole;
+        }
+        return bang ? "" : label;
+      }
+    );
+  }
+};
+function normalizeLabel(label) {
+  return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function isInsideInlineCode(text, offset) {
+  const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+  const before = text.slice(lineStart, offset);
+  return (before.match(/`/g)?.length ?? 0) % 2 === 1;
+}
+const pendingBracketedTail = {
+  name: "matrx-pending-bracketed-tail",
+  priority: 1,
+  handle: (text) => {
+    const match = trailingBracketedTail(text);
+    if (!match) return text;
+    const { whole, bang, label, reference: referencePart } = match;
+    if (isWithinCodeBlock(text, match.index)) return text;
+    if (isInsideInlineCode(text, match.index)) return text;
+    return text.slice(0, text.length - whole.length) + (bang ? "" : label);
+  }
+};
+const TRAILING_EMPTY_EMPHASIS = /(^|\s)[*_~`]+$/;
+const pendingEmptyEmphasis = {
+  name: "matrx-pending-empty-emphasis",
+  priority: 200,
+  handle: (text) => {
+    const match = TRAILING_EMPTY_EMPHASIS.exec(text);
+    if (!match) return text;
+    if (isWithinCodeBlock(text, match.index)) return text;
+    return text.slice(0, match.index + match[1].length);
+  }
+};
+const pendingInlineMath = {
+  name: "matrx-pending-inline-math",
+  priority: 2,
+  handle: (text) => {
+    const lineStart = text.lastIndexOf("\n") + 1;
+    let i = lineStart;
+    while (i < text.length) {
+      const ch = text[i];
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        const close = text.indexOf("`", i + 1);
+        if (close === -1) return text;
+        i = close + 1;
+        continue;
+      }
+      if (ch !== "$") {
+        i += 1;
+        continue;
+      }
+      if (text[i + 1] === "$") {
+        const close = text.indexOf("$$", i + 2);
+        if (close === -1) return text;
+        i = close + 2;
+        continue;
+      }
+      const end = singleDollarMathEnd(text, i);
+      if (end !== -1) {
+        i = end;
+        continue;
+      }
+      const partial = text.slice(i + 1);
+      const opensMath = partial === "" || !/^\s/.test(partial) && looksLikeOpenInlineMath(partial.trimEnd());
+      if (opensMath && !isWithinCodeBlock(text, i) && !isWithinMathBlock(text, i)) {
+        return text.slice(0, i);
+      }
+      i += 1;
+    }
+    return text;
+  }
+};
+const tableCells = rowCells;
+const pendingTable = {
+  name: "matrx-pending-table",
+  priority: 3,
+  handle: (text) => {
+    const lines = text.split("\n");
+    const start = trailingTableStart(lines);
+    if (start === lines.length) return text;
+    const offset = lines.slice(0, start).join("\n").length + (start > 0 ? 1 : 0);
+    if (isWithinCodeBlock(text, offset)) return text;
+    const rows = lines.slice(start);
+    const pipeLed = startsLikeTableRow(rows[0]);
+    const headerCells = tableCells(rows[0]).length;
+    const delimiter = rows[1];
+    const delimiterWhole = delimiter !== void 0 && isGfmDelimiterRow(delimiter) && tableCells(delimiter).length === headerCells && (rows.length > 2 || delimiter.trimEnd().endsWith("|") || !pipeLed);
+    if (!delimiterWhole) return text.slice(0, offset).replace(/\n$/, "\n");
+    const last = rows[rows.length - 1];
+    if (rows.length > 2 && pipeLed && !last.trimEnd().endsWith("|")) {
+      return lines.slice(0, lines.length - 1).join("\n");
+    }
+    return text;
+  }
+};
+const REASONING_OPEN = /(?:<|&lt;)(thinking|think|reasoning)(?:>|&gt;)/g;
+const pendingReasoningSpan = {
+  name: "matrx-pending-reasoning-span",
+  priority: 1,
+  handle: (text) => {
+    let cut = -1;
+    for (const match of text.matchAll(REASONING_OPEN)) {
+      const at = match.index ?? 0;
+      const tag = match[1];
+      const rest = text.slice(at + match[0].length);
+      if (new RegExp(`(?:<|&lt;)/${tag}(?:>|&gt;)`).test(rest)) continue;
+      if (isWithinCodeBlock(text, at)) continue;
+      const lineStart = text.lastIndexOf("\n", at - 1) + 1;
+      if (((text.slice(lineStart, at).match(/`/g) ?? []).length & 1) === 1) continue;
+      cut = at;
+      break;
+    }
+    return cut === -1 ? text : trimTrailingSpaceTab(text.slice(0, cut));
+  }
+};
+const REMEND_OPTIONS = {
+  linkMode: "text-only",
+  handlers: [
+    pendingReasoningSpan,
+    pendingBracketedTail,
+    pendingInlineMath,
+    pendingTable,
+    pendingReferenceDefinition,
+    pendingReferenceUses,
+    pendingEmptyEmphasis,
+    // Extended syntax (front matter, directives, callouts, wikilinks, …).
+    ...SYNTAX_STREAM_HANDLERS
+  ]
+};
+function healStreamingMarkdown(source) {
+  if (!source) return source;
+  return remend(source, REMEND_OPTIONS);
+}
+export {
+  healStreamingMarkdown
+};

package/dist/markdown-core/streaming-context.d.ts

@@ -0,0 +1,2 @@
+export declare const MarkdownStreamingProvider: import("react").Provider<boolean>;
+export declare function useMarkdownStreaming(): boolean;

package/dist/markdown-core/streaming-context.js

@@ -0,0 +1,11 @@
+"use client";
+import { createContext, useContext } from "react";
+const MarkdownStreamingContext = createContext(false);
+const MarkdownStreamingProvider = MarkdownStreamingContext.Provider;
+function useMarkdownStreaming() {
+  return useContext(MarkdownStreamingContext);
+}
+export {
+  MarkdownStreamingProvider,
+  useMarkdownStreaming
+};