@temelj/mdx 0.14.0 → 0.15.0

package/dist/parser/materialize.mjs

@@ -0,0 +1,736 @@
+import { DiagnosticBag, createDiagnostic } from "../diagnostics.mjs";
+import { normalizeIdentifier } from "../identifier.mjs";
+import { nodeText } from "../model.mjs";
+import { sourceText } from "../source.mjs";
+import { decodeFrontmatter } from "../frontmatter.mjs";
+import { parseFlowRange } from "./block-parser.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { parseInline } from "./inline-parser.mjs";
+import { isFlowJsxChildren, jsxParts } from "./materialize-jsx.mjs";
+//#region src/parser/materialize.ts
+function materializeDocument(file, blocks, syntax, limits, options = {}) {
+	const indexes = {
+		definitions: /* @__PURE__ */ new Set(),
+		footnotes: /* @__PURE__ */ new Set()
+	};
+	const context = createContext(file, syntax, limits, options, indexes);
+	if (!context.keepReferences) collectIndexes(blocks, context, indexes);
+	const children = [];
+	const materializedBlocks = [];
+	for (const block of blocks) {
+		if (context.limit !== void 0) break;
+		const before = context.nodes;
+		context.references = /* @__PURE__ */ new Set();
+		const child = materializeBlock(block, context);
+		if (child !== void 0) {
+			children.push(child);
+			materializedBlocks.push(Object.freeze({
+				node: child,
+				nodeCount: context.nodes - before,
+				references: [...context.references]
+			}));
+		}
+	}
+	if (context.limit !== void 0) {
+		const diagnostic = limitDiagnostic(file, context.limit);
+		const diagnostics = Object.freeze([diagnostic]);
+		return Object.freeze({
+			kind: "limitExceeded",
+			limit: context.limit,
+			diagnostics
+		});
+	}
+	const diagnostics = context.diagnostics.snapshot();
+	if (context.authoredInvalid || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+		const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+		if (errors.length === 0) throw new Error("Invalid MDX draft did not produce an error diagnostic");
+		const [first, ...rest] = errors;
+		if (first === void 0) throw new Error("Invalid MDX diagnostic collection changed unexpectedly");
+		const invalidDiagnostics = Object.freeze([first, ...rest]);
+		return Object.freeze({
+			kind: "invalid",
+			diagnostics: invalidDiagnostics
+		});
+	}
+	const document = counted(context, {
+		kind: "document",
+		children,
+		origin: range(0, file.length)
+	});
+	if (document === void 0 || context.limit !== void 0) {
+		const diagnostic = limitDiagnostic(file, "maximumNodes");
+		const diagnostics = Object.freeze([diagnostic]);
+		return Object.freeze({
+			kind: "limitExceeded",
+			limit: "maximumNodes",
+			diagnostics
+		});
+	}
+	return Object.freeze({
+		kind: "ok",
+		document,
+		blocks: Object.freeze(materializedBlocks),
+		diagnostics
+	});
+}
+/**
+* Materializes parsed inline syntax that a stream renders outside a block,
+* keeping references.
+*/
+function materializePhrasing(file, nodes, syntax, limits) {
+	const context = createContext(file, syntax, limits, {
+		keepReferences: true,
+		allowIncomplete: true
+	});
+	const children = [];
+	for (const node of nodes) {
+		const child = materializeInlineNode(node, context);
+		if (child !== void 0) children.push(child);
+	}
+	return {
+		nodes: children,
+		nodeCount: context.nodes
+	};
+}
+/** Independent inline groups share one context while retaining their own node budgets. */
+function materializePhrasingGroups(file, nodes, syntax, limits, cache) {
+	const context = createContext(file, syntax, limits, {
+		keepReferences: true,
+		allowIncomplete: true
+	});
+	return nodes.map((node) => {
+		const hit = cache.get(node);
+		if (hit !== void 0) return hit;
+		context.nodes = 0;
+		context.limit = void 0;
+		context.usedEndOfInput = false;
+		const child = materializeInlineNode(node, context);
+		const materialized = {
+			nodes: child === void 0 ? [] : [child],
+			nodeCount: context.nodes
+		};
+		if (context.limit === void 0 && !context.usedEndOfInput) cache.set(node, materialized);
+		return materialized;
+	});
+}
+/** Only whitespace and at most one line ending follow `offset`. */
+function reachesEndOfInput(file, offset) {
+	return /^[ \t]*(?:\r\n?|\n)?[ \t]*$/u.test(file.slice({
+		start: offset,
+		end: file.length
+	}));
+}
+const emptyIndexes = {
+	definitions: /* @__PURE__ */ new Set(),
+	footnotes: /* @__PURE__ */ new Set()
+};
+function createContext(file, syntax, limits, options, indexes = emptyIndexes) {
+	return {
+		definitions: indexes.definitions,
+		definitionLookup: options.definitionLookup ?? indexes.definitions,
+		references: /* @__PURE__ */ new Set(),
+		diagnostics: new DiagnosticBag(),
+		file,
+		footnotes: indexes.footnotes,
+		limits,
+		syntax,
+		cache: options.keepReferences === true ? options.cache : void 0,
+		flowJsx: /* @__PURE__ */ new Map(),
+		grammarSource: void 0,
+		maximumDepth: 0,
+		usedEndOfInput: false,
+		allowIncomplete: options.allowIncomplete ?? false,
+		keepReferences: options.keepReferences ?? false,
+		open: options.open,
+		depth: 0,
+		nodes: 0,
+		authoredInvalid: false,
+		limit: void 0
+	};
+}
+function materializeBlock(block, context) {
+	return cached(context.cache?.blocks, block, context, () => materializeBlockContent(block, context));
+}
+/**
+* Replays a cached subtree, or materializes and caches it. Subtrees with
+* diagnostics or input-dependent leniency are never cached.
+*/
+function cached(cache, key, context, materialize) {
+	if (cache === void 0) return materialize();
+	const hit = cache.get(key);
+	if (hit !== void 0 && context.depth + hit.depth <= context.limits.maximumNestingDepth && context.nodes + hit.nodeCount <= context.limits.maximumNodes) {
+		for (const identifier of hit.references) context.references.add(identifier);
+		context.nodes += hit.nodeCount;
+		context.maximumDepth = Math.max(context.maximumDepth, context.depth + hit.depth);
+		return hit.node;
+	}
+	const references = context.references;
+	context.references = /* @__PURE__ */ new Set();
+	const nodes = context.nodes;
+	const diagnostics = context.diagnostics.size;
+	const outerDepth = context.maximumDepth;
+	const outerEndOfInput = context.usedEndOfInput;
+	context.maximumDepth = context.depth;
+	context.usedEndOfInput = false;
+	const node = materialize();
+	if (node !== void 0 && context.diagnostics.size === diagnostics && !context.authoredInvalid && context.limit === void 0 && !context.usedEndOfInput) cache.set(key, {
+		node,
+		nodeCount: context.nodes - nodes,
+		depth: context.maximumDepth - context.depth,
+		references: [...context.references]
+	});
+	for (const identifier of context.references) references.add(identifier);
+	context.references = references;
+	context.maximumDepth = Math.max(outerDepth, context.maximumDepth);
+	context.usedEndOfInput ||= outerEndOfInput;
+	return node;
+}
+function materializeBlockContent(block, context) {
+	if (!enter(context)) return;
+	try {
+		const origin = range(block.range.start, block.range.end);
+		if (isOpenLeaf(block, context)) {
+			context.usedEndOfInput = true;
+			return counted(context, openLeafPlaceholder(block, origin));
+		}
+		switch (block.kind) {
+			case "paragraph": return counted(context, {
+				kind: "paragraph",
+				children: materializeInline(block.input, context),
+				origin
+			});
+			case "heading": return counted(context, {
+				kind: "heading",
+				depth: block.depth,
+				children: materializeInline(block.input, context),
+				origin
+			});
+			case "code": return counted(context, {
+				kind: "codeBlock",
+				value: trimFinalLineEnding(inlineInputText(context.file, block.value)),
+				language: sliceOptional(context.file, block.language),
+				meta: sliceOptional(context.file, block.meta),
+				origin
+			});
+			case "thematicBreak": return counted(context, {
+				kind: "thematicBreak",
+				origin
+			});
+			case "blockQuote": return counted(context, {
+				kind: "blockquote",
+				children: materializeBlocks(block.children, context),
+				origin
+			});
+			case "list": return counted(context, {
+				kind: "list",
+				ordered: block.ordered,
+				spread: block.spread,
+				start: block.start ?? 1,
+				children: materializeListItems(block, context),
+				origin
+			});
+			case "definition": return counted(context, {
+				kind: "definition",
+				identifier: normalizeIdentifier(block.identifier),
+				url: context.file.semanticSlice(block.destination),
+				title: semanticSliceOptional(context.file, block.title),
+				origin
+			});
+			case "footnoteDefinition": return counted(context, {
+				kind: "footnoteDefinition",
+				identifier: normalizeIdentifier(block.identifier),
+				label: block.identifier,
+				children: materializeBlocks(block.children, context),
+				origin
+			});
+			case "rawHtml": return counted(context, {
+				kind: "rawHtmlBlock",
+				value: context.file.semanticSlice(block.range),
+				origin
+			});
+			case "frontmatter": {
+				const rawValue = trimFinalLineEnding(context.file.slice(block.value));
+				const valueOrigin = range(block.value.start, block.value.start + rawValue.length);
+				const data = decodeFrontmatter({
+					diagnostics: context.diagnostics,
+					format: block.format,
+					source: rawValue,
+					span: span(context.file, valueOrigin.start, valueOrigin.end)
+				});
+				return counted(context, {
+					kind: "frontmatter",
+					format: block.format,
+					value: rawValue.replace(/\r\n?|\n/gu, "\n"),
+					data,
+					valueOrigin,
+					origin
+				});
+			}
+			case "directive": return counted(context, {
+				kind: "containerDirective",
+				name: block.name,
+				attributes: materializeDirectiveAttributes(block.attributes),
+				label: materializeDirectiveLabel(block.label, context),
+				children: materializeBlocks(block.children, context),
+				origin
+			});
+			case "leafDirective": return counted(context, {
+				kind: "leafDirective",
+				name: block.name,
+				attributes: materializeDirectiveAttributes(block.attributes),
+				label: materializeDirectiveLabel(block.label, context),
+				origin
+			});
+			case "math": {
+				const value = trimFinalLineEnding(inlineInputText(context.file, block.value));
+				return counted(context, block.format === "tex" ? {
+					kind: "displayMath",
+					value,
+					format: "tex",
+					origin
+				} : {
+					kind: "displayMath",
+					value,
+					format: "dollar",
+					meta: sliceOptional(context.file, block.meta),
+					origin
+				});
+			}
+			case "table": return counted(context, {
+				kind: "table",
+				alignments: block.alignments,
+				children: block.rows.map((row) => ({
+					kind: "tableRow",
+					children: row.cells.map((cell) => {
+						const cellRange = inlineSegmentsRange(cell, row.range);
+						return {
+							kind: "tableCell",
+							children: materializeInline(cell, context),
+							origin: range(cellRange.start, cellRange.end)
+						};
+					}),
+					origin: range(row.range.start, row.range.end)
+				})),
+				origin
+			});
+			case "expression": {
+				const authored = context.file.slice(block.range);
+				return counted(context, {
+					kind: "blockExpression",
+					code: authored.slice(authored.indexOf("{") + 1, authored.lastIndexOf("}")),
+					origin
+				});
+			}
+			case "esm": return counted(context, {
+				kind: "esm",
+				code: trimFinalLineEnding(context.file.slice(block.range)),
+				origin
+			});
+			case "jsx": return counted(context, materializeFlowJsx(block, context));
+			case "invalidMdx":
+				if (context.allowIncomplete && block.state === "incomplete" && reachesEndOfInput(context.file, block.range.end)) {
+					context.usedEndOfInput = true;
+					return counted(context, {
+						kind: "rawHtmlBlock",
+						value: context.file.slice(block.range),
+						origin
+					});
+				}
+				context.authoredInvalid = true;
+				context.diagnostics.add({
+					code: `mdx.${block.syntax}.invalid`,
+					message: `Invalid or unfinished MDX ${block.syntax}`,
+					severity: "error",
+					span: span(context.file, origin.start, origin.end)
+				});
+				return;
+		}
+	} finally {
+		context.depth--;
+	}
+}
+function isOpenLeaf(block, context) {
+	return context.open !== void 0 && block.range.start === context.open.start && block.range.end === context.open.end && (block.kind === "paragraph" || block.kind === "code" || block.kind === "math" || block.kind === "invalidMdx");
+}
+function openLeafPlaceholder(block, origin) {
+	switch (block.kind) {
+		case "paragraph": return {
+			kind: "paragraph",
+			children: [],
+			origin
+		};
+		case "code": return {
+			kind: "codeBlock",
+			value: "",
+			origin
+		};
+		case "math": return {
+			kind: "displayMath",
+			value: "",
+			format: "dollar",
+			origin
+		};
+		default: return {
+			kind: "rawHtmlBlock",
+			value: "",
+			origin
+		};
+	}
+}
+/**
+* Materializes list items. A growing list reuses its unchanged leading items
+* as one prefix, so an append materializes only the items after it. The list
+* that contains a stream's open leaf is rebuilt on every append and never
+* cached, so its children array is extended in place instead of copied.
+*/
+function materializeListItems(list, context) {
+	const items = list.items;
+	const closing = list.closing ?? [];
+	const count = items.length + closing.length;
+	const itemAt = (index) => items[index] ?? closing[index - items.length];
+	const open = context.open !== void 0 && containsRange(list.range, context.open);
+	const cache = context.cache;
+	const prefix = cache === void 0 ? void 0 : listPrefix(count, itemAt, cache.lists);
+	const reused = prefix !== void 0 && context.depth + prefix.depth <= context.limits.maximumNestingDepth && context.nodes + prefix.nodeCount <= context.limits.maximumNodes ? prefix : void 0;
+	let children = [];
+	if (reused !== void 0 && reused.live && open) {
+		children = reused.nodes;
+		children.length = reused.length;
+	} else if (reused !== void 0) children = reused.nodes.slice(0, reused.length);
+	let nodeCount = reused?.nodeCount ?? 0;
+	let depth = reused?.depth ?? 0;
+	let cacheable = true;
+	const references = new Set(reused?.references);
+	if (reused !== void 0) {
+		for (const identifier of reused.references) context.references.add(identifier);
+		context.nodes += reused.nodeCount;
+		context.maximumDepth = Math.max(context.maximumDepth, context.depth + reused.depth);
+	}
+	for (let index = (reused?.index ?? -1) + 1; index < count; index++) {
+		const item = itemAt(index);
+		const node = cached(cache?.items, item, context, () => ({
+			kind: "listItem",
+			checked: item.checked,
+			spread: item.spread,
+			children: materializeBlocks(item.children, context),
+			origin: range(item.range.start, item.range.end)
+		}));
+		if (node !== void 0) children.push(node);
+		const entry = cache?.items.get(item);
+		cacheable &&= entry?.node === node;
+		for (const identifier of entry?.references ?? []) references.add(identifier);
+		nodeCount += entry?.nodeCount ?? 0;
+		depth = Math.max(depth, entry?.depth ?? 0);
+		if (cacheable && index >= count - prefixWindow) cache?.lists.set(item, {
+			index,
+			nodes: children,
+			length: children.length,
+			live: open,
+			references: [...references],
+			nodeCount,
+			depth
+		});
+	}
+	return children;
+}
+/**
+* How far back a list prefix can end. The parser closes an item only when the
+* next line completes, so the last two items are rebuilt by each tail draft.
+*/
+const prefixWindow = 8;
+/** The cached prefix ending closest to the end of the list. Closing items can still change. */
+function listPrefix(count, itemAt, lists) {
+	for (let index = count - 1; index >= Math.max(0, count - prefixWindow); index--) {
+		const prefix = lists.get(itemAt(index));
+		if (prefix?.index === index) return prefix;
+	}
+}
+function containsRange(outer, inner) {
+	return outer.start <= inner.start && inner.end <= outer.end;
+}
+function materializeBlocks(blocks, context) {
+	const children = [];
+	for (const block of blocks) {
+		const child = materializeBlock(block, context);
+		if (child !== void 0) children.push(child);
+	}
+	return children;
+}
+function materializeInline(segments, context) {
+	const result = parseInline(new InlineInput(context.file, segments), context.syntax, context.definitionLookup);
+	for (const identifier of result.references) context.references.add(identifier);
+	for (const invalid of result.invalid) {
+		if (context.allowIncomplete && invalid.open && reachesEndOfInput(context.file, invalid.range.end)) {
+			context.usedEndOfInput = true;
+			continue;
+		}
+		context.authoredInvalid = true;
+		context.diagnostics.add({
+			code: `mdx.${invalid.syntax}.invalid`,
+			message: `Invalid or unfinished MDX ${invalid.syntax}`,
+			severity: "error",
+			span: span(context.file, invalid.range.start, invalid.range.end)
+		});
+	}
+	return materializeInlineNodes(result.nodes, context);
+}
+function materializeInlineNodes(nodes, context) {
+	const children = [];
+	for (const node of nodes) {
+		const child = materializeInlineNode(node, context);
+		if (child !== void 0) children.push(child);
+	}
+	return children;
+}
+function materializeInlineNode(node, context) {
+	const origin = range(node.range.start, node.range.end);
+	switch (node.kind) {
+		case "text": return counted(context, {
+			kind: "text",
+			value: node.value,
+			origin
+		});
+		case "emphasis":
+		case "strong":
+		case "delete": return counted(context, {
+			kind: node.kind,
+			children: materializeInlineNodes(node.children, context),
+			origin
+		});
+		case "code": return counted(context, {
+			kind: "inlineCode",
+			value: node.value,
+			origin
+		});
+		case "hardBreak": return counted(context, {
+			kind: "hardBreak",
+			origin
+		});
+		case "link": return counted(context, {
+			kind: "link",
+			url: node.destination,
+			title: node.title,
+			children: materializeInlineNodes(node.children, context),
+			origin
+		});
+		case "image": return counted(context, {
+			kind: "image",
+			url: node.destination,
+			alt: node.alt,
+			title: node.title,
+			origin
+		});
+		case "reference": {
+			const children = materializeInlineNodes(node.children, context);
+			if (!context.keepReferences && !context.definitions.has(node.identifier)) return counted(context, {
+				kind: "text",
+				value: context.file.slice(node.range),
+				origin
+			});
+			const identifier = normalizeIdentifier(node.identifier);
+			return counted(context, node.image ? {
+				kind: "imageReference",
+				identifier,
+				alt: children.map(nodeText).join(""),
+				referenceKind: node.referenceKind,
+				origin
+			} : {
+				kind: "linkReference",
+				identifier,
+				referenceKind: node.referenceKind,
+				children,
+				origin
+			});
+		}
+		case "rawHtml": return counted(context, {
+			kind: "rawHtmlInline",
+			value: node.value,
+			origin
+		});
+		case "expression": return counted(context, {
+			kind: "inlineExpression",
+			code: node.value,
+			origin
+		});
+		case "jsx": return counted(context, materializeTextJsx(node.value, origin, context));
+		case "math": return counted(context, {
+			kind: "inlineMath",
+			value: node.value,
+			format: node.format,
+			origin
+		});
+		case "footnoteReference": return context.keepReferences || context.footnotes.has(node.identifier) ? counted(context, {
+			kind: "footnoteReference",
+			identifier: normalizeIdentifier(node.identifier),
+			label: node.identifier,
+			origin
+		}) : counted(context, {
+			kind: "text",
+			value: context.file.slice(node.range),
+			origin
+		});
+		case "directive": return counted(context, {
+			kind: "textDirective",
+			name: node.name,
+			attributes: materializeDirectiveAttributes(node.attributes),
+			label: {
+				kind: "directiveLabel",
+				children: [],
+				origin
+			},
+			origin
+		});
+	}
+}
+function materializeDirectiveLabel(label, context) {
+	if (label === void 0) return;
+	const labelRange = inlineSegmentsRange(label, {
+		start: 0,
+		end: 0
+	});
+	return {
+		kind: "directiveLabel",
+		children: materializeInline(label, context),
+		origin: range(labelRange.start, labelRange.end)
+	};
+}
+function materializeDirectiveAttributes(attributes) {
+	return attributes.map((attribute) => ({
+		name: attribute.name,
+		value: attribute.value
+	}));
+}
+/**
+* Children on following lines are Markdown flow content. Like MDX, children on
+* the same line are phrasing: the element is text JSX in a paragraph, which
+* lowering does not wrap in `p`.
+*/
+function materializeFlowJsx(block, context) {
+	const { parts, children } = prepareFlowJsx(block, context);
+	const origin = range(block.range.start, block.range.end);
+	if (parts.children !== void 0 && parts.children.start !== parts.children.end && children === void 0) return {
+		kind: "paragraph",
+		children: [materializeTextJsx(context.file.slice(block.range), origin, context, parts)],
+		origin
+	};
+	return {
+		kind: "jsxFlowElement",
+		name: parts.name,
+		attributes: parts.attributes,
+		children: children === void 0 ? [] : materializeBlocks(children, context),
+		origin
+	};
+}
+function prepareFlowJsx(block, context) {
+	const cached = context.flowJsx.get(block);
+	if (cached !== void 0) return cached;
+	const parts = jsxParts(context.file.slice(block.range), block.range.start);
+	const childRange = parts.children;
+	const prepared = {
+		parts,
+		children: childRange === void 0 || childRange.start === childRange.end || !isFlowJsxChildren(context.file, childRange) ? void 0 : parseFlowRange(grammarSource(context), childRange, context.syntax)
+	};
+	context.flowJsx.set(block, prepared);
+	return prepared;
+}
+function grammarSource(context) {
+	context.grammarSource ??= sourceText(context.file).grammar();
+	return context.grammarSource;
+}
+function materializeTextJsx(authored, jsxOrigin, context, parsed = jsxParts(authored, jsxOrigin.start)) {
+	return {
+		kind: "jsxTextElement",
+		name: parsed.name,
+		attributes: parsed.attributes,
+		children: parsed.children === void 0 ? [] : materializeInline([{
+			kind: "source",
+			range: parsed.children
+		}], context),
+		origin: jsxOrigin
+	};
+}
+function collectIndexes(blocks, context, indexes) {
+	const { definitions, footnotes } = indexes;
+	let nodes = 1;
+	const visit = (block, depth) => {
+		if (context.limit !== void 0) return;
+		if (depth > context.limits.maximumNestingDepth) {
+			context.limit = "maximumNestingDepth";
+			return;
+		}
+		nodes++;
+		if (nodes > context.limits.maximumNodes) {
+			context.limit = "maximumNodes";
+			return;
+		}
+		if (block.kind === "definition") definitions.add(normalizeIdentifier(block.identifier));
+		else if (block.kind === "footnoteDefinition") footnotes.add(normalizeIdentifier(block.identifier));
+		if (block.kind === "blockQuote" || block.kind === "footnoteDefinition" || block.kind === "directive") block.children.forEach((child) => visit(child, depth + 1));
+		else if (block.kind === "list") for (const item of [...block.items, ...block.closing ?? []]) item.children.forEach((child) => visit(child, depth + 1));
+		else if (block.kind === "jsx") prepareFlowJsx(block, context).children?.forEach((child) => visit(child, depth + 1));
+	};
+	blocks.forEach((block) => visit(block, 1));
+}
+function inlineInputText(file, segments) {
+	return new InlineInput(file, segments).toString();
+}
+function inlineSegmentsRange(segments, fallback) {
+	const first = segments.find((segment) => segment.kind === "source");
+	const last = segments.findLast((segment) => segment.kind === "source");
+	return first?.kind === "source" && last?.kind === "source" ? {
+		start: first.range.start,
+		end: last.range.end
+	} : fallback;
+}
+function sliceOptional(file, range) {
+	return range === void 0 ? void 0 : file.slice(range);
+}
+function semanticSliceOptional(file, range) {
+	return range === void 0 ? void 0 : file.semanticSlice(range);
+}
+function trimFinalLineEnding(value) {
+	return value.endsWith("\r\n") ? value.slice(0, -2) : value.endsWith("\n") || value.endsWith("\r") ? value.slice(0, -1) : value;
+}
+function span(file, start, end) {
+	return {
+		file,
+		start,
+		end
+	};
+}
+function range(start, end) {
+	return {
+		start,
+		end
+	};
+}
+function enter(context) {
+	context.depth++;
+	context.maximumDepth = Math.max(context.maximumDepth, context.depth);
+	if (context.depth > context.limits.maximumNestingDepth) {
+		context.limit = "maximumNestingDepth";
+		context.depth--;
+		return false;
+	}
+	return true;
+}
+function counted(context, node) {
+	context.nodes++;
+	if (context.nodes > context.limits.maximumNodes) {
+		context.limit = "maximumNodes";
+		return;
+	}
+	return node;
+}
+function limitDiagnostic(file, limit) {
+	return createDiagnostic({
+		code: `mdx.limit.${limit}`,
+		message: `Parser limit ${limit} exceeded`,
+		severity: "error",
+		span: span(file, 0, file.length)
+	});
+}
+//#endregion
+export { materializeDocument, materializePhrasing, materializePhrasingGroups };
+
+//# sourceMappingURL=materialize.mjs.map