@localix-ai/flowdown 0.0.0-stage → 0.5.1

package/dist/core/heal.js

@@ -0,0 +1,220 @@
+import { parseContainerMarker } from "../dialect.js";
+import { inlineMathClose, isLiteralDollar } from "./dollars.js";
+import { openFence } from "./fence-scan.js";
+import { opensInlineMath } from "./math-delimiters.js";
+import { isEscaped } from "./prose.js";
+// src/core/heal.ts
+/**
+* Streaming-tail markdown stabilization.
+*
+* While a reply streams, the accumulated markdown frequently ends mid-construct:
+* an unterminated ``` fence renders the partial code as raw text, a dangling
+* `**` or backtick shows literal markers, a half-typed `[link](url` shows raw
+* syntax — and each of these "pops" into its formatted form a few frames later
+* once the model closes it. `closePartialMarkdown` conservatively completes
+* (or hides) those trailing constructs so the streamed view stays visually
+* stable. It is applied ONLY while streaming; the final text renders verbatim.
+*/
+/** Whether a stabilized fence is the one incomplete body still being written. */
+function isGrowingFence(growing, source) {
+	return growing !== null && growing.trimEnd() === source.trimEnd();
+}
+/**
+* The body of the fence a streaming text ends inside, or null when every fence is closed.
+*
+* Only the LAST fence can be unterminated, so this is how a renderer tells the one block that is
+* still being written from the finished blocks above it — a diagram above the tail is complete
+* and can be drawn now, instead of waiting for the whole reply to settle.
+*/
+function openFenceBody(text) {
+	const fence = openFence(text);
+	return fence ? text.slice(fence.bodyStart) : null;
+}
+/** A trailing half-written image (`![alt](partial-url` or `![alt`) is hidden — a
+* broken-image flash is worse than a beat of nothing. */
+function dropTrailingPartialImage(tail) {
+	return tail.replace(/!\[[^\]]*(\]\([^)]*)?$/, "");
+}
+/** A trailing `[text](partial-url` gets its `)` so the anchor text renders as a
+* link immediately instead of flashing raw syntax until the URL completes. */
+function closeTrailingLink(tail) {
+	return /(^|[^!])\[[^\]]*\]\([^)]*$/.test(tail) ? `${tail})` : tail;
+}
+/**
+* Code spans and CLOSED formulas blanked to spaces, positions kept. Emphasis has no meaning
+* inside either, and the balancers below would otherwise read `$a*b$` or `$x_i$` as an open
+* emphasis and append a stray `*` or `_` to the streaming tail.
+*/
+function maskInert(tail) {
+	const blank = (span) => " ".repeat(span.length);
+	return tail.replace(/`[^`]*`/g, blank).replace(/\$\$[\s\S]*?\$\$|\$[^$\n]+\$/g, blank);
+}
+/**
+* A formula still being typed is withheld from its opening `$` until the closing one arrives.
+* Math is typeset while a reply streams, so a half-typed `$\frac{a}{` would otherwise print as
+* raw LaTeX and then jump into a formula. Dollars are paired by the renderer's own rule
+* (`literalDollars`, `math-delimiters.ts`), so the two never disagree about one `$`: a price, a
+* shell variable or a `$` with a space after it (`5$ and`) opens nothing and hides nothing.
+*
+* Only the first `$` left open is withheld, and only while no `$` follows it: a `$` that came and
+* did not close it (the shell line `$(seq 1 12); do printf "%s" $i`) shows these dollars are text.
+*/
+function withholdPartialMath(tail) {
+	const code = tail.replace(/`[^`]*`/g, (span) => " ".repeat(span.length));
+	const displays = [];
+	for (let index = code.indexOf("$$"); index !== -1; index = code.indexOf("$$", index + 2)) if (!isEscaped(code, index)) displays.push(index);
+	if (displays.length % 2 === 1) return tail.slice(0, displays.at(-1)).trimEnd();
+	const inline = code.replace(/\$\$[\s\S]*?\$\$/g, (span) => " ".repeat(span.length));
+	for (let index = inline.indexOf("$"); index !== -1; index = inline.indexOf("$", index + 1)) {
+		if (isEscaped(inline, index) || isLiteralDollar(inline, index)) continue;
+		const last = index === inline.length - 1;
+		if (!last && !opensInlineMath(inline, index)) continue;
+		const close = last ? -1 : inlineMathClose(inline, index);
+		if (close !== -1) {
+			index = close;
+			continue;
+		}
+		return inline.includes("$", index + 1) ? tail : tail.slice(0, index).trimEnd();
+	}
+	return tail;
+}
+/** Balance inline code: an odd number of backticks means an open span. A bare
+* trailing opener is stripped (closing it would render an empty span as
+* literal ``` `` ```); an opener with content gets closed. */
+function balanceInlineCode(tail) {
+	if ((tail.replace(/\\`/g, "").match(/`/g) ?? []).length % 2 === 0) return tail;
+	return tail.endsWith("`") ? tail.slice(0, -1) : `${tail}\``;
+}
+/** Balance a two-char emphasis delimiter (`**` / `~~`). Occurrences inside
+* inline code spans are ignored. A bare trailing opener is stripped (closing
+* an empty pair would render four literal characters); one with content after
+* it gets closed. */
+function balanceDoubleDelimiter(tail, delim) {
+	const stripped = maskInert(tail);
+	let count = 0;
+	for (let i = 0; (i = stripped.indexOf(delim, i)) !== -1; i += delim.length) count += 1;
+	if (count % 2 === 0) return tail;
+	return tail.endsWith(delim) ? tail.slice(0, -delim.length) : `${tail}${delim}`;
+}
+const WORD_RE = /\w/;
+/**
+* Balance a single-char emphasis delimiter (`*` or `_`) — the most common
+* mid-stream flash after `**`: `*italic` shows the literal `*` until the model
+* closes it, then pops into italics. We append the missing closer so it renders
+* as emphasis immediately.
+*
+* The danger is false positives — a wrongly appended `*`/`_` italicises text the
+* author never marked up. So we count ONLY "emphasis-capable" lone delimiters:
+*   - runs of length ≥ 2 are skipped (they belong to `**`/`__`/`~~` handling);
+*   - inside inline code is masked out;
+*   - `*` counts only when it touches a word char on one side — excludes globs
+*     (`*.ts`), multiplication (`a * b`) and bullets (`* item`), where the `*` is
+*     flanked by whitespace/punctuation;
+*   - `_` additionally requires the word char to be on the OPENING side only —
+*     so intraword underscores (`file_name`, `__init__`, `snake_case`) never
+*     count, matching CommonMark's "no intraword `_` emphasis" rule.
+* An odd active count ⇒ a trailing opener is dangling: append one closer (or
+* strip a bare trailing opener, mirroring the double-delimiter rule).
+*/
+function balanceSingleEmphasis(tail, char) {
+	const masked = maskInert(tail);
+	let active = 0;
+	let i = 0;
+	while (i < masked.length) {
+		if (masked[i] !== char) {
+			i += 1;
+			continue;
+		}
+		let j = i;
+		while (j < masked.length && masked[j] === char) j += 1;
+		if (j - i === 1) {
+			const prevWord = WORD_RE.test(masked[i - 1] ?? "");
+			const nextWord = WORD_RE.test(masked[j] ?? "");
+			if (char === "*" ? prevWord || nextWord : !prevWord && nextWord || prevWord && !nextWord) active += 1;
+		}
+		i = j;
+	}
+	if (active % 2 === 0) return tail;
+	return tail.endsWith(char) ? tail.slice(0, -1) : `${tail}${char}`;
+}
+const ROW_START = /^\s{0,3}\|/;
+/** The row of dashes under a table's header: `|---|:--:|`, its outer pipes optional. */
+const DELIMITER_ROW = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+/** Hide only a partial row of an already established GFM table. A line starting
+* with `|` outside a table may be ordinary prose and must remain visible. */
+function dropTrailingPartialTableRow(text) {
+	if (text.endsWith("\n")) return text;
+	const nl = text.lastIndexOf("\n");
+	if (nl === -1 || !ROW_START.test(text.slice(nl + 1))) return text;
+	for (let end = nl; end > 0;) {
+		const start = text.lastIndexOf("\n", end - 1) + 1;
+		if (start === 0) break;
+		const line = text.slice(start, end);
+		if (DELIMITER_ROW.test(line)) {
+			const above = start === 1 ? 0 : text.lastIndexOf("\n", start - 2) + 1;
+			return ROW_START.test(text.slice(above, start - 1)) ? text.slice(0, nl) : text;
+		}
+		if (!ROW_START.test(line)) break;
+		end = start - 1;
+	}
+	return text;
+}
+/**
+* A quote line that is still typing its callout marker (`> [`, `> [!`, `> [!WARN`) is hidden
+* until the `]` arrives: it would otherwise print as a grey quote reading "[!WARN" and a beat
+* later turn into a note. A complete marker is kept — it already renders as the empty note.
+*/
+function dropTrailingPartialCalloutMarker(text) {
+	const nl = text.lastIndexOf("\n");
+	const lastLine = text.slice(nl + 1);
+	if (!/^\s{0,3}>[ \t]?\[(?:!\w*)?$/.test(lastLine)) return text;
+	return nl === -1 ? "" : text.slice(0, nl);
+}
+/**
+* A form's marker that arrived before its content (`> [!STEPS]` and nothing yet) is hidden: alone,
+* it is a quote reading "[!STEPS]", and the steps replace it a token later. Hidden only while
+* nothing follows it but blank space; once the list starts, the form renders.
+*/
+function dropTrailingBareFormMarker(text) {
+	const trimmed = text.trimEnd();
+	const nl = trimmed.lastIndexOf("\n");
+	const quoted = /^\s{0,3}>[ \t]?(.*)$/.exec(trimmed.slice(nl + 1));
+	if (!quoted || !parseContainerMarker(quoted[1].trim())) return text;
+	return nl === -1 ? "" : trimmed.slice(0, nl + 1);
+}
+function closePartialMarkdown(text) {
+	if (!text) return text;
+	const fence = openFence(text);
+	if (fence) return `${text}${text.endsWith("\n") ? "" : "\n"}${fence.marker}`;
+	return closePartialProse(text);
+}
+/**
+* `closePartialMarkdown` for a text known to end outside a fenced code block: the renderer asks
+* its own scanner about the fence, and comes here with the answer.
+*/
+function closePartialProse(text) {
+	if (!text) return text;
+	const detabled = dropTrailingPartialTableRow(text);
+	if (detabled !== text) return detabled;
+	const unmarked = dropTrailingPartialCalloutMarker(text);
+	if (unmarked !== text) return unmarked;
+	const bare = dropTrailingBareFormMarker(text);
+	if (bare !== text) return bare;
+	const splitAt = text.lastIndexOf("\n\n");
+	const head = splitAt === -1 ? "" : text.slice(0, splitAt + 2);
+	let tail = splitAt === -1 ? text : text.slice(splitAt + 2);
+	if (!tail) return text;
+	tail = dropTrailingPartialImage(tail);
+	tail = withholdPartialMath(tail);
+	tail = closeTrailingLink(tail);
+	tail = balanceInlineCode(tail);
+	tail = balanceDoubleDelimiter(tail, "**");
+	tail = balanceDoubleDelimiter(tail, "~~");
+	tail = balanceSingleEmphasis(tail, "*");
+	tail = balanceSingleEmphasis(tail, "_");
+	if (head.length + tail.length === text.length && text.endsWith(tail)) return text;
+	return head + tail;
+}
+export { closePartialMarkdown, closePartialProse, isGrowingFence, openFenceBody };
+
+//# sourceMappingURL=heal.js.map

package/dist/core/heal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heal.js","names":[],"sources":["../../src/core/heal.ts"],"sourcesContent":["/**\n * Streaming-tail markdown stabilization.\n *\n * While a reply streams, the accumulated markdown frequently ends mid-construct:\n * an unterminated ``` fence renders the partial code as raw text, a dangling\n * `**` or backtick shows literal markers, a half-typed `[link](url` shows raw\n * syntax — and each of these \"pops\" into its formatted form a few frames later\n * once the model closes it. `closePartialMarkdown` conservatively completes\n * (or hides) those trailing constructs so the streamed view stays visually\n * stable. It is applied ONLY while streaming; the final text renders verbatim.\n */\nimport { parseContainerMarker } from '../dialect'\nimport { inlineMathClose, isLiteralDollar } from './dollars'\nimport { openFence } from './fence-scan'\nimport { opensInlineMath } from './math-delimiters'\nimport { isEscaped } from './prose'\n\n/** Whether a stabilized fence is the one incomplete body still being written. */\nexport function isGrowingFence(growing: string | null, source: string): boolean {\n  return growing !== null && growing.trimEnd() === source.trimEnd()\n}\n\n/**\n * The body of the fence a streaming text ends inside, or null when every fence is closed.\n *\n * Only the LAST fence can be unterminated, so this is how a renderer tells the one block that is\n * still being written from the finished blocks above it — a diagram above the tail is complete\n * and can be drawn now, instead of waiting for the whole reply to settle.\n */\nexport function openFenceBody(text: string): string | null {\n  const fence = openFence(text)\n  return fence ? text.slice(fence.bodyStart) : null\n}\n\n/** A trailing half-written image (`![alt](partial-url` or `![alt`) is hidden — a\n * broken-image flash is worse than a beat of nothing. */\nfunction dropTrailingPartialImage(tail: string): string {\n  return tail.replace(/!\\[[^\\]]*(\\]\\([^)]*)?$/, '')\n}\n\n/** A trailing `[text](partial-url` gets its `)` so the anchor text renders as a\n * link immediately instead of flashing raw syntax until the URL completes. */\nfunction closeTrailingLink(tail: string): string {\n  return /(^|[^!])\\[[^\\]]*\\]\\([^)]*$/.test(tail) ? `${tail})` : tail\n}\n\n/**\n * Code spans and CLOSED formulas blanked to spaces, positions kept. Emphasis has no meaning\n * inside either, and the balancers below would otherwise read `$a*b$` or `$x_i$` as an open\n * emphasis and append a stray `*` or `_` to the streaming tail.\n */\nfunction maskInert(tail: string): string {\n  const blank = (span: string) => ' '.repeat(span.length)\n  return tail.replace(/`[^`]*`/g, blank).replace(/\\$\\$[\\s\\S]*?\\$\\$|\\$[^$\\n]+\\$/g, blank)\n}\n\n/**\n * A formula still being typed is withheld from its opening `$` until the closing one arrives.\n * Math is typeset while a reply streams, so a half-typed `$\\frac{a}{` would otherwise print as\n * raw LaTeX and then jump into a formula. Dollars are paired by the renderer's own rule\n * (`literalDollars`, `math-delimiters.ts`), so the two never disagree about one `$`: a price, a\n * shell variable or a `$` with a space after it (`5$ and`) opens nothing and hides nothing.\n *\n * Only the first `$` left open is withheld, and only while no `$` follows it: a `$` that came and\n * did not close it (the shell line `$(seq 1 12); do printf \"%s\" $i`) shows these dollars are text.\n */\nfunction withholdPartialMath(tail: string): string {\n  const code = tail.replace(/`[^`]*`/g, (span) => ' '.repeat(span.length))\n  const displays: number[] = []\n  for (let index = code.indexOf('$$'); index !== -1; index = code.indexOf('$$', index + 2)) {\n    if (!isEscaped(code, index)) displays.push(index)\n  }\n  if (displays.length % 2 === 1) return tail.slice(0, displays.at(-1)).trimEnd()\n\n  const inline = code.replace(/\\$\\$[\\s\\S]*?\\$\\$/g, (span) => ' '.repeat(span.length))\n  for (let index = inline.indexOf('$'); index !== -1; index = inline.indexOf('$', index + 1)) {\n    if (isEscaped(inline, index) || isLiteralDollar(inline, index)) continue\n    // The last character: the one after it, which says whether it opens, is not written yet.\n    const last = index === inline.length - 1\n    if (!last && !opensInlineMath(inline, index)) continue\n    const close = last ? -1 : inlineMathClose(inline, index)\n    if (close !== -1) {\n      index = close\n      continue\n    }\n    return inline.includes('$', index + 1) ? tail : tail.slice(0, index).trimEnd()\n  }\n  return tail\n}\n\n/** Balance inline code: an odd number of backticks means an open span. A bare\n * trailing opener is stripped (closing it would render an empty span as\n * literal ``` `` ```); an opener with content gets closed. */\nfunction balanceInlineCode(tail: string): string {\n  const count = (tail.replace(/\\\\`/g, '').match(/`/g) ?? []).length\n  if (count % 2 === 0) return tail\n  return tail.endsWith('`') ? tail.slice(0, -1) : `${tail}\\``\n}\n\n/** Balance a two-char emphasis delimiter (`**` / `~~`). Occurrences inside\n * inline code spans are ignored. A bare trailing opener is stripped (closing\n * an empty pair would render four literal characters); one with content after\n * it gets closed. */\nfunction balanceDoubleDelimiter(tail: string, delim: string): string {\n  const stripped = maskInert(tail)\n  let count = 0\n  for (let i = 0; (i = stripped.indexOf(delim, i)) !== -1; i += delim.length) count += 1\n  if (count % 2 === 0) return tail\n  return tail.endsWith(delim) ? tail.slice(0, -delim.length) : `${tail}${delim}`\n}\n\nconst WORD_RE = /\\w/\n\n/**\n * Balance a single-char emphasis delimiter (`*` or `_`) — the most common\n * mid-stream flash after `**`: `*italic` shows the literal `*` until the model\n * closes it, then pops into italics. We append the missing closer so it renders\n * as emphasis immediately.\n *\n * The danger is false positives — a wrongly appended `*`/`_` italicises text the\n * author never marked up. So we count ONLY \"emphasis-capable\" lone delimiters:\n *   - runs of length ≥ 2 are skipped (they belong to `**`/`__`/`~~` handling);\n *   - inside inline code is masked out;\n *   - `*` counts only when it touches a word char on one side — excludes globs\n *     (`*.ts`), multiplication (`a * b`) and bullets (`* item`), where the `*` is\n *     flanked by whitespace/punctuation;\n *   - `_` additionally requires the word char to be on the OPENING side only —\n *     so intraword underscores (`file_name`, `__init__`, `snake_case`) never\n *     count, matching CommonMark's \"no intraword `_` emphasis\" rule.\n * An odd active count ⇒ a trailing opener is dangling: append one closer (or\n * strip a bare trailing opener, mirroring the double-delimiter rule).\n */\nfunction balanceSingleEmphasis(tail: string, char: '*' | '_'): string {\n  const masked = maskInert(tail)\n  let active = 0\n  let i = 0\n  while (i < masked.length) {\n    if (masked[i] !== char) {\n      i += 1\n      continue\n    }\n    let j = i\n    while (j < masked.length && masked[j] === char) j += 1\n    if (j - i === 1) {\n      const prevWord = WORD_RE.test(masked[i - 1] ?? '')\n      const nextWord = WORD_RE.test(masked[j] ?? '')\n      const counts =\n        char === '*' ? prevWord || nextWord : (!prevWord && nextWord) || (prevWord && !nextWord)\n      if (counts) active += 1\n    }\n    i = j\n  }\n  if (active % 2 === 0) return tail\n  return tail.endsWith(char) ? tail.slice(0, -1) : `${tail}${char}`\n}\n\nconst ROW_START = /^\\s{0,3}\\|/\n/** The row of dashes under a table's header: `|---|:--:|`, its outer pipes optional. */\nconst DELIMITER_ROW = /^\\s*\\|?\\s*:?-{3,}:?\\s*(?:\\|\\s*:?-{3,}:?\\s*)*\\|?\\s*$/\n\n/** Hide only a partial row of an already established GFM table. A line starting\n * with `|` outside a table may be ordinary prose and must remain visible. */\nfunction dropTrailingPartialTableRow(text: string): string {\n  if (text.endsWith('\\n')) return text\n  const nl = text.lastIndexOf('\\n')\n  if (nl === -1 || !ROW_START.test(text.slice(nl + 1))) return text\n\n  // Up the lines above, one at a time: the rows of the table, to the row of dashes under its\n  // header. The reply is not cut into its lines; a long one would be on every token of a row.\n  for (let end = nl; end > 0;) {\n    const start = text.lastIndexOf('\\n', end - 1) + 1\n    // The first line of the text has no header above it.\n    if (start === 0) break\n    const line = text.slice(start, end)\n    if (DELIMITER_ROW.test(line)) {\n      const above = start === 1 ? 0 : text.lastIndexOf('\\n', start - 2) + 1\n      return ROW_START.test(text.slice(above, start - 1)) ? text.slice(0, nl) : text\n    }\n    if (!ROW_START.test(line)) break\n    end = start - 1\n  }\n  return text\n}\n\n/**\n * A quote line that is still typing its callout marker (`> [`, `> [!`, `> [!WARN`) is hidden\n * until the `]` arrives: it would otherwise print as a grey quote reading \"[!WARN\" and a beat\n * later turn into a note. A complete marker is kept — it already renders as the empty note.\n */\nfunction dropTrailingPartialCalloutMarker(text: string): string {\n  const nl = text.lastIndexOf('\\n')\n  const lastLine = text.slice(nl + 1)\n  if (!/^\\s{0,3}>[ \\t]?\\[(?:!\\w*)?$/.test(lastLine)) return text\n  return nl === -1 ? '' : text.slice(0, nl)\n}\n\n/**\n * A form's marker that arrived before its content (`> [!STEPS]` and nothing yet) is hidden: alone,\n * it is a quote reading \"[!STEPS]\", and the steps replace it a token later. Hidden only while\n * nothing follows it but blank space; once the list starts, the form renders.\n */\nfunction dropTrailingBareFormMarker(text: string): string {\n  // `trimEnd`, not `/\\s+$/`: the pattern is tried at every run of blank space in the text.\n  const trimmed = text.trimEnd()\n  const nl = trimmed.lastIndexOf('\\n')\n  const quoted = /^\\s{0,3}>[ \\t]?(.*)$/.exec(trimmed.slice(nl + 1))\n  if (!quoted || !parseContainerMarker(quoted[1]!.trim())) return text\n  return nl === -1 ? '' : trimmed.slice(0, nl + 1)\n}\n\nexport function closePartialMarkdown(text: string): string {\n  if (!text) return text\n\n  // Inside an unterminated fence: close it and skip inline fixes — everything\n  // after the opener is code, where emphasis/link syntax has no meaning.\n  const fence = openFence(text)\n  if (fence) return `${text}${text.endsWith('\\n') ? '' : '\\n'}${fence.marker}`\n  return closePartialProse(text)\n}\n\n/**\n * `closePartialMarkdown` for a text known to end outside a fenced code block: the renderer asks\n * its own scanner about the fence, and comes here with the answer.\n */\nexport function closePartialProse(text: string): string {\n  if (!text) return text\n\n  // A half-typed table row is its own kind of flash — hide it. The active edit\n  // is that row, so there's nothing else to stabilize this frame.\n  const detabled = dropTrailingPartialTableRow(text)\n  if (detabled !== text) return detabled\n  // Same for a callout marker still being typed on its quote line.\n  const unmarked = dropTrailingPartialCalloutMarker(text)\n  if (unmarked !== text) return unmarked\n  const bare = dropTrailingBareFormMarker(text)\n  if (bare !== text) return bare\n\n  // Inline constructs cannot span a blank line, so only the last paragraph can\n  // be dangling — operate on it alone and keep the rest byte-identical.\n  const splitAt = text.lastIndexOf('\\n\\n')\n  const head = splitAt === -1 ? '' : text.slice(0, splitAt + 2)\n  let tail = splitAt === -1 ? text : text.slice(splitAt + 2)\n  if (!tail) return text\n\n  tail = dropTrailingPartialImage(tail)\n  tail = withholdPartialMath(tail)\n  tail = closeTrailingLink(tail)\n  tail = balanceInlineCode(tail)\n  tail = balanceDoubleDelimiter(tail, '**')\n  tail = balanceDoubleDelimiter(tail, '~~')\n  tail = balanceSingleEmphasis(tail, '*')\n  tail = balanceSingleEmphasis(tail, '_')\n  // Nothing to complete: the very text, so a long reply is not copied on every token.\n  if (head.length + tail.length === text.length && text.endsWith(tail)) return text\n  return head + tail\n}\n"],"mappings":"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"}

package/dist/core/load-once.js

@@ -0,0 +1,23 @@
+// src/core/load-once.ts
+/**
+* A lazy loader that runs once and remembers its success, but not its failure.
+*
+* The heavy parts (the math typesetter, the diagram engine) are fetched on first use. A loader
+* that cached its rejection as faithfully as its result left the feature dead for the rest of the
+* page after one failed chunk fetch (an app updated under an open tab, a dev server re-optimizing a
+* dependency). A failure here clears the slot, so the next caller retries, while concurrent
+* callers still share one request.
+*/
+function loadOnce(load) {
+	let pending = null;
+	return () => {
+		pending ??= load().catch((error) => {
+			pending = null;
+			throw error;
+		});
+		return pending;
+	};
+}
+export { loadOnce };
+
+//# sourceMappingURL=load-once.js.map

package/dist/core/load-once.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-once.js","names":[],"sources":["../../src/core/load-once.ts"],"sourcesContent":["/**\n * A lazy loader that runs once and remembers its success, but not its failure.\n *\n * The heavy parts (the math typesetter, the diagram engine) are fetched on first use. A loader\n * that cached its rejection as faithfully as its result left the feature dead for the rest of the\n * page after one failed chunk fetch (an app updated under an open tab, a dev server re-optimizing a\n * dependency). A failure here clears the slot, so the next caller retries, while concurrent\n * callers still share one request.\n */\nexport function loadOnce<T>(load: () => Promise<T>): () => Promise<T> {\n  let pending: Promise<T> | null = null\n  return () => {\n    pending ??= load().catch((error: unknown) => {\n      pending = null\n      throw error\n    })\n    return pending\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,SAAY,MAA0C;CACpE,IAAI,UAA6B;CACjC,aAAa;EACX,YAAY,KAAK,CAAC,CAAC,OAAO,UAAmB;GAC3C,UAAU;GACV,MAAM;EACR,CAAC;EACD,OAAO;CACT;AACF"}

package/dist/core/math-delimiters.js

@@ -0,0 +1,33 @@
+// src/core/math-delimiters.ts
+/**
+* When one `$` is a delimiter of inline math: pandoc's rule, which GitHub follows. The parser, the
+* KaTeX sniffer, the literal-dollar escaper and the streaming stabilizer all ask here, so they
+* agree about every `$`.
+*
+* - The opening `$` has something other than a space right after it.
+* - The closing `$` has something other than a space right before it, and no digit right after.
+*   An escaped `\$` closes nothing: it is a dollar sign inside the formula.
+*
+* So `$x$` is math, and `$ x $`, `$a$5` and a shell line's `$(seq 1 12) … $i` are not.
+*/
+const isSpace = (char) => char === " " || char === "	" || char === "\n" || char === "\r";
+const isDigit = (char) => char !== void 0 && char >= "0" && char <= "9";
+/** Whether a single `$` at `index` can open a formula. At the end of the text it cannot. */
+function opensInlineMath(text, index) {
+	const next = text[index + 1];
+	return next !== void 0 && next !== "$" && !isSpace(next);
+}
+/**
+* Whether a single `$` at `index` can close a formula. At the end of the text it can: a stream
+* that has not yet written the next character is read as if it ends there.
+*/
+function closesInlineMath(text, index) {
+	const before = text[index - 1];
+	if (before === void 0 || isSpace(before) || before === "$" || isDigit(text[index + 1])) return false;
+	let slashes = 0;
+	while (text[index - 1 - slashes] === "\\") slashes += 1;
+	return slashes % 2 === 0;
+}
+export { closesInlineMath, opensInlineMath };
+
+//# sourceMappingURL=math-delimiters.js.map

package/dist/core/math-delimiters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-delimiters.js","names":[],"sources":["../../src/core/math-delimiters.ts"],"sourcesContent":["/**\n * When one `$` is a delimiter of inline math: pandoc's rule, which GitHub follows. The parser, the\n * KaTeX sniffer, the literal-dollar escaper and the streaming stabilizer all ask here, so they\n * agree about every `$`.\n *\n * - The opening `$` has something other than a space right after it.\n * - The closing `$` has something other than a space right before it, and no digit right after.\n *   An escaped `\\$` closes nothing: it is a dollar sign inside the formula.\n *\n * So `$x$` is math, and `$ x $`, `$a$5` and a shell line's `$(seq 1 12) … $i` are not.\n */\n\nconst isSpace = (char: string | undefined) =>\n  char === ' ' || char === '\\t' || char === '\\n' || char === '\\r'\nconst isDigit = (char: string | undefined) => char !== undefined && char >= '0' && char <= '9'\n\n/** Whether a single `$` at `index` can open a formula. At the end of the text it cannot. */\nexport function opensInlineMath(text: string, index: number): boolean {\n  const next = text[index + 1]\n  return next !== undefined && next !== '$' && !isSpace(next)\n}\n\n/**\n * Whether a single `$` at `index` can close a formula. At the end of the text it can: a stream\n * that has not yet written the next character is read as if it ends there.\n */\nexport function closesInlineMath(text: string, index: number): boolean {\n  const before = text[index - 1]\n  if (before === undefined || isSpace(before) || before === '$' || isDigit(text[index + 1]))\n    return false\n  let slashes = 0\n  while (text[index - 1 - slashes] === '\\\\') slashes += 1\n  return slashes % 2 === 0\n}\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,WAAW,SACf,SAAS,OAAO,SAAS,OAAQ,SAAS,QAAQ,SAAS;AAC7D,MAAM,WAAW,SAA6B,SAAS,KAAA,KAAa,QAAQ,OAAO,QAAQ;;AAG3F,SAAgB,gBAAgB,MAAc,OAAwB;CACpE,MAAM,OAAO,KAAK,QAAQ;CAC1B,OAAO,SAAS,KAAA,KAAa,SAAS,OAAO,CAAC,QAAQ,IAAI;AAC5D;;;;;AAMA,SAAgB,iBAAiB,MAAc,OAAwB;CACrE,MAAM,SAAS,KAAK,QAAQ;CAC5B,IAAI,WAAW,KAAA,KAAa,QAAQ,MAAM,KAAK,WAAW,OAAO,QAAQ,KAAK,QAAQ,EAAE,GACtF,OAAO;CACT,IAAI,UAAU;CACd,OAAO,KAAK,QAAQ,IAAI,aAAa,MAAM,WAAW;CACtD,OAAO,UAAU,MAAM;AACzB"}

package/dist/core/math-syntax.js

@@ -0,0 +1,56 @@
+import { visit } from "../engine/visit.js";
+import { closesInlineMath, opensInlineMath } from "./math-delimiters.js";
+// src/core/math-syntax.ts
+const DOLLAR = 36;
+/**
+* `$x$`, read the way a code span is: a run of dollars opens it, the next run of the same length
+* closes it, and nothing between them is Markdown. A single dollar also follows pandoc's rule
+* (`math-delimiters.ts`): `$ x $`, `$a$5` and a shell line's `$(seq 1 12) … $i` are text.
+*/
+function inlineMath(state) {
+	const { text, pos } = state;
+	let open = pos;
+	while (text.charCodeAt(open) === DOLLAR) open++;
+	const size = open - pos;
+	if (size === 1 && !opensInlineMath(text, pos)) return false;
+	for (let at = text.indexOf("$", open); at !== -1; at = text.indexOf("$", at)) {
+		let end = at;
+		while (text.charCodeAt(end) === DOLLAR) end++;
+		if (end - at === size && (size > 1 || closesInlineMath(text, at))) {
+			let value = text.slice(open, at).replace(/\n/g, " ");
+			if (value.length > 2 && value.startsWith(" ") && value.endsWith(" ") && value.trim() !== "") value = value.slice(1, -1);
+			state.push({
+				type: "inlineMath",
+				value
+			});
+			state.pos = end;
+			return true;
+		}
+		at = end;
+	}
+	return false;
+}
+/** The inline rule of a formula. */
+const MATH_INLINE = [{
+	chars: "$",
+	parse: inlineMath
+}];
+/** A formula of a tree, with GitHub's third way to write a display one made one: a `math` fence. */
+function eachFormula(root, each) {
+	visit(root, (node) => {
+		if (node.type === "code" && node.lang === "math") node.type = "math";
+		if (node.type === "inlineMath" || node.type === "math") each(node, node.type === "math");
+	});
+}
+/** Formulas read and left as their LaTeX: for a target that draws them its own way. */
+const mathSyntax = {
+	name: "math",
+	mathFences: true,
+	inline: MATH_INLINE,
+	transform(root) {
+		eachFormula(root, () => {});
+	}
+};
+export { MATH_INLINE, eachFormula, mathSyntax };
+
+//# sourceMappingURL=math-syntax.js.map

package/dist/core/math-syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-syntax.js","names":[],"sources":["../../src/core/math-syntax.ts"],"sourcesContent":["/**\n * How a formula is written: `$…$`, `$$…$$` and a ```` ```math ```` fence, read into `inlineMath`\n * and `math` nodes that hold the LaTeX as written. What a formula is drawn as is the target's:\n * `@localix-ai/flowdown/math` typesets it with KaTeX for a page, a terminal writes it in Unicode.\n */\nimport type { Extension, InlineRule, InlineState, Node } from '../engine/types'\nimport { visit } from '../engine/visit'\nimport { closesInlineMath, opensInlineMath } from './math-delimiters'\n\nconst DOLLAR = 36\n\n/**\n * `$x$`, read the way a code span is: a run of dollars opens it, the next run of the same length\n * closes it, and nothing between them is Markdown. A single dollar also follows pandoc's rule\n * (`math-delimiters.ts`): `$ x $`, `$a$5` and a shell line's `$(seq 1 12) … $i` are text.\n */\nfunction inlineMath(state: InlineState): boolean {\n  const { text, pos } = state\n  let open = pos\n  while (text.charCodeAt(open) === DOLLAR) open++\n  const size = open - pos\n  if (size === 1 && !opensInlineMath(text, pos)) return false\n  for (let at = text.indexOf('$', open); at !== -1; at = text.indexOf('$', at)) {\n    let end = at\n    while (text.charCodeAt(end) === DOLLAR) end++\n    if (end - at === size && (size > 1 || closesInlineMath(text, at))) {\n      let value = text.slice(open, at).replace(/\\n/g, ' ')\n      // One space of padding inside `$$ … $$` is not part of the formula.\n      if (value.length > 2 && value.startsWith(' ') && value.endsWith(' ') && value.trim() !== '')\n        value = value.slice(1, -1)\n      state.push({ type: 'inlineMath', value })\n      state.pos = end\n      return true\n    }\n    at = end\n  }\n  return false\n}\n\n/** The inline rule of a formula. */\nexport const MATH_INLINE: InlineRule[] = [{ chars: '$', parse: inlineMath }]\n\n/** A formula of a tree, with GitHub's third way to write a display one made one: a `math` fence. */\nexport function eachFormula(root: Node, each: (node: Node, display: boolean) => void): void {\n  visit(root, (node) => {\n    if (node.type === 'code' && node.lang === 'math') node.type = 'math'\n    if (node.type === 'inlineMath' || node.type === 'math') each(node, node.type === 'math')\n  })\n}\n\n/** Formulas read and left as their LaTeX: for a target that draws them its own way. */\nexport const mathSyntax: Extension = {\n  name: 'math',\n  mathFences: true,\n  inline: MATH_INLINE,\n  transform(root) {\n    eachFormula(root, () => {})\n  },\n}\n"],"mappings":";;;AASA,MAAM,SAAS;;;;;;AAOf,SAAS,WAAW,OAA6B;CAC/C,MAAM,EAAE,MAAM,QAAQ;CACtB,IAAI,OAAO;CACX,OAAO,KAAK,WAAW,IAAI,MAAM,QAAQ;CACzC,MAAM,OAAO,OAAO;CACpB,IAAI,SAAS,KAAK,CAAC,gBAAgB,MAAM,GAAG,GAAG,OAAO;CACtD,KAAK,IAAI,KAAK,KAAK,QAAQ,KAAK,IAAI,GAAG,OAAO,IAAI,KAAK,KAAK,QAAQ,KAAK,EAAE,GAAG;EAC5E,IAAI,MAAM;EACV,OAAO,KAAK,WAAW,GAAG,MAAM,QAAQ;EACxC,IAAI,MAAM,OAAO,SAAS,OAAO,KAAK,iBAAiB,MAAM,EAAE,IAAI;GACjE,IAAI,QAAQ,KAAK,MAAM,MAAM,EAAE,CAAC,CAAC,QAAQ,OAAO,GAAG;GAEnD,IAAI,MAAM,SAAS,KAAK,MAAM,WAAW,GAAG,KAAK,MAAM,SAAS,GAAG,KAAK,MAAM,KAAK,MAAM,IACvF,QAAQ,MAAM,MAAM,GAAG,EAAE;GAC3B,MAAM,KAAK;IAAE,MAAM;IAAc;GAAM,CAAC;GACxC,MAAM,MAAM;GACZ,OAAO;EACT;EACA,KAAK;CACP;CACA,OAAO;AACT;;AAGA,MAAa,cAA4B,CAAC;CAAE,OAAO;CAAK,OAAO;AAAW,CAAC;;AAG3E,SAAgB,YAAY,MAAY,MAAoD;CAC1F,MAAM,OAAO,SAAS;EACpB,IAAI,KAAK,SAAS,UAAU,KAAK,SAAS,QAAQ,KAAK,OAAO;EAC9D,IAAI,KAAK,SAAS,gBAAgB,KAAK,SAAS,QAAQ,KAAK,MAAM,KAAK,SAAS,MAAM;CACzF,CAAC;AACH;;AAGA,MAAa,aAAwB;CACnC,MAAM;CACN,YAAY;CACZ,QAAQ;CACR,UAAU,MAAM;EACd,YAAY,YAAY,CAAC,CAAC;CAC5B;AACF"}

package/dist/core/prose.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Which characters of a markdown source are prose — the text outside fenced, indented and inline
+ * code — as one mask the math sniffer, the HTML sniffer and the literal-dollar escaper all read.
+ *
+ * The mask keeps the source's exact length and line breaks: code characters become spaces, so an
+ * index into the mask is an index into the source. The escaper depends on that — it inserts a
+ * backslash at a position found in the mask — and a mask that dropped code lines (as the first
+ * version here did) would shift every position after the first code block.
+ */
+export declare function markdownProseWithoutCode(markdown: string): string;

package/dist/core/prose.js

@@ -0,0 +1,77 @@
+// src/core/prose.ts
+/**
+* Which characters of a markdown source are prose — the text outside fenced, indented and inline
+* code — as one mask the math sniffer, the HTML sniffer and the literal-dollar escaper all read.
+*
+* The mask keeps the source's exact length and line breaks: code characters become spaces, so an
+* index into the mask is an index into the source. The escaper depends on that — it inserts a
+* backslash at a position found in the mask — and a mask that dropped code lines (as the first
+* version here did) would shift every position after the first code block.
+*/
+function markdownProseWithoutCode(markdown) {
+	if (!CODE_HINT.test(markdown)) return markdown;
+	const prose = [];
+	let fence = null;
+	const blank = (line) => " ".repeat(line.length);
+	for (const line of markdown.split("\n")) {
+		const marker = FENCE_MARKER.exec(line);
+		if (fence) {
+			if (marker && marker[1][0] === fence.character && marker[1].length >= fence.length && marker[2].trim() === "") fence = null;
+			prose.push(blank(line));
+			continue;
+		}
+		if (marker && !(marker[1][0] === "`" && marker[2].includes("`"))) {
+			fence = {
+				character: marker[1][0],
+				length: marker[1].length
+			};
+			prose.push(blank(line));
+			continue;
+		}
+		prose.push(INDENTED.test(line) ? blank(line) : line);
+	}
+	const source = prose.join("\n");
+	let visible = "";
+	let copied = 0;
+	for (let index = source.indexOf("`"); index !== -1; index = source.indexOf("`", index)) {
+		if (isEscaped(source, index)) {
+			index += 1;
+			continue;
+		}
+		let delimiterLength = 1;
+		while (source[index + delimiterLength] === "`") delimiterLength += 1;
+		let closing = source.indexOf("`", index + delimiterLength);
+		while (closing !== -1) {
+			if (isEscaped(source, closing)) {
+				closing = source.indexOf("`", closing + 1);
+				continue;
+			}
+			let closingLength = 1;
+			while (source[closing + closingLength] === "`") closingLength += 1;
+			if (closingLength === delimiterLength) break;
+			closing = source.indexOf("`", closing + closingLength);
+		}
+		if (closing === -1) {
+			index += delimiterLength;
+			continue;
+		}
+		const end = closing + delimiterLength;
+		visible += source.slice(copied, index) + source.slice(index, end).replace(NOT_NEWLINE, " ");
+		copied = end;
+		index = end;
+	}
+	return copied === 0 ? source : visible + source.slice(copied);
+}
+const CODE_HINT = /`|~~~|^(?: {4}|\t)/m;
+const FENCE_MARKER = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+const INDENTED = /^(?: {4}|\t)/;
+const NOT_NEWLINE = /[^\n]/g;
+/** Whether the character at `index` is backslash-escaped (an odd run of `\` before it). */
+function isEscaped(text, index) {
+	let slashCount = 0;
+	for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) slashCount += 1;
+	return slashCount % 2 === 1;
+}
+export { isEscaped, markdownProseWithoutCode };
+
+//# sourceMappingURL=prose.js.map

package/dist/core/prose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prose.js","names":[],"sources":["../../src/core/prose.ts"],"sourcesContent":["/**\n * Which characters of a markdown source are prose — the text outside fenced, indented and inline\n * code — as one mask the math sniffer, the HTML sniffer and the literal-dollar escaper all read.\n *\n * The mask keeps the source's exact length and line breaks: code characters become spaces, so an\n * index into the mask is an index into the source. The escaper depends on that — it inserts a\n * backslash at a position found in the mask — and a mask that dropped code lines (as the first\n * version here did) would shift every position after the first code block.\n */\nexport function markdownProseWithoutCode(markdown: string): string {\n  // Nothing here can be code: no backtick or tilde run, no line indented four.\n  if (!CODE_HINT.test(markdown)) return markdown\n  const prose: string[] = []\n  let fence: { character: string; length: number } | null = null\n  const blank = (line: string) => ' '.repeat(line.length)\n\n  for (const line of markdown.split('\\n')) {\n    const marker = FENCE_MARKER.exec(line)\n    if (fence) {\n      if (\n        marker &&\n        marker[1]![0] === fence.character &&\n        marker[1]!.length >= fence.length &&\n        marker[2]!.trim() === ''\n      ) {\n        fence = null\n      }\n      prose.push(blank(line))\n      continue\n    }\n    // A backtick fence has no backtick in its info string: ```` ```a``` ```` is inline code.\n    if (marker && !(marker[1]![0] === '`' && marker[2]!.includes('`'))) {\n      fence = { character: marker[1]![0]!, length: marker[1]!.length }\n      prose.push(blank(line))\n      continue\n    }\n\n    // Four-space/tab-indented CommonMark code is as inert as a fenced block.\n    prose.push(INDENTED.test(line) ? blank(line) : line)\n  }\n\n  // Inline code spans may cross line breaks. Blank only complete spans; an\n  // unmatched backtick stays prose, matching CommonMark's literal treatment.\n  const source = prose.join('\\n')\n  let visible = ''\n  let copied = 0\n  for (let index = source.indexOf('`'); index !== -1; index = source.indexOf('`', index)) {\n    if (isEscaped(source, index)) {\n      index += 1\n      continue\n    }\n    let delimiterLength = 1\n    while (source[index + delimiterLength] === '`') delimiterLength += 1\n    let closing = source.indexOf('`', index + delimiterLength)\n    while (closing !== -1) {\n      if (isEscaped(source, closing)) {\n        closing = source.indexOf('`', closing + 1)\n        continue\n      }\n      let closingLength = 1\n      while (source[closing + closingLength] === '`') closingLength += 1\n      if (closingLength === delimiterLength) break\n      closing = source.indexOf('`', closing + closingLength)\n    }\n    if (closing === -1) {\n      index += delimiterLength\n      continue\n    }\n    const end = closing + delimiterLength\n    visible += source.slice(copied, index) + source.slice(index, end).replace(NOT_NEWLINE, ' ')\n    copied = end\n    index = end\n  }\n  return copied === 0 ? source : visible + source.slice(copied)\n}\n\nconst CODE_HINT = /`|~~~|^(?: {4}|\\t)/m\nconst FENCE_MARKER = /^ {0,3}(`{3,}|~{3,})(.*)$/\nconst INDENTED = /^(?: {4}|\\t)/\nconst NOT_NEWLINE = /[^\\n]/g\n\n/** Whether the character at `index` is backslash-escaped (an odd run of `\\` before it). */\nexport function isEscaped(text: string, index: number): boolean {\n  let slashCount = 0\n  for (let cursor = index - 1; cursor >= 0 && text[cursor] === '\\\\'; cursor -= 1) {\n    slashCount += 1\n  }\n  return slashCount % 2 === 1\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,yBAAyB,UAA0B;CAEjE,IAAI,CAAC,UAAU,KAAK,QAAQ,GAAG,OAAO;CACtC,MAAM,QAAkB,CAAC;CACzB,IAAI,QAAsD;CAC1D,MAAM,SAAS,SAAiB,IAAI,OAAO,KAAK,MAAM;CAEtD,KAAK,MAAM,QAAQ,SAAS,MAAM,IAAI,GAAG;EACvC,MAAM,SAAS,aAAa,KAAK,IAAI;EACrC,IAAI,OAAO;GACT,IACE,UACA,OAAO,EAAE,CAAE,OAAO,MAAM,aACxB,OAAO,EAAE,CAAE,UAAU,MAAM,UAC3B,OAAO,EAAE,CAAE,KAAK,MAAM,IAEtB,QAAQ;GAEV,MAAM,KAAK,MAAM,IAAI,CAAC;GACtB;EACF;EAEA,IAAI,UAAU,EAAE,OAAO,EAAE,CAAE,OAAO,OAAO,OAAO,EAAE,CAAE,SAAS,GAAG,IAAI;GAClE,QAAQ;IAAE,WAAW,OAAO,EAAE,CAAE;IAAK,QAAQ,OAAO,EAAE,CAAE;GAAO;GAC/D,MAAM,KAAK,MAAM,IAAI,CAAC;GACtB;EACF;EAGA,MAAM,KAAK,SAAS,KAAK,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI;CACrD;CAIA,MAAM,SAAS,MAAM,KAAK,IAAI;CAC9B,IAAI,UAAU;CACd,IAAI,SAAS;CACb,KAAK,IAAI,QAAQ,OAAO,QAAQ,GAAG,GAAG,UAAU,IAAI,QAAQ,OAAO,QAAQ,KAAK,KAAK,GAAG;EACtF,IAAI,UAAU,QAAQ,KAAK,GAAG;GAC5B,SAAS;GACT;EACF;EACA,IAAI,kBAAkB;EACtB,OAAO,OAAO,QAAQ,qBAAqB,KAAK,mBAAmB;EACnE,IAAI,UAAU,OAAO,QAAQ,KAAK,QAAQ,eAAe;EACzD,OAAO,YAAY,IAAI;GACrB,IAAI,UAAU,QAAQ,OAAO,GAAG;IAC9B,UAAU,OAAO,QAAQ,KAAK,UAAU,CAAC;IACzC;GACF;GACA,IAAI,gBAAgB;GACpB,OAAO,OAAO,UAAU,mBAAmB,KAAK,iBAAiB;GACjE,IAAI,kBAAkB,iBAAiB;GACvC,UAAU,OAAO,QAAQ,KAAK,UAAU,aAAa;EACvD;EACA,IAAI,YAAY,IAAI;GAClB,SAAS;GACT;EACF;EACA,MAAM,MAAM,UAAU;EACtB,WAAW,OAAO,MAAM,QAAQ,KAAK,IAAI,OAAO,MAAM,OAAO,GAAG,CAAC,CAAC,QAAQ,aAAa,GAAG;EAC1F,SAAS;EACT,QAAQ;CACV;CACA,OAAO,WAAW,IAAI,SAAS,UAAU,OAAO,MAAM,MAAM;AAC9D;AAEA,MAAM,YAAY;AAClB,MAAM,eAAe;AACrB,MAAM,WAAW;AACjB,MAAM,cAAc;;AAGpB,SAAgB,UAAU,MAAc,OAAwB;CAC9D,IAAI,aAAa;CACjB,KAAK,IAAI,SAAS,QAAQ,GAAG,UAAU,KAAK,KAAK,YAAY,MAAM,UAAU,GAC3E,cAAc;CAEhB,OAAO,aAAa,MAAM;AAC5B"}

package/dist/core/remark-answer-blocks.d.ts

@@ -0,0 +1,5 @@
+import { Extension, Tree } from "../engine/types.js";
+/** The dialect as a remark plugin: its forms as the elements and classes `styles.css` draws. */
+export declare const remarkAnswerBlocks: () => (tree: Tree) => void;
+/** The dialect as an extension of the engine: what `<Markdown>` reads every document with. */
+export declare const flowdownDialect: Extension;