@astryx-vue/core 0.3.0 → 0.4.0

package/dist/publicParser-uHC_T0Fo.js

@@ -0,0 +1,895 @@
+import { c as isMarkdownPluginData, i as freezeMarkdownPluginData, o as getMarkdownPluginDefinition } from "./protocol-DHxY0NI8.js";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { gfm } from "micromark-extension-gfm";
+//#region src/Markdown/blocks.ts
+function splitSourceLines(source) {
+	if (source.length === 0) return [];
+	const lines = [];
+	let start = 0;
+	for (let index = 0; index < source.length; index++) {
+		if (source.charCodeAt(index) !== 10) continue;
+		const contentEnd = index > start && source.charCodeAt(index - 1) === 13 ? index - 1 : index;
+		lines.push({
+			text: source.slice(start, contentEnd),
+			start,
+			end: index + 1,
+			newline: true
+		});
+		start = index + 1;
+	}
+	if (start < source.length) lines.push({
+		text: source.slice(start),
+		start,
+		end: source.length,
+		newline: false
+	});
+	return lines;
+}
+function fenceOpener(text) {
+	const indent = /^ {0,3}/.exec(text);
+	const rest = text.slice(indent?.[0].length ?? 0);
+	const markerMatch = /^(`{3,}|~{3,})/.exec(rest);
+	if (markerMatch == null) return null;
+	const marker = markerMatch[1] ?? "";
+	const info = rest.slice(marker.length);
+	if (marker.startsWith("`") && info.includes("`")) return null;
+	const char = marker[0];
+	if (char == null) return null;
+	return {
+		char,
+		length: marker.length
+	};
+}
+function isFenceClose(text, marker) {
+	const match = /^ {0,3}([`~]+)[ \t]*$/.exec(text);
+	if (match == null) return false;
+	const closing = match[1] ?? "";
+	return closing.length >= marker.length && [...closing].every((char) => char === marker.char);
+}
+function isAtxHeading(text) {
+	return /^ {0,3}#{1,6}(?:[ \t]|$)/.test(text);
+}
+function isThematicBreak(text) {
+	return /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/.test(text);
+}
+function isSetextUnderline(text) {
+	return /^ {0,3}(?:=+|-+)[ \t]*$/.test(text);
+}
+function isListItem(text) {
+	return /^ {0,3}(?:[-+*]|\d{1,9}[.)])[ \t]/.test(text);
+}
+function isBlockquote(text) {
+	return /^ {0,3}>/.test(text);
+}
+function isBlank(text) {
+	return /^[ \t]*$/.test(text);
+}
+function isIndented(text) {
+	return /^[ \t]+\S/.test(text);
+}
+function continuesList(text) {
+	return isListItem(text) || isIndented(text);
+}
+function continuesQuote(text) {
+	return isBlockquote(text) || isIndented(text);
+}
+function hasUnsettledParagraph(lines, index, settled) {
+	const previous = lines[index - 1];
+	if (previous == null || isBlank(previous.text) || settled > previous.start) return false;
+	if (isAtxHeading(previous.text) || isListItem(previous.text) || isBlockquote(previous.text)) return false;
+	if (isThematicBreak(previous.text) || fenceOpener(previous.text) != null) return false;
+	return true;
+}
+/**
+* End index of the prefix whose blocks can no longer change if text is only
+* appended. The last open block stays after this index and is re-parsed.
+* The index never moves backwards as `source` grows by appending.
+*/
+function findSettledEnd(source) {
+	const lines = splitSourceLines(source);
+	let settled = 0;
+	let container = "top";
+	let fence = null;
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		if (line == null || !line.newline) return settled;
+		if (fence != null) {
+			if (isFenceClose(line.text, fence)) {
+				fence = null;
+				if (container === "top") settled = line.end;
+			}
+			continue;
+		}
+		const opener = fenceOpener(line.text);
+		if (opener != null) {
+			fence = opener;
+			continue;
+		}
+		if (container === "top" && isAtxHeading(line.text)) {
+			settled = line.end;
+			continue;
+		}
+		if (container === "top" && isSetextUnderline(line.text) && hasUnsettledParagraph(lines, index, settled)) {
+			settled = line.end;
+			continue;
+		}
+		if (container === "top" && isThematicBreak(line.text)) {
+			settled = line.end;
+			continue;
+		}
+		if (isBlank(line.text)) {
+			const next = lines[index + 1];
+			if (next == null || !next.newline) return settled;
+			if (container === "list" && continuesList(next.text)) continue;
+			if (container === "quote" && continuesQuote(next.text)) continue;
+			container = "top";
+			settled = line.end;
+			continue;
+		}
+		if (container === "top" && isListItem(line.text)) {
+			container = "list";
+			continue;
+		}
+		if (container === "top" && isBlockquote(line.text)) container = "quote";
+	}
+	return settled;
+}
+/** True when a fenced code block has been opened and not closed. */
+function hasOpenFence(source) {
+	const lines = splitSourceLines(source);
+	let fence = null;
+	for (const line of lines) {
+		if (!line.newline) return fence != null || fenceOpener(line.text) != null;
+		if (fence != null) {
+			if (isFenceClose(line.text, fence)) fence = null;
+			continue;
+		}
+		const opener = fenceOpener(line.text);
+		if (opener != null) fence = opener;
+	}
+	return fence != null;
+}
+//#endregion
+//#region src/Markdown/trim.ts
+function isInsideCodeSpan(line, index) {
+	let open = false;
+	for (let cursor = 0; cursor < index; cursor++) if (line[cursor] === "`") open = !open;
+	return open;
+}
+function trimIncompleteLink(line) {
+	const image = line.lastIndexOf("![");
+	const bracket = line.lastIndexOf("[");
+	const start = Math.max(image, bracket);
+	if (start < 0 || isInsideCodeSpan(line, start)) return line;
+	const slice = line.slice(start);
+	if (/^!?\[[^\]]*\]\([^)]*\)$/.test(slice) || /^!?\[[^\]]*\]$/.test(slice)) return line;
+	if (/^!?\[[^\]]*\]\([^)]*$/.test(slice) || /^!?\[[^\]]*$/.test(slice)) return line.slice(0, start);
+	return line;
+}
+function markerRuns(line, char, maxLength) {
+	const runs = [];
+	for (let index = 0; index < line.length; index++) {
+		if (line[index] !== char) continue;
+		let length = 1;
+		while (line[index + length] === char) length += 1;
+		if (length <= maxLength) runs.push({
+			start: index,
+			length
+		});
+		index += length - 1;
+	}
+	return runs;
+}
+/** Pair equal-length marker runs and close or drop the ones left open. */
+function closeRuns(line, char, maxLength) {
+	const runs = markerRuns(line, char, maxLength);
+	const openByLength = /* @__PURE__ */ new Map();
+	const closed = /* @__PURE__ */ new Set();
+	runs.forEach((run, index) => {
+		const stack = openByLength.get(run.length) ?? [];
+		const opener = stack.pop();
+		if (opener == null) {
+			stack.push(index);
+			openByLength.set(run.length, stack);
+			return;
+		}
+		closed.add(opener);
+		closed.add(index);
+		openByLength.set(run.length, stack);
+	});
+	const openIndexes = runs.map((_, index) => index).filter((index) => !closed.has(index));
+	if (openIndexes.length === 0) return line;
+	let result = line;
+	for (const index of [...openIndexes].reverse()) {
+		const run = runs[index];
+		if (run == null) continue;
+		const after = result.slice(run.start + run.length);
+		if (after.trim() === "") {
+			result = result.slice(0, run.start) + result.slice(run.start + run.length);
+			continue;
+		}
+		const trailing = after.length - after.trimEnd().length;
+		const closer = char.repeat(run.length);
+		result = result.slice(0, result.length - trailing) + closer + result.slice(result.length - trailing);
+	}
+	return result;
+}
+function closeStrike(line) {
+	const positions = [];
+	let search = 0;
+	while (search < line.length) {
+		const found = line.indexOf("~~", search);
+		if (found === -1) break;
+		positions.push(found);
+		search = found + 2;
+	}
+	if (positions.length % 2 === 0) return line;
+	const start = positions[positions.length - 1];
+	if (start == null) return line;
+	const after = line.slice(start + 2);
+	if (after.trim() === "") return line.slice(0, start);
+	const trailing = after.length - after.trimEnd().length;
+	return `${line.slice(0, line.length - trailing)}~~${line.slice(line.length - trailing)}`;
+}
+/**
+* Hide unfinished link and code markers on the last line, and close emphasis
+* that already has text so the words can render while the stream continues.
+* An open fence is left untouched.
+*/
+function trimStreamingTail(tail) {
+	if (tail === "" || hasOpenFence(tail)) return tail;
+	const lastNewline = tail.lastIndexOf("\n");
+	const head = lastNewline === -1 ? "" : tail.slice(0, lastNewline + 1);
+	let line = lastNewline === -1 ? tail : tail.slice(lastNewline + 1);
+	line = trimIncompleteLink(line);
+	line = closeRuns(line, "`", Number.POSITIVE_INFINITY);
+	line = closeRuns(line, "*", 3);
+	line = closeStrike(line);
+	return head + line;
+}
+//#endregion
+//#region src/Markdown/parse.ts
+const markdownExtensions = [gfm(), { disable: { null: ["htmlFlow", "htmlText"] } }];
+const mdastExtensions = [gfmFromMarkdown()];
+function isAutolinkLiteral(node, source) {
+	if (node.type !== "link" || node.title != null && node.title !== "") return false;
+	const only = node.children?.length === 1 ? node.children[0] : null;
+	if (only == null || only.type !== "text" || only.value == null) return false;
+	const start = node.position?.start?.offset;
+	const end = node.position?.end?.offset;
+	if (start == null || end == null) return false;
+	const raw = source.slice(start, end);
+	if (raw.startsWith("<") || raw.startsWith("[")) return false;
+	return raw === only.value;
+}
+/** Turn bare autolinks back into text. Explicit links and `<url>` stay. */
+function stripAutolinkLiterals(node, source) {
+	if (node.children == null) return node;
+	let changed = false;
+	const children = [];
+	for (const child of node.children) {
+		if (isAutolinkLiteral(child, source)) {
+			const start = child.position?.start?.offset ?? 0;
+			const end = child.position?.end?.offset ?? start;
+			children.push({
+				type: "text",
+				value: source.slice(start, end)
+			});
+			changed = true;
+			continue;
+		}
+		const next = stripAutolinkLiterals(child, source);
+		if (next !== child) changed = true;
+		children.push(next);
+	}
+	if (!changed) return node;
+	return {
+		...node,
+		children: mergeAdjacentText(children)
+	};
+}
+function mergeAdjacentText(children) {
+	const merged = [];
+	for (const child of children) {
+		const previous = merged[merged.length - 1];
+		if (previous?.type === "text" && child.type === "text") {
+			merged[merged.length - 1] = {
+				type: "text",
+				value: `${previous.value ?? ""}${child.value ?? ""}`
+			};
+			continue;
+		}
+		merged.push(child);
+	}
+	return merged;
+}
+function parseMarkdown$1(source, options) {
+	const root = fromMarkdown(source, {
+		extensions: markdownExtensions,
+		mdastExtensions
+	});
+	if (options?.autolink === "gfm") return root;
+	return stripAutolinkLiterals(root, source);
+}
+function createIncrementalMarkdownState() {
+	return {
+		settledEnd: 0,
+		settledSource: "",
+		blocks: []
+	};
+}
+function resetIncrementalState(state) {
+	state.settledEnd = 0;
+	state.settledSource = "";
+	state.blocks = [];
+}
+/**
+* Parse `source`, reusing the AST of every block that has already closed.
+* Only the suffix after {@link findSettledEnd} is parsed again. When `source`
+* is no longer an append of the previous value, the cache is dropped.
+*/
+function parseMarkdownIncremental$1(source, state, options) {
+	const settledPrefix = state.settledSource.slice(0, state.settledEnd);
+	if (settledPrefix.length > 0 && !source.startsWith(settledPrefix)) resetIncrementalState(state);
+	const end = findSettledEnd(source);
+	if (end < state.settledEnd) resetIncrementalState(state);
+	if (end > state.settledEnd) {
+		const slice = source.slice(state.settledEnd, end);
+		if (slice.trim() !== "") {
+			const children = parseMarkdown$1(slice, { autolink: options?.autolink }).children ?? [];
+			state.blocks = state.blocks.concat(children);
+		}
+		state.settledEnd = end;
+	}
+	state.settledSource = source;
+	const tail = source.slice(state.settledEnd);
+	const prepared = options?.trimTail === true ? trimStreamingTail(tail) : tail;
+	const tailBlocks = prepared.trim() === "" ? [] : parseMarkdown$1(prepared, { autolink: options?.autolink }).children ?? [];
+	return {
+		blocks: state.blocks.concat(tailBlocks),
+		settledCount: state.blocks.length
+	};
+}
+//#endregion
+//#region src/Markdown/plugin-protocol/run.ts
+/**
+* Run each plugin transform in order. A plugin that returns the same root
+* leaves settled blocks reusable. Reported messages are warnings, not throws.
+*/
+function applyProtocolTransforms(root, plugins, source, isFinal) {
+	let current = root;
+	for (const plugin of plugins) {
+		const definition = getMarkdownPluginDefinition(plugin);
+		if (definition.transform == null) continue;
+		const reports = [];
+		const next = definition.transform(current, {
+			source,
+			isFinal,
+			display: "block",
+			report(message) {
+				reports.push(message);
+			}
+		});
+		for (const message of reports) if (typeof console !== "undefined") console.warn(`[Astryx] Markdown plugin "${definition.name}": ${message}`);
+		if (next != null) current = next;
+	}
+	return current;
+}
+//#endregion
+//#region src/Markdown/plugin-protocol/syntax.ts
+function prepareSyntax(plugins) {
+	const inline = [];
+	const block = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		const definition = getMarkdownPluginDefinition(plugin);
+		if (names.has(definition.name)) throw new Error(`Markdown plugin: duplicate name "${definition.name}"`);
+		names.add(definition.name);
+		if (!("syntax" in definition) || definition.syntax == null) continue;
+		const rendererNames = new Set(Object.keys(definition.renderers));
+		const take = (display, group) => {
+			for (const contribution of group ?? []) {
+				const prepared = {
+					pluginName: definition.name,
+					display,
+					startsWith: contribution.startsWith,
+					maxSpan: contribution.maxSpan,
+					tokenize: contribution.tokenize,
+					rendererNames
+				};
+				(display === "inline" ? inline : block).push(prepared);
+			}
+		};
+		take("inline", definition.syntax.inline);
+		take("block", definition.syntax.block);
+	}
+	return {
+		inline,
+		block
+	};
+}
+function pointAt(source, offset) {
+	let line = 1;
+	let column = 1;
+	const limit = Math.min(offset, source.length);
+	for (let index = 0; index < limit; index += 1) if (source.charCodeAt(index) === 10) {
+		line += 1;
+		column = 1;
+	} else column += 1;
+	return {
+		line,
+		column,
+		offset
+	};
+}
+function matchAt(source, offset, limit, display, contributions, isFinal) {
+	const first = source[offset];
+	if (first == null) return { status: "none" };
+	for (const contribution of contributions) {
+		if (!contribution.startsWith.some((prefix) => prefix[0] === first)) continue;
+		let fullPrefix = false;
+		for (const prefix of contribution.startsWith) {
+			if (source.startsWith(prefix, offset)) {
+				fullPrefix = true;
+				break;
+			}
+			if (!isFinal) {
+				const remaining = source.slice(offset);
+				if (remaining.length < prefix.length && prefix.startsWith(remaining)) return { status: "defer" };
+			}
+		}
+		if (!fullPrefix) continue;
+		const endLimit = Math.min(source.length, offset + contribution.maxSpan, limit);
+		let result;
+		try {
+			result = contribution.tokenize({
+				source: endLimit === source.length ? source : source.slice(0, endLimit),
+				offset,
+				end: endLimit,
+				isFinal,
+				context: display,
+				lineStart: source.lastIndexOf("\n", offset - 1) + 1,
+				column: offset - (source.lastIndexOf("\n", offset - 1) + 1)
+			});
+		} catch {
+			continue;
+		}
+		if (result == null || typeof result !== "object" || typeof result.then === "function") continue;
+		if (result.status === "no-match") continue;
+		if (result.status === "defer") {
+			if (!isFinal && endLimit === source.length && source.length - offset < contribution.maxSpan) return { status: "defer" };
+			continue;
+		}
+		if (result.status !== "match") continue;
+		const node = result.node;
+		if (!Number.isInteger(result.end) || result.end <= offset || result.end > endLimit || node.type !== "extension" || node.plugin !== contribution.pluginName || node.display !== display || node.name.trim() === "" || !isMarkdownPluginData(node.data) || !contribution.rendererNames.has(node.name)) continue;
+		return {
+			status: "match",
+			end: result.end,
+			node: {
+				...node,
+				data: freezeMarkdownPluginData(node.data),
+				source: source.slice(offset, result.end),
+				position: {
+					start: pointAt(source, offset),
+					end: pointAt(source, result.end)
+				}
+			}
+		};
+	}
+	return { status: "none" };
+}
+function splitText(node, source, contributions, isFinal) {
+	const value = node.value ?? "";
+	const base = node.position?.start?.offset;
+	const end = node.position?.end?.offset;
+	const raw = base != null && end != null ? source.slice(base, end) : value;
+	const usingDocument = raw === value && base != null;
+	const text = usingDocument ? source : value;
+	const origin = usingDocument ? base : 0;
+	const limit = origin + (usingDocument ? raw.length : value.length);
+	const pieces = [];
+	let cursor = origin;
+	let textStart = origin;
+	let changed = false;
+	while (cursor < limit) {
+		const matched = matchAt(text, cursor, limit, "inline", contributions, isFinal);
+		if (matched.status === "match") {
+			if (cursor > textStart) pieces.push({
+				type: "text",
+				value: text.slice(textStart, cursor)
+			});
+			pieces.push(matched.node);
+			cursor = matched.end;
+			textStart = cursor;
+			changed = true;
+			continue;
+		}
+		if (matched.status === "defer") break;
+		cursor += 1;
+	}
+	if (!changed) return null;
+	if (textStart < limit) pieces.push({
+		type: "text",
+		value: text.slice(textStart, limit)
+	});
+	return pieces;
+}
+function mapChildren(nodes, source, contributions, isFinal, parentType) {
+	if (parentType === "code" || parentType === "inlineCode") return {
+		nodes: [...nodes],
+		changed: false
+	};
+	let changed = false;
+	const next = [];
+	for (const node of nodes) {
+		if (node.type === "text" && node.value != null && node.value !== "") {
+			const parts = splitText(node, source, contributions, isFinal);
+			if (parts != null) {
+				changed = true;
+				next.push(...parts);
+				continue;
+			}
+		}
+		if (node.children != null && node.children.length > 0) {
+			const mapped = mapChildren(node.children, source, contributions, isFinal, node.type);
+			if (mapped.changed) {
+				changed = true;
+				next.push({
+					...node,
+					children: mapped.nodes
+				});
+				continue;
+			}
+		}
+		next.push(node);
+	}
+	return {
+		nodes: next,
+		changed
+	};
+}
+function codeRanges(root) {
+	const ranges = [];
+	const visit = (node) => {
+		if (node.type === "code") {
+			const start = node.position?.start?.offset;
+			const end = node.position?.end?.offset;
+			if (start != null && end != null) ranges.push({
+				start,
+				end
+			});
+		}
+		for (const child of node.children ?? []) visit(child);
+	};
+	visit(root);
+	return ranges;
+}
+function replaceBlocks(root, source, contributions, isFinal) {
+	const ranges = codeRanges(root);
+	const matches = [];
+	let offset = 0;
+	let coveredUntil = 0;
+	while (offset <= source.length) {
+		const insideCode = ranges.some((range) => offset >= range.start && offset < range.end);
+		if (offset >= coveredUntil && !insideCode) {
+			const matched = matchAt(source, offset, source.length, "block", contributions, isFinal);
+			if (matched.status === "match") {
+				matches.push({
+					start: offset,
+					end: matched.end,
+					node: matched.node
+				});
+				coveredUntil = matched.end;
+				offset = matched.end;
+				continue;
+			}
+		}
+		const next = source.indexOf("\n", offset);
+		if (next === -1) break;
+		offset = next + 1;
+	}
+	if (matches.length === 0) return root;
+	const children = root.children ?? [];
+	const next = [];
+	let matchIndex = 0;
+	for (const child of children) {
+		const start = child.position?.start?.offset;
+		const end = child.position?.end?.offset;
+		const match = matches[matchIndex];
+		if (match != null && start != null && end != null && end > match.start && start < match.end) {
+			if (next[next.length - 1] !== match.node) next.push(match.node);
+			if (end >= match.end) matchIndex += 1;
+			continue;
+		}
+		next.push(child);
+	}
+	return {
+		...root,
+		children: next
+	};
+}
+/**
+* Apply plugin syntax after the CommonMark parse.
+* Inline matches are spliced into text nodes. Block matches replace
+* top-level children that overlap the match. Code fences are left alone.
+*/
+function applyMarkdownSyntax(root, source, plugins, isFinal) {
+	const prepared = prepareSyntax(plugins);
+	if (prepared.inline.length === 0 && prepared.block.length === 0) return root;
+	let current = root;
+	if (prepared.inline.length > 0 && current.children != null) {
+		const mapped = mapChildren(current.children, source, prepared.inline, isFinal, "root");
+		if (mapped.changed) current = {
+			...current,
+			children: mapped.nodes
+		};
+	}
+	if (prepared.block.length > 0) current = replaceBlocks(current, source, prepared.block, isFinal);
+	return current;
+}
+const BRACKET_CITE = /\[([^\]\s]+)\]|【([^】\s]+)】/g;
+/** Turn `[id]` and `【id】` text into citation nodes when the id is known. */
+function applyCitations(root, sourceIds) {
+	const visit = (nodes, parentType) => {
+		if (parentType === "code" || parentType === "inlineCode") return {
+			nodes: [...nodes],
+			changed: false
+		};
+		let changed = false;
+		const next = [];
+		for (const node of nodes) {
+			const text = node.type === "text" ? node.value ?? "" : "";
+			if (text.includes("[") || text.includes("【")) {
+				const parts = splitCitations(node.value ?? "", sourceIds);
+				if (parts != null) {
+					changed = true;
+					next.push(...parts);
+					continue;
+				}
+			}
+			if (node.children != null && node.children.length > 0) {
+				const mapped = visit(node.children, node.type);
+				if (mapped.changed) {
+					changed = true;
+					next.push({
+						...node,
+						children: mapped.nodes
+					});
+					continue;
+				}
+			}
+			next.push(node);
+		}
+		return {
+			nodes: next,
+			changed
+		};
+	};
+	if (root.children == null) return root;
+	const mapped = visit(root.children, "root");
+	return mapped.changed ? {
+		...root,
+		children: mapped.nodes
+	} : root;
+}
+function splitCitations(value, sourceIds) {
+	const pieces = [];
+	let cursor = 0;
+	let changed = false;
+	BRACKET_CITE.lastIndex = 0;
+	for (const match of value.matchAll(BRACKET_CITE)) {
+		const id = match[1] ?? match[2] ?? "";
+		const index = match.index ?? 0;
+		if (!sourceIds.has(id)) continue;
+		if (match[1] != null && value[index + match[0].length] === "(") continue;
+		if (index > cursor) pieces.push({
+			type: "text",
+			value: value.slice(cursor, index)
+		});
+		pieces.push({
+			type: "citation",
+			sourceId: id
+		});
+		cursor = index + match[0].length;
+		changed = true;
+	}
+	if (!changed) return null;
+	if (cursor < value.length) pieces.push({
+		type: "text",
+		value: value.slice(cursor)
+	});
+	return pieces;
+}
+//#endregion
+//#region src/Markdown/legacyNodes.ts
+function rangeOf(node, withRange) {
+	if (!withRange) return {};
+	const start = node.position?.start?.offset;
+	const end = node.position?.end?.offset;
+	if (start == null || end == null) return {};
+	return { range: {
+		start,
+		end
+	} };
+}
+function projectInline(node) {
+	switch (node.type) {
+		case "text":
+		case "html": return {
+			type: "text",
+			content: node.value ?? ""
+		};
+		case "strong": return {
+			type: "bold",
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "emphasis": return {
+			type: "italic",
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "delete": return {
+			type: "strikethrough",
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "inlineCode": return {
+			type: "code",
+			content: node.value ?? ""
+		};
+		case "break": return { type: "break" };
+		case "link":
+		case "linkReference": return {
+			type: "link",
+			href: node.url ?? "",
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "image":
+		case "imageReference": return {
+			type: "image",
+			src: node.url ?? "",
+			alt: node.alt ?? node.label ?? ""
+		};
+		case "citation": return {
+			type: "citation",
+			sourceId: node.sourceId ?? ""
+		};
+		case "extension": return node;
+		default: return {
+			type: "text",
+			content: node.value ?? ""
+		};
+	}
+}
+function projectBlock(node, withRange) {
+	const range = rangeOf(node, withRange);
+	switch (node.type) {
+		case "heading": return {
+			...range,
+			type: "heading",
+			level: node.depth ?? 1,
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "paragraph": return {
+			...range,
+			type: "paragraph",
+			children: (node.children ?? []).map(projectInline)
+		};
+		case "code": return {
+			...range,
+			type: "codeblock",
+			language: node.lang ?? "",
+			content: node.value ?? ""
+		};
+		case "blockquote": return {
+			...range,
+			type: "blockquote",
+			children: (node.children ?? []).map((child) => projectBlock(child, false))
+		};
+		case "list": return {
+			...range,
+			type: "list",
+			ordered: node.ordered === true,
+			start: node.start ?? void 0,
+			loose: node.spread === true ? true : void 0,
+			items: (node.children ?? []).map((item) => ({
+				checked: item.checked ?? void 0,
+				children: (item.children ?? []).map((child) => projectBlock(child, false))
+			}))
+		};
+		case "table": {
+			const rows = node.children ?? [];
+			const header = rows[0];
+			const alignments = node.align ?? [];
+			const cell = (entry) => ({ children: (entry.children ?? []).map(projectInline) });
+			return {
+				...range,
+				type: "table",
+				headers: (header?.children ?? []).map(cell),
+				alignments,
+				rows: rows.slice(1).map((row) => (row.children ?? []).map(cell))
+			};
+		}
+		case "thematicBreak": return {
+			...range,
+			type: "hr"
+		};
+		case "image": return {
+			...range,
+			type: "image",
+			src: node.url ?? "",
+			alt: node.alt ?? ""
+		};
+		case "extension": return {
+			...node,
+			...range
+		};
+		default: return {
+			...range,
+			type: "paragraph",
+			children: (node.children ?? []).map(projectInline)
+		};
+	}
+}
+function projectBlocks(nodes, withRange) {
+	return nodes.map((node) => projectBlock(node, withRange));
+}
+//#endregion
+//#region src/Markdown/publicParser.ts
+function idSet(sourceIds) {
+	if (sourceIds == null) return void 0;
+	const ids = sourceIds instanceof Set ? sourceIds : new Set(sourceIds);
+	return ids.size === 0 ? void 0 : ids;
+}
+function parseTree(source, options) {
+	let root = parseMarkdown$1(source, { autolink: options?.autolink });
+	const ids = idSet(options?.sourceIds);
+	if (ids != null) root = applyCitations(root, ids);
+	const plugins = options?.plugins;
+	if (plugins != null && plugins.length > 0) {
+		const isFinal = options?.isFinal !== false;
+		root = applyMarkdownSyntax(root, source, plugins, isFinal);
+		root = applyProtocolTransforms(root, plugins, source, isFinal);
+	}
+	return root;
+}
+/** Canonical mdast-shaped root, including plugin syntax and transforms. */
+function parseMarkdownAst(source, options) {
+	return parseTree(source, options);
+}
+/** Phrasing children of a one-paragraph document. Anything else is empty. */
+function parseInlineAst(source, options) {
+	const root = parseTree(source, options);
+	const only = root.children?.length === 1 ? root.children[0] : void 0;
+	if (only?.type === "paragraph") return only.children ?? [];
+	return [];
+}
+/** Legacy block list. `sourceRanges` adds offsets on the top-level blocks. */
+function parseMarkdown(source, options) {
+	return projectBlocks(parseTree(source, options).children ?? [], options?.sourceRanges === true);
+}
+function parseInline(source, options) {
+	return parseInlineAst(source, options).map((node) => projectInline(node));
+}
+function createIncrementalState() {
+	return {
+		prevInput: "",
+		settledText: "",
+		settledBlocks: [],
+		settledUpTo: 0
+	};
+}
+/**
+* Public incremental entry. The result matches a full parse. The state records
+* the latest source so a later call can see what was already settled.
+*/
+function parseMarkdownIncremental(source, state, options) {
+	const blocks = parseMarkdown(source, options);
+	state.prevInput = source;
+	state.settledText = source;
+	state.settledBlocks = blocks;
+	state.settledUpTo = source.length;
+	return blocks;
+}
+//#endregion
+export { parseMarkdownAst as a, applyProtocolTransforms as c, parseMarkdownIncremental$1 as d, parseMarkdown as i, createIncrementalMarkdownState as l, parseInline as n, parseMarkdownIncremental as o, parseInlineAst as r, applyMarkdownSyntax as s, createIncrementalState as t, parseMarkdown$1 as u };