@stream-mdx/core 0.0.2 → 0.1.0

package/dist/index.mjs

@@ -202,12 +202,42 @@ function filterAllowedAttributes(attrs) {
 }
 
 // src/inline-parser.ts
+function ensureGlobal(pattern) {
+  if (pattern.global) return pattern;
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}
+function findLastMatch(pattern, value) {
+  const re = ensureGlobal(pattern);
+  let match = null;
+  let next;
+  while ((next = re.exec(value)) !== null) {
+    match = next;
+  }
+  return match;
+}
+function findMatchAfter(pattern, value, startIndex) {
+  const re = ensureGlobal(pattern);
+  re.lastIndex = Math.max(0, startIndex);
+  return re.exec(value);
+}
+function isSamePattern(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function countMatches(pattern, value) {
+  const re = ensureGlobal(pattern);
+  let count = 0;
+  while (re.exec(value)) {
+    count += 1;
+  }
+  return count;
+}
 var InlineParser = class {
   constructor(options = {}) {
     this.plugins = [];
     this.cache = /* @__PURE__ */ new Map();
     this.maxCacheEntries = Number.isFinite(options.maxCacheEntries ?? Number.NaN) ? Math.max(0, options.maxCacheEntries ?? 0) : 2e3;
-    this.registerDefaultPlugins();
+    this.registerDefaultPlugins({ enableMath: options.enableMath !== false });
   }
   /**
    * Register a plugin with the parser
@@ -249,6 +279,42 @@ var InlineParser = class {
     }
     return result;
   }
+  /**
+   * Streaming regex anticipation helper. Returns an append string if a plugin
+   * declares an incomplete match at the end of the buffer.
+   */
+  getRegexAnticipationAppend(content) {
+    if (!content || this.plugins.length === 0) {
+      return null;
+    }
+    for (const plugin of this.plugins) {
+      if (!("re" in plugin)) continue;
+      const regexPlugin = plugin;
+      const anticipation = regexPlugin.anticipation;
+      if (!anticipation) continue;
+      const maxScanChars = Number.isFinite(anticipation.maxScanChars ?? Number.NaN) ? Math.max(1, anticipation.maxScanChars ?? 0) : 240;
+      const scan = content.slice(Math.max(0, content.length - maxScanChars));
+      if (regexPlugin.fastCheck && !regexPlugin.fastCheck(scan)) {
+        continue;
+      }
+      const lastStart = findLastMatch(anticipation.start, scan);
+      if (!lastStart) continue;
+      if (isSamePattern(anticipation.start, anticipation.end)) {
+        const occurrences = countMatches(anticipation.start, scan);
+        if (occurrences % 2 === 0) {
+          continue;
+        }
+      } else {
+        const startIndex = lastStart.index + lastStart[0].length;
+        const hasEnd = Boolean(findMatchAfter(anticipation.end, scan, startIndex));
+        if (hasEnd) continue;
+      }
+      const appendValue = typeof anticipation.append === "function" ? anticipation.append(lastStart, content) : anticipation.append;
+      if (!appendValue) continue;
+      return appendValue;
+    }
+    return null;
+  }
   /**
    * Clear the memoization cache
    */
@@ -273,10 +339,27 @@ var InlineParser = class {
    * Register default plugins with proper precedence ordering
    * Lower priority numbers = higher precedence (run first)
    */
-  registerDefaultPlugins() {
+  registerDefaultPlugins(options) {
+    if (options.enableMath) {
+      this.registerPlugin({
+        id: "math-display",
+        priority: 0,
+        re: /\$\$([\s\S]+?)\$\$/g,
+        toNode: (match) => ({ kind: "math-display", tex: match[1].trim() }),
+        fastCheck: (text) => text.indexOf("$$") !== -1
+      });
+      this.registerPlugin({
+        id: "math-inline",
+        priority: 1,
+        re: /\$([^$\n]+?)\$/g,
+        // Non-greedy to prevent spanning multiple expressions
+        toNode: (match) => ({ kind: "math-inline", tex: match[1].trim() }),
+        fastCheck: (text) => text.indexOf("$") !== -1
+      });
+    }
     this.registerPlugin({
       id: "escaped-character",
-      priority: 0,
+      priority: 2,
       re: /\\([\\`*_{}\[\]()#+\-.!>])/g,
       toNode: (match) => ({
         kind: "text",
@@ -285,19 +368,11 @@ var InlineParser = class {
       fastCheck: (text) => text.indexOf("\\") !== -1
     });
     this.registerPlugin({
-      id: "math-display",
-      priority: 1,
-      re: /\$\$([^$]+?)\$\$/g,
-      toNode: (match) => ({ kind: "math-display", tex: match[1].trim() }),
-      fastCheck: (text) => text.indexOf("$$") !== -1
-    });
-    this.registerPlugin({
-      id: "math-inline",
+      id: "hard-break",
       priority: 2,
-      re: /\$([^$\n]+?)\$/g,
-      // Non-greedy to prevent spanning multiple expressions
-      toNode: (match) => ({ kind: "math-inline", tex: match[1].trim() }),
-      fastCheck: (text) => text.indexOf("$") !== -1
+      re: /\\\r?\n| {2,}\r?\n/g,
+      toNode: (_match) => ({ kind: "br" }),
+      fastCheck: (text) => text.indexOf("\n") !== -1 || text.indexOf("\r") !== -1
     });
     this.registerPlugin({
       id: "code-spans",
@@ -368,9 +443,16 @@ var InlineParser = class {
     this.registerPlugin({
       id: "citations",
       priority: 10,
-      re: /\[\^([^\]]+)\]|@cite\{([^}]+)\}/g,
-      toNode: (match) => ({ kind: "citation", id: match[1] || match[2] }),
-      fastCheck: (text) => text.indexOf("@") !== -1 || text.indexOf("[^") !== -1
+      re: /\[\^([^\]\n]+)\]|@cite\{([^}\n]+)\}|\{cite:([^}\n]+)\}/g,
+      toNode: (match) => ({ kind: "citation", id: match[1] || match[2] || match[3] }),
+      fastCheck: (text) => text.indexOf("@cite") !== -1 || text.indexOf("[^") !== -1 || text.indexOf("{cite:") !== -1,
+      anticipation: {
+        start: /@cite\{|\{cite:/g,
+        end: /\}/g,
+        full: /@cite\{[^}\n]+?\}|\{cite:[^}\n]+?\}/g,
+        append: "}",
+        maxScanChars: 120
+      }
     });
     this.registerPlugin({
       id: "mentions",
@@ -470,9 +552,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 {
@@ -588,9 +684,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") {
@@ -601,22 +715,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;
@@ -628,8 +778,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,
@@ -638,6 +788,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);
@@ -762,6 +923,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;
@@ -2712,6 +2915,130 @@ var CustomStreamingMatcher = class {
     return false;
   }
 };
+
+// src/streaming/inline-streaming.ts
+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 enableMath = options?.math !== false;
+  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 === 10 || code === 13) {
+      if (mathDisplayOpen) {
+        mathDisplayCrossedNewline = true;
+      }
+      continue;
+    }
+    if (code === 96) {
+      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) {
+        toggleToken("strong");
+        i += 1;
+      } else {
+        toggleToken("em");
+      }
+      continue;
+    }
+    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 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 (hasIncompleteFormatting && !enableInlineAnticipation) {
+    return { kind: "raw", status: "raw", reason: "incomplete-formatting" };
+  }
+  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 };
+}
 export {
   CSP_HEADERS,
   CustomStreamingMatcher,
@@ -2755,8 +3082,10 @@ export {
   inlineNodesToPlainText,
   isLikelyMdxComponent,
   normalizeBlockquoteText,
+  normalizeFormatAnticipation,
   normalizeLang,
   parseCodeFenceInfo,
+  prepareInlineStreamingContent,
   removeHeadingMarkers,
   sanitizeCodeHTML,
   sanitizeHTML,

package/dist/inline-parser.cjs

@@ -25,12 +25,42 @@ __export(inline_parser_exports, {
   applyRegexPlugin: () => applyRegexPlugin
 });
 module.exports = __toCommonJS(inline_parser_exports);
+function ensureGlobal(pattern) {
+  if (pattern.global) return pattern;
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}
+function findLastMatch(pattern, value) {
+  const re = ensureGlobal(pattern);
+  let match = null;
+  let next;
+  while ((next = re.exec(value)) !== null) {
+    match = next;
+  }
+  return match;
+}
+function findMatchAfter(pattern, value, startIndex) {
+  const re = ensureGlobal(pattern);
+  re.lastIndex = Math.max(0, startIndex);
+  return re.exec(value);
+}
+function isSamePattern(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function countMatches(pattern, value) {
+  const re = ensureGlobal(pattern);
+  let count = 0;
+  while (re.exec(value)) {
+    count += 1;
+  }
+  return count;
+}
 var InlineParser = class {
   constructor(options = {}) {
     this.plugins = [];
     this.cache = /* @__PURE__ */ new Map();
     this.maxCacheEntries = Number.isFinite(options.maxCacheEntries ?? Number.NaN) ? Math.max(0, options.maxCacheEntries ?? 0) : 2e3;
-    this.registerDefaultPlugins();
+    this.registerDefaultPlugins({ enableMath: options.enableMath !== false });
   }
   /**
    * Register a plugin with the parser
@@ -72,6 +102,42 @@ var InlineParser = class {
     }
     return result;
   }
+  /**
+   * Streaming regex anticipation helper. Returns an append string if a plugin
+   * declares an incomplete match at the end of the buffer.
+   */
+  getRegexAnticipationAppend(content) {
+    if (!content || this.plugins.length === 0) {
+      return null;
+    }
+    for (const plugin of this.plugins) {
+      if (!("re" in plugin)) continue;
+      const regexPlugin = plugin;
+      const anticipation = regexPlugin.anticipation;
+      if (!anticipation) continue;
+      const maxScanChars = Number.isFinite(anticipation.maxScanChars ?? Number.NaN) ? Math.max(1, anticipation.maxScanChars ?? 0) : 240;
+      const scan = content.slice(Math.max(0, content.length - maxScanChars));
+      if (regexPlugin.fastCheck && !regexPlugin.fastCheck(scan)) {
+        continue;
+      }
+      const lastStart = findLastMatch(anticipation.start, scan);
+      if (!lastStart) continue;
+      if (isSamePattern(anticipation.start, anticipation.end)) {
+        const occurrences = countMatches(anticipation.start, scan);
+        if (occurrences % 2 === 0) {
+          continue;
+        }
+      } else {
+        const startIndex = lastStart.index + lastStart[0].length;
+        const hasEnd = Boolean(findMatchAfter(anticipation.end, scan, startIndex));
+        if (hasEnd) continue;
+      }
+      const appendValue = typeof anticipation.append === "function" ? anticipation.append(lastStart, content) : anticipation.append;
+      if (!appendValue) continue;
+      return appendValue;
+    }
+    return null;
+  }
   /**
    * Clear the memoization cache
    */
@@ -96,10 +162,27 @@ var InlineParser = class {
    * Register default plugins with proper precedence ordering
    * Lower priority numbers = higher precedence (run first)
    */
-  registerDefaultPlugins() {
+  registerDefaultPlugins(options) {
+    if (options.enableMath) {
+      this.registerPlugin({
+        id: "math-display",
+        priority: 0,
+        re: /\$\$([\s\S]+?)\$\$/g,
+        toNode: (match) => ({ kind: "math-display", tex: match[1].trim() }),
+        fastCheck: (text) => text.indexOf("$$") !== -1
+      });
+      this.registerPlugin({
+        id: "math-inline",
+        priority: 1,
+        re: /\$([^$\n]+?)\$/g,
+        // Non-greedy to prevent spanning multiple expressions
+        toNode: (match) => ({ kind: "math-inline", tex: match[1].trim() }),
+        fastCheck: (text) => text.indexOf("$") !== -1
+      });
+    }
     this.registerPlugin({
       id: "escaped-character",
-      priority: 0,
+      priority: 2,
       re: /\\([\\`*_{}\[\]()#+\-.!>])/g,
       toNode: (match) => ({
         kind: "text",
@@ -108,19 +191,11 @@ var InlineParser = class {
       fastCheck: (text) => text.indexOf("\\") !== -1
     });
     this.registerPlugin({
-      id: "math-display",
-      priority: 1,
-      re: /\$\$([^$]+?)\$\$/g,
-      toNode: (match) => ({ kind: "math-display", tex: match[1].trim() }),
-      fastCheck: (text) => text.indexOf("$$") !== -1
-    });
-    this.registerPlugin({
-      id: "math-inline",
+      id: "hard-break",
       priority: 2,
-      re: /\$([^$\n]+?)\$/g,
-      // Non-greedy to prevent spanning multiple expressions
-      toNode: (match) => ({ kind: "math-inline", tex: match[1].trim() }),
-      fastCheck: (text) => text.indexOf("$") !== -1
+      re: /\\\r?\n| {2,}\r?\n/g,
+      toNode: (_match) => ({ kind: "br" }),
+      fastCheck: (text) => text.indexOf("\n") !== -1 || text.indexOf("\r") !== -1
     });
     this.registerPlugin({
       id: "code-spans",
@@ -191,9 +266,16 @@ var InlineParser = class {
     this.registerPlugin({
       id: "citations",
       priority: 10,
-      re: /\[\^([^\]]+)\]|@cite\{([^}]+)\}/g,
-      toNode: (match) => ({ kind: "citation", id: match[1] || match[2] }),
-      fastCheck: (text) => text.indexOf("@") !== -1 || text.indexOf("[^") !== -1
+      re: /\[\^([^\]\n]+)\]|@cite\{([^}\n]+)\}|\{cite:([^}\n]+)\}/g,
+      toNode: (match) => ({ kind: "citation", id: match[1] || match[2] || match[3] }),
+      fastCheck: (text) => text.indexOf("@cite") !== -1 || text.indexOf("[^") !== -1 || text.indexOf("{cite:") !== -1,
+      anticipation: {
+        start: /@cite\{|\{cite:/g,
+        end: /\}/g,
+        full: /@cite\{[^}\n]+?\}|\{cite:[^}\n]+?\}/g,
+        append: "}",
+        maxScanChars: 120
+      }
     });
     this.registerPlugin({
       id: "mentions",

package/dist/inline-parser.d.cts

@@ -7,6 +7,11 @@ interface InlineParserOptions {
      * parsing many intermediate states.
      */
     maxCacheEntries?: number;
+    /**
+     * Enable parsing `$...$` and `$$...$$` math nodes.
+     * Defaults to `true`.
+     */
+    enableMath?: boolean;
 }
 interface InlineParseOptions {
     /**
@@ -31,6 +36,11 @@ declare class InlineParser {
      * Parse inline content with memoization
      */
     parse(content: string, options?: InlineParseOptions): InlineNode[];
+    /**
+     * Streaming regex anticipation helper. Returns an append string if a plugin
+     * declares an incomplete match at the end of the buffer.
+     */
+    getRegexAnticipationAppend(content: string): string | null;
     /**
      * Clear the memoization cache
      */