@localix-ai/flowdown 0.0.0-stage → 0.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LocalixAI and flowdown contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,106 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="https://raw.githubusercontent.com/rsaryev/flowdown/main/docs/assets/logo.svg" width="72" height="72" alt="">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<h1 align="center">flowdown</h1>
+
+<p align="center">
+  <strong>Ultrafast, lightweight streaming Markdown for React and AI replies</strong><br>
+  Its own parser · 0 dependencies · 32 KB gzipped · 17× faster on a long stream
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@localix-ai/flowdown"><img alt="npm" src="https://img.shields.io/npm/v/@localix-ai/flowdown?color=cb3837"></a>
+  <a href="https://github.com/rsaryev/flowdown/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/rsaryev/flowdown/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/rsaryev/flowdown/blob/main/packages/flowdown/LICENSE"><img alt="MIT licence" src="https://img.shields.io/badge/licence-MIT-blue"></a>
+</p>
+
+<p align="center">
+  <a href="https://flowdown.dev"><b>flowdown.dev</b></a> ·
+  <a href="https://flowdown.dev/docs/getting-started">Get started</a> ·
+  <a href="https://flowdown.dev/docs/syntax">Syntax</a> ·
+  <a href="https://flowdown.dev/docs/api">API</a> ·
+  <a href="https://flowdown.dev/docs/comparison">Comparison</a>
+</p>
+
+<p align="center">
+  <img alt="One reply streaming twice, side by side on black: on a page as callouts, steps, tabs, highlighted code, headline figures, a table, a diagram and a formula, and in a terminal as the same forms in styled text" src="https://raw.githubusercontent.com/rsaryev/flowdown/main/docs/assets/readme/pair.gif" width="878">
+</p>
+
+<p align="center">
+  <sub>One reply, streamed twice: by <code>&lt;Markdown&gt;</code> on a page and by <code>@localix-ai/flowdown/tui</code> in a terminal.</sub>
+</p>
+
+GitHub Markdown, plus the forms a model can write and a reader can scan: steps, tabs, headline
+figures, pros and cons, callouts, folded sections, sources, file trees, titled code, diagrams and
+math. It is drawn as the text arrives, without flicker or raw syntax showing.
+
+```sh
+npm install @localix-ai/flowdown
+```
+
+```tsx
+import { Markdown } from '@localix-ai/flowdown'
+import '@localix-ai/flowdown/styles.css'
+
+export function Reply({ text, done }: { text: string; done: boolean }) {
+  return <Markdown streaming={!done}>{text}</Markdown>
+}
+```
+
+`<Markdown>` needs React 18 or 19. A model writes the forms once its system prompt has the dialect:
+`answerFormatPrompt()` from `@localix-ai/flowdown/prompt` is that text ([prompting](https://flowdown.dev/docs/prompting)).
+
+## Why
+
+- **Fast.** A 100k-character reply streams in 0.14 s. The next fastest renderer takes 2.4 s and
+  Streamdown 6.5 s.
+- **Linear.** A reply four times longer costs about three times more, not sixteen, and no update
+  takes more than 5 ms.
+- **Repairs a reply mid-stream.** Unfinished `**bold`, half-typed links and open code fences never
+  show their raw syntax.
+- **Complete.** Its parser passes every example of CommonMark and of GitHub's extensions.
+- **Light.** One package with no dependencies, 32 KB gzipped, styled without Tailwind.
+- **Safe.** Raw HTML from a reply is sanitized, and links are held to safe protocols.
+
+<p align="center">
+  <a href="https://flowdown.dev/docs/comparison"><img alt="flowdown beside five other React Markdown renderers: time to stream six kinds of reply, download size, packages installed, and the cost of a four times longer reply" src="https://raw.githubusercontent.com/rsaryev/flowdown/main/bench/results/charts/compare.png" width="878"></a>
+</p>
+
+Every figure, its method and where another renderer suits better are in
+[the comparison](https://flowdown.dev/docs/comparison).
+
+## Beyond React
+
+The same reply, from the same package, by import path. None but the first imports React.
+
+| Import             | Draws                                              |
+| ------------------ | -------------------------------------------------- |
+| `@localix-ai/flowdown` | React elements                                     |
+| `@localix-ai/flowdown/static`  | HTML text, for a server or an email                |
+| `@localix-ai/flowdown/dom`     | a page with no framework, kept up to date in place |
+| `@localix-ai/flowdown/element` | `<flow-down>`, for Vue, Svelte, Solid or Angular   |
+| `@localix-ai/flowdown/tui`     | the rows of a terminal                             |
+
+[Other targets](https://flowdown.dev/docs/targets) has each one's options.
+
+## Documentation
+
+Everything is at **[flowdown.dev](https://flowdown.dev)**:
+[getting started](https://flowdown.dev/docs/getting-started) ·
+[syntax](https://flowdown.dev/docs/syntax) ·
+[prompting](https://flowdown.dev/docs/prompting) ·
+[streaming](https://flowdown.dev/docs/streaming) ·
+[styling](https://flowdown.dev/docs/styling) ·
+[components](https://flowdown.dev/docs/components) ·
+[math](https://flowdown.dev/docs/math) ·
+[diagrams](https://flowdown.dev/docs/diagrams) ·
+[highlighting](https://flowdown.dev/docs/highlighting) ·
+[security](https://flowdown.dev/docs/security) ·
+[extensions](https://flowdown.dev/docs/remark) ·
+[API](https://flowdown.dev/docs/api) ·
+[releases](https://github.com/rsaryev/flowdown/blob/main/packages/flowdown/CHANGELOG.md)
+
+## License
+
+MIT

package/dist/browser/file-actions.js

@@ -0,0 +1,80 @@
+// src/browser/file-actions.ts
+/** What a code block's buttons do with its text: put it on the clipboard, or save it as a file. */
+/**
+* Puts `text` on the clipboard. The Clipboard API where the page has it; on an insecure origin, or
+* where it is refused, a selected hidden textarea and the old copy command, which still works on a
+* click. Resolves whether the text was copied.
+*/
+async function copyText(text) {
+	try {
+		if (typeof navigator !== "undefined" && navigator.clipboard) {
+			await navigator.clipboard.writeText(text);
+			return true;
+		}
+	} catch {}
+	if (typeof document === "undefined" || typeof document.execCommand !== "function") return false;
+	const area = document.createElement("textarea");
+	area.value = text;
+	area.setAttribute("readonly", "");
+	area.style.cssText = "position:fixed;top:0;left:0;opacity:0;pointer-events:none";
+	const active = document.activeElement;
+	document.body.append(area);
+	area.focus();
+	area.select();
+	let copied = false;
+	try {
+		copied = document.execCommand("copy");
+	} catch {
+		copied = false;
+	}
+	area.remove();
+	active?.focus();
+	return copied;
+}
+/** Saves `text` as a file named `name`, through a temporary `a[download]`. */
+function downloadFile(text, name, type = "text/plain") {
+	const url = URL.createObjectURL(new Blob([text], { type }));
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = name;
+	link.style.display = "none";
+	document.body.append(link);
+	link.click();
+	link.remove();
+	setTimeout(() => URL.revokeObjectURL(url), 1e3);
+}
+/** The file extension of a fence's language, for a code block saved without a title. */
+const EXTENSIONS = {
+	ts: "ts",
+	typescript: "ts",
+	tsx: "tsx",
+	js: "js",
+	javascript: "js",
+	jsx: "jsx",
+	json: "json",
+	sh: "sh",
+	bash: "sh",
+	shell: "sh",
+	zsh: "sh",
+	py: "py",
+	python: "py",
+	css: "css",
+	html: "html",
+	yaml: "yaml",
+	yml: "yaml",
+	sql: "sql",
+	md: "md",
+	markdown: "md"
+};
+/**
+* The name a code block is saved under: the file its fence names (`title="src/app.ts"`, its last
+* path segment), or `code.<ext>` from its language, `code.txt` when the language is unknown.
+*/
+function codeFileName(title, language) {
+	const named = title?.split(/[\\/]/).pop()?.trim();
+	if (named) return named;
+	return `code.${language && EXTENSIONS[language.toLowerCase()] || "txt"}`;
+}
+export { codeFileName, copyText, downloadFile };
+
+//# sourceMappingURL=file-actions.js.map

package/dist/browser/file-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-actions.js","names":[],"sources":["../../src/browser/file-actions.ts"],"sourcesContent":["/** What a code block's buttons do with its text: put it on the clipboard, or save it as a file. */\n\n/**\n * Puts `text` on the clipboard. The Clipboard API where the page has it; on an insecure origin, or\n * where it is refused, a selected hidden textarea and the old copy command, which still works on a\n * click. Resolves whether the text was copied.\n */\nexport async function copyText(text: string): Promise<boolean> {\n  try {\n    if (typeof navigator !== 'undefined' && navigator.clipboard) {\n      await navigator.clipboard.writeText(text)\n      return true\n    }\n  } catch {\n    // Refused (an insecure origin, a denied permission): try the textarea.\n  }\n  if (typeof document === 'undefined' || typeof document.execCommand !== 'function') return false\n  const area = document.createElement('textarea')\n  area.value = text\n  area.setAttribute('readonly', '')\n  area.style.cssText = 'position:fixed;top:0;left:0;opacity:0;pointer-events:none'\n  const active = document.activeElement as HTMLElement | null\n  document.body.append(area)\n  area.focus()\n  area.select()\n  let copied = false\n  try {\n    // oxlint-disable-next-line typescript/no-deprecated -- the one copy that works without the API\n    copied = document.execCommand('copy')\n  } catch {\n    copied = false\n  }\n  area.remove()\n  active?.focus()\n  return copied\n}\n\n/** Saves `text` as a file named `name`, through a temporary `a[download]`. */\nexport function downloadFile(text: string, name: string, type = 'text/plain') {\n  const url = URL.createObjectURL(new Blob([text], { type }))\n  const link = document.createElement('a')\n  link.href = url\n  link.download = name\n  link.style.display = 'none'\n  document.body.append(link)\n  link.click()\n  link.remove()\n  // Revoked a moment later: a browser that starts the download after this task still finds it.\n  setTimeout(() => URL.revokeObjectURL(url), 1_000)\n}\n\n/** The file extension of a fence's language, for a code block saved without a title. */\nconst EXTENSIONS: Record<string, string> = {\n  ts: 'ts',\n  typescript: 'ts',\n  tsx: 'tsx',\n  js: 'js',\n  javascript: 'js',\n  jsx: 'jsx',\n  json: 'json',\n  sh: 'sh',\n  bash: 'sh',\n  shell: 'sh',\n  zsh: 'sh',\n  py: 'py',\n  python: 'py',\n  css: 'css',\n  html: 'html',\n  yaml: 'yaml',\n  yml: 'yaml',\n  sql: 'sql',\n  md: 'md',\n  markdown: 'md',\n}\n\n/**\n * The name a code block is saved under: the file its fence names (`title=\"src/app.ts\"`, its last\n * path segment), or `code.<ext>` from its language, `code.txt` when the language is unknown.\n */\nexport function codeFileName(title: string | undefined, language: string | undefined): string {\n  const named = title?.split(/[\\\\/]/).pop()?.trim()\n  if (named) return named\n  return `code.${(language && EXTENSIONS[language.toLowerCase()]) || 'txt'}`\n}\n"],"mappings":";;;;;;;AAOA,eAAsB,SAAS,MAAgC;CAC7D,IAAI;EACF,IAAI,OAAO,cAAc,eAAe,UAAU,WAAW;GAC3D,MAAM,UAAU,UAAU,UAAU,IAAI;GACxC,OAAO;EACT;CACF,QAAQ,CAER;CACA,IAAI,OAAO,aAAa,eAAe,OAAO,SAAS,gBAAgB,YAAY,OAAO;CAC1F,MAAM,OAAO,SAAS,cAAc,UAAU;CAC9C,KAAK,QAAQ;CACb,KAAK,aAAa,YAAY,EAAE;CAChC,KAAK,MAAM,UAAU;CACrB,MAAM,SAAS,SAAS;CACxB,SAAS,KAAK,OAAO,IAAI;CACzB,KAAK,MAAM;CACX,KAAK,OAAO;CACZ,IAAI,SAAS;CACb,IAAI;EAEF,SAAS,SAAS,YAAY,MAAM;CACtC,QAAQ;EACN,SAAS;CACX;CACA,KAAK,OAAO;CACZ,QAAQ,MAAM;CACd,OAAO;AACT;;AAGA,SAAgB,aAAa,MAAc,MAAc,OAAO,cAAc;CAC5E,MAAM,MAAM,IAAI,gBAAgB,IAAI,KAAK,CAAC,IAAI,GAAG,EAAE,KAAK,CAAC,CAAC;CAC1D,MAAM,OAAO,SAAS,cAAc,GAAG;CACvC,KAAK,OAAO;CACZ,KAAK,WAAW;CAChB,KAAK,MAAM,UAAU;CACrB,SAAS,KAAK,OAAO,IAAI;CACzB,KAAK,MAAM;CACX,KAAK,OAAO;CAEZ,iBAAiB,IAAI,gBAAgB,GAAG,GAAG,GAAK;AAClD;;AAGA,MAAM,aAAqC;CACzC,IAAI;CACJ,YAAY;CACZ,KAAK;CACL,IAAI;CACJ,YAAY;CACZ,KAAK;CACL,MAAM;CACN,IAAI;CACJ,MAAM;CACN,OAAO;CACP,KAAK;CACL,IAAI;CACJ,QAAQ;CACR,KAAK;CACL,MAAM;CACN,MAAM;CACN,KAAK;CACL,KAAK;CACL,IAAI;CACJ,UAAU;AACZ;;;;;AAMA,SAAgB,aAAa,OAA2B,UAAsC;CAC5F,MAAM,QAAQ,OAAO,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK;CAChD,IAAI,OAAO,OAAO;CAClB,OAAO,QAAS,YAAY,WAAW,SAAS,YAAY,MAAO;AACrE"}

package/dist/core/block-facts.js

@@ -0,0 +1,72 @@
+import { hasRareEntity } from "../engine/entities.js";
+import { isFenceBlock } from "./blocks.js";
+import { escapeLiteralDollars } from "./dollars.js";
+import { headingBases } from "./headings.js";
+import { hasHtmlSyntax, hasMathSyntax } from "./syntax.js";
+// src/core/block-facts.ts
+/**
+* What a renderer needs to know about each block, worked out once per block.
+*
+* The splitter hands back the blocks that did not change as the same objects, so anything
+* computed from a block's text can be kept beside it: on the next token only the reply's end is
+* scanned again. Each answer is the one a scan of the whole document gives, because every
+* construct these scans look for lies inside one top-level block (a document where something
+* resolves across blocks, footnotes or link definitions, is never split).
+*/
+function remembered(compute) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (block) => {
+		if (cache.has(block)) return cache.get(block);
+		const value = compute(block);
+		cache.set(block, value);
+		return value;
+	};
+}
+/** A fence whose language is `math`: a display formula, as GitHub writes one. */
+const MATH_FENCE = /(?:^|\n) {0,3}(?:`{3,}|~{3,})[ \t]*math[ \t]*(?:\n|$)/;
+/**
+* Whether the block has a formula. A block that is one fenced code block has no prose to look in
+* (only its opening line says whether it is a formula): a long fence that is still streaming is
+* not scanned again on every token.
+*/
+const blockHasMath = remembered((block) => isFenceBlock(block) ? MATH_FENCE.test(block.source.slice(0, 40)) : hasMathSyntax(block.source) || MATH_FENCE.test(block.source));
+/** Whether the block names a character reference outside the common ones (`↛`). */
+const blockHasRareEntity = remembered((block) => !isFenceBlock(block) && block.source.includes("&") && hasRareEntity(block.source));
+/** Whether the block has raw HTML in its prose. */
+const blockHasHtml = remembered((block) => !isFenceBlock(block) && hasHtmlSyntax(block.source));
+/**
+* The block with its literal dollars escaped (`$5`), for a page that typesets `$…$`. The same
+* block always gives back the same object, so a memoized renderer still skips it.
+*/
+const escapedBlock = remembered((block) => {
+	if (isFenceBlock(block)) return block;
+	const source = escapeLiteralDollars(block.source);
+	return source === block.source ? block : {
+		...block,
+		source
+	};
+});
+/** The headings in a block: where each starts in it, and the text its id is made from. */
+const blockHeadings = remembered((block) => !isFenceBlock(block) && (block.source.includes("#") || /\n *(=+|-+) *(\n|$)/.test(block.source)) ? headingBases(block.source) : []);
+/**
+* Every heading's id across the blocks, keyed by where it starts in the document, numbered in
+* document order (the second `## Setup` is `setup-1`) just as one parse of the whole would.
+* Returned per block, so a block is handed only its own anchors.
+*/
+function headingIdsOfBlocks(blocks) {
+	const used = /* @__PURE__ */ new Set();
+	return blocks.map((block) => {
+		const ids = /* @__PURE__ */ new Map();
+		for (const { offset, base } of blockHeadings(block)) {
+			let id = base;
+			let suffix = 1;
+			while (used.has(id)) id = `${base}-${suffix++}`;
+			used.add(id);
+			ids.set(block.offset + offset, id);
+		}
+		return ids;
+	});
+}
+export { blockHasHtml, blockHasMath, blockHasRareEntity, escapedBlock, headingIdsOfBlocks };
+
+//# sourceMappingURL=block-facts.js.map

package/dist/core/block-facts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-facts.js","names":[],"sources":["../../src/core/block-facts.ts"],"sourcesContent":["/**\n * What a renderer needs to know about each block, worked out once per block.\n *\n * The splitter hands back the blocks that did not change as the same objects, so anything\n * computed from a block's text can be kept beside it: on the next token only the reply's end is\n * scanned again. Each answer is the one a scan of the whole document gives, because every\n * construct these scans look for lies inside one top-level block (a document where something\n * resolves across blocks, footnotes or link definitions, is never split).\n */\nimport { hasRareEntity } from '../engine/entities'\nimport { isFenceBlock, type MarkdownBlock } from './blocks'\nimport { escapeLiteralDollars } from './dollars'\nimport { headingBases } from './headings'\nimport { hasHtmlSyntax, hasMathSyntax } from './syntax'\n\nfunction remembered<T>(compute: (block: MarkdownBlock) => T) {\n  const cache = new WeakMap<MarkdownBlock, T>()\n  return (block: MarkdownBlock): T => {\n    if (cache.has(block)) return cache.get(block) as T\n    const value = compute(block)\n    cache.set(block, value)\n    return value\n  }\n}\n\n/** A fence whose language is `math`: a display formula, as GitHub writes one. */\nconst MATH_FENCE = /(?:^|\\n) {0,3}(?:`{3,}|~{3,})[ \\t]*math[ \\t]*(?:\\n|$)/\n\n/**\n * Whether the block has a formula. A block that is one fenced code block has no prose to look in\n * (only its opening line says whether it is a formula): a long fence that is still streaming is\n * not scanned again on every token.\n */\nexport const blockHasMath = remembered((block) =>\n  isFenceBlock(block)\n    ? MATH_FENCE.test(block.source.slice(0, 40))\n    : hasMathSyntax(block.source) || MATH_FENCE.test(block.source),\n)\n\n/** Whether the block names a character reference outside the common ones (`&nrarr;`). */\nexport const blockHasRareEntity = remembered(\n  (block) => !isFenceBlock(block) && block.source.includes('&') && hasRareEntity(block.source),\n)\n\n/** Whether the block has raw HTML in its prose. */\nexport const blockHasHtml = remembered(\n  (block) => !isFenceBlock(block) && hasHtmlSyntax(block.source),\n)\n\n/**\n * The block with its literal dollars escaped (`$5`), for a page that typesets `$…$`. The same\n * block always gives back the same object, so a memoized renderer still skips it.\n */\nexport const escapedBlock = remembered((block): MarkdownBlock => {\n  if (isFenceBlock(block)) return block\n  const source = escapeLiteralDollars(block.source)\n  return source === block.source ? block : { ...block, source }\n})\n\n/** The headings in a block: where each starts in it, and the text its id is made from. */\nconst blockHeadings = remembered((block) =>\n  !isFenceBlock(block) && (block.source.includes('#') || /\\n *(=+|-+) *(\\n|$)/.test(block.source))\n    ? headingBases(block.source)\n    : [],\n)\n\n/**\n * Every heading's id across the blocks, keyed by where it starts in the document, numbered in\n * document order (the second `## Setup` is `setup-1`) just as one parse of the whole would.\n * Returned per block, so a block is handed only its own anchors.\n */\nexport function headingIdsOfBlocks(blocks: readonly MarkdownBlock[]): Array<Map<number, string>> {\n  const used = new Set<string>()\n  return blocks.map((block) => {\n    const ids = new Map<number, string>()\n    for (const { offset, base } of blockHeadings(block)) {\n      let id = base\n      let suffix = 1\n      while (used.has(id)) id = `${base}-${suffix++}`\n      used.add(id)\n      ids.set(block.offset + offset, id)\n    }\n    return ids\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,SAAS,WAAc,SAAsC;CAC3D,MAAM,wBAAQ,IAAI,QAA0B;CAC5C,QAAQ,UAA4B;EAClC,IAAI,MAAM,IAAI,KAAK,GAAG,OAAO,MAAM,IAAI,KAAK;EAC5C,MAAM,QAAQ,QAAQ,KAAK;EAC3B,MAAM,IAAI,OAAO,KAAK;EACtB,OAAO;CACT;AACF;;AAGA,MAAM,aAAa;;;;;;AAOnB,MAAa,eAAe,YAAY,UACtC,aAAa,KAAK,IACd,WAAW,KAAK,MAAM,OAAO,MAAM,GAAG,EAAE,CAAC,IACzC,cAAc,MAAM,MAAM,KAAK,WAAW,KAAK,MAAM,MAAM,CACjE;;AAGA,MAAa,qBAAqB,YAC/B,UAAU,CAAC,aAAa,KAAK,KAAK,MAAM,OAAO,SAAS,GAAG,KAAK,cAAc,MAAM,MAAM,CAC7F;;AAGA,MAAa,eAAe,YACzB,UAAU,CAAC,aAAa,KAAK,KAAK,cAAc,MAAM,MAAM,CAC/D;;;;;AAMA,MAAa,eAAe,YAAY,UAAyB;CAC/D,IAAI,aAAa,KAAK,GAAG,OAAO;CAChC,MAAM,SAAS,qBAAqB,MAAM,MAAM;CAChD,OAAO,WAAW,MAAM,SAAS,QAAQ;EAAE,GAAG;EAAO;CAAO;AAC9D,CAAC;;AAGD,MAAM,gBAAgB,YAAY,UAChC,CAAC,aAAa,KAAK,MAAM,MAAM,OAAO,SAAS,GAAG,KAAK,sBAAsB,KAAK,MAAM,MAAM,KAC1F,aAAa,MAAM,MAAM,IACzB,CAAC,CACP;;;;;;AAOA,SAAgB,mBAAmB,QAA8D;CAC/F,MAAM,uBAAO,IAAI,IAAY;CAC7B,OAAO,OAAO,KAAK,UAAU;EAC3B,MAAM,sBAAM,IAAI,IAAoB;EACpC,KAAK,MAAM,EAAE,QAAQ,UAAU,cAAc,KAAK,GAAG;GACnD,IAAI,KAAK;GACT,IAAI,SAAS;GACb,OAAO,KAAK,IAAI,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG;GACrC,KAAK,IAAI,EAAE;GACX,IAAI,IAAI,MAAM,SAAS,QAAQ,EAAE;EACnC;EACA,OAAO;CACT,CAAC;AACH"}

package/dist/core/blocks.d.ts

@@ -0,0 +1,25 @@
+export interface MarkdownBlock {
+  /** The block's own source. */
+  source: string;
+  /** Where it starts in the document: characters before it, and its 1-based line. */
+  offset: number;
+  line: number;
+}
+/** Whether the splitter cut this block as one fenced code block. */
+export declare const isFenceBlock: (block: MarkdownBlock) => boolean;
+/** The top-level blocks of a document, cut where one parse of the whole would not join them. */
+export declare function splitBlocks(input: string): MarkdownBlock[];
+export interface BlockSplitter {
+  /** The same blocks as `splitBlocks(markdown)`; the ones that did not change are the same objects. */
+  split(markdown: string): MarkdownBlock[];
+  /** Characters scanned so far: the work the splitter has done. */
+  readonly lexed: number;
+}
+/**
+ * `splitBlocks` for a document that grows at its end, as a streaming reply does. It remembers the
+ * blocks it cut last time and where its scan stopped: when the new text still starts with all of
+ * them but the last two, it keeps those, as the very same objects, and scans only the lines that
+ * are new. Any other text (a reply that was regenerated, or edited above its end) is split afresh.
+ * Each update then costs the new characters, not the reply: a stream is linear in its length.
+ */
+export declare function createBlockSplitter(): BlockSplitter;