@copilotkit/markdown 0.0.1 → 2.0.0-rc.12

package/dist/index.mjs

@@ -0,0 +1,2018 @@
+//#region src/parser/helpers.ts
+/**
+* Default parser options for streaming markdown.
+*/
+const DEFAULT_OPTIONS = {
+	segmenter: true,
+	enableTables: true,
+	enableAutolinks: true
+};
+/**
+* Merges user-provided parser options with defaults.
+*
+* @param options - Optional partial parser options.
+* @returns Fully populated parser options.
+*/
+function normalizeOptions(options) {
+	return {
+		segmenter: options?.segmenter ?? DEFAULT_OPTIONS.segmenter,
+		enableTables: options?.enableTables ?? DEFAULT_OPTIONS.enableTables,
+		enableAutolinks: options?.enableAutolinks ?? DEFAULT_OPTIONS.enableAutolinks
+	};
+}
+/**
+* Normalizes streaming input chunks by handling trailing carriage-return boundaries.
+*
+* @param chunk - Incoming raw chunk.
+* @param hadPendingCR - Whether the previous chunk ended with `\\r`.
+* @returns Normalized text and whether this chunk now ends with a pending `\\r`.
+*/
+function normalizeChunk(chunk, hadPendingCR) {
+	const input = (hadPendingCR ? "\r" : "") + chunk;
+	const pendingCarriageReturn = input.endsWith("\r");
+	return {
+		text: (pendingCarriageReturn ? input.slice(0, -1) : input).replace(/\r\n?/g, "\n"),
+		pendingCarriageReturn
+	};
+}
+/**
+* Splits normalized source text into lines with source offsets.
+*
+* @param source - Normalized source text.
+* @returns Line descriptors preserving absolute ranges.
+*/
+function splitLines(source) {
+	const lines = [];
+	let start = 0;
+	for (let i = 0; i < source.length; i += 1) {
+		if (source[i] !== "\n") continue;
+		lines.push({
+			text: source.slice(start, i),
+			start,
+			end: i + 1,
+			hasNewline: true
+		});
+		start = i + 1;
+	}
+	if (start < source.length || source.length === 0) lines.push({
+		text: source.slice(start),
+		start,
+		end: source.length,
+		hasNewline: false
+	});
+	return lines;
+}
+/**
+* Returns the trailing unterminated line text.
+*
+* @param source - Full source text.
+* @returns Last line content after the final newline.
+*/
+function getLineBuffer(source) {
+	const newline = source.lastIndexOf("\n");
+	return newline < 0 ? source : source.slice(newline + 1);
+}
+/**
+* Converts an absolute source index to 1-based line/column.
+*
+* @param source - Source text.
+* @param index - Absolute index.
+* @returns 1-based line and column coordinates.
+*/
+function toLineColumn(source, index) {
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < index; i += 1) if (source[i] === "\n") {
+		line += 1;
+		column = 1;
+	} else column += 1;
+	return {
+		line,
+		column
+	};
+}
+/**
+* Returns true for blank lines.
+*/
+function isBlank(value) {
+	return /^\s*$/.test(value);
+}
+/**
+* Returns true when a line is a citation definition.
+*/
+function isCitationDefinitionLine(value) {
+	return /^\s{0,3}\[\^([^\]\s]+)\]:\s*(.*)$/.test(value);
+}
+/**
+* Returns true when a line is an unfinished citation-definition prefix candidate.
+*
+* This enables optimistic streaming behavior for definition lines that begin with
+* `[^` but are not yet complete enough to classify as either:
+* 1) a valid citation definition, or
+* 2) plain paragraph text.
+*
+* @param value - Raw line text.
+* @param hasNewline - Whether the source line is newline-terminated.
+* @param isComplete - Whether the parser has been finalized.
+*/
+function isCitationDefinitionPrefixCandidate(value, hasNewline, isComplete) {
+	if (hasNewline || isComplete || isCitationDefinitionLine(value)) return false;
+	return /^\s{0,3}\[\^[^\]\s]*$/.test(value) || /^\s{0,3}\[\^[^\]\s]+\]$/.test(value);
+}
+/**
+* Matches an opening fenced code block marker.
+*/
+function matchFenceOpen(value) {
+	const trimmed = value.trimStart();
+	const backtick = /^(`{3,})(.*)$/.exec(trimmed);
+	if (backtick) return {
+		marker: "```",
+		length: backtick[1].length,
+		info: backtick[2].trim()
+	};
+	const tilde = /^(~{3,})(.*)$/.exec(trimmed);
+	if (tilde) return {
+		marker: "~~~",
+		length: tilde[1].length,
+		info: tilde[2].trim()
+	};
+	return null;
+}
+/**
+* Matches a valid fenced code block closing line.
+*/
+function matchFenceClose(value, marker, length) {
+	if (!(marker === "```" ? /^\s*`{3,}\s*$/ : /^\s*~{3,}\s*$/).test(value)) return false;
+	return value.trim().length >= length;
+}
+/**
+* Matches ATX heading syntax and extracts heading metadata.
+*/
+function matchAtxHeading(value) {
+	const match = /^\s{0,3}(#{1,6})[ \t]+(.+?)\s*#*\s*$/.exec(value);
+	if (!match) return null;
+	return {
+		level: match[1].length,
+		text: match[2],
+		contentOffset: value.indexOf(match[2])
+	};
+}
+/**
+* Returns true for setext heading underline lines.
+*/
+function isSetextUnderline(value) {
+	return /^\s{0,3}(=+|-+)\s*$/.test(value);
+}
+/**
+* Returns true for thematic break syntax.
+*/
+function isThematicBreak(value) {
+	return /^\s{0,3}((\*\s*){3,}|(-\s*){3,}|(_\s*){3,})$/.test(value);
+}
+/**
+* Matches ordered and unordered list-item markers.
+*/
+function matchListItem(value) {
+	const unordered = /^(\s{0,3})([-+*])(\s+)(.*)$/.exec(value);
+	if (unordered) {
+		const indent = unordered[1].length;
+		const contentIndent = indent + unordered[2].length + unordered[3].length;
+		return {
+			ordered: false,
+			start: 1,
+			content: unordered[4],
+			indent,
+			contentIndent
+		};
+	}
+	const ordered = /^(\s{0,3})(\d{1,9})([.)])(\s+)(.*)$/.exec(value);
+	if (ordered) {
+		const indent = ordered[1].length;
+		const contentIndent = indent + (ordered[2].length + ordered[3].length) + ordered[4].length;
+		return {
+			ordered: true,
+			start: Number(ordered[2]),
+			content: ordered[5],
+			indent,
+			contentIndent
+		};
+	}
+	return null;
+}
+/**
+* Returns true for blockquote marker lines.
+*/
+function isBlockquoteLine(value) {
+	return /^\s{0,3}>\s?/.test(value);
+}
+/**
+* Returns true when two lines form a GFM table header + divider pair.
+*/
+function isPipeTableHeader(first, second) {
+	return looksLikeTableRow(first.text) && isTableDividerRow(second.text);
+}
+/**
+* Returns true when a line appears to be a table row.
+*/
+function looksLikeTableRow(value) {
+	return value.includes("|") && /\S/.test(value.replace(/\|/g, ""));
+}
+/**
+* Returns true for GFM table divider rows.
+*/
+function isTableDividerRow(value) {
+	const cells = splitTableCells(value);
+	if (cells.length === 0) return false;
+	return cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+/**
+* Splits a pipe-table row into trimmed cell values.
+*/
+function splitTableCells(value) {
+	const trimmed = value.trim();
+	const body = trimmed.startsWith("|") ? trimmed.slice(1) : trimmed;
+	return (body.endsWith("|") ? body.slice(0, -1) : body).split("|").map((cell) => cell.trim());
+}
+/**
+* Converts table divider cells into alignment metadata.
+*/
+function parseTableAlignment(cells) {
+	return cells.map((cell) => {
+		const trimmed = cell.trim();
+		const left = trimmed.startsWith(":");
+		const right = trimmed.endsWith(":");
+		if (left && right) return "center";
+		if (left) return "left";
+		if (right) return "right";
+		return "none";
+	});
+}
+/**
+* Determines whether a line starts a new block construct.
+*/
+function startsNewBlock(lines, index, enableTables) {
+	const line = lines[index].text;
+	return !!matchFenceOpen(line) || !!matchAtxHeading(line) || isThematicBreak(line) || !!matchListItem(line) || isBlockquoteLine(line) || enableTables && index + 1 < lines.length && isPipeTableHeader(lines[index], lines[index + 1]);
+}
+/**
+* Returns true when a character is escapable in CommonMark inline syntax.
+*/
+function isEscapable(ch) {
+	return /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/.test(ch);
+}
+/**
+* Finds the matching closing delimiter for a nested delimiter pair.
+*/
+function findClosing(input, openAt, openChar, closeChar) {
+	let depth = 0;
+	for (let i = openAt; i < input.length; i += 1) {
+		const ch = input[i];
+		if (ch === "\\") {
+			i += 1;
+			continue;
+		}
+		if (ch === openChar) {
+			depth += 1;
+			continue;
+		}
+		if (ch === closeChar) {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+/**
+* Parses a markdown link destination and optional title.
+*/
+function parseLinkDestination(input) {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("<")) {
+		const close = trimmed.indexOf(">");
+		if (close > 0) {
+			const url = trimmed.slice(1, close);
+			const title = parseLinkTitle(trimmed.slice(close + 1).trim());
+			return title ? {
+				url,
+				title
+			} : { url };
+		}
+	}
+	const firstSpace = trimmed.search(/\s/);
+	if (firstSpace < 0) return { url: trimmed };
+	const url = trimmed.slice(0, firstSpace);
+	const title = parseLinkTitle(trimmed.slice(firstSpace).trim());
+	return title ? {
+		url,
+		title
+	} : { url };
+}
+/**
+* Parses CommonMark-style link titles (`\"...\"`, `'...'`, `( ... )`).
+*/
+function parseLinkTitle(input) {
+	if (!input) return;
+	if (input.startsWith("\"") && input.endsWith("\"") || input.startsWith("'") && input.endsWith("'")) return input.slice(1, -1);
+	if (input.startsWith("(") && input.endsWith(")")) return input.slice(1, -1);
+}
+/**
+* Returns true for URL-shaped text supported by autolink detection.
+*/
+function isUrl(value) {
+	return /^(https?:\/\/|www\.)\S+$/.test(value);
+}
+/**
+* Returns true for email-shaped text supported by autolink detection.
+*/
+function isEmail(value) {
+	return /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/.test(value);
+}
+/**
+* Trims punctuation suffixes from autolink candidates.
+*/
+function trimAutolinkTrailingPunctuation(value) {
+	let end = value.length;
+	while (end > 0 && /[.,;:!?]/.test(value[end - 1])) end -= 1;
+	let candidate = value.slice(0, end);
+	if (candidate.endsWith(")")) {
+		const open = (candidate.match(/\(/g) ?? []).length;
+		if ((candidate.match(/\)/g) ?? []).length > open) candidate = candidate.slice(0, -1);
+	}
+	return candidate;
+}
+
+//#endregion
+//#region src/parser/citations.ts
+/**
+* Extracts citation definitions from source text.
+*
+* @param source - Full normalized markdown source.
+* @param warnings - Mutable warning collection for parse diagnostics.
+* @returns Citation state with collected definitions and empty reference order.
+*/
+function parseCitationDefinitions(source) {
+	const definitions = {};
+	const warnings = [];
+	const lines = source.split("\n");
+	let offset = 0;
+	for (const line of lines) {
+		const match = /^\s{0,3}\[\^([^\]\s]+)\]:\s*(.*)$/.exec(line);
+		if (!match) {
+			offset += line.length + 1;
+			continue;
+		}
+		const id = match[1];
+		if (definitions[id]) {
+			warnings.push({
+				code: "invalid_citation_definition",
+				at: offset
+			});
+			offset += line.length + 1;
+			continue;
+		}
+		const extracted = extractTrailingUrl(match[2].trim());
+		definitions[id] = {
+			id,
+			text: extracted.text,
+			...extracted.url ? { url: extracted.url } : {}
+		};
+		offset += line.length + 1;
+	}
+	return {
+		citations: {
+			order: [],
+			numbers: {},
+			definitions
+		},
+		warnings
+	};
+}
+/**
+* Assigns or returns a stable citation number by first-seen inline reference order.
+*
+* @param citations - Citation state that tracks numbering.
+* @param idRef - Citation identifier (without `[^` and `]` markers).
+* @returns Stable numeric citation number.
+*/
+function assignCitationNumber(citations, idRef) {
+	const existing = citations.numbers[idRef];
+	if (typeof existing === "number") return {
+		citations,
+		number: existing
+	};
+	const next = citations.order.length + 1;
+	return {
+		citations: {
+			...citations,
+			order: [...citations.order, idRef],
+			numbers: {
+				...citations.numbers,
+				[idRef]: next
+			}
+		},
+		number: next
+	};
+}
+function extractTrailingUrl(input) {
+	if (!input) return { text: "" };
+	const match = /(?:\s|^)(https?:\/\/\S+|www\.\S+)$/.exec(input);
+	if (!match) return { text: input };
+	return {
+		text: input.slice(0, match.index).trimEnd(),
+		url: match[1]
+	};
+}
+
+//#endregion
+//#region src/parser/segments.ts
+/**
+* Computes parse-time text segments for animation and incremental rendering.
+*
+* @param text - Raw text content for a single text node.
+* @param absoluteStart - Absolute source index where `text` begins.
+* @param context - Parse context containing segmenter options and warning state.
+* @returns Segment list or empty list when segmentation is disabled/unavailable.
+*/
+function createSegments(text, absoluteStart, options) {
+	if (options.segmenter === false) return {
+		segments: [],
+		hasWarnedSegmenterUnavailable: options.hasWarnedSegmenterUnavailable
+	};
+	const segmenterCtor = typeof Intl === "undefined" ? void 0 : Intl.Segmenter;
+	if (!segmenterCtor) {
+		if (!options.hasWarnedSegmenterUnavailable) return {
+			segments: [],
+			warning: {
+				code: "segmenter_unavailable",
+				at: absoluteStart
+			},
+			hasWarnedSegmenterUnavailable: true
+		};
+		return {
+			segments: [],
+			hasWarnedSegmenterUnavailable: true
+		};
+	}
+	const granularity = options.segmenter === true ? "word" : options.segmenter.granularity ?? "word";
+	const segmenter = new segmenterCtor(options.segmenter === true ? void 0 : options.segmenter.locale, { granularity });
+	const segments = [];
+	for (const segment of segmenter.segment(text)) {
+		const segmentText = segment.segment;
+		const start = absoluteStart + segment.index;
+		segments.push({
+			text: segmentText,
+			start,
+			end: start + segmentText.length,
+			kind: granularity,
+			isWhitespace: /^\s+$/.test(segmentText)
+		});
+	}
+	return {
+		segments: clusterPunctuationSegments(segments),
+		hasWarnedSegmenterUnavailable: options.hasWarnedSegmenterUnavailable
+	};
+}
+function clusterPunctuationSegments(segments) {
+	const withClosingAttached = segments.reduce((acc, segment) => {
+		const previous = acc[acc.length - 1];
+		if (previous && !previous.isWhitespace && isClosingPunctuationOnly(segment.text)) {
+			acc[acc.length - 1] = {
+				...previous,
+				text: `${previous.text}${segment.text}`,
+				end: segment.end
+			};
+			return acc;
+		}
+		return [...acc, segment];
+	}, []);
+	const clustered = [];
+	let i = 0;
+	while (i < withClosingAttached.length) {
+		const current = withClosingAttached[i];
+		const next = i + 1 < withClosingAttached.length ? withClosingAttached[i + 1] : null;
+		if (next && !next.isWhitespace && isOpeningPunctuationOnly(current.text)) {
+			clustered.push({
+				...next,
+				text: `${current.text}${next.text}`,
+				start: current.start
+			});
+			i += 2;
+			continue;
+		}
+		clustered.push(current);
+		i += 1;
+	}
+	return clustered;
+}
+function isClosingPunctuationOnly(value) {
+	return isOnlyFromSet(value, CLOSING_PUNCTUATION$1);
+}
+function isOpeningPunctuationOnly(value) {
+	return isOnlyFromSet(value, OPENING_PUNCTUATION);
+}
+function isOnlyFromSet(value, charset) {
+	return value.length > 0 && [...value].every((character) => charset.has(character));
+}
+const CLOSING_PUNCTUATION$1 = new Set([
+	"]",
+	",",
+	".",
+	"!",
+	"?",
+	";",
+	":",
+	"%",
+	")",
+	"}",
+	">",
+	"\"",
+	"'",
+	"、",
+	"。",
+	"，",
+	"．",
+	"！",
+	"？",
+	"：",
+	"；",
+	"％",
+	"）",
+	"］",
+	"｝",
+	"〉",
+	"》",
+	"」",
+	"』",
+	"】",
+	"〕",
+	"〗"
+]);
+const OPENING_PUNCTUATION = new Set([
+	"(",
+	"{",
+	"[",
+	"\"",
+	"'",
+	"〈",
+	"《",
+	"「",
+	"『",
+	"【",
+	"〔",
+	"〖",
+	"（",
+	"［",
+	"｛"
+]);
+
+//#endregion
+//#region src/parser/inline-parser.ts
+/**
+* Parses inline markdown content into inline draft nodes.
+*
+* @param text - Inline source text.
+* @param absoluteStart - Absolute source offset for the first character in `text`.
+* @param path - Stable path prefix for emitted nodes.
+* @param context - Immutable parse context shared across block/inline parsing.
+* @returns Inline draft nodes and updated immutable parser context.
+*/
+function parseInline(text, absoluteStart, path, context) {
+	const nodes = [];
+	let i = 0;
+	let textBuffer = "";
+	let textBufferStart = -1;
+	let citations = context.citations;
+	let warnings = context.warnings;
+	let hasWarnedSegmenterUnavailable = context.hasWarnedSegmenterUnavailable;
+	const flushTextBuffer = () => {
+		if (textBuffer.length === 0 || textBufferStart < 0) return;
+		const appendResult = appendText(nodes, textBuffer, textBufferStart, path, context.options.segmenter, hasWarnedSegmenterUnavailable);
+		warnings = appendResult.warnings.length > 0 ? [...warnings, ...appendResult.warnings] : warnings;
+		hasWarnedSegmenterUnavailable = appendResult.hasWarnedSegmenterUnavailable;
+		textBuffer = "";
+		textBufferStart = -1;
+	};
+	const appendBufferedText = (value, start) => {
+		if (value.length === 0) return;
+		if (textBuffer.length === 0) textBufferStart = start;
+		textBuffer += value;
+	};
+	while (i < text.length) {
+		const current = text[i];
+		if (current === "\n") {
+			const hardByBackslash = countTrailing(text, i - 1, "\\") % 2 === 1;
+			const hardBySpaces = i > 1 && text.slice(i - 2, i) === "  ";
+			const hard = hardByBackslash || hardBySpaces;
+			if (hardByBackslash && textBuffer.endsWith("\\")) textBuffer = textBuffer.slice(0, -1);
+			flushTextBuffer();
+			nodes.push({
+				path: `${path}.${nodes.length}`,
+				type: hard ? "hard-break" : "soft-break",
+				range: {
+					start: absoluteStart + i,
+					end: absoluteStart + i + 1
+				},
+				closed: true,
+				props: {},
+				children: []
+			});
+			i += 1;
+			continue;
+		}
+		if (current === "\\" && i + 1 < text.length && isEscapable(text[i + 1])) {
+			appendBufferedText(text[i + 1], absoluteStart + i);
+			i += 2;
+			continue;
+		}
+		const citation = parseCitationInline(text, i, absoluteStart, path, citations, nodes.length, context.isComplete);
+		if (citation) {
+			flushTextBuffer();
+			nodes.push(citation.node);
+			i = citation.next;
+			citations = citation.citations;
+			continue;
+		}
+		const image = parseImageInline(text, i, absoluteStart, path, nodes.length);
+		if (image) {
+			flushTextBuffer();
+			nodes.push(image.node);
+			i = image.next;
+			continue;
+		}
+		const link = parseLinkInline(text, i, absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable);
+		if (link) {
+			flushTextBuffer();
+			nodes.push(link.node);
+			i = link.next;
+			citations = link.citations;
+			warnings = link.warnings;
+			hasWarnedSegmenterUnavailable = link.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const auto = parseAutolinkInline(text, i, absoluteStart, path, context.options.enableAutolinks, nodes.length);
+		if (auto) {
+			flushTextBuffer();
+			nodes.push(auto.node);
+			i = auto.next;
+			continue;
+		}
+		const code = parseInlineCode(text, i, absoluteStart, path, nodes.length);
+		if (code) {
+			flushTextBuffer();
+			nodes.push(code.node);
+			i = code.next;
+			continue;
+		}
+		const strong = parseDelimitedInline(text, i, "**", "strong", absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable) ?? parseDelimitedInline(text, i, "__", "strong", absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable);
+		if (strong) {
+			flushTextBuffer();
+			nodes.push(strong.node);
+			i = strong.next;
+			citations = strong.citations;
+			warnings = strong.warnings;
+			hasWarnedSegmenterUnavailable = strong.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const strike = parseDelimitedInline(text, i, "~~", "strikethrough", absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable);
+		if (strike) {
+			flushTextBuffer();
+			nodes.push(strike.node);
+			i = strike.next;
+			citations = strike.citations;
+			warnings = strike.warnings;
+			hasWarnedSegmenterUnavailable = strike.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const em = parseDelimitedInline(text, i, "*", "em", absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable) ?? parseDelimitedInline(text, i, "_", "em", absoluteStart, path, nodes.length, context, citations, warnings, hasWarnedSegmenterUnavailable);
+		if (em) {
+			flushTextBuffer();
+			nodes.push(em.node);
+			i = em.next;
+			citations = em.citations;
+			warnings = em.warnings;
+			hasWarnedSegmenterUnavailable = em.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		appendBufferedText(text[i], absoluteStart + i);
+		i += 1;
+	}
+	flushTextBuffer();
+	return {
+		value: annotateNoBreakBeforeSegments(nodes),
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	};
+}
+function countTrailing(text, index, value) {
+	let run = 0;
+	let i = index;
+	while (i >= 0 && text[i] === value) {
+		run += 1;
+		i -= 1;
+	}
+	return run;
+}
+function annotateNoBreakBeforeSegments(nodes) {
+	let changed = false;
+	const next = nodes.map((node, index) => {
+		if (node.type !== "text") return node;
+		const segments = node.props["segments"];
+		if (!Array.isArray(segments) || segments.length === 0) return node;
+		const typedSegments = segments;
+		const firstSegment = typedSegments[0];
+		if (!firstSegment) return node;
+		const previous = index > 0 ? nodes[index - 1] : null;
+		const shouldMark = startsWithClosingPunctuation(firstSegment.text) && shouldPreventBreakBeforeNode(previous);
+		if (shouldMark === (firstSegment.noBreakBefore === true)) return node;
+		const nextSegments = [shouldMark ? {
+			...firstSegment,
+			noBreakBefore: true
+		} : {
+			...firstSegment,
+			noBreakBefore: void 0
+		}, ...typedSegments.slice(1)];
+		changed = true;
+		return {
+			...node,
+			props: {
+				...node.props,
+				segments: nextSegments
+			}
+		};
+	});
+	return changed ? next : nodes;
+}
+function shouldPreventBreakBeforeNode(node) {
+	if (!node) return false;
+	if (node.type === "soft-break" || node.type === "hard-break") return false;
+	if (node.type === "text") {
+		const text = String(node.props["text"] ?? "");
+		if (!text || /\s$/u.test(text)) return false;
+	}
+	return true;
+}
+function startsWithClosingPunctuation(value) {
+	if (!value) return false;
+	const [first] = [...value];
+	return first != null && CLOSING_PUNCTUATION.has(first);
+}
+const CLOSING_PUNCTUATION = new Set([
+	"]",
+	",",
+	".",
+	"!",
+	"?",
+	";",
+	":",
+	"%",
+	")",
+	"}",
+	">",
+	"\"",
+	"'",
+	"、",
+	"。",
+	"，",
+	"．",
+	"！",
+	"？",
+	"：",
+	"；",
+	"％",
+	"）",
+	"］",
+	"｝",
+	"〉",
+	"》",
+	"」",
+	"』",
+	"】",
+	"〕",
+	"〗"
+]);
+function appendText(nodes, text, start, path, segmenter, hasWarnedSegmenterUnavailable) {
+	if (!text) return {
+		warnings: [],
+		hasWarnedSegmenterUnavailable
+	};
+	const segmentation = createSegments(text, start, {
+		segmenter,
+		hasWarnedSegmenterUnavailable
+	});
+	nodes.push({
+		path: `${path}.${nodes.length}`,
+		type: "text",
+		range: {
+			start,
+			end: start + text.length
+		},
+		closed: true,
+		props: {
+			text,
+			segments: segmentation.segments
+		},
+		children: []
+	});
+	return {
+		warnings: segmentation.warning ? [segmentation.warning] : [],
+		hasWarnedSegmenterUnavailable: segmentation.hasWarnedSegmenterUnavailable
+	};
+}
+function parseCitationInline(text, at, start, path, citations, index, isComplete) {
+	if (!text.startsWith("[^", at)) return null;
+	const close = text.indexOf("]", at + 2);
+	if (close >= 0) {
+		const idRef = text.slice(at + 2, close).trim();
+		if (!idRef) return null;
+		const numbered = assignCitationNumber(citations, idRef);
+		return {
+			node: {
+				path: `${path}.${index}`,
+				type: "citation",
+				range: {
+					start: start + at,
+					end: start + close + 1
+				},
+				closed: true,
+				props: {
+					idRef,
+					number: numbered.number
+				},
+				children: []
+			},
+			next: close + 1,
+			citations: numbered.citations
+		};
+	}
+	if (isComplete) return null;
+	const partial = text.slice(at);
+	if (!/^\[\^[^\]\s]+$/u.test(partial)) return null;
+	const partialIdRef = partial.slice(2);
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type: "citation",
+			range: {
+				start: start + at,
+				end: start + text.length
+			},
+			closed: false,
+			props: { idRef: partialIdRef },
+			children: []
+		},
+		next: text.length,
+		citations
+	};
+}
+function parseImageInline(text, at, start, path, index) {
+	if (!text.startsWith("![", at)) return null;
+	const labelEnd = findClosing(text, at + 1, "[", "]");
+	if (labelEnd < 0 || text[labelEnd + 1] !== "(") return null;
+	const destEnd = findClosing(text, labelEnd + 1, "(", ")");
+	if (destEnd < 0) return null;
+	const alt = text.slice(at + 2, labelEnd);
+	const parsed = parseLinkDestination(text.slice(labelEnd + 2, destEnd));
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type: "image",
+			range: {
+				start: start + at,
+				end: start + destEnd + 1
+			},
+			closed: true,
+			props: {
+				url: parsed.url,
+				alt,
+				...parsed.title ? { title: parsed.title } : {}
+			},
+			children: []
+		},
+		next: destEnd + 1
+	};
+}
+function parseLinkInline(text, at, start, path, index, context, citations, warnings, hasWarnedSegmenterUnavailable) {
+	if (text[at] !== "[" || text.startsWith("[^", at)) return null;
+	const labelEnd = findClosing(text, at, "[", "]");
+	if (labelEnd < 0 || text[labelEnd + 1] !== "(") return null;
+	const destEnd = findClosing(text, labelEnd + 1, "(", ")");
+	if (destEnd < 0) return null;
+	const label = text.slice(at + 1, labelEnd);
+	const parsed = parseLinkDestination(text.slice(labelEnd + 2, destEnd));
+	const childResult = parseInline(label, start + at + 1, `${path}.${index}`, {
+		...context,
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	});
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type: "link",
+			range: {
+				start: start + at,
+				end: start + destEnd + 1
+			},
+			closed: true,
+			props: {
+				url: parsed.url,
+				...parsed.title ? { title: parsed.title } : {}
+			},
+			children: childResult.value
+		},
+		next: destEnd + 1,
+		citations: childResult.citations,
+		warnings: childResult.warnings,
+		hasWarnedSegmenterUnavailable: childResult.hasWarnedSegmenterUnavailable
+	};
+}
+function parseAutolinkInline(text, at, start, path, enabled, index) {
+	if (!enabled) return null;
+	if (text[at] === "<") {
+		const close = text.indexOf(">", at + 1);
+		if (close > at + 1) {
+			const value = text.slice(at + 1, close).trim();
+			if (isUrl(value) || isEmail(value)) {
+				const url = isEmail(value) ? `mailto:${value}` : value;
+				return {
+					node: {
+						path: `${path}.${index}`,
+						type: "autolink",
+						range: {
+							start: start + at,
+							end: start + close + 1
+						},
+						closed: true,
+						props: {
+							url,
+							text: value
+						},
+						children: []
+					},
+					next: close + 1
+				};
+			}
+		}
+	}
+	if (!(at === 0 || /\s|[([{"'`]/.test(text[at - 1]))) return null;
+	const match = /^(https?:\/\/\S+|www\.\S+|[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/.exec(text.slice(at));
+	if (!match) return null;
+	const raw = trimAutolinkTrailingPunctuation(match[1]);
+	if (!raw) return null;
+	const url = isEmail(raw) ? `mailto:${raw}` : raw.startsWith("www.") ? `https://${raw}` : raw;
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type: "autolink",
+			range: {
+				start: start + at,
+				end: start + at + raw.length
+			},
+			closed: true,
+			props: {
+				url,
+				text: raw
+			},
+			children: []
+		},
+		next: at + raw.length
+	};
+}
+function parseInlineCode(text, at, start, path, index) {
+	if (text[at] !== "`") return null;
+	let len = 1;
+	while (text[at + len] === "`") len += 1;
+	const delimiter = "`".repeat(len);
+	const close = text.indexOf(delimiter, at + len);
+	if (close < 0) return {
+		node: {
+			path: `${path}.${index}`,
+			type: "inline-code",
+			range: {
+				start: start + at,
+				end: start + text.length
+			},
+			closed: false,
+			props: { text: text.slice(at + len) },
+			children: []
+		},
+		next: text.length
+	};
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type: "inline-code",
+			range: {
+				start: start + at,
+				end: start + close + len
+			},
+			closed: true,
+			props: { text: text.slice(at + len, close) },
+			children: []
+		},
+		next: close + len
+	};
+}
+function parseDelimitedInline(text, at, delimiter, type, start, path, index, context, citations, warnings, hasWarnedSegmenterUnavailable) {
+	if (!text.startsWith(delimiter, at)) return null;
+	const close = text.indexOf(delimiter, at + delimiter.length);
+	if (close < 0) {
+		const children = parseInline(text.slice(at + delimiter.length), start + at + delimiter.length, `${path}.${index}`, {
+			...context,
+			citations,
+			warnings,
+			hasWarnedSegmenterUnavailable
+		});
+		return {
+			node: {
+				path: `${path}.${index}`,
+				type,
+				range: {
+					start: start + at,
+					end: start + text.length
+				},
+				closed: false,
+				props: {},
+				children: children.value
+			},
+			next: text.length,
+			citations: children.citations,
+			warnings: children.warnings,
+			hasWarnedSegmenterUnavailable: children.hasWarnedSegmenterUnavailable
+		};
+	}
+	const children = parseInline(text.slice(at + delimiter.length, close), start + at + delimiter.length, `${path}.${index}`, {
+		...context,
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	});
+	return {
+		node: {
+			path: `${path}.${index}`,
+			type,
+			range: {
+				start: start + at,
+				end: start + close + delimiter.length
+			},
+			closed: true,
+			props: {},
+			children: children.value
+		},
+		next: close + delimiter.length,
+		citations: children.citations,
+		warnings: children.warnings,
+		hasWarnedSegmenterUnavailable: children.hasWarnedSegmenterUnavailable
+	};
+}
+
+//#endregion
+//#region src/parser/block-parser.ts
+/**
+* Parses a contiguous range of source lines into block-level draft nodes.
+*
+* @param lines - Line-split source with offsets.
+* @param from - Inclusive start line index.
+* @param to - Exclusive end line index.
+* @param path - Stable path prefix for emitted nodes.
+* @param context - Shared parse context carrying options, warnings, and citations.
+* @param isRoot - Whether this parse call is for the document root.
+* @returns Root draft node plus updated immutable parse context.
+*/
+function parseBlocks(lines, from, to, path, context, isRoot) {
+	let root = {
+		path,
+		type: "document",
+		range: {
+			start: from < to ? lines[from].start : 0,
+			end: from < to ? lines[to - 1].end : 0
+		},
+		closed: false,
+		props: {},
+		children: []
+	};
+	let i = from;
+	let citations = context.citations;
+	let warnings = context.warnings;
+	let hasWarnedSegmenterUnavailable = context.hasWarnedSegmenterUnavailable;
+	while (i < to) {
+		const line = lines[i];
+		const isCitationDefinition = isCitationDefinitionLine(line.text);
+		const isCitationDefinitionPrefix = isCitationDefinitionPrefixCandidate(line.text, line.hasNewline, context.isComplete);
+		if (isBlank(line.text) || isCitationDefinition || isCitationDefinitionPrefix) {
+			i += 1;
+			continue;
+		}
+		const fenced = matchFenceOpen(line.text);
+		if (fenced) {
+			const nodePath = `${path}.${root.children.length}`;
+			const parsed = parseCodeFence(lines, i, to, nodePath, context, fenced);
+			root.children = [...root.children, parsed.node];
+			i = parsed.next;
+			continue;
+		}
+		if (isBlockquoteLine(line.text)) {
+			const nodePath = `${path}.${root.children.length}`;
+			const parsed = parseBlockquote(lines, i, to, nodePath, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			});
+			root.children = [...root.children, parsed.value];
+			i = parsed.next;
+			citations = parsed.citations;
+			warnings = parsed.warnings;
+			hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const listMarker = matchListItem(line.text);
+		if (listMarker) {
+			const nodePath = `${path}.${root.children.length}`;
+			const parsed = parseList(lines, i, to, nodePath, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			}, listMarker.ordered);
+			root.children = [...root.children, parsed.value];
+			i = parsed.next;
+			citations = parsed.citations;
+			warnings = parsed.warnings;
+			hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const heading = matchAtxHeading(line.text);
+		if (heading) {
+			const nodePath = `${path}.${root.children.length}`;
+			const children = parseInline(heading.text, line.start + heading.contentOffset, nodePath, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			});
+			root.children = [...root.children, {
+				path: nodePath,
+				type: "heading",
+				range: {
+					start: line.start,
+					end: line.end
+				},
+				closed: context.isComplete || line.hasNewline,
+				props: { level: heading.level },
+				children: children.value
+			}];
+			citations = children.citations;
+			warnings = children.warnings;
+			hasWarnedSegmenterUnavailable = children.hasWarnedSegmenterUnavailable;
+			i += 1;
+			continue;
+		}
+		if (i + 1 < to && isSetextUnderline(lines[i + 1].text) && !isBlank(line.text)) {
+			const nodePath = `${path}.${root.children.length}`;
+			const level = lines[i + 1].text.trim().startsWith("=") ? 1 : 2;
+			const children = parseInline(line.text, line.start, nodePath, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			});
+			root.children = [...root.children, {
+				path: nodePath,
+				type: "heading",
+				range: {
+					start: line.start,
+					end: lines[i + 1].end
+				},
+				closed: context.isComplete || lines[i + 1].hasNewline,
+				props: { level },
+				children: children.value
+			}];
+			citations = children.citations;
+			warnings = children.warnings;
+			hasWarnedSegmenterUnavailable = children.hasWarnedSegmenterUnavailable;
+			i += 2;
+			continue;
+		}
+		if (isThematicBreak(line.text)) {
+			root.children = [...root.children, {
+				path: `${path}.${root.children.length}`,
+				type: "thematic-break",
+				range: {
+					start: line.start,
+					end: line.end
+				},
+				closed: true,
+				props: {},
+				children: []
+			}];
+			i += 1;
+			continue;
+		}
+		if (context.options.enableTables && i + 1 < to && isPipeTableHeader(lines[i], lines[i + 1])) {
+			const nodePath = `${path}.${root.children.length}`;
+			const parsed = parsePipeTable(lines, i, to, nodePath, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			});
+			root.children = [...root.children, parsed.value];
+			i = parsed.next;
+			citations = parsed.citations;
+			warnings = parsed.warnings;
+			hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+			continue;
+		}
+		const nodePath = `${path}.${root.children.length}`;
+		const parsed = parseParagraph(lines, i, to, nodePath, {
+			...context,
+			citations,
+			warnings,
+			hasWarnedSegmenterUnavailable
+		});
+		root.children = [...root.children, parsed.value];
+		i = parsed.next;
+		citations = parsed.citations;
+		warnings = parsed.warnings;
+		hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+	}
+	root = {
+		...root,
+		closed: !isRoot || context.isComplete || to > from && lines[to - 1].hasNewline && root.children.every((child) => child.closed)
+	};
+	return {
+		value: root,
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	};
+}
+function parseCodeFence(lines, from, to, path, context, fenceOpen) {
+	let i = from + 1;
+	let closeLine = -1;
+	while (i < to) {
+		if (matchFenceClose(lines[i].text, fenceOpen.marker, fenceOpen.length)) {
+			closeLine = i;
+			break;
+		}
+		i += 1;
+	}
+	const endLine = closeLine >= 0 ? closeLine : to - 1;
+	const text = lines.slice(from + 1, closeLine >= 0 ? closeLine : to).map((line) => line.text).join("\n");
+	const closed = closeLine >= 0 || context.isComplete;
+	return {
+		node: {
+			path,
+			type: "code-block",
+			range: {
+				start: lines[from].start,
+				end: lines[endLine].end
+			},
+			closed,
+			props: {
+				fence: fenceOpen.marker,
+				...fenceOpen.info ? { info: fenceOpen.info.split(/\s+/)[0] } : {},
+				...fenceOpen.info.includes(" ") ? { meta: fenceOpen.info.slice(fenceOpen.info.indexOf(" ") + 1) } : {},
+				text
+			},
+			children: []
+		},
+		next: closeLine >= 0 ? closeLine + 1 : to
+	};
+}
+function parseBlockquote(lines, from, to, path, context) {
+	const picked = [];
+	let i = from;
+	while (i < to) {
+		const line = lines[i];
+		if (isBlank(line.text) && picked.length > 0) {
+			picked.push(line);
+			i += 1;
+			continue;
+		}
+		if (isBlockquoteLine(line.text) || !isBlank(line.text) && picked.length > 0 && !startsNewBlock(lines, i, context.options.enableTables)) {
+			picked.push(line);
+			i += 1;
+			continue;
+		}
+		break;
+	}
+	const stripped = picked.map((line) => {
+		const marker = /^(\s{0,3}>\s?)/.exec(line.text);
+		const markerWidth = marker?.[1].length ?? 0;
+		const text = marker ? line.text.slice(markerWidth) : line.text;
+		const start = line.start + markerWidth;
+		return {
+			text,
+			start,
+			end: start + text.length,
+			hasNewline: line.hasNewline
+		};
+	});
+	const children = parseBlocks(stripped, 0, stripped.length, path, context, false);
+	return {
+		value: {
+			path,
+			type: "blockquote",
+			range: {
+				start: picked[0].start,
+				end: picked[picked.length - 1].end
+			},
+			closed: context.isComplete || picked[picked.length - 1].hasNewline,
+			props: {},
+			children: children.value.children
+		},
+		next: i,
+		citations: children.citations,
+		warnings: children.warnings,
+		hasWarnedSegmenterUnavailable: children.hasWarnedSegmenterUnavailable
+	};
+}
+function parseList(lines, from, to, path, context, ordered) {
+	const items = [];
+	let i = from;
+	let sawBlankBetweenItems = false;
+	let listStartNumber = null;
+	let citations = context.citations;
+	let warnings = context.warnings;
+	let hasWarnedSegmenterUnavailable = context.hasWarnedSegmenterUnavailable;
+	while (i < to) {
+		const marker = matchListItem(lines[i].text);
+		if (!marker || marker.ordered !== ordered) break;
+		if (ordered && listStartNumber === null) listStartNumber = marker.start;
+		const contentLines = [{
+			...lines[i],
+			text: marker.content
+		}];
+		const contentIndent = marker.contentIndent;
+		i += 1;
+		let hadBlank = false;
+		while (i < to) {
+			const next = lines[i];
+			if (matchListItem(next.text)) break;
+			if (isBlank(next.text)) {
+				hadBlank = true;
+				contentLines.push(next);
+				i += 1;
+				if (i < to) {
+					if (matchListItem(lines[i].text)) {
+						sawBlankBetweenItems = true;
+						break;
+					}
+				}
+				continue;
+			}
+			if ((/^\s*/.exec(next.text)?.[0].length ?? 0) < contentIndent) break;
+			const continuation = next.text.slice(contentIndent);
+			contentLines.push({
+				...next,
+				text: continuation
+			});
+			i += 1;
+		}
+		const paragraphText = contentLines.map((line) => line.text).join("\n").trimEnd();
+		const itemPath = `${path}.${items.length}`;
+		const parsedInline = parseInline(paragraphText, contentLines[0].start, `${itemPath}.0`, {
+			...context,
+			citations,
+			warnings,
+			hasWarnedSegmenterUnavailable
+		});
+		const paragraph = {
+			path: `${itemPath}.0`,
+			type: "paragraph",
+			range: {
+				start: contentLines[0].start,
+				end: contentLines[contentLines.length - 1].end
+			},
+			closed: context.isComplete || contentLines[contentLines.length - 1].hasNewline,
+			props: {},
+			children: parsedInline.value
+		};
+		items.push({
+			path: itemPath,
+			type: "list-item",
+			range: {
+				start: contentLines[0].start,
+				end: contentLines[contentLines.length - 1].end
+			},
+			closed: context.isComplete || contentLines[contentLines.length - 1].hasNewline,
+			props: {},
+			children: [paragraph]
+		});
+		citations = parsedInline.citations;
+		warnings = parsedInline.warnings;
+		hasWarnedSegmenterUnavailable = parsedInline.hasWarnedSegmenterUnavailable;
+		if (hadBlank) sawBlankBetweenItems = true;
+	}
+	return {
+		value: {
+			path,
+			type: "list",
+			range: {
+				start: lines[from].start,
+				end: lines[Math.max(from, i - 1)].end
+			},
+			closed: context.isComplete || lines[Math.max(from, i - 1)].hasNewline,
+			props: {
+				ordered,
+				start: ordered ? listStartNumber ?? 1 : null,
+				tight: !sawBlankBetweenItems
+			},
+			children: items
+		},
+		next: i,
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	};
+}
+function parsePipeTable(lines, from, to, path, context) {
+	const header = splitTableCells(lines[from].text);
+	const align = parseTableAlignment(splitTableCells(lines[from + 1].text));
+	const rows = [];
+	let i = from + 2;
+	while (i < to && looksLikeTableRow(lines[i].text)) {
+		rows.push(splitTableCells(lines[i].text));
+		i += 1;
+	}
+	let citations = context.citations;
+	let warnings = context.warnings;
+	let hasWarnedSegmenterUnavailable = context.hasWarnedSegmenterUnavailable;
+	const headerChildren = [];
+	for (let cellIndex = 0; cellIndex < header.length; cellIndex += 1) {
+		const parsed = parseInline(header[cellIndex], lines[from].start, `${path}.0.${cellIndex}`, {
+			...context,
+			citations,
+			warnings,
+			hasWarnedSegmenterUnavailable
+		});
+		headerChildren.push({
+			path: `${path}.0.${cellIndex}`,
+			type: "table-cell",
+			range: {
+				start: lines[from].start,
+				end: lines[from].end
+			},
+			closed: true,
+			props: {},
+			children: parsed.value
+		});
+		citations = parsed.citations;
+		warnings = parsed.warnings;
+		hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+	}
+	const headerRow = {
+		path: `${path}.0`,
+		type: "table-row",
+		range: {
+			start: lines[from].start,
+			end: lines[from].end
+		},
+		closed: true,
+		props: { isHeader: true },
+		children: headerChildren
+	};
+	const bodyRows = [];
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+		const row = rows[rowIndex];
+		const cellNodes = [];
+		for (let cellIndex = 0; cellIndex < row.length; cellIndex += 1) {
+			const parsed = parseInline(row[cellIndex], lines[from + 2 + rowIndex].start, `${path}.${rowIndex + 1}.${cellIndex}`, {
+				...context,
+				citations,
+				warnings,
+				hasWarnedSegmenterUnavailable
+			});
+			cellNodes.push({
+				path: `${path}.${rowIndex + 1}.${cellIndex}`,
+				type: "table-cell",
+				range: {
+					start: lines[from + 2 + rowIndex].start,
+					end: lines[from + 2 + rowIndex].end
+				},
+				closed: true,
+				props: {},
+				children: parsed.value
+			});
+			citations = parsed.citations;
+			warnings = parsed.warnings;
+			hasWarnedSegmenterUnavailable = parsed.hasWarnedSegmenterUnavailable;
+		}
+		bodyRows.push({
+			path: `${path}.${rowIndex + 1}`,
+			type: "table-row",
+			range: {
+				start: lines[from + 2 + rowIndex].start,
+				end: lines[from + 2 + rowIndex].end
+			},
+			closed: true,
+			props: { isHeader: false },
+			children: cellNodes
+		});
+	}
+	return {
+		value: {
+			path,
+			type: "table",
+			range: {
+				start: lines[from].start,
+				end: lines[i - 1].end
+			},
+			closed: context.isComplete || lines[i - 1].hasNewline,
+			props: { align },
+			children: [headerRow, ...bodyRows]
+		},
+		next: i,
+		citations,
+		warnings,
+		hasWarnedSegmenterUnavailable
+	};
+}
+function parseParagraph(lines, from, to, path, context) {
+	const picked = [];
+	let i = from;
+	while (i < to) {
+		if (isBlank(lines[i].text)) break;
+		if (picked.length > 0 && startsNewBlock(lines, i, context.options.enableTables)) break;
+		if (isCitationDefinitionLine(lines[i].text) || isCitationDefinitionPrefixCandidate(lines[i].text, lines[i].hasNewline, context.isComplete)) break;
+		picked.push(lines[i]);
+		i += 1;
+	}
+	const children = parseInline(picked.map((line) => line.text).join("\n"), picked[0].start, path, context);
+	return {
+		value: {
+			path,
+			type: "paragraph",
+			range: {
+				start: picked[0].start,
+				end: picked[picked.length - 1].end
+			},
+			closed: context.isComplete || picked[picked.length - 1].hasNewline,
+			props: {},
+			children: children.value
+		},
+		next: i,
+		citations: children.citations,
+		warnings: children.warnings,
+		hasWarnedSegmenterUnavailable: children.hasWarnedSegmenterUnavailable
+	};
+}
+
+//#endregion
+//#region src/parser/ops.ts
+/**
+* Flattens a draft tree into reducer operations.
+*
+* @param root - Draft AST root.
+* @returns Ordered operations for reducer application.
+*/
+function createAstOpsFromDraft(root) {
+	const ops = [];
+	function visit(node, parentPath) {
+		const childPaths = node.children.map((child, index) => `${node.path}.${index}`);
+		ops.push({
+			kind: "upsert-node",
+			path: node.path,
+			parentPath,
+			type: node.type,
+			range: node.range,
+			closed: node.closed,
+			props: node.props,
+			childPaths
+		});
+		for (let index = 0; index < node.children.length; index += 1) {
+			const child = node.children[index];
+			visit({
+				...child,
+				path: `${node.path}.${index}`
+			}, node.path);
+		}
+	}
+	visit(root, null);
+	return ops;
+}
+/**
+* Applies AST ops with identity reuse for unchanged nodes.
+*
+* @param input - Previous parser state fragments and ops to apply.
+* @returns Next materialized state fragments.
+*/
+function applyAstOps(input) {
+	const previousNodeById = new Map(input.previousNodes.map((node) => [node.id, node]));
+	const nodeOps = input.ops.filter((op) => op.kind === "upsert-node");
+	const pathToId = {};
+	let nextId = input.nextId;
+	for (const op of nodeOps) {
+		const id = input.previousPathToId[op.path] ?? nextId++;
+		pathToId[op.path] = id;
+	}
+	const nodesById = /* @__PURE__ */ new Map();
+	for (const op of nodeOps) {
+		const id = pathToId[op.path];
+		const materialized = opToAstNode(op, id, op.parentPath ? pathToId[op.parentPath] : null, op.childPaths.map((childPath) => pathToId[childPath]));
+		const previous = previousNodeById.get(id);
+		const reconciled = previous?.type === "text" && materialized.type === "text" ? reconcileTextNode(previous, materialized) : materialized;
+		nodesById.set(id, previous && astNodeEquals(previous, reconciled) ? previous : reconciled);
+	}
+	const rootPath = nodeOps[0]?.path;
+	if (!rootPath) throw new Error("StreamingMarkdown op stream did not include a root node");
+	const warnings = input.ops.find((op) => op.kind === "set-warnings")?.warnings ?? [];
+	const citations = input.ops.find((op) => op.kind === "set-citations")?.citations ?? {
+		order: [],
+		numbers: {},
+		definitions: {}
+	};
+	const hasWarnedSegmenterUnavailable = input.ops.find((op) => op.kind === "set-segmenter-warning-state")?.hasWarnedSegmenterUnavailable ?? false;
+	return {
+		nodes: Array.from(nodesById.values()).sort((a, b) => a.id - b.id),
+		rootId: pathToId[rootPath],
+		nextId,
+		pathToId,
+		warnings,
+		citations,
+		hasWarnedSegmenterUnavailable
+	};
+}
+function opToAstNode(op, id, parentId, children) {
+	const base = {
+		id,
+		type: op.type,
+		parentId,
+		closed: op.closed,
+		range: op.range
+	};
+	switch (op.type) {
+		case "document": return {
+			...base,
+			type: "document",
+			children
+		};
+		case "paragraph": return {
+			...base,
+			type: "paragraph",
+			children
+		};
+		case "heading": return {
+			...base,
+			type: "heading",
+			level: op.props["level"],
+			children
+		};
+		case "blockquote": return {
+			...base,
+			type: "blockquote",
+			children
+		};
+		case "list": return {
+			...base,
+			type: "list",
+			ordered: op.props["ordered"],
+			start: op.props["start"],
+			tight: op.props["tight"],
+			children
+		};
+		case "list-item": return {
+			...base,
+			type: "list-item",
+			children
+		};
+		case "code-block": return {
+			...base,
+			type: "code-block",
+			fence: op.props["fence"],
+			info: op.props["info"],
+			meta: op.props["meta"],
+			text: op.props["text"]
+		};
+		case "table": return {
+			...base,
+			type: "table",
+			align: op.props["align"],
+			children
+		};
+		case "table-row": return {
+			...base,
+			type: "table-row",
+			isHeader: op.props["isHeader"],
+			children
+		};
+		case "table-cell": return {
+			...base,
+			type: "table-cell",
+			children
+		};
+		case "thematic-break": return {
+			...base,
+			type: "thematic-break"
+		};
+		case "text": return {
+			...base,
+			type: "text",
+			text: op.props["text"],
+			segments: op.props["segments"]
+		};
+		case "em": return {
+			...base,
+			type: "em",
+			children
+		};
+		case "strong": return {
+			...base,
+			type: "strong",
+			children
+		};
+		case "strikethrough": return {
+			...base,
+			type: "strikethrough",
+			children
+		};
+		case "inline-code": return {
+			...base,
+			type: "inline-code",
+			text: op.props["text"]
+		};
+		case "soft-break": return {
+			...base,
+			type: "soft-break"
+		};
+		case "hard-break": return {
+			...base,
+			type: "hard-break"
+		};
+		case "link": return {
+			...base,
+			type: "link",
+			url: op.props["url"],
+			title: op.props["title"],
+			children
+		};
+		case "image": return {
+			...base,
+			type: "image",
+			url: op.props["url"],
+			title: op.props["title"],
+			alt: op.props["alt"]
+		};
+		case "autolink": return {
+			...base,
+			type: "autolink",
+			url: op.props["url"],
+			text: op.props["text"]
+		};
+		default: return {
+			...base,
+			type: "citation",
+			idRef: op.props["idRef"],
+			number: op.props["number"]
+		};
+	}
+}
+function astNodeEquals(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function reconcileTextNode(previous, next) {
+	if (next.segments.length === 0 || previous.segments.length === 0) return next;
+	const previousBySignature = groupSegmentsBySignature(previous.segments);
+	let reusedAnySegment = false;
+	const segments = next.segments.map((segment) => {
+		const signature = getSegmentSignature(segment);
+		const bucket = previousBySignature.get(signature);
+		if (!bucket?.length) return segment;
+		const [reused, ...rest] = bucket;
+		if (rest.length) previousBySignature.set(signature, rest);
+		else previousBySignature.delete(signature);
+		reusedAnySegment = true;
+		return reused;
+	});
+	if (areSegmentArraysIdentical(previous.segments, segments)) return {
+		...next,
+		segments: previous.segments
+	};
+	if (!reusedAnySegment) return next;
+	return {
+		...next,
+		segments
+	};
+}
+/**
+* Returns true when both arrays contain the same segment object references in order.
+*/
+function areSegmentArraysIdentical(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((segment, index) => segment === b[index]);
+}
+/**
+* Produces a stable signature for matching segments across immutable parse iterations.
+*/
+function getSegmentSignature(segment) {
+	return `${segment.start}:${segment.end}:${segment.text}:${segment.kind}:${String(segment.isWhitespace)}:${String(segment.noBreakBefore === true)}`;
+}
+/**
+* Groups previous segments by signature to support one-to-one identity reuse.
+*/
+function groupSegmentsBySignature(segments) {
+	const bySignature = /* @__PURE__ */ new Map();
+	for (const segment of segments) {
+		const signature = getSegmentSignature(segment);
+		const existing = bySignature.get(signature) ?? [];
+		bySignature.set(signature, [...existing, segment]);
+	}
+	return bySignature;
+}
+
+//#endregion
+//#region src/parser/state.ts
+/**
+* Creates a new streaming markdown parser state.
+*
+* @param options - Optional parser option overrides.
+* @returns New immutable parser state.
+* @public
+*/
+function createStreamingMarkdownParserState(options) {
+	return {
+		nextId: 2,
+		nodes: [{
+			id: 1,
+			type: "document",
+			parentId: null,
+			closed: false,
+			range: {
+				start: 0,
+				end: 0
+			},
+			children: []
+		}],
+		rootId: 1,
+		stack: [1],
+		mode: "block",
+		warnings: [],
+		citations: {
+			order: [],
+			numbers: {},
+			definitions: {}
+		},
+		lineBuffer: "",
+		isComplete: false,
+		index: 0,
+		line: 1,
+		column: 1,
+		options: normalizeOptions(options),
+		source: "",
+		pathToId: { "0": 1 },
+		pendingCarriageReturn: false,
+		hasWarnedSegmenterUnavailable: false
+	};
+}
+/**
+* Parses a streaming chunk and returns the next immutable parser state.
+*
+* @param state - Current parser state.
+* @param chunk - Incoming text chunk.
+* @returns Updated parser state.
+* @public
+*/
+function parseStreamingMarkdownChunk(state, chunk) {
+	const normalized = normalizeChunk(chunk, state.pendingCarriageReturn);
+	return rebuildState(state, {
+		source: state.source + normalized.text,
+		isComplete: false,
+		pendingCarriageReturn: normalized.pendingCarriageReturn
+	});
+}
+/**
+* Finalizes parsing by closing any provisional nodes and flushing trailing CR.
+*
+* @param state - Current parser state.
+* @returns Final parser state.
+* @public
+*/
+function finalizeStreamingMarkdown(state) {
+	if (state.isComplete) return state;
+	return rebuildState(state, {
+		source: state.source + (state.pendingCarriageReturn ? "\n" : ""),
+		isComplete: true,
+		pendingCarriageReturn: false
+	});
+}
+function rebuildState(prev, input) {
+	const definitions = parseCitationDefinitions(input.source);
+	const parseContext = {
+		options: prev.options,
+		warnings: definitions.warnings,
+		citations: definitions.citations,
+		isComplete: input.isComplete,
+		hasWarnedSegmenterUnavailable: prev.hasWarnedSegmenterUnavailable
+	};
+	const lines = splitLines(input.source);
+	const parsedBlocks = parseBlocks(lines, 0, lines.length, "0", parseContext, true);
+	const ops = [
+		{
+			kind: "set-warnings",
+			warnings: parsedBlocks.warnings
+		},
+		{
+			kind: "set-citations",
+			citations: parsedBlocks.citations
+		},
+		{
+			kind: "set-segmenter-warning-state",
+			hasWarnedSegmenterUnavailable: parsedBlocks.hasWarnedSegmenterUnavailable
+		},
+		...createAstOpsFromDraft(parsedBlocks.value)
+	];
+	const reduced = applyAstOps({
+		previousNodes: prev.nodes,
+		previousPathToId: prev.pathToId,
+		nextId: prev.nextId,
+		ops
+	});
+	const lineBuffer = getLineBuffer(input.source);
+	const { line, column } = toLineColumn(input.source, input.source.length);
+	return {
+		...prev,
+		nextId: reduced.nextId,
+		nodes: reduced.nodes,
+		rootId: reduced.rootId,
+		stack: computeOpenStack(reduced.nodes, reduced.rootId),
+		mode: inferMode(reduced.nodes, reduced.rootId),
+		warnings: reduced.warnings,
+		citations: reduced.citations,
+		lineBuffer,
+		isComplete: input.isComplete,
+		index: input.source.length,
+		line,
+		column,
+		source: input.source,
+		pathToId: reduced.pathToId,
+		pendingCarriageReturn: input.pendingCarriageReturn,
+		hasWarnedSegmenterUnavailable: reduced.hasWarnedSegmenterUnavailable
+	};
+}
+function computeOpenStack(nodes, rootId) {
+	const nodeById = new Map(nodes.map((node) => [node.id, node]));
+	const stack = [];
+	let cursor = rootId;
+	while (cursor != null) {
+		const node = nodeById.get(cursor);
+		if (!node || node.closed) break;
+		stack.push(cursor);
+		if (!("children" in node) || node.children.length === 0) break;
+		const lastChild = node.children[node.children.length - 1];
+		cursor = typeof lastChild === "number" ? lastChild : null;
+	}
+	return stack;
+}
+function inferMode(nodes, rootId) {
+	if (rootId == null) return "block";
+	const root = nodes.find((node) => node.id === rootId);
+	if (!root || !("children" in root) || root.children.length === 0) return "block";
+	const lastChild = nodes.find((node) => node.id === root.children[root.children.length - 1]);
+	if (!lastChild || lastChild.closed) return "block";
+	if (lastChild.type === "paragraph") return "paragraph";
+	if (lastChild.type === "heading") return "heading";
+	if (lastChild.type === "blockquote") return "blockquote";
+	if (lastChild.type === "list-item") return "list-item";
+	if (lastChild.type === "code-block") return "code-fence";
+	if (lastChild.type === "table") return "table";
+	return "block";
+}
+
+//#endregion
+//#region src/dev-warning.ts
+let warned = false;
+const MIGRATION_GUIDE_URL = "https://docs.copilotkit.ai/migrate/markdown-renderer#migrate-with-your-ai-assistant";
+const HIGHLIGHTABLE_CODE = /(^|\n)[ \t]*(```|~~~)[ \t]*[A-Za-z][\w+#-]*/;
+const BLOCK_MATH = /\$\$[\s\S]+?\$\$/;
+const BRACKET_MATH = /\\\[[\s\S]+?\\\]/;
+function isProduction() {
+	return typeof process !== "undefined" && process.env != null && process.env.NODE_ENV === "production";
+}
+/**
+* Dev-only, once-per-session warning emitted when CopilotKit's built-in default
+* markdown renderer encounters markdown it won't render richly — math
+* (`$$…$$` / `\[…\]`) or a language-tagged fenced code block (rendered as plain,
+* un-highlighted code). Helps people upgrading from the bundled Streamdown
+* default notice the behavioral change and points them at the migration guide.
+*
+* No-op in production and after the first warning. Only the built-in default
+* renderers call this — a custom `markdownRenderer` never triggers it.
+*
+* @internal
+*/
+function warnUnsupportedRichSyntaxOnce(content) {
+	if (warned || !content || isProduction()) return;
+	const hasMath = BLOCK_MATH.test(content) || BRACKET_MATH.test(content);
+	const hasHighlightableCode = HIGHLIGHTABLE_CODE.test(content);
+	if (!hasMath && !hasHighlightableCode) return;
+	warned = true;
+	const [feature, missing] = hasMath ? ["math", "math typesetting"] : ["a syntax-highlighted code block", "syntax highlighting"];
+	console.warn(`[CopilotKit] The built-in markdown renderer rendered ${feature} without ${missing}. It supports GFM, tables, autolinks, and citations, but not math, syntax highlighting, or diagrams. To restore those, plug in a custom markdownRenderer (e.g. react-markdown or streamdown) — or paste the migration prompt into your AI assistant: ${MIGRATION_GUIDE_URL}`);
+}
+
+//#endregion
+export { createStreamingMarkdownParserState, finalizeStreamingMarkdown, parseStreamingMarkdownChunk, warnUnsupportedRichSyntaxOnce };
+//# sourceMappingURL=index.mjs.map