@localix-ai/flowdown 0.0.0-stage → 0.5.0

package/dist/core/syntax.js

@@ -0,0 +1,32 @@
+import { inlineMathClose, isLiteralDollar } from "./dollars.js";
+import { opensInlineMath } from "./math-delimiters.js";
+import { isEscaped, markdownProseWithoutCode } from "./prose.js";
+// src/core/syntax.ts
+/**
+* Whether the prose holds a formula, so KaTeX is worth loading: a `$$…$$` pair, or a single-dollar
+* pair by the parser's rule (`math-delimiters.ts`). Prices, shell variables and code do not count.
+*/
+function hasMathSyntax(markdown) {
+	if (!markdown.includes("$")) return false;
+	const text = markdownProseWithoutCode(markdown);
+	for (let index = text.indexOf("$"); index !== -1; index = text.indexOf("$", index + 1)) {
+		if (isEscaped(text, index)) continue;
+		if (text[index + 1] === "$") {
+			const closing = text.indexOf("$$", index + 2);
+			if (closing !== -1 && text.slice(index + 2, closing).trim()) return true;
+			index = closing === -1 ? index + 1 : closing + 1;
+			continue;
+		}
+		if (text[index - 1] === "$" || isLiteralDollar(text, index)) continue;
+		if (opensInlineMath(text, index) && inlineMathClose(text, index) !== -1) return true;
+	}
+	return false;
+}
+/** Raw HTML only matters in prose. Tags shown inside fenced/indented/inline code
+* stay literal, so they must not enable the full rehype-raw + sanitize pipeline. */
+function hasHtmlSyntax(markdown) {
+	return /<[a-zA-Z][\w-]*[\s/>]/.test(markdownProseWithoutCode(markdown));
+}
+export { hasHtmlSyntax, hasMathSyntax };
+
+//# sourceMappingURL=syntax.js.map

package/dist/core/syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.js","names":[],"sources":["../../src/core/syntax.ts"],"sourcesContent":["import { inlineMathClose, isLiteralDollar } from './dollars'\nimport { opensInlineMath } from './math-delimiters'\nimport { isEscaped, markdownProseWithoutCode } from './prose'\n\n/**\n * Whether the prose holds a formula, so KaTeX is worth loading: a `$$…$$` pair, or a single-dollar\n * pair by the parser's rule (`math-delimiters.ts`). Prices, shell variables and code do not count.\n */\nexport function hasMathSyntax(markdown: string): boolean {\n  if (!markdown.includes('$')) return false\n  const text = markdownProseWithoutCode(markdown)\n\n  for (let index = text.indexOf('$'); index !== -1; index = text.indexOf('$', index + 1)) {\n    if (isEscaped(text, index)) continue\n    if (text[index + 1] === '$') {\n      const closing = text.indexOf('$$', index + 2)\n      if (closing !== -1 && text.slice(index + 2, closing).trim()) return true\n      index = closing === -1 ? index + 1 : closing + 1\n      continue\n    }\n    if (text[index - 1] === '$' || isLiteralDollar(text, index)) continue\n    if (opensInlineMath(text, index) && inlineMathClose(text, index) !== -1) return true\n  }\n\n  return false\n}\n\n/** Raw HTML only matters in prose. Tags shown inside fenced/indented/inline code\n * stay literal, so they must not enable the full rehype-raw + sanitize pipeline. */\nexport function hasHtmlSyntax(markdown: string): boolean {\n  return /<[a-zA-Z][\\w-]*[\\s/>]/.test(markdownProseWithoutCode(markdown))\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,cAAc,UAA2B;CACvD,IAAI,CAAC,SAAS,SAAS,GAAG,GAAG,OAAO;CACpC,MAAM,OAAO,yBAAyB,QAAQ;CAE9C,KAAK,IAAI,QAAQ,KAAK,QAAQ,GAAG,GAAG,UAAU,IAAI,QAAQ,KAAK,QAAQ,KAAK,QAAQ,CAAC,GAAG;EACtF,IAAI,UAAU,MAAM,KAAK,GAAG;EAC5B,IAAI,KAAK,QAAQ,OAAO,KAAK;GAC3B,MAAM,UAAU,KAAK,QAAQ,MAAM,QAAQ,CAAC;GAC5C,IAAI,YAAY,MAAM,KAAK,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,KAAK,GAAG,OAAO;GACpE,QAAQ,YAAY,KAAK,QAAQ,IAAI,UAAU;GAC/C;EACF;EACA,IAAI,KAAK,QAAQ,OAAO,OAAO,gBAAgB,MAAM,KAAK,GAAG;EAC7D,IAAI,gBAAgB,MAAM,KAAK,KAAK,gBAAgB,MAAM,KAAK,MAAM,IAAI,OAAO;CAClF;CAEA,OAAO;AACT;;;AAIA,SAAgB,cAAc,UAA2B;CACvD,OAAO,wBAAwB,KAAK,yBAAyB,QAAQ,CAAC;AACxE"}

package/dist/dialect.d.ts

@@ -0,0 +1,92 @@
+/** Shared answer/document grammar; this leaf has no server or browser imports. */
+/**
+ * Callout kinds, in GitHub's alert syntax (`> [!WARNING]`). GitHub's own set, not an invented
+ * one: the model already writes it, and an answer pasted into an issue or a README keeps its
+ * rendering there.
+ */
+export declare const CALLOUT_KINDS: readonly ['note', 'tip', 'important', 'warning', 'caution'];
+export type CalloutKind = (typeof CALLOUT_KINDS)[number];
+/** Fence language whose body renders as a diagram rather than as code. */
+export declare const DIAGRAM_FENCE_LANGUAGE = "mermaid";
+/**
+ * Diagram types worth naming to the model. Mermaid parses more; these are the ones that read
+ * well at chat width, so the prompt steers toward them instead of listing the whole grammar.
+ */
+export declare const DIAGRAM_KINDS: readonly ['flowchart', 'sequenceDiagram', 'stateDiagram-v2', 'erDiagram', 'gantt', 'pie', 'xychart-beta', 'classDiagram', 'mindmap', 'timeline', 'quadrantChart', 'sankey-beta', 'radar-beta', 'treemap-beta', 'gitGraph'];
+/**
+ * A quote's closing source line: `— Author` (em dash) or `-- Author` for keyboards without one.
+ * Anchored at a line start, so a dash inside a sentence never turns into an attribution.
+ */
+export declare const ATTRIBUTION_PREFIX: RegExp;
+export interface CalloutMarker {
+  kind: CalloutKind;
+  /** Text after the marker on its own line (`> [!TIP] Faster builds`), or '' for none. */
+  title: string;
+  /** Characters of the input the marker and its title line consumed, newline included. */
+  consumed: number;
+}
+/**
+ * Read a callout marker at the start of a quote's first line.
+ *
+ * An unknown kind (`[!FOO]`) is not a callout: it stays a quote with its text intact, which is
+ * also what GitHub does, so a typo degrades to readable text instead of a mislabelled box.
+ */
+export declare function parseCalloutMarker(text: string): CalloutMarker | null;
+/**
+ * CONTAINER FORMS: a quote opened by a marker of ours, over ordinary Markdown, that the renderer
+ * lays out as something a plain list or heading cannot be.
+ *
+ *   steps   a list of stages read in order → a vertical timeline (dot, title, quiet "when", text)
+ *   tabs    `#### Label` sections → one panel per variant (an OS, a language), one shown at a time
+ *   stats   a list of `**value** label` items → a row of headline figures
+ *   pros    a list → the case for, with a check per point
+ *   cons    a list → the case against; right after `pros` the two sit side by side
+ *   details the quote's own content, folded under its title (a log, a derivation, an aside the
+ *           reader may skip) → a native `<details>`
+ *   sources a list of links → the numbered references of a reply, each with its site
+ *
+ * Opt-in by marker, never guessed from shape: models open MANY list items with bold
+ * (`**Pros:** …`) and section with headings, and turning each of those into a widget would be
+ * wrong far more often than right. In the quote they stay plain Markdown — a quote holding a list
+ * or sections — so an answer still reads anywhere this dialect is not rendered.
+ */
+export declare const CONTAINER_KINDS: readonly ['steps', 'tabs', 'stats', 'pros', 'cons', 'details', 'sources'];
+export type ContainerKind = (typeof CONTAINER_KINDS)[number];
+/** The marker as the prompt writes it: `[!STEPS]`, `[!TABS]`, … */
+export declare const containerMarker: (kind: ContainerKind) => string;
+/**
+ * The prompt's example of each container form, kept here so the renderer's tests render the very
+ * text the model is shown — an example that drew as stray markers would teach the model a broken
+ * form. Each is written the way models write these forms: the marker alone as a one-line quote,
+ * the content unquoted after it (the renderer reads that by grammar, `remarkAnswerContainers`).
+ * Shown, not described: the markers are ours and absent from any training data, and a model that
+ * was only TOLD about a form kept writing the table or numbered list it writes by habit.
+ */
+export declare const ANSWER_FORM_EXAMPLES: {
+  readonly comparison: readonly [`> ${string}`, "#### PostgreSQL", `> ${string}`, "- concurrent writes", "", `> ${string}`, "- needs a server", "", "---"];
+  readonly verdict: readonly [`> ${string}`, "- typed APIs", "", `> ${string}`, "- a build step"];
+  readonly steps: readonly [`> ${string}`, "1. **First 24 hours**", "   *Day 1*", "   Rest and keep warm."];
+  readonly stats: readonly [`> ${string}`, "- **3×** faster installs", "- **−40%** memory"];
+  readonly details: readonly [`> ${string} Full log`, "> The long part, quoted."];
+  readonly sources: readonly [`> ${string}`, "- [Page title](https://example.com/page)"];
+};
+export interface ContainerMarker {
+  kind: ContainerKind;
+  /** Text after the marker on its own line (`> [!STEPS] Recovery`), or '' for none. */
+  title: string;
+  /** Characters of the input the marker and its title line consumed, newline included. */
+  consumed: number;
+}
+/** Read a container marker at a quote's start. An unknown kind is not one (nor a callout). */
+export declare function parseContainerMarker(text: string): ContainerMarker | null;
+/**
+ * Fence language whose body is a directory layout (`├──` / `└──` lines) drawn as a file tree.
+ * A fence the model already writes as `text`: naming it `tree` is the whole opt-in.
+ */
+export declare const TREE_FENCE_LANGUAGE = "tree";
+/**
+ * The file a code fence names after its language: ` ```ts title="src/app.ts" ` (also `filename=`,
+ * `file=`), or the path alone (` ```ts src/app.ts `), the way an agent writing a file labels it.
+ * '' when the info string names none; any other word there (`{1,3}`, `showLineNumbers`) is not one.
+ */
+export declare function fenceTitle(meta: string | null | undefined): string;

package/dist/dialect.js

@@ -0,0 +1,176 @@
+// src/dialect.ts
+/** Shared answer/document grammar; this leaf has no server or browser imports. */
+/**
+* Callout kinds, in GitHub's alert syntax (`> [!WARNING]`). GitHub's own set, not an invented
+* one: the model already writes it, and an answer pasted into an issue or a README keeps its
+* rendering there.
+*/
+const CALLOUT_KINDS = [
+	"note",
+	"tip",
+	"important",
+	"warning",
+	"caution"
+];
+/** Fence language whose body renders as a diagram rather than as code. */
+const DIAGRAM_FENCE_LANGUAGE = "mermaid";
+/**
+* Diagram types worth naming to the model. Mermaid parses more; these are the ones that read
+* well at chat width, so the prompt steers toward them instead of listing the whole grammar.
+*/
+const DIAGRAM_KINDS = [
+	"flowchart",
+	"sequenceDiagram",
+	"stateDiagram-v2",
+	"erDiagram",
+	"gantt",
+	"pie",
+	"xychart-beta",
+	"classDiagram",
+	"mindmap",
+	"timeline",
+	"quadrantChart",
+	"sankey-beta",
+	"radar-beta",
+	"treemap-beta",
+	"gitGraph"
+];
+/**
+* A quote's closing source line: `— Author` (em dash) or `-- Author` for keyboards without one.
+* Anchored at a line start, so a dash inside a sentence never turns into an attribution.
+*/
+const ATTRIBUTION_PREFIX = /^(?:—|--)[ \t]+/;
+const CALLOUT_MARKER = /^\[!([A-Za-z]+)\][ \t]*/;
+function isCalloutKind(value) {
+	return CALLOUT_KINDS.includes(value);
+}
+/**
+* Read a callout marker at the start of a quote's first line.
+*
+* An unknown kind (`[!FOO]`) is not a callout: it stays a quote with its text intact, which is
+* also what GitHub does, so a typo degrades to readable text instead of a mislabelled box.
+*/
+function parseCalloutMarker(text) {
+	const marker = readMarker(text);
+	return marker && isCalloutKind(marker.kind) ? {
+		...marker,
+		kind: marker.kind
+	} : null;
+}
+/** A `[!KIND] title` marker line of either form, before its kind is checked. */
+function readMarker(text) {
+	const match = CALLOUT_MARKER.exec(text);
+	if (!match) return null;
+	const rest = text.slice(match[0].length);
+	const lineEnd = rest.indexOf("\n");
+	const title = (lineEnd === -1 ? rest : rest.slice(0, lineEnd)).trim();
+	const consumed = match[0].length + (lineEnd === -1 ? rest.length : lineEnd + 1);
+	return {
+		kind: match[1].toLowerCase(),
+		title,
+		consumed
+	};
+}
+/**
+* CONTAINER FORMS: a quote opened by a marker of ours, over ordinary Markdown, that the renderer
+* lays out as something a plain list or heading cannot be.
+*
+*   steps   a list of stages read in order → a vertical timeline (dot, title, quiet "when", text)
+*   tabs    `#### Label` sections → one panel per variant (an OS, a language), one shown at a time
+*   stats   a list of `**value** label` items → a row of headline figures
+*   pros    a list → the case for, with a check per point
+*   cons    a list → the case against; right after `pros` the two sit side by side
+*   details the quote's own content, folded under its title (a log, a derivation, an aside the
+*           reader may skip) → a native `<details>`
+*   sources a list of links → the numbered references of a reply, each with its site
+*
+* Opt-in by marker, never guessed from shape: models open MANY list items with bold
+* (`**Pros:** …`) and section with headings, and turning each of those into a widget would be
+* wrong far more often than right. In the quote they stay plain Markdown — a quote holding a list
+* or sections — so an answer still reads anywhere this dialect is not rendered.
+*/
+const CONTAINER_KINDS = [
+	"steps",
+	"tabs",
+	"stats",
+	"pros",
+	"cons",
+	"details",
+	"sources"
+];
+/** The marker as the prompt writes it: `[!STEPS]`, `[!TABS]`, … */
+const containerMarker = (kind) => `[!${kind.toUpperCase()}]`;
+/**
+* The prompt's example of each container form, kept here so the renderer's tests render the very
+* text the model is shown — an example that drew as stray markers would teach the model a broken
+* form. Each is written the way models write these forms: the marker alone as a one-line quote,
+* the content unquoted after it (the renderer reads that by grammar, `remarkAnswerContainers`).
+* Shown, not described: the markers are ours and absent from any training data, and a model that
+* was only TOLD about a form kept writing the table or numbered list it writes by habit.
+*/
+const ANSWER_FORM_EXAMPLES = {
+	comparison: [
+		`> ${containerMarker("tabs")}`,
+		"#### PostgreSQL",
+		`> ${containerMarker("pros")}`,
+		"- concurrent writes",
+		"",
+		`> ${containerMarker("cons")}`,
+		"- needs a server",
+		"",
+		"---"
+	],
+	verdict: [
+		`> ${containerMarker("pros")}`,
+		"- typed APIs",
+		"",
+		`> ${containerMarker("cons")}`,
+		"- a build step"
+	],
+	steps: [
+		`> ${containerMarker("steps")}`,
+		"1. **First 24 hours**",
+		"   *Day 1*",
+		"   Rest and keep warm."
+	],
+	stats: [
+		`> ${containerMarker("stats")}`,
+		"- **3×** faster installs",
+		"- **−40%** memory"
+	],
+	details: [`> ${containerMarker("details")} Full log`, "> The long part, quoted."],
+	sources: [`> ${containerMarker("sources")}`, "- [Page title](https://example.com/page)"]
+};
+function isContainerKind(value) {
+	return CONTAINER_KINDS.includes(value);
+}
+/** Read a container marker at a quote's start. An unknown kind is not one (nor a callout). */
+function parseContainerMarker(text) {
+	const marker = readMarker(text);
+	return marker && isContainerKind(marker.kind) ? {
+		...marker,
+		kind: marker.kind
+	} : null;
+}
+/**
+* Fence language whose body is a directory layout (`├──` / `└──` lines) drawn as a file tree.
+* A fence the model already writes as `text`: naming it `tree` is the whole opt-in.
+*/
+const TREE_FENCE_LANGUAGE = "tree";
+const FENCE_TITLE = /(?:^|\s)(?:title|filename|file)=(?:"([^"]*)"|'([^']*)'|(\S+))/;
+const FENCE_PATH = /^[\w@.\-/\\[\]()]*[\w)\]]\.[A-Za-z0-9]+$/;
+/**
+* The file a code fence names after its language: ` ```ts title="src/app.ts" ` (also `filename=`,
+* `file=`), or the path alone (` ```ts src/app.ts `), the way an agent writing a file labels it.
+* '' when the info string names none; any other word there (`{1,3}`, `showLineNumbers`) is not one.
+*/
+function fenceTitle(meta) {
+	if (!meta) return "";
+	const named = FENCE_TITLE.exec(meta);
+	if (named) return (named[1] ?? named[2] ?? named[3] ?? "").trim();
+	const bare = meta.trim();
+	return FENCE_PATH.test(bare) ? bare : "";
+}
+export { ANSWER_FORM_EXAMPLES, ATTRIBUTION_PREFIX, CALLOUT_KINDS, CONTAINER_KINDS, DIAGRAM_FENCE_LANGUAGE, DIAGRAM_KINDS, TREE_FENCE_LANGUAGE, containerMarker, fenceTitle, parseCalloutMarker, parseContainerMarker };
+
+//# sourceMappingURL=dialect.js.map

package/dist/dialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.js","names":[],"sources":["../src/dialect.ts"],"sourcesContent":["/** Shared answer/document grammar; this leaf has no server or browser imports. */\n\n/**\n * Callout kinds, in GitHub's alert syntax (`> [!WARNING]`). GitHub's own set, not an invented\n * one: the model already writes it, and an answer pasted into an issue or a README keeps its\n * rendering there.\n */\nexport const CALLOUT_KINDS = ['note', 'tip', 'important', 'warning', 'caution'] as const\nexport type CalloutKind = (typeof CALLOUT_KINDS)[number]\n\n/** Fence language whose body renders as a diagram rather than as code. */\nexport const DIAGRAM_FENCE_LANGUAGE = 'mermaid'\n\n/**\n * Diagram types worth naming to the model. Mermaid parses more; these are the ones that read\n * well at chat width, so the prompt steers toward them instead of listing the whole grammar.\n */\nexport const DIAGRAM_KINDS = [\n  'flowchart',\n  'sequenceDiagram',\n  'stateDiagram-v2',\n  'erDiagram',\n  'gantt',\n  'pie',\n  'xychart-beta',\n  'classDiagram',\n  'mindmap',\n  'timeline',\n  'quadrantChart',\n  'sankey-beta',\n  'radar-beta',\n  'treemap-beta',\n  'gitGraph',\n] as const\n\n/**\n * A quote's closing source line: `— Author` (em dash) or `-- Author` for keyboards without one.\n * Anchored at a line start, so a dash inside a sentence never turns into an attribution.\n */\nexport const ATTRIBUTION_PREFIX = /^(?:—|--)[ \\t]+/\n\nconst CALLOUT_MARKER = /^\\[!([A-Za-z]+)\\][ \\t]*/\n\nexport interface CalloutMarker {\n  kind: CalloutKind\n  /** Text after the marker on its own line (`> [!TIP] Faster builds`), or '' for none. */\n  title: string\n  /** Characters of the input the marker and its title line consumed, newline included. */\n  consumed: number\n}\n\nfunction isCalloutKind(value: string): value is CalloutKind {\n  return (CALLOUT_KINDS as readonly string[]).includes(value)\n}\n\n/**\n * Read a callout marker at the start of a quote's first line.\n *\n * An unknown kind (`[!FOO]`) is not a callout: it stays a quote with its text intact, which is\n * also what GitHub does, so a typo degrades to readable text instead of a mislabelled box.\n */\nexport function parseCalloutMarker(text: string): CalloutMarker | null {\n  const marker = readMarker(text)\n  return marker && isCalloutKind(marker.kind) ? { ...marker, kind: marker.kind } : null\n}\n\n/** A `[!KIND] title` marker line of either form, before its kind is checked. */\nfunction readMarker(text: string): { kind: string; title: string; consumed: number } | null {\n  const match = CALLOUT_MARKER.exec(text)\n  if (!match) return null\n  const rest = text.slice(match[0].length)\n  const lineEnd = rest.indexOf('\\n')\n  const title = (lineEnd === -1 ? rest : rest.slice(0, lineEnd)).trim()\n  const consumed = match[0].length + (lineEnd === -1 ? rest.length : lineEnd + 1)\n  return { kind: match[1]!.toLowerCase(), title, consumed }\n}\n\n/**\n * CONTAINER FORMS: a quote opened by a marker of ours, over ordinary Markdown, that the renderer\n * lays out as something a plain list or heading cannot be.\n *\n *   steps   a list of stages read in order → a vertical timeline (dot, title, quiet \"when\", text)\n *   tabs    `#### Label` sections → one panel per variant (an OS, a language), one shown at a time\n *   stats   a list of `**value** label` items → a row of headline figures\n *   pros    a list → the case for, with a check per point\n *   cons    a list → the case against; right after `pros` the two sit side by side\n *   details the quote's own content, folded under its title (a log, a derivation, an aside the\n *           reader may skip) → a native `<details>`\n *   sources a list of links → the numbered references of a reply, each with its site\n *\n * Opt-in by marker, never guessed from shape: models open MANY list items with bold\n * (`**Pros:** …`) and section with headings, and turning each of those into a widget would be\n * wrong far more often than right. In the quote they stay plain Markdown — a quote holding a list\n * or sections — so an answer still reads anywhere this dialect is not rendered.\n */\nexport const CONTAINER_KINDS = [\n  'steps',\n  'tabs',\n  'stats',\n  'pros',\n  'cons',\n  'details',\n  'sources',\n] as const\nexport type ContainerKind = (typeof CONTAINER_KINDS)[number]\n\n/** The marker as the prompt writes it: `[!STEPS]`, `[!TABS]`, … */\nexport const containerMarker = (kind: ContainerKind) => `[!${kind.toUpperCase()}]`\n\n/**\n * The prompt's example of each container form, kept here so the renderer's tests render the very\n * text the model is shown — an example that drew as stray markers would teach the model a broken\n * form. Each is written the way models write these forms: the marker alone as a one-line quote,\n * the content unquoted after it (the renderer reads that by grammar, `remarkAnswerContainers`).\n * Shown, not described: the markers are ours and absent from any training data, and a model that\n * was only TOLD about a form kept writing the table or numbered list it writes by habit.\n */\nexport const ANSWER_FORM_EXAMPLES = {\n  comparison: [\n    `> ${containerMarker('tabs')}`,\n    '#### PostgreSQL',\n    `> ${containerMarker('pros')}`,\n    '- concurrent writes',\n    '',\n    `> ${containerMarker('cons')}`,\n    '- needs a server',\n    '',\n    '---',\n  ],\n  verdict: [\n    `> ${containerMarker('pros')}`,\n    '- typed APIs',\n    '',\n    `> ${containerMarker('cons')}`,\n    '- a build step',\n  ],\n  steps: [\n    `> ${containerMarker('steps')}`,\n    '1. **First 24 hours**',\n    '   *Day 1*',\n    '   Rest and keep warm.',\n  ],\n  stats: [`> ${containerMarker('stats')}`, '- **3×** faster installs', '- **−40%** memory'],\n  details: [`> ${containerMarker('details')} Full log`, '> The long part, quoted.'],\n  sources: [`> ${containerMarker('sources')}`, '- [Page title](https://example.com/page)'],\n} as const satisfies Record<string, readonly string[]>\n\nfunction isContainerKind(value: string): value is ContainerKind {\n  return (CONTAINER_KINDS as readonly string[]).includes(value)\n}\n\nexport interface ContainerMarker {\n  kind: ContainerKind\n  /** Text after the marker on its own line (`> [!STEPS] Recovery`), or '' for none. */\n  title: string\n  /** Characters of the input the marker and its title line consumed, newline included. */\n  consumed: number\n}\n\n/** Read a container marker at a quote's start. An unknown kind is not one (nor a callout). */\nexport function parseContainerMarker(text: string): ContainerMarker | null {\n  const marker = readMarker(text)\n  return marker && isContainerKind(marker.kind) ? { ...marker, kind: marker.kind } : null\n}\n\n/**\n * Fence language whose body is a directory layout (`├──` / `└──` lines) drawn as a file tree.\n * A fence the model already writes as `text`: naming it `tree` is the whole opt-in.\n */\nexport const TREE_FENCE_LANGUAGE = 'tree'\n\nconst FENCE_TITLE = /(?:^|\\s)(?:title|filename|file)=(?:\"([^\"]*)\"|'([^']*)'|(\\S+))/\nconst FENCE_PATH = /^[\\w@.\\-/\\\\[\\]()]*[\\w)\\]]\\.[A-Za-z0-9]+$/\n\n/**\n * The file a code fence names after its language: ` ```ts title=\"src/app.ts\" ` (also `filename=`,\n * `file=`), or the path alone (` ```ts src/app.ts `), the way an agent writing a file labels it.\n * '' when the info string names none; any other word there (`{1,3}`, `showLineNumbers`) is not one.\n */\nexport function fenceTitle(meta: string | null | undefined): string {\n  if (!meta) return ''\n  const named = FENCE_TITLE.exec(meta)\n  if (named) return (named[1] ?? named[2] ?? named[3] ?? '').trim()\n  const bare = meta.trim()\n  return FENCE_PATH.test(bare) ? bare : ''\n}\n"],"mappings":";;;;;;;AAOA,MAAa,gBAAgB;CAAC;CAAQ;CAAO;CAAa;CAAW;AAAS;;AAI9E,MAAa,yBAAyB;;;;;AAMtC,MAAa,gBAAgB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;AAMA,MAAa,qBAAqB;AAElC,MAAM,iBAAiB;AAUvB,SAAS,cAAc,OAAqC;CAC1D,OAAQ,cAAoC,SAAS,KAAK;AAC5D;;;;;;;AAQA,SAAgB,mBAAmB,MAAoC;CACrE,MAAM,SAAS,WAAW,IAAI;CAC9B,OAAO,UAAU,cAAc,OAAO,IAAI,IAAI;EAAE,GAAG;EAAQ,MAAM,OAAO;CAAK,IAAI;AACnF;;AAGA,SAAS,WAAW,MAAwE;CAC1F,MAAM,QAAQ,eAAe,KAAK,IAAI;CACtC,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,OAAO,KAAK,MAAM,MAAM,EAAE,CAAC,MAAM;CACvC,MAAM,UAAU,KAAK,QAAQ,IAAI;CACjC,MAAM,SAAS,YAAY,KAAK,OAAO,KAAK,MAAM,GAAG,OAAO,EAAA,CAAG,KAAK;CACpE,MAAM,WAAW,MAAM,EAAE,CAAC,UAAU,YAAY,KAAK,KAAK,SAAS,UAAU;CAC7E,OAAO;EAAE,MAAM,MAAM,EAAE,CAAE,YAAY;EAAG;EAAO;CAAS;AAC1D;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,kBAAkB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAIA,MAAa,mBAAmB,SAAwB,KAAK,KAAK,YAAY,EAAE;;;;;;;;;AAUhF,MAAa,uBAAuB;CAClC,YAAY;EACV,KAAK,gBAAgB,MAAM;EAC3B;EACA,KAAK,gBAAgB,MAAM;EAC3B;EACA;EACA,KAAK,gBAAgB,MAAM;EAC3B;EACA;EACA;CACF;CACA,SAAS;EACP,KAAK,gBAAgB,MAAM;EAC3B;EACA;EACA,KAAK,gBAAgB,MAAM;EAC3B;CACF;CACA,OAAO;EACL,KAAK,gBAAgB,OAAO;EAC5B;EACA;EACA;CACF;CACA,OAAO;EAAC,KAAK,gBAAgB,OAAO;EAAK;EAA4B;CAAmB;CACxF,SAAS,CAAC,KAAK,gBAAgB,SAAS,EAAE,YAAY,0BAA0B;CAChF,SAAS,CAAC,KAAK,gBAAgB,SAAS,KAAK,0CAA0C;AACzF;AAEA,SAAS,gBAAgB,OAAuC;CAC9D,OAAQ,gBAAsC,SAAS,KAAK;AAC9D;;AAWA,SAAgB,qBAAqB,MAAsC;CACzE,MAAM,SAAS,WAAW,IAAI;CAC9B,OAAO,UAAU,gBAAgB,OAAO,IAAI,IAAI;EAAE,GAAG;EAAQ,MAAM,OAAO;CAAK,IAAI;AACrF;;;;;AAMA,MAAa,sBAAsB;AAEnC,MAAM,cAAc;AACpB,MAAM,aAAa;;;;;;AAOnB,SAAgB,WAAW,MAAyC;CAClE,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,QAAQ,YAAY,KAAK,IAAI;CACnC,IAAI,OAAO,QAAQ,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,GAAA,CAAI,KAAK;CAChE,MAAM,OAAO,KAAK,KAAK;CACvB,OAAO,WAAW,KAAK,IAAI,IAAI,OAAO;AACxC"}

package/dist/document/fence.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The fence read last time: its body up to `clean` is complete lines, none of which closes it. A
+ * fence that grows is read once per token, and the next read starts where this one stopped.
+ */
+export interface FenceMemory {
+  read: {
+    fence: string;
+    body: string;
+    clean: number;
+  } | null;
+}
+/** A place for it. A block that draws a growing fence keeps its own; this one is the default. */
+export declare const createFenceMemory: () => FenceMemory;
+/** An open fence: its language, the file it names, and the code written so far. */
+export interface GrowingFence {
+  language: string | undefined;
+  title: string;
+  body: string;
+}
+/**
+ * The language and code of a block that is one open fence, closed by the healer; else null.
+ * `closer` is the healer's line when it is kept beside `source` (a newline, unless the source ends
+ * in one, and the markers): the block is read as the two joined, without joining them.
+ */
+export declare function growingFence(source: string, closer?: string, memory?: FenceMemory): GrowingFence | null;

package/dist/document/fence.js

@@ -0,0 +1,101 @@
+import { fenceTitle } from "../dialect.js";
+// src/document/fence.ts
+/**
+* A block that is one code fence still being written, read without parsing the block: what a
+* renderer needs to draw a long fence in pieces, a token costing only its last lines.
+*/
+const OPENING = /^(`{3,}|~{3,})([^\n`]*)\n/;
+/** Whether the line of `text` from `from` to `to` closes a fence: `length` markers or more, alone. */
+function closesFence(text, from, to, marker, length, indent) {
+	let at = from;
+	while (at < to && at - from < indent && text[at] === " ") at += 1;
+	const run = at;
+	while (at < to && text[at] === marker) at += 1;
+	if (at - run < length) return false;
+	while (at < to && (text[at] === " " || text[at] === "	")) at += 1;
+	return at === to;
+}
+/** A place for it. A block that draws a growing fence keeps its own; this one is the default. */
+const createFenceMemory = () => ({ read: null });
+const shared = createFenceMemory();
+/** `rest` without its last line, when that line closes the fence: the healer's is not code. */
+function unclosed(rest, marker, length) {
+	const closing = rest.lastIndexOf("\n");
+	return closesFence(rest, closing + 1, rest.length, marker, length, 0) ? rest.slice(0, Math.max(closing, 0)) : rest;
+}
+/**
+* The language and code of a block that is one open fence, closed by the healer; else null.
+* `closer` is the healer's line when it is kept beside `source` (a newline, unless the source ends
+* in one, and the markers): the block is read as the two joined, without joining them.
+*/
+function growingFence(source, closer = "", memory = shared) {
+	if (closer && !source.includes("\n")) return growingFence(source + closer, "", memory);
+	const opening = OPENING.exec(source);
+	if (!opening) return null;
+	const fence = opening[1] ?? "```";
+	const marker = fence[0] ?? "`";
+	const rest = source.slice(opening[0].length);
+	const markers = closer.trimStart();
+	let body;
+	if (!closer) body = unclosed(rest, marker, fence.length);
+	else if (markers[0] !== marker || markers.length < fence.length) body = unclosed(rest + closer, marker, fence.length);
+	else body = closer !== markers || !rest ? rest : rest.slice(0, -1);
+	const read = memory.read;
+	let at = read !== null && read.fence === fence && body.length >= read.clean && body.startsWith(read.body.slice(0, read.clean)) ? read.clean : 0;
+	memory.read = null;
+	for (let end = body.indexOf("\n", at); end !== -1; end = body.indexOf("\n", at)) {
+		if (closesFence(body, at, end, marker, fence.length, 3)) return null;
+		at = end + 1;
+	}
+	if (closesFence(body, at, body.length, marker, fence.length, 3)) return null;
+	memory.read = {
+		fence,
+		body,
+		clean: at
+	};
+	const info = opening[2]?.trim() ?? "";
+	const language = info.split(/\s+/)[0] || void 0;
+	return {
+		language,
+		title: fenceTitle(info.slice(language?.length ?? 0)),
+		body
+	};
+}
+/** How many lines a piece of a growing fence holds. */
+const LINES = 40;
+/**
+* Cuts a body that grows at its end into its pieces. It remembers where the complete pieces end,
+* so a token costs the last piece and not a count of every line above it.
+*/
+function createCutter() {
+	let text = "";
+	/** Where each complete piece ends in `text`. */
+	let ends = [];
+	let run = 0;
+	return (body) => {
+		const done = ends.at(-1) ?? 0;
+		if (done > 0 && !(body.length >= done && body.startsWith(text.slice(0, done)))) {
+			ends = [];
+			run += 1;
+		}
+		let start = ends.at(-1) ?? 0;
+		let line = 0;
+		for (let at = body.indexOf("\n", start); at !== -1; at = body.indexOf("\n", at + 1)) {
+			line += 1;
+			if (line % LINES === 0) {
+				start = at + 1;
+				ends.push(start);
+			}
+		}
+		text = body;
+		const parts = ends.map((end, index) => body.slice(ends[index - 1] ?? 0, end));
+		parts.push(body.slice(start));
+		return {
+			parts,
+			run
+		};
+	};
+}
+export { createCutter, createFenceMemory, growingFence };
+
+//# sourceMappingURL=fence.js.map

package/dist/document/fence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence.js","names":[],"sources":["../../src/document/fence.ts"],"sourcesContent":["/**\n * A block that is one code fence still being written, read without parsing the block: what a\n * renderer needs to draw a long fence in pieces, a token costing only its last lines.\n */\nimport { fenceTitle } from '../dialect'\n\nconst OPENING = /^(`{3,}|~{3,})([^\\n`]*)\\n/\n\n/** Whether the line of `text` from `from` to `to` closes a fence: `length` markers or more, alone. */\nfunction closesFence(\n  text: string,\n  from: number,\n  to: number,\n  marker: string,\n  length: number,\n  indent: number,\n): boolean {\n  let at = from\n  while (at < to && at - from < indent && text[at] === ' ') at += 1\n  const run = at\n  while (at < to && text[at] === marker) at += 1\n  if (at - run < length) return false\n  while (at < to && (text[at] === ' ' || text[at] === '\\t')) at += 1\n  return at === to\n}\n\n/**\n * The fence read last time: its body up to `clean` is complete lines, none of which closes it. A\n * fence that grows is read once per token, and the next read starts where this one stopped.\n */\nexport interface FenceMemory {\n  read: { fence: string; body: string; clean: number } | null\n}\n\n/** A place for it. A block that draws a growing fence keeps its own; this one is the default. */\nexport const createFenceMemory = (): FenceMemory => ({ read: null })\n\nconst shared = createFenceMemory()\n\n/** `rest` without its last line, when that line closes the fence: the healer's is not code. */\nfunction unclosed(rest: string, marker: string, length: number): string {\n  const closing = rest.lastIndexOf('\\n')\n  return closesFence(rest, closing + 1, rest.length, marker, length, 0)\n    ? rest.slice(0, Math.max(closing, 0))\n    : rest\n}\n\n/** An open fence: its language, the file it names, and the code written so far. */\nexport interface GrowingFence {\n  language: string | undefined\n  title: string\n  body: string\n}\n\n/**\n * The language and code of a block that is one open fence, closed by the healer; else null.\n * `closer` is the healer's line when it is kept beside `source` (a newline, unless the source ends\n * in one, and the markers): the block is read as the two joined, without joining them.\n */\nexport function growingFence(\n  source: string,\n  closer = '',\n  memory: FenceMemory = shared,\n): GrowingFence | null {\n  // The opening line is still being written: short, and read joined.\n  if (closer && !source.includes('\\n')) return growingFence(source + closer, '', memory)\n  const opening = OPENING.exec(source)\n  if (!opening) return null\n  const fence = opening[1] ?? '```'\n  const marker = fence[0] ?? '`'\n  const rest = source.slice(opening[0].length)\n  const markers = closer.trimStart()\n  let body: string\n  if (!closer) body = unclosed(rest, marker, fence.length)\n  else if (markers[0] !== marker || markers.length < fence.length)\n    // Not a line that closes this fence: it is read with the text, as any other line.\n    body = unclosed(rest + closer, marker, fence.length)\n  // It closes the fence: the code is what is above it, without the newline that ends that.\n  else body = closer !== markers || !rest ? rest : rest.slice(0, -1)\n  // A fence closed earlier in the block means the block is not just this fence.\n  const read = memory.read\n  let at =\n    read !== null &&\n    read.fence === fence &&\n    body.length >= read.clean &&\n    body.startsWith(read.body.slice(0, read.clean))\n      ? read.clean\n      : 0\n  memory.read = null\n  for (let end = body.indexOf('\\n', at); end !== -1; end = body.indexOf('\\n', at)) {\n    if (closesFence(body, at, end, marker, fence.length, 3)) return null\n    at = end + 1\n  }\n  // The last line is still being written: read, but not remembered.\n  if (closesFence(body, at, body.length, marker, fence.length, 3)) return null\n  memory.read = { fence, body, clean: at }\n  const info = opening[2]?.trim() ?? ''\n  const language = info.split(/\\s+/)[0] || undefined\n  return { language, title: fenceTitle(info.slice(language?.length ?? 0)), body }\n}\n\n/** How many lines a piece of a growing fence holds. */\nconst LINES = 40\n\n/** The pieces of a body: their text, each ending in its newline but the last. */\nexport interface Cut {\n  parts: string[]\n  /**\n   * Changes when the body is not the last one grown: pieces of the same run that are complete\n   * are the same text, and are not compared.\n   */\n  run: number\n}\n\n/**\n * Cuts a body that grows at its end into its pieces. It remembers where the complete pieces end,\n * so a token costs the last piece and not a count of every line above it.\n */\nexport function createCutter(): (body: string) => Cut {\n  let text = ''\n  /** Where each complete piece ends in `text`. */\n  let ends: number[] = []\n  let run = 0\n  return (body) => {\n    const done = ends.at(-1) ?? 0\n    if (done > 0 && !(body.length >= done && body.startsWith(text.slice(0, done)))) {\n      ends = []\n      run += 1\n    }\n    let start = ends.at(-1) ?? 0\n    let line = 0\n    for (let at = body.indexOf('\\n', start); at !== -1; at = body.indexOf('\\n', at + 1)) {\n      line += 1\n      if (line % LINES === 0) {\n        start = at + 1\n        ends.push(start)\n      }\n    }\n    text = body\n    // Cut from this body each time, so no piece keeps an earlier body alive.\n    const parts = ends.map((end, index) => body.slice(ends[index - 1] ?? 0, end))\n    parts.push(body.slice(start))\n    return { parts, run }\n  }\n}\n"],"mappings":"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"}

package/dist/document/index.d.ts

@@ -0,0 +1,46 @@
+import { MarkdownBlock, isFenceBlock, splitBlocks } from "../core/blocks.js";
+import { FenceMemory, GrowingFence, createFenceMemory, growingFence } from "./fence.js";
+import { TableRows, tableRows } from "./table.js";
+import { flowdownDialect } from "../core/remark-answer-blocks.js";
+import { Form, FormName, formOf } from "../core/forms.js";
+export interface UpdateOptions {
+  /** The text is a reply still arriving: its unfinished end is completed. */
+  streaming?: boolean;
+  /** The renderer typesets `$…$`: a literal dollar (`$5`) is escaped so it is not read as one. */
+  math?: boolean;
+  /** Work out an id for every heading, numbered across the document (`setup`, `setup-1`). */
+  headingIds?: boolean;
+}
+export interface DocumentState {
+  /**
+   * The document's top-level blocks, in order. A block that reads the same as at the last update
+   * is the same object: compare by identity to know what to draw again.
+   */
+  blocks: readonly MarkdownBlock[];
+  /**
+   * The line that closes the code fence the text ends inside, or ''. It belongs after the last
+   * block's source and is kept beside it, not joined: a long fence is then not copied on every
+   * token. A renderer reads the last block as `source + closer`.
+   */
+  closer: string;
+  /** Whether the text ends inside a code fence that is still being written. */
+  growing: boolean;
+  /** Each block's heading ids, by where the heading starts in the document; null when not asked for. */
+  headingIds: ReadonlyArray<ReadonlyMap<number, string>> | null;
+}
+export interface MarkdownDocument {
+  /** The document for `text`. The same text and options give back the same state object. */
+  update(text: string, options?: UpdateOptions): DocumentState;
+}
+/** Whether any block has a formula: a renderer that loads its typesetter on demand asks this. */
+export declare const usesMath: (blocks: readonly MarkdownBlock[]) => boolean;
+/** Whether any block has raw HTML in its prose. */
+export declare const usesHtml: (blocks: readonly MarkdownBlock[]) => boolean;
+/** Whether any block names a character reference outside the common ones (`&nrarr;`). */
+export declare const usesRareEntity: (blocks: readonly MarkdownBlock[]) => boolean;
+/**
+ * One document that is drawn more than once: a reply while it streams, a text being edited. It
+ * remembers the blocks it cut, so an update costs the end of the text, not the text.
+ */
+export declare function createDocument(): MarkdownDocument;
+export { type FenceMemory, type Form, type FormName, type GrowingFence, type MarkdownBlock, type TableRows, createFenceMemory, flowdownDialect, formOf, growingFence, isFenceBlock, splitBlocks, tableRows };

package/dist/document/index.js

@@ -0,0 +1,66 @@
+import { blockHasHtml, blockHasMath, blockHasRareEntity, escapedBlock, headingIdsOfBlocks } from "../core/block-facts.js";
+import { createBlockSplitter, isFenceBlock, normalizeLineEndings, splitBlocks } from "../core/blocks.js";
+import { createFenceScanner } from "../core/fence-scan.js";
+import { closePartialProse } from "../core/heal.js";
+import { createFenceMemory, growingFence } from "./fence.js";
+import { tableRows } from "./table.js";
+import { flowdownDialect } from "../core/remark-answer-blocks.js";
+import { formOf } from "../core/forms.js";
+// src/document/index.ts
+/**
+* `@localix-ai/flowdown/document`: a Markdown text as the blocks a renderer draws, kept up while it grows.
+*
+* This is the part of streaming that belongs to no renderer. A reply arrives a few characters at a
+* time; each update the text is completed where it stops mid-construct, cut into its top-level
+* blocks, and the blocks that did not change are handed back as the very same objects. A renderer
+* for any target (React, the DOM, a terminal) then draws a block once and, on the next token,
+* only the last one again:
+*
+*     const document = createDocument()
+*     for await (const text of reply) {
+*       const { blocks } = document.update(text, { streaming: true })
+*       // draw the blocks that are new objects; the rest are already on the page
+*     }
+*     document.update(text) // the finished reply: nothing is completed any more
+*/
+/** Whether any block has a formula: a renderer that loads its typesetter on demand asks this. */
+const usesMath = (blocks) => blocks.some(blockHasMath);
+/** Whether any block has raw HTML in its prose. */
+const usesHtml = (blocks) => blocks.some(blockHasHtml);
+/** Whether any block names a character reference outside the common ones (`↛`). */
+const usesRareEntity = (blocks) => blocks.some(blockHasRareEntity);
+/**
+* One document that is drawn more than once: a reply while it streams, a text being edited. It
+* remembers the blocks it cut, so an update costs the end of the text, not the text.
+*/
+function createDocument() {
+	const openFence = createFenceScanner();
+	const splitter = createBlockSplitter();
+	let last = null;
+	return { update(input, { streaming = false, math = false, headingIds = false } = {}) {
+		const text = normalizeLineEndings(input);
+		if (last !== null && last.text === text && last.streaming === streaming && last.math === math && last.headingIds === headingIds) return last.state;
+		const fence = streaming ? openFence(text) : null;
+		const closer = fence ? `${text.endsWith("\n") ? "" : "\n"}${fence.marker}` : "";
+		const healed = streaming && !fence ? closePartialProse(text) : text;
+		const cut = splitter.split(healed);
+		const blocks = math ? cut.map(escapedBlock) : cut;
+		const state = {
+			blocks,
+			closer,
+			growing: fence !== null,
+			headingIds: headingIds ? headingIdsOfBlocks(blocks) : null
+		};
+		last = {
+			text,
+			streaming,
+			math,
+			headingIds,
+			state
+		};
+		return state;
+	} };
+}
+export { createDocument, createFenceMemory, flowdownDialect, formOf, growingFence, isFenceBlock, splitBlocks, tableRows, usesHtml, usesMath, usesRareEntity };
+
+//# sourceMappingURL=index.js.map

package/dist/document/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/document/index.ts"],"sourcesContent":["/**\n * `@localix-ai/flowdown/document`: a Markdown text as the blocks a renderer draws, kept up while it grows.\n *\n * This is the part of streaming that belongs to no renderer. A reply arrives a few characters at a\n * time; each update the text is completed where it stops mid-construct, cut into its top-level\n * blocks, and the blocks that did not change are handed back as the very same objects. A renderer\n * for any target (React, the DOM, a terminal) then draws a block once and, on the next token,\n * only the last one again:\n *\n *     const document = createDocument()\n *     for await (const text of reply) {\n *       const { blocks } = document.update(text, { streaming: true })\n *       // draw the blocks that are new objects; the rest are already on the page\n *     }\n *     document.update(text) // the finished reply: nothing is completed any more\n */\nimport {\n  blockHasHtml,\n  blockHasMath,\n  blockHasRareEntity,\n  escapedBlock,\n  headingIdsOfBlocks,\n} from '../core/block-facts'\nimport { createBlockSplitter, normalizeLineEndings, type MarkdownBlock } from '../core/blocks'\nimport { createFenceScanner } from '../core/fence-scan'\nimport { closePartialProse } from '../core/heal'\n\nexport { splitBlocks, isFenceBlock, type MarkdownBlock } from '../core/blocks'\nexport { growingFence, createFenceMemory, type FenceMemory, type GrowingFence } from './fence'\nexport { tableRows, type TableRows } from './table'\n/**\n * The dialect for `parse` of `@localix-ai/flowdown/engine`, and what it marked a node as: a target of your\n * own passes `extensions: [flowdownDialect]` and switches on `formOf(node)?.form`.\n */\nexport { flowdownDialect } from '../core/remark-answer-blocks'\nexport { formOf, type Form, type FormName } from '../core/forms'\n\nexport interface UpdateOptions {\n  /** The text is a reply still arriving: its unfinished end is completed. */\n  streaming?: boolean\n  /** The renderer typesets `$…$`: a literal dollar (`$5`) is escaped so it is not read as one. */\n  math?: boolean\n  /** Work out an id for every heading, numbered across the document (`setup`, `setup-1`). */\n  headingIds?: boolean\n}\n\nexport interface DocumentState {\n  /**\n   * The document's top-level blocks, in order. A block that reads the same as at the last update\n   * is the same object: compare by identity to know what to draw again.\n   */\n  blocks: readonly MarkdownBlock[]\n  /**\n   * The line that closes the code fence the text ends inside, or ''. It belongs after the last\n   * block's source and is kept beside it, not joined: a long fence is then not copied on every\n   * token. A renderer reads the last block as `source + closer`.\n   */\n  closer: string\n  /** Whether the text ends inside a code fence that is still being written. */\n  growing: boolean\n  /** Each block's heading ids, by where the heading starts in the document; null when not asked for. */\n  headingIds: ReadonlyArray<ReadonlyMap<number, string>> | null\n}\n\nexport interface MarkdownDocument {\n  /** The document for `text`. The same text and options give back the same state object. */\n  update(text: string, options?: UpdateOptions): DocumentState\n}\n\n/** Whether any block has a formula: a renderer that loads its typesetter on demand asks this. */\nexport const usesMath = (blocks: readonly MarkdownBlock[]): boolean => blocks.some(blockHasMath)\n\n/** Whether any block has raw HTML in its prose. */\nexport const usesHtml = (blocks: readonly MarkdownBlock[]): boolean => blocks.some(blockHasHtml)\n\n/** Whether any block names a character reference outside the common ones (`&nrarr;`). */\nexport const usesRareEntity = (blocks: readonly MarkdownBlock[]): boolean =>\n  blocks.some(blockHasRareEntity)\n\n/**\n * One document that is drawn more than once: a reply while it streams, a text being edited. It\n * remembers the blocks it cut, so an update costs the end of the text, not the text.\n */\nexport function createDocument(): MarkdownDocument {\n  // The scan and the split are this document's own: another reply streaming beside it does not\n  // make either start over.\n  const openFence = createFenceScanner()\n  const splitter = createBlockSplitter()\n  let last: {\n    text: string\n    streaming: boolean\n    math: boolean\n    headingIds: boolean\n    state: DocumentState\n  } | null = null\n\n  return {\n    update(input, { streaming = false, math = false, headingIds = false } = {}) {\n      // `\\r\\n` from a Windows file or a server that sends it reads as `\\n` everywhere below.\n      const text = normalizeLineEndings(input)\n      if (\n        last !== null &&\n        last.text === text &&\n        last.streaming === streaming &&\n        last.math === math &&\n        last.headingIds === headingIds\n      )\n        return last.state\n      // Inside a fence left open, the reply is read as it is and the line that closes the fence\n      // goes to the last block beside its text: joined here, every token would copy the reply.\n      const fence = streaming ? openFence(text) : null\n      const closer = fence ? `${text.endsWith('\\n') ? '' : '\\n'}${fence.marker}` : ''\n      const healed = streaming && !fence ? closePartialProse(text) : text\n      // Blocks that did not change come back as the same objects, and everything worked out\n      // from a block is kept beside it.\n      const cut = splitter.split(healed)\n      // Literal dollars are escaped only where `$` can mean math: elsewhere positions stay exact.\n      const blocks = math ? cut.map(escapedBlock) : cut\n      const state: DocumentState = {\n        blocks,\n        closer,\n        growing: fence !== null,\n        headingIds: headingIds ? headingIdsOfBlocks(blocks) : null,\n      }\n      last = { text, streaming, math, headingIds, state }\n      return state\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,MAAa,YAAY,WAA8C,OAAO,KAAK,YAAY;;AAG/F,MAAa,YAAY,WAA8C,OAAO,KAAK,YAAY;;AAG/F,MAAa,kBAAkB,WAC7B,OAAO,KAAK,kBAAkB;;;;;AAMhC,SAAgB,iBAAmC;CAGjD,MAAM,YAAY,mBAAmB;CACrC,MAAM,WAAW,oBAAoB;CACrC,IAAI,OAMO;CAEX,OAAO,EACL,OAAO,OAAO,EAAE,YAAY,OAAO,OAAO,OAAO,aAAa,UAAU,CAAC,GAAG;EAE1E,MAAM,OAAO,qBAAqB,KAAK;EACvC,IACE,SAAS,QACT,KAAK,SAAS,QACd,KAAK,cAAc,aACnB,KAAK,SAAS,QACd,KAAK,eAAe,YAEpB,OAAO,KAAK;EAGd,MAAM,QAAQ,YAAY,UAAU,IAAI,IAAI;EAC5C,MAAM,SAAS,QAAQ,GAAG,KAAK,SAAS,IAAI,IAAI,KAAK,OAAO,MAAM,WAAW;EAC7E,MAAM,SAAS,aAAa,CAAC,QAAQ,kBAAkB,IAAI,IAAI;EAG/D,MAAM,MAAM,SAAS,MAAM,MAAM;EAEjC,MAAM,SAAS,OAAO,IAAI,IAAI,YAAY,IAAI;EAC9C,MAAM,QAAuB;GAC3B;GACA;GACA,SAAS,UAAU;GACnB,YAAY,aAAa,mBAAmB,MAAM,IAAI;EACxD;EACA,OAAO;GAAE;GAAM;GAAW;GAAM;GAAY;EAAM;EAClD,OAAO;CACT,EACF;AACF"}

package/dist/document/table.d.ts

@@ -0,0 +1,11 @@
+/** A table's header (its two lines, each with its line break) and its body rows. */
+export interface TableRows {
+  head: string;
+  rows: string[];
+}
+/**
+ * The header (its two lines) and the body rows of a block that is one table and nothing else:
+ * every line opens with a pipe, so none of them can be anything but a row. Null for any other
+ * block, and for a table this cannot read with certainty; those are drawn by one parse, as ever.
+ */
+export declare function tableRows(source: string): TableRows | null;