@stream-mdx/core 0.0.3 → 0.1.1

package/dist/mixed-content.cjs

@@ -41,9 +41,23 @@ var rehypeParse = __toESM(require("rehype-parse"), 1);
 var rehypeSanitize = __toESM(require("rehype-sanitize"), 1);
 var rehypeStringify = __toESM(require("rehype-stringify"), 1);
 var import_unified = require("unified");
-var { defaultSchema } = rehypeSanitize;
+var rehypeSanitizeModule = rehypeSanitize;
+var defaultSchema = rehypeSanitizeModule.defaultSchema;
+var resolvePlugin = (mod) => {
+  if (typeof mod === "function") return mod;
+  if (mod && typeof mod.default === "function") {
+    return mod.default;
+  }
+  if (mod && typeof mod.default?.default === "function") {
+    return mod.default?.default;
+  }
+  return mod;
+};
+var rehypeParsePlugin = resolvePlugin(rehypeParse);
+var rehypeSanitizePlugin = resolvePlugin(rehypeSanitizeModule);
+var rehypeStringifyPlugin = resolvePlugin(rehypeStringify);
 var SANITIZED_SCHEMA = createSchema();
-var sanitizeProcessor = (0, import_unified.unified)().use(rehypeParse.default, { fragment: true }).use(rehypeSanitize.default, SANITIZED_SCHEMA).use(rehypeStringify.default).freeze();
+var sanitizeProcessor = (0, import_unified.unified)().use(rehypeParsePlugin, { fragment: true }).use(rehypeSanitizePlugin, SANITIZED_SCHEMA).use(rehypeStringifyPlugin).freeze();
 function sanitizeHtmlInWorker(html) {
   if (!html) return "";
   try {
@@ -159,9 +173,27 @@ function mergeAttributes(existing, additions) {
 }
 
 // src/mixed-content.ts
-function extractMixedContentSegments(raw, baseOffset, parseInline) {
+var DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS = /* @__PURE__ */ new Set([
+  "span",
+  "em",
+  "strong",
+  "code",
+  "kbd",
+  "del",
+  "s",
+  "mark",
+  "sub",
+  "sup",
+  "i",
+  "b",
+  "u",
+  "small",
+  "abbr",
+  "a"
+]);
+function extractMixedContentSegments(raw, baseOffset, parseInline, options) {
   if (!raw) return [];
-  const initial = splitByTagSegments(raw, baseOffset, parseInline);
+  const initial = splitByTagSegments(raw, baseOffset, parseInline, options);
   const expanded = [];
   for (const segment of initial) {
     if (segment.kind === "text") {
@@ -172,22 +204,58 @@ function extractMixedContentSegments(raw, baseOffset, parseInline) {
   }
   return mergeAdjacentTextSegments(expanded, parseInline);
 }
-function splitByTagSegments(source, baseOffset, parseInline) {
+function splitByTagSegments(source, baseOffset, parseInline, options) {
   const segments = [];
   const lowerSource = source.toLowerCase();
   const tagPattern = /<([A-Za-z][\w:-]*)([^<>]*?)\/?>/g;
   let cursor = 0;
   let match = tagPattern.exec(source);
   const baseIsFinite = typeof baseOffset === "number" && Number.isFinite(baseOffset);
+  const htmlAllowTags = normalizeHtmlAllowlist(options?.html?.allowTags);
+  const htmlAutoClose = options?.html?.autoClose === true;
+  const htmlMaxNewlines = normalizeNewlineLimit(options?.html?.maxNewlines);
+  const mdxAutoClose = options?.mdx?.autoClose === true;
+  const mdxMaxNewlines = normalizeNewlineLimit(options?.mdx?.maxNewlines);
+  const mdxAllowlist = normalizeComponentAllowlist(options?.mdx?.componentAllowlist);
   while (match !== null) {
     const start = match.index;
     const tagName = match[1];
     const matchText = match[0];
-    const isSelfClosing = matchText.endsWith("/>") || isVoidHtmlTag(tagName);
+    const tagNameLower = tagName.toLowerCase();
+    const isSelfClosing = matchText.endsWith("/>") || isVoidHtmlTag(tagNameLower);
+    const mdxCandidate = isLikelyMdxComponent(tagName);
+    const mdxAllowed = mdxCandidate && (!mdxAllowlist || mdxAllowlist.has(tagName));
+    if (mdxCandidate && mdxAllowlist && !mdxAllowed) {
+      tagPattern.lastIndex = start + 1;
+      match = tagPattern.exec(source);
+      continue;
+    }
     let end = tagPattern.lastIndex;
-    if (!isSelfClosing && !isLikelyMdxComponent(tagName)) {
+    if (!isSelfClosing && !mdxAllowed) {
       const closingIndex = findClosingHtmlTag(lowerSource, tagName.toLowerCase(), end);
       if (closingIndex === -1) {
+        if (htmlAutoClose && htmlAllowTags.has(tagNameLower)) {
+          const tail = source.slice(end);
+          const newlineCount = countNewlines(tail, htmlMaxNewlines + 1);
+          if (newlineCount <= htmlMaxNewlines) {
+            if (start > cursor) {
+              const absoluteFrom = baseIsFinite ? baseOffset + cursor : void 0;
+              const absoluteTo = baseIsFinite ? baseOffset + start : void 0;
+              pushTextSegment(segments, source.slice(cursor, start), absoluteFrom, absoluteTo, parseInline);
+            }
+            const rawSegment2 = source.slice(start);
+            const closedValue = `${rawSegment2}</${tagName}>`;
+            const segment2 = {
+              kind: "html",
+              value: closedValue,
+              range: createSegmentRange(baseOffset, start, source.length),
+              sanitized: sanitizeHtmlInWorker(closedValue)
+            };
+            segments.push(segment2);
+            cursor = source.length;
+            break;
+          }
+        }
         tagPattern.lastIndex = start + 1;
         match = tagPattern.exec(source);
         continue;
@@ -199,8 +267,8 @@ function splitByTagSegments(source, baseOffset, parseInline) {
       const absoluteTo = baseIsFinite ? baseOffset + start : void 0;
       pushTextSegment(segments, source.slice(cursor, start), absoluteFrom, absoluteTo, parseInline);
     }
-    const rawSegment = source.slice(start, end);
-    const kind = isLikelyMdxComponent(tagName) ? "mdx" : "html";
+    let rawSegment = source.slice(start, end);
+    const kind = mdxAllowed ? "mdx" : "html";
     const segment = {
       kind,
       value: rawSegment,
@@ -209,6 +277,17 @@ function splitByTagSegments(source, baseOffset, parseInline) {
     if (kind === "html") {
       segment.sanitized = sanitizeHtmlInWorker(rawSegment);
     } else {
+      const tail = source.slice(end);
+      const newlineCount = countNewlines(tail, mdxMaxNewlines + 1);
+      if (mdxAutoClose && newlineCount > mdxMaxNewlines) {
+        tagPattern.lastIndex = start + 1;
+        match = tagPattern.exec(source);
+        continue;
+      }
+      if (mdxAutoClose && !rawSegment.endsWith("/>")) {
+        rawSegment = selfCloseTag(rawSegment);
+        segment.value = rawSegment;
+      }
       segment.status = "pending";
     }
     segments.push(segment);
@@ -333,6 +412,48 @@ var VOID_HTML_TAGS = /* @__PURE__ */ new Set(["br", "hr", "img", "meta", "input"
 function isVoidHtmlTag(tagName) {
   return VOID_HTML_TAGS.has(tagName.toLowerCase());
 }
+function normalizeNewlineLimit(value) {
+  if (!Number.isFinite(value ?? Number.NaN)) {
+    return 2;
+  }
+  return Math.max(0, value ?? 0);
+}
+function normalizeHtmlAllowlist(value) {
+  if (!value) return DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS;
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of value) {
+    if (tag) {
+      tags.add(tag.toLowerCase());
+    }
+  }
+  return tags.size > 0 ? tags : DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS;
+}
+function normalizeComponentAllowlist(value) {
+  if (!value) return null;
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of value) {
+    if (tag) tags.add(tag);
+  }
+  return tags.size > 0 ? tags : null;
+}
+function countNewlines(value, limit) {
+  let count = 0;
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) === 10) {
+      count += 1;
+      if (limit !== void 0 && count >= limit) {
+        return count;
+      }
+    }
+  }
+  return count;
+}
+function selfCloseTag(rawTag) {
+  if (rawTag.endsWith("/>")) return rawTag;
+  const closeIndex = rawTag.lastIndexOf(">");
+  if (closeIndex === -1) return rawTag;
+  return `${rawTag.slice(0, closeIndex)}/>`;
+}
 function isLikelyMdxComponent(tagName) {
   const first = tagName.charAt(0);
   return first.toUpperCase() === first && first.toLowerCase() !== first;

package/dist/mixed-content.d.cts

@@ -1,7 +1,21 @@
 import { InlineNode, MixedContentSegment } from './types.cjs';
 
-declare function extractMixedContentSegments(raw: string, baseOffset: number | undefined, parseInline: (content: string) => InlineNode[]): MixedContentSegment[];
+interface MixedContentAutoCloseHtmlOptions {
+    autoClose?: boolean;
+    maxNewlines?: number;
+    allowTags?: Iterable<string>;
+}
+interface MixedContentAutoCloseMdxOptions {
+    autoClose?: boolean;
+    maxNewlines?: number;
+    componentAllowlist?: Iterable<string>;
+}
+interface MixedContentOptions {
+    html?: MixedContentAutoCloseHtmlOptions;
+    mdx?: MixedContentAutoCloseMdxOptions;
+}
+declare function extractMixedContentSegments(raw: string, baseOffset: number | undefined, parseInline: (content: string) => InlineNode[], options?: MixedContentOptions): MixedContentSegment[];
 declare function isLikelyMdxComponent(tagName: string): boolean;
 declare function findClosingHtmlTag(lowerSource: string, lowerTagName: string, startIndex: number): number;
 
-export { extractMixedContentSegments, findClosingHtmlTag, isLikelyMdxComponent };
+export { type MixedContentAutoCloseHtmlOptions, type MixedContentAutoCloseMdxOptions, type MixedContentOptions, extractMixedContentSegments, findClosingHtmlTag, isLikelyMdxComponent };

package/dist/mixed-content.d.ts

@@ -1,7 +1,21 @@
 import { InlineNode, MixedContentSegment } from './types.js';
 
-declare function extractMixedContentSegments(raw: string, baseOffset: number | undefined, parseInline: (content: string) => InlineNode[]): MixedContentSegment[];
+interface MixedContentAutoCloseHtmlOptions {
+    autoClose?: boolean;
+    maxNewlines?: number;
+    allowTags?: Iterable<string>;
+}
+interface MixedContentAutoCloseMdxOptions {
+    autoClose?: boolean;
+    maxNewlines?: number;
+    componentAllowlist?: Iterable<string>;
+}
+interface MixedContentOptions {
+    html?: MixedContentAutoCloseHtmlOptions;
+    mdx?: MixedContentAutoCloseMdxOptions;
+}
+declare function extractMixedContentSegments(raw: string, baseOffset: number | undefined, parseInline: (content: string) => InlineNode[], options?: MixedContentOptions): MixedContentSegment[];
 declare function isLikelyMdxComponent(tagName: string): boolean;
 declare function findClosingHtmlTag(lowerSource: string, lowerTagName: string, startIndex: number): number;
 
-export { extractMixedContentSegments, findClosingHtmlTag, isLikelyMdxComponent };
+export { type MixedContentAutoCloseHtmlOptions, type MixedContentAutoCloseMdxOptions, type MixedContentOptions, extractMixedContentSegments, findClosingHtmlTag, isLikelyMdxComponent };

package/dist/mixed-content.mjs

@@ -3,9 +3,23 @@ import * as rehypeParse from "rehype-parse";
 import * as rehypeSanitize from "rehype-sanitize";
 import * as rehypeStringify from "rehype-stringify";
 import { unified } from "unified";
-var { defaultSchema } = rehypeSanitize;
+var rehypeSanitizeModule = rehypeSanitize;
+var defaultSchema = rehypeSanitizeModule.defaultSchema;
+var resolvePlugin = (mod) => {
+  if (typeof mod === "function") return mod;
+  if (mod && typeof mod.default === "function") {
+    return mod.default;
+  }
+  if (mod && typeof mod.default?.default === "function") {
+    return mod.default?.default;
+  }
+  return mod;
+};
+var rehypeParsePlugin = resolvePlugin(rehypeParse);
+var rehypeSanitizePlugin = resolvePlugin(rehypeSanitizeModule);
+var rehypeStringifyPlugin = resolvePlugin(rehypeStringify);
 var SANITIZED_SCHEMA = createSchema();
-var sanitizeProcessor = unified().use(rehypeParse.default, { fragment: true }).use(rehypeSanitize.default, SANITIZED_SCHEMA).use(rehypeStringify.default).freeze();
+var sanitizeProcessor = unified().use(rehypeParsePlugin, { fragment: true }).use(rehypeSanitizePlugin, SANITIZED_SCHEMA).use(rehypeStringifyPlugin).freeze();
 function sanitizeHtmlInWorker(html) {
   if (!html) return "";
   try {
@@ -121,9 +135,27 @@ function mergeAttributes(existing, additions) {
 }
 
 // src/mixed-content.ts
-function extractMixedContentSegments(raw, baseOffset, parseInline) {
+var DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS = /* @__PURE__ */ new Set([
+  "span",
+  "em",
+  "strong",
+  "code",
+  "kbd",
+  "del",
+  "s",
+  "mark",
+  "sub",
+  "sup",
+  "i",
+  "b",
+  "u",
+  "small",
+  "abbr",
+  "a"
+]);
+function extractMixedContentSegments(raw, baseOffset, parseInline, options) {
   if (!raw) return [];
-  const initial = splitByTagSegments(raw, baseOffset, parseInline);
+  const initial = splitByTagSegments(raw, baseOffset, parseInline, options);
   const expanded = [];
   for (const segment of initial) {
     if (segment.kind === "text") {
@@ -134,22 +166,58 @@ function extractMixedContentSegments(raw, baseOffset, parseInline) {
   }
   return mergeAdjacentTextSegments(expanded, parseInline);
 }
-function splitByTagSegments(source, baseOffset, parseInline) {
+function splitByTagSegments(source, baseOffset, parseInline, options) {
   const segments = [];
   const lowerSource = source.toLowerCase();
   const tagPattern = /<([A-Za-z][\w:-]*)([^<>]*?)\/?>/g;
   let cursor = 0;
   let match = tagPattern.exec(source);
   const baseIsFinite = typeof baseOffset === "number" && Number.isFinite(baseOffset);
+  const htmlAllowTags = normalizeHtmlAllowlist(options?.html?.allowTags);
+  const htmlAutoClose = options?.html?.autoClose === true;
+  const htmlMaxNewlines = normalizeNewlineLimit(options?.html?.maxNewlines);
+  const mdxAutoClose = options?.mdx?.autoClose === true;
+  const mdxMaxNewlines = normalizeNewlineLimit(options?.mdx?.maxNewlines);
+  const mdxAllowlist = normalizeComponentAllowlist(options?.mdx?.componentAllowlist);
   while (match !== null) {
     const start = match.index;
     const tagName = match[1];
     const matchText = match[0];
-    const isSelfClosing = matchText.endsWith("/>") || isVoidHtmlTag(tagName);
+    const tagNameLower = tagName.toLowerCase();
+    const isSelfClosing = matchText.endsWith("/>") || isVoidHtmlTag(tagNameLower);
+    const mdxCandidate = isLikelyMdxComponent(tagName);
+    const mdxAllowed = mdxCandidate && (!mdxAllowlist || mdxAllowlist.has(tagName));
+    if (mdxCandidate && mdxAllowlist && !mdxAllowed) {
+      tagPattern.lastIndex = start + 1;
+      match = tagPattern.exec(source);
+      continue;
+    }
     let end = tagPattern.lastIndex;
-    if (!isSelfClosing && !isLikelyMdxComponent(tagName)) {
+    if (!isSelfClosing && !mdxAllowed) {
       const closingIndex = findClosingHtmlTag(lowerSource, tagName.toLowerCase(), end);
       if (closingIndex === -1) {
+        if (htmlAutoClose && htmlAllowTags.has(tagNameLower)) {
+          const tail = source.slice(end);
+          const newlineCount = countNewlines(tail, htmlMaxNewlines + 1);
+          if (newlineCount <= htmlMaxNewlines) {
+            if (start > cursor) {
+              const absoluteFrom = baseIsFinite ? baseOffset + cursor : void 0;
+              const absoluteTo = baseIsFinite ? baseOffset + start : void 0;
+              pushTextSegment(segments, source.slice(cursor, start), absoluteFrom, absoluteTo, parseInline);
+            }
+            const rawSegment2 = source.slice(start);
+            const closedValue = `${rawSegment2}</${tagName}>`;
+            const segment2 = {
+              kind: "html",
+              value: closedValue,
+              range: createSegmentRange(baseOffset, start, source.length),
+              sanitized: sanitizeHtmlInWorker(closedValue)
+            };
+            segments.push(segment2);
+            cursor = source.length;
+            break;
+          }
+        }
         tagPattern.lastIndex = start + 1;
         match = tagPattern.exec(source);
         continue;
@@ -161,8 +229,8 @@ function splitByTagSegments(source, baseOffset, parseInline) {
       const absoluteTo = baseIsFinite ? baseOffset + start : void 0;
       pushTextSegment(segments, source.slice(cursor, start), absoluteFrom, absoluteTo, parseInline);
     }
-    const rawSegment = source.slice(start, end);
-    const kind = isLikelyMdxComponent(tagName) ? "mdx" : "html";
+    let rawSegment = source.slice(start, end);
+    const kind = mdxAllowed ? "mdx" : "html";
     const segment = {
       kind,
       value: rawSegment,
@@ -171,6 +239,17 @@ function splitByTagSegments(source, baseOffset, parseInline) {
     if (kind === "html") {
       segment.sanitized = sanitizeHtmlInWorker(rawSegment);
     } else {
+      const tail = source.slice(end);
+      const newlineCount = countNewlines(tail, mdxMaxNewlines + 1);
+      if (mdxAutoClose && newlineCount > mdxMaxNewlines) {
+        tagPattern.lastIndex = start + 1;
+        match = tagPattern.exec(source);
+        continue;
+      }
+      if (mdxAutoClose && !rawSegment.endsWith("/>")) {
+        rawSegment = selfCloseTag(rawSegment);
+        segment.value = rawSegment;
+      }
       segment.status = "pending";
     }
     segments.push(segment);
@@ -295,6 +374,48 @@ var VOID_HTML_TAGS = /* @__PURE__ */ new Set(["br", "hr", "img", "meta", "input"
 function isVoidHtmlTag(tagName) {
   return VOID_HTML_TAGS.has(tagName.toLowerCase());
 }
+function normalizeNewlineLimit(value) {
+  if (!Number.isFinite(value ?? Number.NaN)) {
+    return 2;
+  }
+  return Math.max(0, value ?? 0);
+}
+function normalizeHtmlAllowlist(value) {
+  if (!value) return DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS;
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of value) {
+    if (tag) {
+      tags.add(tag.toLowerCase());
+    }
+  }
+  return tags.size > 0 ? tags : DEFAULT_INLINE_HTML_AUTOCLOSE_TAGS;
+}
+function normalizeComponentAllowlist(value) {
+  if (!value) return null;
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of value) {
+    if (tag) tags.add(tag);
+  }
+  return tags.size > 0 ? tags : null;
+}
+function countNewlines(value, limit) {
+  let count = 0;
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) === 10) {
+      count += 1;
+      if (limit !== void 0 && count >= limit) {
+        return count;
+      }
+    }
+  }
+  return count;
+}
+function selfCloseTag(rawTag) {
+  if (rawTag.endsWith("/>")) return rawTag;
+  const closeIndex = rawTag.lastIndexOf(">");
+  if (closeIndex === -1) return rawTag;
+  return `${rawTag.slice(0, closeIndex)}/>`;
+}
 function isLikelyMdxComponent(tagName) {
   const first = tagName.charAt(0);
   return first.toUpperCase() === first && first.toLowerCase() !== first;

package/dist/streaming/inline-streaming.cjs

@@ -20,69 +20,134 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/streaming/inline-streaming.ts
 var inline_streaming_exports = {};
 __export(inline_streaming_exports, {
+  normalizeFormatAnticipation: () => normalizeFormatAnticipation,
   prepareInlineStreamingContent: () => prepareInlineStreamingContent
 });
 module.exports = __toCommonJS(inline_streaming_exports);
+var DEFAULT_FORMAT_ANTICIPATION = {
+  inline: false,
+  mathInline: false,
+  mathBlock: false,
+  html: false,
+  mdx: false,
+  regex: false
+};
+function normalizeFormatAnticipation(input) {
+  if (input === true) {
+    return { ...DEFAULT_FORMAT_ANTICIPATION, inline: true };
+  }
+  if (!input) {
+    return { ...DEFAULT_FORMAT_ANTICIPATION };
+  }
+  return {
+    inline: input.inline ?? false,
+    mathInline: input.mathInline ?? false,
+    mathBlock: input.mathBlock ?? false,
+    html: input.html ?? false,
+    mdx: input.mdx ?? false,
+    regex: input.regex ?? false
+  };
+}
 function prepareInlineStreamingContent(content, options) {
-  const enableAnticipation = Boolean(options?.formatAnticipation);
   const enableMath = options?.math !== false;
-  let dollarCount = 0;
-  let backtickCount = 0;
-  let starCount = 0;
-  let doubleStarCount = 0;
-  let tildePairCount = 0;
+  const anticipation = normalizeFormatAnticipation(options?.formatAnticipation);
+  const enableInlineAnticipation = anticipation.inline;
+  const enableMathInlineAnticipation = anticipation.mathInline;
+  const enableMathBlockAnticipation = anticipation.mathBlock;
+  const stack = [];
+  const toggleToken = (token) => {
+    const last = stack[stack.length - 1];
+    if (last === token) {
+      stack.pop();
+    } else {
+      stack.push(token);
+    }
+  };
+  let mathDisplayOpen = false;
+  let mathDisplayCrossedNewline = false;
   for (let i = 0; i < content.length; i++) {
     const code = content.charCodeAt(i);
-    if (code === 36) {
-      dollarCount += 1;
+    if (code === 10 || code === 13) {
+      if (mathDisplayOpen) {
+        mathDisplayCrossedNewline = true;
+      }
       continue;
     }
     if (code === 96) {
-      backtickCount += 1;
+      toggleToken("code");
+      continue;
+    }
+    if (code === 126 && i + 1 < content.length && content.charCodeAt(i + 1) === 126) {
+      toggleToken("strike");
+      i += 1;
       continue;
     }
     if (code === 42) {
       if (i + 1 < content.length && content.charCodeAt(i + 1) === 42) {
-        doubleStarCount += 1;
-        starCount += 2;
+        toggleToken("strong");
         i += 1;
       } else {
-        starCount += 1;
+        toggleToken("em");
       }
       continue;
     }
-    if (code === 126) {
-      if (i + 1 < content.length && content.charCodeAt(i + 1) === 126) {
-        tildePairCount += 1;
+    if (enableMath && code === 36) {
+      if (i + 1 < content.length && content.charCodeAt(i + 1) === 36) {
+        toggleToken("math-display");
+        if (mathDisplayOpen) {
+          mathDisplayOpen = false;
+          mathDisplayCrossedNewline = false;
+        } else {
+          mathDisplayOpen = true;
+          mathDisplayCrossedNewline = false;
+        }
         i += 1;
+      } else {
+        toggleToken("math-inline");
       }
     }
   }
-  const hasIncompleteMath = enableMath && dollarCount % 2 !== 0;
-  if (hasIncompleteMath) {
-    return { kind: "raw", status: "raw", reason: "incomplete-math" };
-  }
-  const hasIncompleteCode = backtickCount % 2 !== 0;
-  const hasIncompleteStrong = doubleStarCount % 2 !== 0;
-  const singleStarCount = starCount - doubleStarCount * 2;
-  const hasIncompleteEmphasis = singleStarCount % 2 !== 0;
-  const hasIncompleteStrike = tildePairCount % 2 !== 0;
-  const hasAnyIncomplete = hasIncompleteCode || hasIncompleteStrong || hasIncompleteEmphasis || hasIncompleteStrike;
-  if (!hasAnyIncomplete) {
-    return { kind: "parse", status: "complete", content, appended: "" };
+  const hasIncompleteFormatting = stack.some((token) => token === "code" || token === "strike" || token === "strong" || token === "em");
+  const hasIncompleteMathInline = stack.includes("math-inline");
+  const hasIncompleteMathDisplay = stack.includes("math-display");
+  const hasIncompleteMath = hasIncompleteMathInline || hasIncompleteMathDisplay;
+  if (enableMath && hasIncompleteMath) {
+    if (hasIncompleteMathInline && !enableMathInlineAnticipation) {
+      return { kind: "raw", status: "raw", reason: "incomplete-math" };
+    }
+    if (hasIncompleteMathDisplay && (!enableMathBlockAnticipation || mathDisplayCrossedNewline)) {
+      return { kind: "raw", status: "raw", reason: "incomplete-math" };
+    }
   }
-  if (!enableAnticipation) {
+  if (hasIncompleteFormatting && !enableInlineAnticipation) {
     return { kind: "raw", status: "raw", reason: "incomplete-formatting" };
   }
-  let appended = "";
-  if (hasIncompleteCode) appended += "`";
-  if (hasIncompleteStrike) appended += "~~";
-  if (hasIncompleteStrong && hasIncompleteEmphasis) appended += "***";
-  else if (hasIncompleteStrong) appended += "**";
-  else if (hasIncompleteEmphasis) appended += "*";
+  if (!hasIncompleteFormatting && !hasIncompleteMath) {
+    return { kind: "parse", status: "complete", content, appended: "" };
+  }
+  const appendForToken = (token) => {
+    switch (token) {
+      case "code":
+        return "`";
+      case "strike":
+        return "~~";
+      case "strong":
+        return "**";
+      case "em":
+        return "*";
+      case "math-inline":
+        return "$";
+      case "math-display":
+        return "$$";
+      default:
+        return "";
+    }
+  };
+  const appended = stack.slice().reverse().map((token) => appendForToken(token)).join("");
   return { kind: "parse", status: "anticipated", content: content + appended, appended };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  normalizeFormatAnticipation,
   prepareInlineStreamingContent
 });

package/dist/streaming/inline-streaming.d.cts

@@ -1,4 +1,15 @@
+import { FormatAnticipationConfig } from '../types.cjs';
+
 type InlineStreamingInlineStatus = "complete" | "anticipated" | "raw";
+type NormalizedFormatAnticipation = {
+    inline: boolean;
+    mathInline: boolean;
+    mathBlock: boolean;
+    html: boolean;
+    mdx: boolean;
+    regex: boolean;
+};
+declare function normalizeFormatAnticipation(input?: FormatAnticipationConfig): NormalizedFormatAnticipation;
 type InlineStreamingPrepareResult = {
     kind: "raw";
     status: "raw";
@@ -10,8 +21,8 @@ type InlineStreamingPrepareResult = {
     appended: string;
 };
 declare function prepareInlineStreamingContent(content: string, options?: {
-    formatAnticipation?: boolean;
+    formatAnticipation?: FormatAnticipationConfig;
     math?: boolean;
 }): InlineStreamingPrepareResult;
 
-export { type InlineStreamingInlineStatus, type InlineStreamingPrepareResult, prepareInlineStreamingContent };
+export { type InlineStreamingInlineStatus, type InlineStreamingPrepareResult, type NormalizedFormatAnticipation, normalizeFormatAnticipation, prepareInlineStreamingContent };

package/dist/streaming/inline-streaming.d.ts

@@ -1,4 +1,15 @@
+import { FormatAnticipationConfig } from '../types.js';
+
 type InlineStreamingInlineStatus = "complete" | "anticipated" | "raw";
+type NormalizedFormatAnticipation = {
+    inline: boolean;
+    mathInline: boolean;
+    mathBlock: boolean;
+    html: boolean;
+    mdx: boolean;
+    regex: boolean;
+};
+declare function normalizeFormatAnticipation(input?: FormatAnticipationConfig): NormalizedFormatAnticipation;
 type InlineStreamingPrepareResult = {
     kind: "raw";
     status: "raw";
@@ -10,8 +21,8 @@ type InlineStreamingPrepareResult = {
     appended: string;
 };
 declare function prepareInlineStreamingContent(content: string, options?: {
-    formatAnticipation?: boolean;
+    formatAnticipation?: FormatAnticipationConfig;
     math?: boolean;
 }): InlineStreamingPrepareResult;
 
-export { type InlineStreamingInlineStatus, type InlineStreamingPrepareResult, prepareInlineStreamingContent };
+export { type InlineStreamingInlineStatus, type InlineStreamingPrepareResult, type NormalizedFormatAnticipation, normalizeFormatAnticipation, prepareInlineStreamingContent };