@localix-ai/flowdown 0.0.0-stage → 0.5.1

package/dist/core/blocks.js

@@ -0,0 +1,464 @@
+import { parseContainerMarker } from "../dialect.js";
+import { continues } from "./continues.js";
+// src/core/blocks.ts
+/**
+* Splitting a document into top-level blocks that can be rendered, and remembered, one by one.
+*
+* A streaming reply grows at its end, and re-rendering the whole of it on every token is work
+* proportional to its length, repeated per token. Cut at its top-level blocks instead, every block
+* but the last is text that no longer changes: a renderer that memoizes each block by its source
+* parses and reconciles only the tail.
+*
+* The cut must never change the result, so the text is cut only where one parse of the whole
+* document is certain to start a new top-level block, and a block is merged with its neighbours
+* wherever that parse would read them together:
+*   - the dialect's forms: a marker-only quote (`> [!STEPS]`) governs the list after it, `[!TABS]`
+*     the run of sections after it, and a `[!PROS]` right before a `[!CONS]` is one pair;
+*   - an image alone in its paragraph and an emphasis-only line under it, its caption;
+*   - an HTML block whose tag is closed further down;
+*   - a `$$` display formula with blank lines inside;
+*   - a document with footnote or link reference definitions, which resolve across blocks, is
+*     not split at all.
+*
+* The boundaries are found by a scan of the lines (`step`), not by a Markdown lexer: it follows
+* only what decides where a top-level block can end (a fence, a list, an HTML block that blank
+* lines do not end), and where it cannot tell, it stops cutting for the rest of the document.
+* Merging is always safe, a wrong cut never is. The tests render a corpus both ways and require
+* the same markup, at every prefix.
+*/
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+const INNER_FENCE = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+const ITEM = /^( {0,3})([-+*]|\d{1,9}[.)])(.*)$/;
+/** A list item that may interrupt a paragraph: a bullet, or the number 1, with text after it. */
+const INTERRUPTING_ITEM = /^ {0,3}(?:[-+*]|1[.)]) +\S/;
+const RULE = /^ {0,3}(?:(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})$/;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]|$)/;
+const UNDERLINE = /\n {0,3}(?:=+|-+)[ \t]*(?:\n|$)/;
+const QUOTE = /^ {0,3}>[ \t]?(.*)$/;
+/** HTML blocks that a blank line does not end: how each opens, and what closes it. */
+const LONG_HTML = [
+	[/^ {0,3}<(?:pre|script|style|textarea)(?=[\s>]|$)/i, /<\/(?:pre|script|style|textarea)>/i],
+	[/^ {0,3}<!--/, /-->/],
+	[/^ {0,3}<\?/, /\?>/],
+	[/^ {0,3}<!\[CDATA\[/, /\]\]>/],
+	[/^ {0,3}<![A-Za-z]/, />/]
+];
+const HTML_START = /^ {0,3}<[A-Za-z/!?]/;
+const HTML_LINE = /^ {0,3}<[A-Za-z]/m;
+const HTML_LINES = /^ {0,3}<([A-Za-z][\w:-]*)(?=[\s>/])/gm;
+const FOOTNOTE_DEFINITION = /\[\^[^\]\s]{1,200}\]:/;
+const LINK_DEFINITION = /^ {0,3}\[[^\]]+\]:/;
+const OPEN_LABEL = /^ {0,3}\[[^\]]*$/;
+const IMAGE_ONLY = /^!\[[^\]]*\]\([^)]*\)$/;
+const DOUBLE_DOLLAR = /(?<!\\)\$\$/g;
+const VOID_TAGS = /* @__PURE__ */ new Set([
+	"area",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"source",
+	"wbr"
+]);
+const whole = (markdown) => [{
+	source: markdown,
+	offset: 0,
+	line: 1
+}];
+const start = () => ({
+	fence: null,
+	html: null,
+	list: 0,
+	unsure: false,
+	markup: false,
+	fresh: true,
+	odd: false,
+	label: false,
+	closed: false,
+	indented: false,
+	mixed: false,
+	inner: null,
+	seen: false,
+	stuck: false,
+	whole: false
+});
+/** The column a line's text starts at, tabs to the next multiple of four; -1 for a blank line. */
+function indentOf(line) {
+	let column = 0;
+	for (let index = 0; index < line.length; index += 1) {
+		const code = line.charCodeAt(index);
+		if (code === 32) column += 1;
+		else if (code === 9) column += 4 - column % 4;
+		else return column;
+	}
+	return -1;
+}
+/**
+* The content column of a list item's line, 0 when the line is not one, -1 when it is one whose
+* column a tab after the marker leaves unknown.
+*/
+function itemColumn(line) {
+	const item = ITEM.exec(line);
+	if (!item) return 0;
+	const base = item[1].length + item[2].length;
+	const rest = item[3];
+	if (rest === "") return base + 1;
+	if (rest[0] === "	") return -1;
+	if (rest[0] !== " ") return 0;
+	const text = rest.trimStart();
+	const spaces = rest.length - text.length;
+	if (text === "") return base + 1;
+	if (rest.slice(0, spaces).includes("	")) return -1;
+	return base + (spaces > 4 ? 1 : spaces);
+}
+/**
+* One line through the scan. True when the line starts a new top-level block for certain: after a
+* blank line outside every open construct, or as the fence line of a top-level fence.
+*/
+function step(scan, line) {
+	const seen = scan.seen;
+	const closed = scan.closed;
+	if (!seen && line.trim() !== "") scan.seen = true;
+	const cut = advance(scan, line);
+	if (closed && !scan.closed && !cut) scan.mixed = true;
+	return cut && seen;
+}
+function advance(scan, line) {
+	if (scan.stuck || scan.whole) return false;
+	if (scan.fence) {
+		const closing = FENCE.exec(line);
+		if (closing && closing[1][0] === scan.fence[0] && closing[1].length >= scan.fence.length && closing[2].trim() === "") {
+			scan.fence = null;
+			scan.fresh = true;
+			scan.closed = true;
+		}
+		return false;
+	}
+	if (scan.html) {
+		if (scan.html.test(line)) scan.html = null;
+		return false;
+	}
+	const indent = indentOf(line);
+	if (indent === -1) {
+		scan.fresh = true;
+		scan.markup = false;
+		scan.label = false;
+		return false;
+	}
+	const fresh = scan.fresh;
+	const closed = scan.closed;
+	scan.fresh = false;
+	scan.closed = false;
+	if (FOOTNOTE_DEFINITION.test(line) || LINK_DEFINITION.test(line)) return definition(scan);
+	if (scan.label) {
+		const close = line.indexOf("]");
+		if (close !== -1) {
+			if (line[close + 1] === ":") return definition(scan);
+			scan.label = false;
+		}
+	} else if (OPEN_LABEL.test(line)) scan.label = true;
+	const odd = scan.odd;
+	if (line.includes("$$") && (line.match(DOUBLE_DOLLAR)?.length ?? 0) % 2 === 1) scan.odd = !odd;
+	const fence = FENCE.exec(line);
+	const opensFence = fence !== null && !(fence[1][0] === "`" && fence[2].includes("`"));
+	if (opensFence && (odd || scan.markup)) return stick(scan);
+	if (scan.list > 0) {
+		if (indent >= scan.list) {
+			if (opensFence && scan.unsure) return stick(scan);
+			const inner = INNER_FENCE.exec(line);
+			if (scan.inner) {
+				if (inner && inner[1][0] === scan.inner[0] && inner[1].length >= scan.inner.length && inner[2].trim() === "") scan.inner = null;
+			} else if (inner && !(inner[1][0] === "`" && inner[2].includes("`"))) scan.inner = inner[1];
+			return false;
+		}
+		if (scan.inner) return stick(scan);
+		const column = RULE.test(line) ? 0 : itemColumn(line);
+		if (column === -1) return stick(scan);
+		if (column > 0) {
+			scan.list = column;
+			if (fresh) scan.unsure = false;
+			return false;
+		}
+		if (fresh || opensFence || HEADING.test(line) || RULE.test(line) || QUOTE.test(line) || LONG_HTML.some(([opens]) => opens.test(line))) {
+			scan.list = 0;
+			scan.unsure = false;
+		} else {
+			scan.unsure = true;
+			if (HTML_START.test(line)) scan.markup = true;
+			return false;
+		}
+	}
+	const indented = scan.indented;
+	scan.indented = indent >= 4;
+	const cut = closed || fresh && indent < 4 && !odd && !indented;
+	for (const [opens, closes] of LONG_HTML) {
+		if (!opens.test(line)) continue;
+		if (!closes.test(line.replace(opens, ""))) scan.html = closes;
+		return cut;
+	}
+	if (opensFence) {
+		scan.fence = fence[1];
+		return !odd;
+	}
+	const column = indent < 4 && !RULE.test(line) ? itemColumn(line) : 0;
+	if (column === -1) return stick(scan);
+	if (column > 0 && indented && !INTERRUPTING_ITEM.test(line)) return stick(scan);
+	if (column > 0) {
+		scan.list = column;
+		scan.unsure = scan.markup || !fresh && !INTERRUPTING_ITEM.test(line);
+		return cut;
+	}
+	if (HTML_START.test(line)) scan.markup = true;
+	return cut;
+}
+function stick(scan) {
+	scan.stuck = true;
+	return false;
+}
+function definition(scan) {
+	scan.whole = true;
+	return false;
+}
+/** The line of `text` that starts at `at`, without its newline. */
+function lineAt(text, at) {
+	const end = text.indexOf("\n", at);
+	return text.slice(at, end === -1 ? text.length : end);
+}
+/** Whether `raw` has a line that opens an HTML tag still open at its end. */
+function htmlOpen(raw) {
+	if (raw.includes("<!--") && raw.split("<!--").length > raw.split("-->").length) return true;
+	if (!HTML_LINE.test(raw)) return false;
+	const tried = /* @__PURE__ */ new Set();
+	for (const opener of raw.matchAll(HTML_LINES)) {
+		const tag = opener[1].toLowerCase();
+		if (tried.has(tag) || VOID_TAGS.has(tag)) continue;
+		tried.add(tag);
+		const rest = raw.slice(opener.index);
+		if ((rest.match(new RegExp(`<${tag}(?=[\\s>/])[^>]*>`, "gi")) ?? []).filter((found) => !found.endsWith("/>")).length > (rest.match(new RegExp(`</${tag}\\s*>`, "gi"))?.length ?? 0)) return true;
+	}
+	return false;
+}
+/**
+* The pieces the scan cut (`starts`, offsets into `text`) joined into the blocks that must render
+* together: the offsets where a block starts. Read by the same grammar as the remark pass.
+*/
+function group(text, starts) {
+	const count = starts.length;
+	const endOf = (piece) => piece + 1 < count ? starts[piece + 1] : text.length;
+	const first = (piece) => piece < count ? lineAt(text, starts[piece]) : "";
+	const kindOf = (line) => {
+		const quoted = QUOTE.exec(line);
+		return quoted ? parseContainerMarker(quoted[1].trimStart())?.kind ?? null : null;
+	};
+	const isItem = (line) => !RULE.test(line) && itemColumn(line) !== 0;
+	/** The piece after the tabs whose first heading is in `holder`, on `line` or underlined. */
+	const tabsEnd = (holder, line, fallback) => {
+		if (holder >= count) return fallback;
+		const opening = HEADING.exec(line);
+		if (!opening && !UNDERLINE.test(text.slice(starts[holder], endOf(holder)))) return fallback;
+		const depth = opening ? opening[1].length : 1;
+		let end = holder + 1;
+		for (; end < count; end += 1) {
+			const next = first(end);
+			if (RULE.test(next)) break;
+			const heading = HEADING.exec(next);
+			if (heading && heading[1].length < depth) break;
+		}
+		return end;
+	};
+	/**
+	* The form a piece holds a marker line for, and the piece after everything it governs. A list
+	* form takes the one list right after it; tabs take the sections from the heading right after
+	* them up to a shallower heading, a `---` or the end. The marker is a quote of its own, on any
+	* line of the piece: on the last, what it governs is the next piece. A marker whose quote goes
+	* on (`> [!PROS]\n> - a`) holds its own content. Of several markers, the one that reaches
+	* furthest decides.
+	*/
+	const form = (piece) => {
+		if (piece >= count) return null;
+		const body = text.slice(starts[piece], endOf(piece)).trimEnd();
+		if (!body.includes("[!")) return null;
+		const lines = body.split("\n");
+		let found = null;
+		for (let index = 0; index < lines.length; index += 1) {
+			const kind = kindOf(lines[index]);
+			if (!kind || index > 0 && QUOTE.test(lines[index - 1])) continue;
+			const next = lines[index + 1];
+			let end = piece + 1;
+			if (next === void 0) {
+				if (kind === "tabs") end = tabsEnd(piece + 1, first(piece + 1), piece + 1);
+				else if (isItem(first(piece + 1))) end = piece + 2;
+			} else if (kind === "tabs" && !QUOTE.test(next)) end = tabsEnd(piece, next, piece + 1);
+			const reach = found ? found.end : 0;
+			found = {
+				kind,
+				end: Math.max(end, reach)
+			};
+		}
+		return found;
+	};
+	const blocks = [];
+	let piece = 0;
+	while (piece < count) {
+		const from = piece;
+		const found = form(piece);
+		piece = found ? found.end : piece + 1;
+		if (found && (found.kind === "pros" || found.kind === "cons")) {
+			const other = form(piece);
+			if (other && other.kind === (found.kind === "pros" ? "cons" : "pros")) piece = other.end;
+		}
+		if (piece === from + 1 && piece < count && IMAGE_ONLY.test(text.slice(starts[from], endOf(from)).trim()) && /^[*_]/.test(first(piece).trimStart())) piece += 1;
+		while (piece < count && htmlOpen(text.slice(starts[from], starts[piece]))) piece += 1;
+		blocks.push(starts[from]);
+	}
+	return blocks;
+}
+/**
+* Line endings as the scan reads them: `\r\n` and `\r` become `\n`. Offsets of the blocks are into
+* the normalized text, which is what the renderer draws from.
+*/
+const normalizeLineEndings = (markdown) => markdown.includes("\r") ? markdown.replace(/\r\n?/g, "\n") : markdown;
+/** Blocks that are one fenced code block and nothing else: no prose, HTML, math or heading. */
+const fenced = /* @__PURE__ */ new WeakSet();
+/** Whether the splitter cut this block as one fenced code block. */
+const isFenceBlock = (block) => fenced.has(block);
+const MARKS = 3;
+/**
+* The pieces of `text` from `from` on: the offsets where the scan cut, or null when a definition
+* keeps the document whole. `progress` and `mark` are where an earlier scan of the same start
+* can go on from.
+*/
+function pieces(text, from, progress, mark) {
+	const scan = mark ? { ...mark.scan } : start();
+	const starts = progress && mark ? progress.starts.slice(0, mark.count) : [from];
+	const marks = progress && mark ? progress.marks.filter((kept) => kept.at <= mark.at) : [];
+	let at = mark ? mark.at : from;
+	let marked = text.length;
+	for (let back = 0; back < MARKS && marked > at; back += 1) marked = text.lastIndexOf("\n", marked - 1);
+	for (let end = text.indexOf("\n", at); end !== -1; end = text.indexOf("\n", at)) {
+		if (step(scan, text.slice(at, end)) && at > from) starts.push(at);
+		at = end + 1;
+		if (end >= marked) marks.push({
+			at,
+			scan: { ...scan },
+			count: starts.length
+		});
+	}
+	const next = {
+		from,
+		starts: [...starts],
+		marks: marks.slice(-3)
+	};
+	if (at < text.length && step(scan, text.slice(at)) && at > from) starts.push(at);
+	return scan.whole ? null : {
+		starts,
+		progress: next,
+		mixed: scan.mixed
+	};
+}
+/** The blocks of `text` that the pieces at `cuts` make, the first on line `line`. */
+function build(text, cuts, line, mixed) {
+	const starts = group(text, cuts);
+	const blocks = [];
+	let current = line;
+	let piece = 0;
+	for (let index = 0; index < starts.length; index += 1) {
+		const offset = starts[index];
+		const end = starts[index + 1] ?? text.length;
+		const source = text.slice(offset, end);
+		const block = {
+			source,
+			offset,
+			line: current
+		};
+		while (cuts[piece] < offset) piece += 1;
+		if ((cuts[piece + 1] ?? text.length) === end && !(mixed && end === text.length)) {
+			const opening = FENCE.exec(lineAt(text, offset));
+			if (opening && !(opening[1][0] === "`" && opening[2].includes("`"))) fenced.add(block);
+		}
+		blocks.push(block);
+		if (index + 1 === starts.length) break;
+		for (let at = source.indexOf("\n"); at !== -1; at = source.indexOf("\n", at + 1)) current += 1;
+	}
+	return blocks;
+}
+/** The top-level blocks of a document, cut where one parse of the whole would not join them. */
+function splitBlocks(input) {
+	const markdown = normalizeLineEndings(input);
+	if (!markdown) return whole(markdown);
+	const cut = pieces(markdown, 0, null, null);
+	return cut ? build(markdown, cut.starts, 1, cut.mixed) : whole(markdown);
+}
+/**
+* How many blocks at the end are read again. Text appended to a document can change only the
+* group it is appended to, and that group can join the one before it (a `[!CONS]` arriving
+* under a `[!PROS]`); every group above those two is final.
+*/
+const REOPENED = 2;
+/**
+* `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.
+*/
+function createBlockSplitter() {
+	let text = "";
+	let blocks = [];
+	let progress = null;
+	let lexed = 0;
+	return {
+		get lexed() {
+			return lexed;
+		},
+		split(input) {
+			const markdown = normalizeLineEndings(input);
+			if (!markdown) {
+				text = "";
+				blocks = [];
+				progress = null;
+				return whole(markdown);
+			}
+			let kept = blocks.slice(0, Math.max(0, blocks.length - REOPENED));
+			let last = kept.at(-1);
+			let from = last ? last.offset + last.source.length : 0;
+			if (from > 0 && !continues(markdown, text, from)) {
+				kept = [];
+				last = void 0;
+				from = 0;
+			}
+			let mark = null;
+			if (progress !== null && progress.from === from) for (let index = progress.marks.length - 1; index >= 0 && !mark; index -= 1) {
+				const tried = progress.marks[index];
+				if (continues(markdown, text, tried.at, from)) mark = tried;
+			}
+			lexed += markdown.length - (mark ? mark.at : from);
+			const cut = pieces(markdown, from, mark ? progress : null, mark);
+			text = markdown;
+			if (!cut) {
+				blocks = [];
+				progress = null;
+				return whole(markdown);
+			}
+			progress = cut.progress;
+			let line = 1;
+			if (last) {
+				line = last.line;
+				for (let at = last.source.indexOf("\n"); at !== -1; at = last.source.indexOf("\n", at + 1)) line += 1;
+			}
+			const rest = build(markdown, cut.starts, line, cut.mixed);
+			for (let index = 0; index < rest.length; index += 1) {
+				const before = blocks[kept.length + index];
+				const after = rest[index];
+				if (before && before.offset === after.offset && before.source === after.source) rest[index] = before;
+			}
+			blocks = [...kept, ...rest];
+			return blocks;
+		}
+	};
+}
+export { createBlockSplitter, isFenceBlock, normalizeLineEndings, splitBlocks };
+
+//# sourceMappingURL=blocks.js.map

package/dist/core/blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","names":[],"sources":["../../src/core/blocks.ts"],"sourcesContent":["/**\n * Splitting a document into top-level blocks that can be rendered, and remembered, one by one.\n *\n * A streaming reply grows at its end, and re-rendering the whole of it on every token is work\n * proportional to its length, repeated per token. Cut at its top-level blocks instead, every block\n * but the last is text that no longer changes: a renderer that memoizes each block by its source\n * parses and reconciles only the tail.\n *\n * The cut must never change the result, so the text is cut only where one parse of the whole\n * document is certain to start a new top-level block, and a block is merged with its neighbours\n * wherever that parse would read them together:\n *   - the dialect's forms: a marker-only quote (`> [!STEPS]`) governs the list after it, `[!TABS]`\n *     the run of sections after it, and a `[!PROS]` right before a `[!CONS]` is one pair;\n *   - an image alone in its paragraph and an emphasis-only line under it, its caption;\n *   - an HTML block whose tag is closed further down;\n *   - a `$$` display formula with blank lines inside;\n *   - a document with footnote or link reference definitions, which resolve across blocks, is\n *     not split at all.\n *\n * The boundaries are found by a scan of the lines (`step`), not by a Markdown lexer: it follows\n * only what decides where a top-level block can end (a fence, a list, an HTML block that blank\n * lines do not end), and where it cannot tell, it stops cutting for the rest of the document.\n * Merging is always safe, a wrong cut never is. The tests render a corpus both ways and require\n * the same markup, at every prefix.\n */\nimport { parseContainerMarker, type ContainerKind } from '../dialect'\nimport { continues } from './continues'\n\nexport interface MarkdownBlock {\n  /** The block's own source. */\n  source: string\n  /** Where it starts in the document: characters before it, and its 1-based line. */\n  offset: number\n  line: number\n}\n\nconst FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/\nconst INNER_FENCE = /^[ \\t]*(`{3,}|~{3,})(.*)$/\nconst ITEM = /^( {0,3})([-+*]|\\d{1,9}[.)])(.*)$/\n/** A list item that may interrupt a paragraph: a bullet, or the number 1, with text after it. */\nconst INTERRUPTING_ITEM = /^ {0,3}(?:[-+*]|1[.)]) +\\S/\nconst RULE = /^ {0,3}(?:(?:-[ \\t]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})$/\nconst HEADING = /^ {0,3}(#{1,6})(?:[ \\t]|$)/\nconst UNDERLINE = /\\n {0,3}(?:=+|-+)[ \\t]*(?:\\n|$)/\nconst QUOTE = /^ {0,3}>[ \\t]?(.*)$/\n/** HTML blocks that a blank line does not end: how each opens, and what closes it. */\nconst LONG_HTML: ReadonlyArray<readonly [RegExp, RegExp]> = [\n  [/^ {0,3}<(?:pre|script|style|textarea)(?=[\\s>]|$)/i, /<\\/(?:pre|script|style|textarea)>/i],\n  [/^ {0,3}<!--/, /-->/],\n  [/^ {0,3}<\\?/, /\\?>/],\n  [/^ {0,3}<!\\[CDATA\\[/, /\\]\\]>/],\n  [/^ {0,3}<![A-Za-z]/, />/],\n]\nconst HTML_START = /^ {0,3}<[A-Za-z/!?]/\nconst HTML_LINE = /^ {0,3}<[A-Za-z]/m\nconst HTML_LINES = /^ {0,3}<([A-Za-z][\\w:-]*)(?=[\\s>/])/gm\nconst FOOTNOTE_DEFINITION = /\\[\\^[^\\]\\s]{1,200}\\]:/\nconst LINK_DEFINITION = /^ {0,3}\\[[^\\]]+\\]:/\nconst OPEN_LABEL = /^ {0,3}\\[[^\\]]*$/\nconst IMAGE_ONLY = /^!\\[[^\\]]*\\]\\([^)]*\\)$/\nconst DOUBLE_DOLLAR = /(?<!\\\\)\\$\\$/g\nconst VOID_TAGS = new Set(['area', 'br', 'col', 'embed', 'hr', 'img', 'input', 'source', 'wbr'])\n\nconst whole = (markdown: string): MarkdownBlock[] => [{ source: markdown, offset: 0, line: 1 }]\n\n/** What the scan knows after a line: only what decides where a top-level block can end. */\ninterface Scan {\n  /** The opening run of the top-level fence the text is inside. */\n  fence: string | null\n  /** What closes the HTML block the text is inside, one that blank lines do not end. */\n  html: RegExp | null\n  /** The content column of the open top-level list item; 0 outside a list. */\n  list: number\n  /** The list may already be over: a line left of the item that was a lazy continuation or not. */\n  unsure: boolean\n  /** The lines since the last blank one may be an HTML block, where a fence line is not a fence. */\n  markup: boolean\n  /** The next line starts a block: the last one was blank or closed a fence, or there was none. */\n  fresh: boolean\n  /** An odd number of `$$` so far in this block: a display formula may be open. */\n  odd: boolean\n  /** A `[label` that has not closed yet: it may turn out to be a link definition. */\n  label: boolean\n  /**\n   * The last line with text was indented four or more: code, or the rest of a paragraph. The\n   * parser still has indented code open when it reads the next line, and reads it as one that\n   * interrupts: `2. two` or an empty `-` is then text, not a list. The line after is never cut.\n   */\n  indented: boolean\n  /** The last line with text closed a top-level fence: whatever comes next is a new block. */\n  closed: boolean\n  /** Text follows a closed fence in the same piece: that piece is not only a fence. */\n  mixed: boolean\n  /** The opening run of a fence inside the open list item. */\n  inner: string | null\n  /** A line with text has been read: blank lines at the very start belong to the first block. */\n  seen: boolean\n  /** The scan cannot tell what the next lines are: no more cuts. */\n  stuck: boolean\n  /** A definition that resolves across blocks: the document stays one block. */\n  whole: boolean\n}\n\nconst start = (): Scan => ({\n  fence: null,\n  html: null,\n  list: 0,\n  unsure: false,\n  markup: false,\n  fresh: true,\n  odd: false,\n  label: false,\n  closed: false,\n  indented: false,\n  mixed: false,\n  inner: null,\n  seen: false,\n  stuck: false,\n  whole: false,\n})\n\n/** The column a line's text starts at, tabs to the next multiple of four; -1 for a blank line. */\nfunction indentOf(line: string): number {\n  let column = 0\n  for (let index = 0; index < line.length; index += 1) {\n    const code = line.charCodeAt(index)\n    if (code === 32) column += 1\n    else if (code === 9) column += 4 - (column % 4)\n    else return column\n  }\n  return -1\n}\n\n/**\n * The content column of a list item's line, 0 when the line is not one, -1 when it is one whose\n * column a tab after the marker leaves unknown.\n */\nfunction itemColumn(line: string): number {\n  const item = ITEM.exec(line)\n  if (!item) return 0\n  const base = item[1]!.length + item[2]!.length\n  const rest = item[3]!\n  if (rest === '') return base + 1\n  if (rest[0] === '\\t') return -1\n  if (rest[0] !== ' ') return 0\n  const text = rest.trimStart()\n  const spaces = rest.length - text.length\n  if (text === '') return base + 1\n  if (rest.slice(0, spaces).includes('\\t')) return -1\n  return base + (spaces > 4 ? 1 : spaces)\n}\n\n/**\n * One line through the scan. True when the line starts a new top-level block for certain: after a\n * blank line outside every open construct, or as the fence line of a top-level fence.\n */\nfunction step(scan: Scan, line: string): boolean {\n  const seen = scan.seen\n  const closed = scan.closed\n  if (!seen && line.trim() !== '') scan.seen = true\n  const cut = advance(scan, line)\n  // A line with text right after a fence that did not start a block: the scan was stuck on it.\n  if (closed && !scan.closed && !cut) scan.mixed = true\n  return cut && seen\n}\n\nfunction advance(scan: Scan, line: string): boolean {\n  if (scan.stuck || scan.whole) return false\n  if (scan.fence) {\n    const closing = FENCE.exec(line)\n    if (\n      closing &&\n      closing[1]![0] === scan.fence[0] &&\n      closing[1]!.length >= scan.fence.length &&\n      closing[2]!.trim() === ''\n    ) {\n      scan.fence = null\n      scan.fresh = true\n      scan.closed = true\n    }\n    return false\n  }\n  if (scan.html) {\n    if (scan.html.test(line)) scan.html = null\n    return false\n  }\n  const indent = indentOf(line)\n  if (indent === -1) {\n    scan.fresh = true\n    scan.markup = false\n    scan.label = false\n    return false\n  }\n  const fresh = scan.fresh\n  const closed = scan.closed\n  scan.fresh = false\n  scan.closed = false\n\n  if (FOOTNOTE_DEFINITION.test(line) || LINK_DEFINITION.test(line)) return definition(scan)\n  if (scan.label) {\n    const close = line.indexOf(']')\n    if (close !== -1) {\n      if (line[close + 1] === ':') return definition(scan)\n      scan.label = false\n    }\n  } else if (OPEN_LABEL.test(line)) scan.label = true\n\n  const odd = scan.odd\n  if (line.includes('$$') && (line.match(DOUBLE_DOLLAR)?.length ?? 0) % 2 === 1) scan.odd = !odd\n\n  const fence = FENCE.exec(line)\n  // A backtick fence has no backtick in its info string: ```` ```a``` ```` is inline code.\n  const opensFence = fence !== null && !(fence[1]![0] === '`' && fence[2]!.includes('`'))\n  // Inside a formula or an HTML block a fence line is text, and which of the two it is here\n  // cannot be told from the lines alone.\n  if (opensFence && (odd || scan.markup)) return stick(scan)\n\n  if (scan.list > 0) {\n    if (indent >= scan.list) {\n      // In the item, if the list is still open; a top-level fence if it is not.\n      if (opensFence && scan.unsure) return stick(scan)\n      const inner = INNER_FENCE.exec(line)\n      if (scan.inner) {\n        if (\n          inner &&\n          inner[1]![0] === scan.inner[0] &&\n          inner[1]!.length >= scan.inner.length &&\n          inner[2]!.trim() === ''\n        )\n          scan.inner = null\n      } else if (inner && !(inner[1]![0] === '`' && inner[2]!.includes('`'))) scan.inner = inner[1]!\n      return false\n    }\n    // A fence in the item that a line left of the item ends: where its last blank lines go\n    // depends on what follows, so nothing is cut from here on.\n    if (scan.inner) return stick(scan)\n    const column = RULE.test(line) ? 0 : itemColumn(line)\n    if (column === -1) return stick(scan)\n    if (column > 0) {\n      // The next item of the list (or of a new one right after it).\n      scan.list = column\n      if (fresh) scan.unsure = false\n      return false\n    }\n    if (\n      fresh ||\n      opensFence ||\n      HEADING.test(line) ||\n      RULE.test(line) ||\n      QUOTE.test(line) ||\n      LONG_HTML.some(([opens]) => opens.test(line))\n    ) {\n      // Left of the item after a blank line, or a block that cannot be a lazy continuation: the\n      // list is over, and the line is read as a top-level one below.\n      scan.list = 0\n      scan.unsure = false\n    } else {\n      // A lazy continuation of the item's paragraph, or, if the item did not end in a paragraph,\n      // the first line after the list.\n      scan.unsure = true\n      if (HTML_START.test(line)) scan.markup = true\n      return false\n    }\n  }\n\n  // Indented four or more after a blank line: indented code, which goes on over blank lines.\n  // Right after a fence, any line starts a block.\n  const indented = scan.indented\n  scan.indented = indent >= 4\n  const cut = closed || (fresh && indent < 4 && !odd && !indented)\n  for (const [opens, closes] of LONG_HTML) {\n    if (!opens.test(line)) continue\n    if (!closes.test(line.replace(opens, ''))) scan.html = closes\n    return cut\n  }\n  if (opensFence) {\n    scan.fence = fence![1]!\n    // A fence starts a block wherever it is written, and is one whatever follows it.\n    return !odd\n  }\n  const column = indent < 4 && !RULE.test(line) ? itemColumn(line) : 0\n  if (column === -1) return stick(scan)\n  // After a line indented four, which was code or the rest of a paragraph, only the scan of the\n  // lines before it could say which a list item that cannot interrupt is.\n  if (column > 0 && indented && !INTERRUPTING_ITEM.test(line)) return stick(scan)\n  if (column > 0) {\n    scan.list = column\n    scan.unsure = scan.markup || (!fresh && !INTERRUPTING_ITEM.test(line))\n    return cut\n  }\n  if (HTML_START.test(line)) scan.markup = true\n  return cut\n}\n\nfunction stick(scan: Scan): false {\n  scan.stuck = true\n  return false\n}\n\nfunction definition(scan: Scan): false {\n  scan.whole = true\n  return false\n}\n\n/** The line of `text` that starts at `at`, without its newline. */\nfunction lineAt(text: string, at: number): string {\n  const end = text.indexOf('\\n', at)\n  return text.slice(at, end === -1 ? text.length : end)\n}\n\n/** Whether `raw` has a line that opens an HTML tag still open at its end. */\nfunction htmlOpen(raw: string): boolean {\n  // A comment left open takes whatever follows it.\n  if (raw.includes('<!--') && raw.split('<!--').length > raw.split('-->').length) return true\n  if (!HTML_LINE.test(raw)) return false\n  const tried = new Set<string>()\n  for (const opener of raw.matchAll(HTML_LINES)) {\n    const tag = opener[1]!.toLowerCase()\n    if (tried.has(tag) || VOID_TAGS.has(tag)) continue\n    tried.add(tag)\n    const rest = raw.slice(opener.index)\n    const openers = rest.match(new RegExp(`<${tag}(?=[\\\\s>/])[^>]*>`, 'gi')) ?? []\n    const opened = openers.filter((found) => !found.endsWith('/>')).length\n    const closed = rest.match(new RegExp(`</${tag}\\\\s*>`, 'gi'))?.length ?? 0\n    if (opened > closed) return true\n  }\n  return false\n}\n\n/**\n * The pieces the scan cut (`starts`, offsets into `text`) joined into the blocks that must render\n * together: the offsets where a block starts. Read by the same grammar as the remark pass.\n */\nfunction group(text: string, starts: readonly number[]): number[] {\n  const count = starts.length\n  const endOf = (piece: number) => (piece + 1 < count ? starts[piece + 1]! : text.length)\n  const first = (piece: number) => (piece < count ? lineAt(text, starts[piece]!) : '')\n  const kindOf = (line: string): ContainerKind | null => {\n    const quoted = QUOTE.exec(line)\n    return quoted ? (parseContainerMarker(quoted[1]!.trimStart())?.kind ?? null) : null\n  }\n  const isItem = (line: string) => !RULE.test(line) && itemColumn(line) !== 0\n  /** The piece after the tabs whose first heading is in `holder`, on `line` or underlined. */\n  const tabsEnd = (holder: number, line: string, fallback: number): number => {\n    if (holder >= count) return fallback\n    const opening = HEADING.exec(line)\n    // A heading underlined with `===` has a depth this scan does not read: it ends at a `---`.\n    if (!opening && !UNDERLINE.test(text.slice(starts[holder]!, endOf(holder)))) return fallback\n    const depth = opening ? opening[1]!.length : 1\n    let end = holder + 1\n    for (; end < count; end += 1) {\n      const next = first(end)\n      if (RULE.test(next)) break\n      const heading = HEADING.exec(next)\n      if (heading && heading[1]!.length < depth) break\n    }\n    return end\n  }\n  /**\n   * The form a piece holds a marker line for, and the piece after everything it governs. A list\n   * form takes the one list right after it; tabs take the sections from the heading right after\n   * them up to a shallower heading, a `---` or the end. The marker is a quote of its own, on any\n   * line of the piece: on the last, what it governs is the next piece. A marker whose quote goes\n   * on (`> [!PROS]\\n> - a`) holds its own content. Of several markers, the one that reaches\n   * furthest decides.\n   */\n  const form = (piece: number): { kind: ContainerKind; end: number } | null => {\n    if (piece >= count) return null\n    const body = text.slice(starts[piece]!, endOf(piece)).trimEnd()\n    if (!body.includes('[!')) return null\n    const lines = body.split('\\n')\n    let found: { kind: ContainerKind; end: number } | null = null\n    for (let index = 0; index < lines.length; index += 1) {\n      const kind = kindOf(lines[index]!)\n      // The marker opens its quote: the line above it is not of the same quote.\n      if (!kind || (index > 0 && QUOTE.test(lines[index - 1]!))) continue\n      const next = lines[index + 1]\n      let end = piece + 1\n      if (next === undefined) {\n        if (kind === 'tabs') end = tabsEnd(piece + 1, first(piece + 1), piece + 1)\n        else if (isItem(first(piece + 1))) end = piece + 2\n      } else if (kind === 'tabs' && !QUOTE.test(next)) end = tabsEnd(piece, next, piece + 1)\n      const reach: number = found ? found.end : 0\n      found = { kind, end: Math.max(end, reach) }\n    }\n    return found\n  }\n\n  const blocks: number[] = []\n  let piece = 0\n  while (piece < count) {\n    const from = piece\n    const found = form(piece)\n    piece = found ? found.end : piece + 1\n\n    // A pros right before a cons (or the reverse) is set as one pair.\n    if (found && (found.kind === 'pros' || found.kind === 'cons')) {\n      const other = form(piece)\n      if (other && other.kind === (found.kind === 'pros' ? 'cons' : 'pros')) piece = other.end\n    }\n\n    // An image alone in its paragraph takes the emphasis line under it as its caption. Merging is\n    // always safe (it is what one parse does anyway), so the test here can be loose.\n    if (\n      piece === from + 1 &&\n      piece < count &&\n      IMAGE_ONLY.test(text.slice(starts[from]!, endOf(from)).trim()) &&\n      /^[*_]/.test(first(piece).trimStart())\n    )\n      piece += 1\n\n    // An HTML block whose tag closes further down.\n    while (piece < count && htmlOpen(text.slice(starts[from]!, starts[piece]!))) piece += 1\n\n    blocks.push(starts[from]!)\n  }\n  return blocks\n}\n\n/**\n * Line endings as the scan reads them: `\\r\\n` and `\\r` become `\\n`. Offsets of the blocks are into\n * the normalized text, which is what the renderer draws from.\n */\nexport const normalizeLineEndings = (markdown: string): string =>\n  markdown.includes('\\r') ? markdown.replace(/\\r\\n?/g, '\\n') : markdown\n\n/** Blocks that are one fenced code block and nothing else: no prose, HTML, math or heading. */\nconst fenced = new WeakSet<MarkdownBlock>()\n\n/** Whether the splitter cut this block as one fenced code block. */\nexport const isFenceBlock = (block: MarkdownBlock): boolean => fenced.has(block)\n\n/** The scan after a complete line: the next text can go on from there. */\ninterface Mark {\n  /** The offset after that line. */\n  at: number\n  scan: Scan\n  /** How many pieces had been cut by then. */\n  count: number\n}\n\n/** Where a scan can be resumed. */\ninterface Progress {\n  /** Where the scan started: the end of the blocks kept as final. */\n  from: number\n  /** The pieces cut up to the last mark, `from` first. */\n  starts: number[]\n  /**\n   * The scan after each of the last complete lines, oldest first. Several, because a healed\n   * stream rewrites its end: the fence it closes or the row it drops is a line that the next\n   * update does not have, and the scan then goes on from the line before.\n   */\n  marks: Mark[]\n}\n\nconst MARKS = 3\n\n/**\n * The pieces of `text` from `from` on: the offsets where the scan cut, or null when a definition\n * keeps the document whole. `progress` and `mark` are where an earlier scan of the same start\n * can go on from.\n */\nfunction pieces(\n  text: string,\n  from: number,\n  progress: Progress | null,\n  mark: Mark | null,\n): { starts: number[]; progress: Progress; mixed: boolean } | null {\n  const scan = mark ? { ...mark.scan } : start()\n  const starts = progress && mark ? progress.starts.slice(0, mark.count) : [from]\n  const marks = progress && mark ? progress.marks.filter((kept) => kept.at <= mark.at) : []\n  let at = mark ? mark.at : from\n  // Marks are left after the last complete lines only.\n  let marked = text.length\n  for (let back = 0; back < MARKS && marked > at; back += 1)\n    marked = text.lastIndexOf('\\n', marked - 1)\n  for (let end = text.indexOf('\\n', at); end !== -1; end = text.indexOf('\\n', at)) {\n    if (step(scan, text.slice(at, end)) && at > from) starts.push(at)\n    at = end + 1\n    if (end >= marked) marks.push({ at, scan: { ...scan }, count: starts.length })\n  }\n  const next: Progress = { from, starts: [...starts], marks: marks.slice(-MARKS) }\n  // The last line is still being written: read, but not remembered.\n  if (at < text.length && step(scan, text.slice(at)) && at > from) starts.push(at)\n  return scan.whole ? null : { starts, progress: next, mixed: scan.mixed }\n}\n\n/** The blocks of `text` that the pieces at `cuts` make, the first on line `line`. */\nfunction build(\n  text: string,\n  cuts: readonly number[],\n  line: number,\n  mixed: boolean,\n): MarkdownBlock[] {\n  const starts = group(text, cuts)\n  const blocks: MarkdownBlock[] = []\n  let current = line\n  let piece = 0\n  for (let index = 0; index < starts.length; index += 1) {\n    const offset = starts[index]!\n    const end = starts[index + 1] ?? text.length\n    const source = text.slice(offset, end)\n    const block = { source, offset, line: current }\n    while (cuts[piece]! < offset) piece += 1\n    // One piece that opens with a fence line is that fence and the blank lines after it: the scan\n    // cuts before a top-level fence and after the line that closes it.\n    // (When the scan got stuck after a fence, the last piece holds more than that fence.)\n    if ((cuts[piece + 1] ?? text.length) === end && !(mixed && end === text.length)) {\n      const opening = FENCE.exec(lineAt(text, offset))\n      if (opening && !(opening[1]![0] === '`' && opening[2]!.includes('`'))) fenced.add(block)\n    }\n    blocks.push(block)\n    // The last block's lines place nothing: a fence that grows is not counted on every token.\n    if (index + 1 === starts.length) break\n    for (let at = source.indexOf('\\n'); at !== -1; at = source.indexOf('\\n', at + 1)) current += 1\n  }\n  return blocks\n}\n\n/** The top-level blocks of a document, cut where one parse of the whole would not join them. */\nexport function splitBlocks(input: string): MarkdownBlock[] {\n  const markdown = normalizeLineEndings(input)\n  if (!markdown) return whole(markdown)\n  const cut = pieces(markdown, 0, null, null)\n  return cut ? build(markdown, cut.starts, 1, cut.mixed) : whole(markdown)\n}\n\n/**\n * How many blocks at the end are read again. Text appended to a document can change only the\n * group it is appended to, and that group can join the one before it (a `[!CONS]` arriving\n * under a `[!PROS]`); every group above those two is final.\n */\nconst REOPENED = 2\n\nexport interface BlockSplitter {\n  /** The same blocks as `splitBlocks(markdown)`; the ones that did not change are the same objects. */\n  split(markdown: string): MarkdownBlock[]\n  /** Characters scanned so far: the work the splitter has done. */\n  readonly lexed: number\n}\n\n/**\n * `splitBlocks` for a document that grows at its end, as a streaming reply does. It remembers the\n * blocks it cut last time and where its scan stopped: when the new text still starts with all of\n * them but the last two, it keeps those, as the very same objects, and scans only the lines that\n * are new. Any other text (a reply that was regenerated, or edited above its end) is split afresh.\n * Each update then costs the new characters, not the reply: a stream is linear in its length.\n */\nexport function createBlockSplitter(): BlockSplitter {\n  let text = ''\n  let blocks: MarkdownBlock[] = []\n  let progress: Progress | null = null\n  let lexed = 0\n\n  return {\n    get lexed() {\n      return lexed\n    },\n    split(input) {\n      const markdown = normalizeLineEndings(input)\n      if (!markdown) {\n        text = ''\n        blocks = []\n        progress = null\n        return whole(markdown)\n      }\n      let kept = blocks.slice(0, Math.max(0, blocks.length - REOPENED))\n      let last = kept.at(-1)\n      let from = last ? last.offset + last.source.length : 0\n      if (from > 0 && !continues(markdown, text, from)) {\n        kept = []\n        last = undefined\n        from = 0\n      }\n      // The scan goes on from the last line it read that is still there, when it started at the\n      // same place.\n      let mark: Mark | null = null\n      if (progress !== null && progress.from === from) {\n        for (let index = progress.marks.length - 1; index >= 0 && !mark; index -= 1) {\n          const tried = progress.marks[index]!\n          if (continues(markdown, text, tried.at, from)) mark = tried\n        }\n      }\n      lexed += markdown.length - (mark ? mark.at : from)\n      const cut = pieces(markdown, from, mark ? progress : null, mark)\n      text = markdown\n      if (!cut) {\n        // A definition arrived: what was cut before it is one block with it now.\n        blocks = []\n        progress = null\n        return whole(markdown)\n      }\n      progress = cut.progress\n      let line = 1\n      if (last) {\n        line = last.line\n        for (let at = last.source.indexOf('\\n'); at !== -1; at = last.source.indexOf('\\n', at + 1))\n          line += 1\n      }\n      const rest = build(markdown, cut.starts, line, cut.mixed)\n      // A block that reads the same as last time is the same object, with what was worked out\n      // from it.\n      for (let index = 0; index < rest.length; index += 1) {\n        const before = blocks[kept.length + index]\n        const after = rest[index]!\n        if (before && before.offset === after.offset && before.source === after.source) {\n          rest[index] = before\n        }\n      }\n      blocks = [...kept, ...rest]\n      return blocks\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/core/bounded-cache.js

@@ -0,0 +1,42 @@
+// src/core/bounded-cache.ts
+function createBoundedCache({ maxEntries, maxWeight = Number.POSITIVE_INFINITY, weigh = () => 0 }) {
+	const entries = /* @__PURE__ */ new Map();
+	let total = 0;
+	const remove = (key) => {
+		const entry = entries.get(key);
+		if (!entry) return;
+		total -= entry.weight;
+		entries.delete(key);
+	};
+	return {
+		get(key) {
+			const entry = entries.get(key);
+			if (!entry) return void 0;
+			entries.delete(key);
+			entries.set(key, entry);
+			return entry.value;
+		},
+		set(key, value) {
+			remove(key);
+			const weight = weigh(value, key);
+			if (weight > maxWeight) return false;
+			entries.set(key, {
+				value,
+				weight
+			});
+			total += weight;
+			while (entries.size > maxEntries || total > maxWeight) {
+				const oldest = entries.keys().next();
+				if (oldest.done) break;
+				remove(oldest.value);
+			}
+			return entries.has(key);
+		},
+		get size() {
+			return entries.size;
+		}
+	};
+}
+export { createBoundedCache };
+
+//# sourceMappingURL=bounded-cache.js.map

package/dist/core/bounded-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-cache.js","names":[],"sources":["../../src/core/bounded-cache.ts"],"sourcesContent":["/**\n * A least-recently-used cache bounded by entry count and by total weight.\n *\n * Typeset formulas and drawn diagrams are kept for the life of the page, so a long chat does not\n * pay KaTeX or Mermaid again when a message scrolls back into view. Both are bounded by weight as\n * well as count: one big entity diagram is hundreds of kilobytes of SVG, so a count alone would\n * not bound the heap.\n *\n * `Map` insertion order is the recency queue: a hit is re-inserted at the tail, and eviction takes\n * from the head. A value heavier than the whole budget is not stored, so it cannot flush every\n * small entry on its way in.\n */\nexport interface BoundedCache<K, V> {\n  get(key: K): V | undefined\n  set(key: K, value: V): boolean\n  readonly size: number\n}\n\nexport interface BoundedCacheOptions<K, V> {\n  maxEntries: number\n  maxWeight?: number\n  weigh?: (value: V, key: K) => number\n}\n\nexport function createBoundedCache<K, V>({\n  maxEntries,\n  maxWeight = Number.POSITIVE_INFINITY,\n  weigh = () => 0,\n}: BoundedCacheOptions<K, V>): BoundedCache<K, V> {\n  const entries = new Map<K, { value: V; weight: number }>()\n  let total = 0\n\n  const remove = (key: K) => {\n    const entry = entries.get(key)\n    if (!entry) return\n    total -= entry.weight\n    entries.delete(key)\n  }\n\n  return {\n    get(key) {\n      const entry = entries.get(key)\n      if (!entry) return undefined\n      entries.delete(key)\n      entries.set(key, entry)\n      return entry.value\n    },\n    set(key, value) {\n      remove(key)\n      const weight = weigh(value, key)\n      if (weight > maxWeight) return false\n      entries.set(key, { value, weight })\n      total += weight\n      // oxlint-disable-next-line no-unmodified-loop-condition -- `remove` lowers `total`.\n      while (entries.size > maxEntries || total > maxWeight) {\n        const oldest = entries.keys().next()\n        if (oldest.done) break\n        remove(oldest.value)\n      }\n      return entries.has(key)\n    },\n    get size() {\n      return entries.size\n    },\n  }\n}\n"],"mappings":";AAwBA,SAAgB,mBAAyB,EACvC,YACA,YAAY,OAAO,mBACnB,cAAc,KACkC;CAChD,MAAM,0BAAU,IAAI,IAAqC;CACzD,IAAI,QAAQ;CAEZ,MAAM,UAAU,QAAW;EACzB,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,IAAI,CAAC,OAAO;EACZ,SAAS,MAAM;EACf,QAAQ,OAAO,GAAG;CACpB;CAEA,OAAO;EACL,IAAI,KAAK;GACP,MAAM,QAAQ,QAAQ,IAAI,GAAG;GAC7B,IAAI,CAAC,OAAO,OAAO,KAAA;GACnB,QAAQ,OAAO,GAAG;GAClB,QAAQ,IAAI,KAAK,KAAK;GACtB,OAAO,MAAM;EACf;EACA,IAAI,KAAK,OAAO;GACd,OAAO,GAAG;GACV,MAAM,SAAS,MAAM,OAAO,GAAG;GAC/B,IAAI,SAAS,WAAW,OAAO;GAC/B,QAAQ,IAAI,KAAK;IAAE;IAAO;GAAO,CAAC;GAClC,SAAS;GAET,OAAO,QAAQ,OAAO,cAAc,QAAQ,WAAW;IACrD,MAAM,SAAS,QAAQ,KAAK,CAAC,CAAC,KAAK;IACnC,IAAI,OAAO,MAAM;IACjB,OAAO,OAAO,KAAK;GACrB;GACA,OAAO,QAAQ,IAAI,GAAG;EACxB;EACA,IAAI,OAAO;GACT,OAAO,QAAQ;EACjB;CACF;AACF"}

package/dist/core/continues.js

@@ -0,0 +1,15 @@
+// src/core/continues.ts
+/**
+* Whether `next` holds what `previous` held from `from` up to `upTo`: the question every part that
+* remembers a growing text asks on each token, before it goes on from where it stopped.
+*
+* It is asked with `===` on two slices, not with `startsWith`. The two say the same, but V8
+* (Chrome, Edge, Node) compares the slices as memory and walks `startsWith` a character at a
+* time: on a 35 KB reply that is one microsecond against seventy, on every token.
+*
+* `upTo` is a place inside `previous`; past its end the answer is no, and the caller starts over.
+*/
+const continues = (next, previous, upTo, from = 0) => next.length >= upTo && next.slice(from, upTo) === previous.slice(from, upTo);
+export { continues };
+
+//# sourceMappingURL=continues.js.map

package/dist/core/continues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"continues.js","names":[],"sources":["../../src/core/continues.ts"],"sourcesContent":["/**\n * Whether `next` holds what `previous` held from `from` up to `upTo`: the question every part that\n * remembers a growing text asks on each token, before it goes on from where it stopped.\n *\n * It is asked with `===` on two slices, not with `startsWith`. The two say the same, but V8\n * (Chrome, Edge, Node) compares the slices as memory and walks `startsWith` a character at a\n * time: on a 35 KB reply that is one microsecond against seventy, on every token.\n *\n * `upTo` is a place inside `previous`; past its end the answer is no, and the caller starts over.\n */\nexport const continues = (next: string, previous: string, upTo: number, from = 0): boolean =>\n  next.length >= upTo && next.slice(from, upTo) === previous.slice(from, upTo)\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,aAAa,MAAc,UAAkB,MAAc,OAAO,MAC7E,KAAK,UAAU,QAAQ,KAAK,MAAM,MAAM,IAAI,MAAM,SAAS,MAAM,MAAM,IAAI"}

package/dist/core/dollars.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Whether the `$` at `index` is a dollar sign by its own look: a price or a shell variable. A `$`
+ * that pairs with no other (`$ x`, the shell line `$(seq 1 12) … $i`) is text as well, but that
+ * takes the whole paragraph to tell: `literalDollars` asks both.
+ */
+export declare function isLiteralDollar(text: string, index: number): boolean;
+/**
+ * The source with every dollar in prose that is not a delimiter escaped (`\$`), so a parser
+ * that pairs any two dollars (remark-math) reads the same formulas `<Markdown>` does. Code is left
+ * byte for byte.
+ */
+export declare function escapeLiteralDollars(markdown: string): string;