@temelj/mdx 0.14.0 → 0.15.0

package/dist/parser/inline-pending.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-pending.mjs","names":[],"sources":["../../src/parser/inline-pending.ts"],"sourcesContent":["import type { SourceText } from \"../source-text.ts\";\nimport type { ResolvedSyntaxOptions } from \"../syntax-options.ts\";\nimport type { InlineInput } from \"./inline-input.ts\";\nimport type { Output } from \"./inline-output.ts\";\nimport type { InlinePendingSyntax } from \"./inline-syntax.ts\";\n\nimport { isUnicodeWhitespace } from \"./characters.ts\";\nimport { codeSpan } from \"./inline-code.ts\";\nimport { convertOutput, isDelimiter, markerRunEnd, textNode } from \"./inline-output.ts\";\n\nexport interface PendingCandidate {\n  readonly start: number;\n  readonly pending: InlinePendingSyntax;\n}\n\nexport interface PendingInlineResult {\n  readonly pending: InlinePendingSyntax | undefined;\n  /** Earliest raw syntax future input can change; the input length means none remains. */\n  readonly earliest: number;\n}\n\n/**\n * The construct still open at the end of the input. Before `from`, a safe\n * point, every construct is closed, so scans start there, and at `fromOutput`\n * in the output.\n */\nexport function pendingInline(\n  input: InlineInput,\n  value: SourceText,\n  output: readonly Output[],\n  openEmbedded: PendingCandidate | undefined,\n  syntax: ResolvedSyntaxOptions,\n  from: number,\n  fromOutput: number,\n  checkpoint: number | undefined,\n): PendingInlineResult {\n  const candidates: PendingCandidate[] = openEmbedded === undefined ? [] : [openEmbedded];\n  let earliest = value.length;\n\n  for (let index = output.length - 1; index >= fromOutput; index--) {\n    const opener = output[index];\n\n    if (!isDelimiter(opener) || !opener.canOpen || index === output.length - 1) {\n      continue;\n    }\n\n    const kind =\n      opener.marker === \"~\"\n        ? opener.length >= (syntax.singleTilde ? 1 : 2)\n          ? \"delete\"\n          : undefined\n        : opener.length >= 2\n          ? \"strong\"\n          : \"emphasis\";\n\n    if (kind === undefined || isUnicodeWhitespace(value.char(opener.start + opener.length) ?? \"\")) {\n      continue;\n    }\n\n    candidates.push({\n      start: opener.start,\n      pending: {\n        kind,\n        range: input.sourceRange(opener.start, input.length),\n        children: convertOutput(input, output.slice(index + 1)),\n      },\n    });\n    break;\n  }\n\n  for (let offset = value.indexOf(\"`\", from); offset !== -1;) {\n    const matched = codeSpan(input, value, offset);\n\n    if (matched !== undefined) {\n      if (checkpoint !== undefined && offset < checkpoint && matched.end > checkpoint) {\n        earliest = Math.min(earliest, offset);\n      }\n\n      offset = value.indexOf(\"`\", matched.end);\n      continue;\n    }\n\n    const openingEnd = markerRunEnd(value, offset, \"`\");\n    earliest = Math.min(earliest, offset);\n\n    if (openingEnd < value.length) {\n      candidates.push({\n        start: offset,\n        pending: {\n          kind: \"code\",\n          range: input.sourceRange(offset, input.length),\n          value: value.slice(openingEnd).replace(/\\r\\n|[\\r\\n]/gu, \" \"),\n        },\n      });\n    }\n\n    break;\n  }\n\n  const suffix = value.slice(from);\n  // Escaped brackets and brackets inside code still participate in raw pending syntax.\n  const label = /!?\\[[^\\]]*\\]?$/u.exec(suffix);\n\n  if (label !== null) {\n    earliest = Math.min(earliest, from + label.index);\n  }\n\n  const pendingLink = /(!?)\\[([^\\]]+)\\]\\(([^)]*)$/u.exec(suffix);\n\n  if (pendingLink !== null) {\n    const start = from + pendingLink.index;\n    const image = pendingLink[1] === \"!\";\n    candidates.push({\n      start,\n      pending: image\n        ? {\n            kind: \"image\",\n            range: input.sourceRange(start, input.length),\n            alt: pendingLink[2],\n          }\n        : {\n            kind: \"link\",\n            range: input.sourceRange(start, input.length),\n            children: [textNode(input, value, start + 1, start + 1 + pendingLink[2].length)],\n          },\n    });\n  }\n\n  if (syntax.math.includes(\"tex\")) {\n    const start = value.lastIndexOf(\"\\\\(\");\n\n    if (start !== -1 && value.indexOf(\"\\\\)\", start + 2) === -1 && start + 2 < value.length) {\n      candidates.push({\n        start,\n        pending: {\n          kind: \"math\",\n          range: input.sourceRange(start, input.length),\n          value: value.slice(start + 2),\n          format: \"tex\",\n        },\n      });\n    }\n  }\n\n  if (syntax.math.includes(\"dollar\")) {\n    const start = value.lastIndexOf(\"$\");\n\n    if (\n      start !== -1 &&\n      start + 1 < value.length &&\n      !isUnicodeWhitespace(value.char(start + 1) ?? \"\")\n    ) {\n      candidates.push({\n        start,\n        pending: {\n          kind: \"math\",\n          range: input.sourceRange(start, input.length),\n          value: value.slice(start + 1),\n          format: \"dollar\",\n        },\n      });\n    }\n  }\n\n  candidates.sort((left, right) => right.start - left.start);\n\n  return {\n    pending: candidates[0]?.pending,\n    earliest: Math.min(earliest, candidates.at(-1)?.start ?? value.length),\n  };\n}\n"],"mappings":"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"}

package/dist/parser/inline-syntax.d.mts

@@ -0,0 +1,118 @@
+import { SourceRange } from "../ranges.mjs";
+import { MathFormat } from "../syntax-options.mjs";
+//#region src/parser/inline-syntax.d.ts
+export type DefinitionLookup = Pick<ReadonlySet<string>, "has">;
+interface InlineSyntaxBase {
+  readonly range: SourceRange;
+}
+export interface TextSyntax extends InlineSyntaxBase {
+  readonly kind: "text";
+  readonly value: string;
+}
+export interface InlineParentSyntax extends InlineSyntaxBase {
+  readonly kind: "emphasis" | "strong" | "delete";
+  readonly children: readonly InlineSyntax[];
+}
+export interface CodeSpanSyntax extends InlineSyntaxBase {
+  readonly kind: "code";
+  readonly value: string;
+}
+export interface HardBreakSyntax extends InlineSyntaxBase {
+  readonly kind: "hardBreak";
+}
+export interface LinkSyntax extends InlineSyntaxBase {
+  readonly kind: "link";
+  readonly destination: string;
+  readonly title: string | undefined;
+  readonly children: readonly InlineSyntax[];
+}
+export interface ImageSyntax extends InlineSyntaxBase {
+  readonly kind: "image";
+  readonly destination: string;
+  readonly title: string | undefined;
+  readonly alt: string;
+}
+export interface ReferenceSyntax extends InlineSyntaxBase {
+  readonly kind: "reference";
+  readonly identifier: string;
+  readonly referenceKind: "full" | "collapsed" | "shortcut";
+  readonly image: boolean;
+  readonly children: readonly InlineSyntax[];
+}
+interface ValuedInlineSyntax extends InlineSyntaxBase {
+  readonly value: string;
+}
+export interface RawHtmlSyntax extends ValuedInlineSyntax {
+  readonly kind: "rawHtml";
+}
+export interface ExpressionSyntax extends ValuedInlineSyntax {
+  readonly kind: "expression";
+}
+export interface JsxSyntax extends ValuedInlineSyntax {
+  readonly kind: "jsx";
+}
+export interface InlineMathSyntax extends ValuedInlineSyntax {
+  readonly kind: "math";
+  readonly format: MathFormat;
+}
+export interface FootnoteReferenceSyntax extends InlineSyntaxBase {
+  readonly kind: "footnoteReference";
+  readonly identifier: string;
+}
+export interface InlineDirectiveAttribute {
+  readonly name: string;
+  readonly value: string;
+}
+export interface InlineDirectiveSyntax extends InlineSyntaxBase {
+  readonly kind: "directive";
+  readonly name: string;
+  readonly label: readonly InlineSyntax[];
+  readonly attributes: readonly InlineDirectiveAttribute[];
+}
+export type InlineSyntax = TextSyntax | InlineParentSyntax | CodeSpanSyntax | HardBreakSyntax | LinkSyntax | ImageSyntax | ReferenceSyntax | RawHtmlSyntax | ExpressionSyntax | JsxSyntax | InlineMathSyntax | FootnoteReferenceSyntax | InlineDirectiveSyntax;
+export interface InvalidInlineSyntax {
+  readonly range: SourceRange;
+  readonly syntax: "expression" | "jsx";
+  readonly open: boolean;
+}
+export interface InlineParseResult {
+  /** Includes references that could change which surrounding link wins. */
+  readonly references: readonly string[];
+  /**
+   * Parsed nodes. A resumed parse shares this array with the next parse that
+   * resumes from it, so read it before parsing the same input again.
+   */
+  readonly nodes: readonly InlineSyntax[];
+  readonly invalid: readonly InvalidInlineSyntax[];
+  readonly pending?: InlinePendingSyntax;
+  /** First node whose materialized output must be rebuilt. */
+  readonly changedFrom: number;
+}
+export interface PendingInlineParentSyntax extends InlineSyntaxBase {
+  readonly kind: "strong" | "emphasis" | "delete";
+  readonly children: readonly InlineSyntax[];
+}
+export interface PendingCodeSyntax extends InlineSyntaxBase {
+  readonly kind: "code";
+  readonly value: string;
+}
+export interface PendingLinkSyntax extends InlineSyntaxBase {
+  readonly kind: "link";
+  readonly children: readonly InlineSyntax[];
+}
+export interface PendingImageSyntax extends InlineSyntaxBase {
+  readonly kind: "image";
+  readonly alt: string;
+}
+export interface PendingMathSyntax extends InlineSyntaxBase {
+  readonly kind: "math";
+  readonly value: string;
+  readonly format: MathFormat;
+}
+export interface PendingEmbeddedSyntax extends InlineSyntaxBase {
+  readonly kind: "jsx" | "expression";
+}
+export type InlinePendingSyntax = PendingInlineParentSyntax | PendingCodeSyntax | PendingLinkSyntax | PendingImageSyntax | PendingMathSyntax | PendingEmbeddedSyntax;
+//#endregion
+export {};
+//# sourceMappingURL=inline-syntax.d.mts.map

package/dist/parser/inline-syntax.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-syntax.d.mts","names":[],"sources":["../../src/parser/inline-syntax.ts"],"mappings":";;;YAGY,mBAAmB,KAAK;UAE1B;WACC,OAAO;;iBAGD,mBAAmB;WACzB;WACA;;iBAGM,2BAA2B;WACjC;WACA,mBAAmB;;iBAGb,uBAAuB;WAC7B;WACA;;iBAGM,wBAAwB;WAC9B;;iBAGM,mBAAmB;WACzB;WACA;WACA;WACA,mBAAmB;;iBAGb,oBAAoB;WAC1B;WACA;WACA;WACA;;iBAGM,wBAAwB;WAC9B;WACA;WACA;WACA;WACA,mBAAmB;;UAGpB,2BAA2B;WAC1B;;iBAGM,sBAAsB;WAC5B;;iBAGM,yBAAyB;WAC/B;;iBAGM,kBAAkB;WACxB;;iBAGM,yBAAyB;WAC/B;WACA,QAAQ;;iBAGF,gCAAgC;WACtC;WACA;;iBAGM;WACN;WACA;;iBAGM,8BAA8B;WACpC;WACA;WACA,gBAAgB;WAChB,qBAAqB;;YAGpB,eACR,aACA,qBACA,iBACA,kBACA,aACA,cACA,kBACA,gBACA,mBACA,YACA,mBACA,0BACA;iBAEa;WACN,OAAO;WACP;WAEA;;iBAGM;;WAEN;;;;;WAKA,gBAAgB;WAChB,kBAAkB;WAClB,UAAU;;WAEV;;iBAGM,kCAAkC;WACxC;WACA,mBAAmB;;iBAGb,0BAA0B;WAChC;WACA;;iBAGM,0BAA0B;WAChC;WACA,mBAAmB;;iBAGb,2BAA2B;WACjC;WACA;;iBAGM,0BAA0B;WAChC;WACA;WACA,QAAQ;;iBAGF,8BAA8B;WACpC;;YAGC,sBACR,4BACA,oBACA,oBACA,qBACA,oBACA"}

package/dist/parser/inline-syntax.mjs

@@ -0,0 +1 @@
+export {};

package/dist/parser/javascript-boundary.d.mts

@@ -0,0 +1,16 @@
+import { JavaScriptScannerState } from "./javascript-scanner.mjs";
+//#region src/parser/javascript-boundary.d.ts
+export type EmbeddedJavaScriptKind = "expression" | "jsxExpression" | "esm";
+export type JavaScriptBoundaryResult = Readonly<{
+  kind: "valid";
+}> | Readonly<{
+  kind: "incompleteAtPhysicalEof";
+  offset: number;
+  state: JavaScriptScannerState;
+}> | Readonly<{
+  kind: "invalid";
+  offset: number;
+}>;
+export declare function parseJavaScriptBoundary(kind: EmbeddedJavaScriptKind, source: string, sourceOffset?: number): JavaScriptBoundaryResult;
+//#endregion
+//# sourceMappingURL=javascript-boundary.d.mts.map

package/dist/parser/javascript-boundary.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-boundary.d.mts","names":[],"sources":["../../src/parser/javascript-boundary.ts"],"mappings":";;YASY;YAEA,2BACR;EAAW;KACX;EACE;EACA;EACA,OAAO;KAET;EAAW;EAAiB;;wBAEhB,wBACd,MAAM,wBACN,gBACA,wBACC"}

package/dist/parser/javascript-boundary.mjs

@@ -0,0 +1,42 @@
+import { hasJavaScriptToken, parseJavaScriptExpression, parseJavaScriptProgram } from "../javascript.mjs";
+import { JavaScriptScanner } from "./javascript-scanner.mjs";
+import { isNumber, isObject } from "@temelj/value";
+//#region src/parser/javascript-boundary.ts
+function parseJavaScriptBoundary(kind, source, sourceOffset = 0) {
+	try {
+		const node = kind === "esm" ? parseJavaScriptProgram(source) : parseJavaScriptExpression(source);
+		if (kind !== "esm" && hasJavaScriptToken(source.slice(node.end))) return {
+			kind: "invalid",
+			offset: sourceOffset + node.end
+		};
+		return { kind: "valid" };
+	} catch (cause) {
+		const offset = acornFailureOffset(cause);
+		const scanner = new JavaScriptScanner();
+		const scanned = scanner.append(source);
+		if (scanned.kind === "invalid") return {
+			kind: "invalid",
+			offset: sourceOffset + scanned.offset
+		};
+		if (scanner.incomplete || offset >= source.length) return {
+			kind: "incompleteAtPhysicalEof",
+			offset: sourceOffset + source.length,
+			state: scanner.state
+		};
+		return {
+			kind: "invalid",
+			offset: sourceOffset + offset
+		};
+	}
+}
+function acornFailureOffset(cause) {
+	if (!isObject(cause) || !("pos" in cause)) throw cause;
+	const position = cause.pos;
+	if (!isNumber(position)) throw cause;
+	const raisedAt = "raisedAt" in cause ? cause.raisedAt : void 0;
+	return isNumber(raisedAt) ? Math.max(position, raisedAt) : position;
+}
+//#endregion
+export { parseJavaScriptBoundary };
+
+//# sourceMappingURL=javascript-boundary.mjs.map

package/dist/parser/javascript-boundary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-boundary.mjs","names":[],"sources":["../../src/parser/javascript-boundary.ts"],"sourcesContent":["import { isObject, isNumber } from \"@temelj/value\";\n\nimport {\n  hasJavaScriptToken,\n  parseJavaScriptExpression,\n  parseJavaScriptProgram,\n} from \"../javascript.ts\";\nimport { JavaScriptScanner, type JavaScriptScannerState } from \"./javascript-scanner.ts\";\n\nexport type EmbeddedJavaScriptKind = \"expression\" | \"jsxExpression\" | \"esm\";\n\nexport type JavaScriptBoundaryResult =\n  | Readonly<{ kind: \"valid\" }>\n  | Readonly<{\n      kind: \"incompleteAtPhysicalEof\";\n      offset: number;\n      state: JavaScriptScannerState;\n    }>\n  | Readonly<{ kind: \"invalid\"; offset: number }>;\n\nexport function parseJavaScriptBoundary(\n  kind: EmbeddedJavaScriptKind,\n  source: string,\n  sourceOffset = 0,\n): JavaScriptBoundaryResult {\n  try {\n    const node =\n      kind === \"esm\" ? parseJavaScriptProgram(source) : parseJavaScriptExpression(source);\n\n    if (kind !== \"esm\" && hasJavaScriptToken(source.slice(node.end))) {\n      return { kind: \"invalid\", offset: sourceOffset + node.end };\n    }\n\n    return { kind: \"valid\" };\n  } catch (cause) {\n    const offset = acornFailureOffset(cause);\n    const scanner = new JavaScriptScanner();\n    const scanned = scanner.append(source);\n\n    if (scanned.kind === \"invalid\") {\n      return { kind: \"invalid\", offset: sourceOffset + scanned.offset };\n    }\n\n    if (scanner.incomplete || offset >= source.length) {\n      return {\n        kind: \"incompleteAtPhysicalEof\",\n        offset: sourceOffset + source.length,\n        state: scanner.state,\n      };\n    }\n\n    return { kind: \"invalid\", offset: sourceOffset + offset };\n  }\n}\n\nfunction acornFailureOffset(cause: unknown): number {\n  if (!isObject(cause) || !(\"pos\" in cause)) {\n    throw cause;\n  }\n\n  const position = cause.pos;\n\n  if (!isNumber(position)) {\n    throw cause;\n  }\n\n  const raisedAt = \"raisedAt\" in cause ? cause.raisedAt : undefined;\n\n  return isNumber(raisedAt) ? Math.max(position, raisedAt) : position;\n}\n"],"mappings":";;;;AAoBA,SAAgB,wBACd,MACA,QACA,eAAe,GACW;CAC1B,IAAI;EACF,MAAM,OACJ,SAAS,QAAQ,uBAAuB,MAAM,IAAI,0BAA0B,MAAM;EAEpF,IAAI,SAAS,SAAS,mBAAmB,OAAO,MAAM,KAAK,GAAG,CAAC,GAC7D,OAAO;GAAE,MAAM;GAAW,QAAQ,eAAe,KAAK;EAAI;EAG5D,OAAO,EAAE,MAAM,QAAQ;CACzB,SAAS,OAAO;EACd,MAAM,SAAS,mBAAmB,KAAK;EACvC,MAAM,UAAU,IAAI,kBAAkB;EACtC,MAAM,UAAU,QAAQ,OAAO,MAAM;EAErC,IAAI,QAAQ,SAAS,WACnB,OAAO;GAAE,MAAM;GAAW,QAAQ,eAAe,QAAQ;EAAO;EAGlE,IAAI,QAAQ,cAAc,UAAU,OAAO,QACzC,OAAO;GACL,MAAM;GACN,QAAQ,eAAe,OAAO;GAC9B,OAAO,QAAQ;EACjB;EAGF,OAAO;GAAE,MAAM;GAAW,QAAQ,eAAe;EAAO;CAC1D;AACF;AAEA,SAAS,mBAAmB,OAAwB;CAClD,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,SAAS,QACjC,MAAM;CAGR,MAAM,WAAW,MAAM;CAEvB,IAAI,CAAC,SAAS,QAAQ,GACpB,MAAM;CAGR,MAAM,WAAW,cAAc,QAAQ,MAAM,WAAW,KAAA;CAExD,OAAO,SAAS,QAAQ,IAAI,KAAK,IAAI,UAAU,QAAQ,IAAI;AAC7D"}

package/dist/parser/javascript-scanner.d.mts

@@ -0,0 +1,22 @@
+//#region src/parser/javascript-scanner.d.ts
+export type EmbeddedScannerResult = Readonly<{
+  kind: "open";
+}> | Readonly<{
+  kind: "closed";
+  offset: number;
+}> | Readonly<{
+  kind: "invalid";
+  offset: number;
+}>;
+export type JavaScriptScannerState = "code" | "singleQuotedString" | "doubleQuotedString" | "template" | "lineComment" | "blockComment" | "regularExpression";
+/** Retained lexical state shared by embedded expressions and strict JavaScript validation. */
+export declare class JavaScriptScanner {
+  #private;
+  constructor(outer?: "}");
+  get state(): JavaScriptScannerState;
+  get incomplete(): boolean;
+  append(text: string): EmbeddedScannerResult;
+  clone(): JavaScriptScanner;
+}
+//#endregion
+//# sourceMappingURL=javascript-scanner.d.mts.map

package/dist/parser/javascript-scanner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-scanner.d.mts","names":[],"sources":["../../src/parser/javascript-scanner.ts"],"mappings":";YAEY,wBACR;EAAW;KACX;EAAW;EAAgB;KAC3B;EAAW;EAAiB;;YAEpB;;qBAeC;;EAQX,YAAmB;MAQR,SAAS;MAIT;EAIJ,OAAO,eAAe;EAwHtB,SAAS"}

package/dist/parser/javascript-scanner.mjs

@@ -0,0 +1,122 @@
+import { startsRegularExpression } from "../javascript.mjs";
+//#region src/parser/javascript-scanner.ts
+/** Retained lexical state shared by embedded expressions and strict JavaScript validation. */
+var JavaScriptScanner = class JavaScriptScanner {
+	#delimiters = [];
+	#outer;
+	#source = "";
+	#characterClass = false;
+	#escaped = false;
+	#state = "code";
+	constructor(outer) {
+		this.#outer = outer;
+		if (outer !== void 0) this.#delimiters.push({
+			character: outer,
+			resumesTemplate: false
+		});
+	}
+	get state() {
+		return this.#state === "lineComment" ? "code" : this.#state;
+	}
+	get incomplete() {
+		return this.state !== "code" || this.#delimiters.length > 0;
+	}
+	append(text) {
+		const start = this.#source.length;
+		this.#source += text;
+		for (let index = 0; index < text.length; index++) {
+			const character = text[index];
+			const next = text[index + 1];
+			if (this.#state === "lineComment") {
+				if (character === "\n" || character === "\r") this.#state = "code";
+				continue;
+			}
+			if (this.#state === "blockComment") {
+				if (character === "*" && next === "/") {
+					this.#state = "code";
+					index++;
+				}
+				continue;
+			}
+			if (this.#state === "singleQuotedString" || this.#state === "doubleQuotedString") {
+				if (this.#escaped) this.#escaped = false;
+				else if (character === "\\") this.#escaped = true;
+				else if (this.#state === "singleQuotedString" && character === "'" || this.#state === "doubleQuotedString" && character === "\"") this.#state = "code";
+				continue;
+			}
+			if (this.#state === "regularExpression") {
+				if (this.#escaped) this.#escaped = false;
+				else if (character === "\\") this.#escaped = true;
+				else if (character === "[") this.#characterClass = true;
+				else if (character === "]") this.#characterClass = false;
+				else if (character === "/" && !this.#characterClass) this.#state = "code";
+				continue;
+			}
+			if (this.#state === "template") {
+				if (this.#escaped) this.#escaped = false;
+				else if (character === "\\") this.#escaped = true;
+				else if (character === "`") this.#state = "code";
+				else if (character === "$" && next === "{") {
+					this.#delimiters.push({
+						character: "}",
+						resumesTemplate: true
+					});
+					this.#state = "code";
+					index++;
+				}
+				continue;
+			}
+			if (character === "/" && next === "/") {
+				this.#state = "lineComment";
+				index++;
+			} else if (character === "/" && next === "*") {
+				this.#state = "blockComment";
+				index++;
+			} else if (character === "/" && startsRegularExpression((this.#outer === void 0 ? "" : "(") + this.#source.slice(0, start + index))) {
+				this.#state = "regularExpression";
+				this.#characterClass = false;
+			} else if (character === "'") this.#state = "singleQuotedString";
+			else if (character === "\"") this.#state = "doubleQuotedString";
+			else if (character === "`") this.#state = "template";
+			else if (character === "(") this.#delimiters.push({
+				character: ")",
+				resumesTemplate: false
+			});
+			else if (character === "[") this.#delimiters.push({
+				character: "]",
+				resumesTemplate: false
+			});
+			else if (character === "{") this.#delimiters.push({
+				character: "}",
+				resumesTemplate: false
+			});
+			else if (character === ")" || character === "]" || character === "}") {
+				const delimiter = this.#delimiters.at(-1);
+				if (delimiter?.character !== character) return {
+					kind: "invalid",
+					offset: index
+				};
+				this.#delimiters.pop();
+				if (this.#outer !== void 0 && this.#delimiters.length === 0) return {
+					kind: "closed",
+					offset: index + 1
+				};
+				if (delimiter.resumesTemplate) this.#state = "template";
+			}
+		}
+		return { kind: "open" };
+	}
+	clone() {
+		const copy = new JavaScriptScanner(this.#outer);
+		copy.#source = this.#source;
+		copy.#characterClass = this.#characterClass;
+		copy.#delimiters.splice(0, copy.#delimiters.length, ...this.#delimiters);
+		copy.#escaped = this.#escaped;
+		copy.#state = this.#state;
+		return copy;
+	}
+};
+//#endregion
+export { JavaScriptScanner };
+
+//# sourceMappingURL=javascript-scanner.mjs.map

package/dist/parser/javascript-scanner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-scanner.mjs","names":[],"sources":["../../src/parser/javascript-scanner.ts"],"sourcesContent":["import { startsRegularExpression } from \"../javascript.ts\";\n\nexport type EmbeddedScannerResult =\n  | Readonly<{ kind: \"open\" }>\n  | Readonly<{ kind: \"closed\"; offset: number }>\n  | Readonly<{ kind: \"invalid\"; offset: number }>;\n\nexport type JavaScriptScannerState =\n  | \"code\"\n  | \"singleQuotedString\"\n  | \"doubleQuotedString\"\n  | \"template\"\n  | \"lineComment\"\n  | \"blockComment\"\n  | \"regularExpression\";\n\ninterface JavaScriptDelimiter {\n  readonly character: \")\" | \"]\" | \"}\";\n  readonly resumesTemplate: boolean;\n}\n\n/** Retained lexical state shared by embedded expressions and strict JavaScript validation. */\nexport class JavaScriptScanner {\n  readonly #delimiters: JavaScriptDelimiter[] = [];\n  readonly #outer: \"}\" | undefined;\n  #source = \"\";\n  #characterClass = false;\n  #escaped = false;\n  #state: JavaScriptScannerState = \"code\";\n\n  public constructor(outer?: \"}\") {\n    this.#outer = outer;\n\n    if (outer !== undefined) {\n      this.#delimiters.push({ character: outer, resumesTemplate: false });\n    }\n  }\n\n  public get state(): JavaScriptScannerState {\n    return this.#state === \"lineComment\" ? \"code\" : this.#state;\n  }\n\n  public get incomplete(): boolean {\n    return this.state !== \"code\" || this.#delimiters.length > 0;\n  }\n\n  public append(text: string): EmbeddedScannerResult {\n    const start = this.#source.length;\n    this.#source += text;\n\n    for (let index = 0; index < text.length; index++) {\n      const character = text[index];\n      const next = text[index + 1];\n\n      if (this.#state === \"lineComment\") {\n        if (character === \"\\n\" || character === \"\\r\") {\n          this.#state = \"code\";\n        }\n\n        continue;\n      }\n\n      if (this.#state === \"blockComment\") {\n        if (character === \"*\" && next === \"/\") {\n          this.#state = \"code\";\n          index++;\n        }\n\n        continue;\n      }\n\n      if (this.#state === \"singleQuotedString\" || this.#state === \"doubleQuotedString\") {\n        if (this.#escaped) {\n          this.#escaped = false;\n        } else if (character === \"\\\\\") {\n          this.#escaped = true;\n        } else if (\n          (this.#state === \"singleQuotedString\" && character === \"'\") ||\n          (this.#state === \"doubleQuotedString\" && character === '\"')\n        ) {\n          this.#state = \"code\";\n        }\n\n        continue;\n      }\n\n      if (this.#state === \"regularExpression\") {\n        if (this.#escaped) {\n          this.#escaped = false;\n        } else if (character === \"\\\\\") {\n          this.#escaped = true;\n        } else if (character === \"[\") {\n          this.#characterClass = true;\n        } else if (character === \"]\") {\n          this.#characterClass = false;\n        } else if (character === \"/\" && !this.#characterClass) {\n          this.#state = \"code\";\n        }\n\n        continue;\n      }\n\n      if (this.#state === \"template\") {\n        if (this.#escaped) {\n          this.#escaped = false;\n        } else if (character === \"\\\\\") {\n          this.#escaped = true;\n        } else if (character === \"`\") {\n          this.#state = \"code\";\n        } else if (character === \"$\" && next === \"{\") {\n          this.#delimiters.push({ character: \"}\", resumesTemplate: true });\n          this.#state = \"code\";\n          index++;\n        }\n\n        continue;\n      }\n\n      if (character === \"/\" && next === \"/\") {\n        this.#state = \"lineComment\";\n        index++;\n      } else if (character === \"/\" && next === \"*\") {\n        this.#state = \"blockComment\";\n        index++;\n      } else if (\n        character === \"/\" &&\n        startsRegularExpression(\n          (this.#outer === undefined ? \"\" : \"(\") + this.#source.slice(0, start + index),\n        )\n      ) {\n        this.#state = \"regularExpression\";\n        this.#characterClass = false;\n      } else if (character === \"'\") {\n        this.#state = \"singleQuotedString\";\n      } else if (character === '\"') {\n        this.#state = \"doubleQuotedString\";\n      } else if (character === \"`\") {\n        this.#state = \"template\";\n      } else if (character === \"(\") {\n        this.#delimiters.push({ character: \")\", resumesTemplate: false });\n      } else if (character === \"[\") {\n        this.#delimiters.push({ character: \"]\", resumesTemplate: false });\n      } else if (character === \"{\") {\n        this.#delimiters.push({ character: \"}\", resumesTemplate: false });\n      } else if (character === \")\" || character === \"]\" || character === \"}\") {\n        const delimiter = this.#delimiters.at(-1);\n\n        if (delimiter?.character !== character) {\n          return { kind: \"invalid\", offset: index };\n        }\n\n        this.#delimiters.pop();\n\n        if (this.#outer !== undefined && this.#delimiters.length === 0) {\n          return { kind: \"closed\", offset: index + 1 };\n        }\n\n        if (delimiter.resumesTemplate) {\n          this.#state = \"template\";\n        }\n      }\n    }\n\n    return { kind: \"open\" };\n  }\n\n  public clone(): JavaScriptScanner {\n    const copy = new JavaScriptScanner(this.#outer);\n    copy.#source = this.#source;\n    copy.#characterClass = this.#characterClass;\n    copy.#delimiters.splice(0, copy.#delimiters.length, ...this.#delimiters);\n    copy.#escaped = this.#escaped;\n    copy.#state = this.#state;\n\n    return copy;\n  }\n}\n"],"mappings":"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"}

package/dist/parser/materialize-cache.d.mts

@@ -0,0 +1,34 @@
+import { FlowContent, ListItemNode } from "../model.mjs";
+import { BlockSyntax, ListItemSyntax } from "./block-syntax.mjs";
+//#region src/parser/materialize-cache.d.ts
+export interface CachedMaterialization<TNode> {
+  readonly node: TNode;
+  readonly nodeCount: number;
+  readonly depth: number;
+  readonly references: readonly string[];
+}
+/**
+ * Materialized nodes keyed by parser output identity, for materialization that
+ * keeps references. Resolving references depends on the definitions, so a
+ * resolving materialization does not use a cache.
+ */
+export interface MaterializeCache {
+  readonly blocks: WeakMap<BlockSyntax, CachedMaterialization<FlowContent>>;
+  readonly items: WeakMap<ListItemSyntax, CachedMaterialization<ListItemNode>>;
+  /** A growing list's leading items, by the item they end with. */
+  readonly lists: WeakMap<ListItemSyntax, CachedListPrefix>;
+}
+/** The materialized first `index + 1` items of a list: the first `length` of `nodes`. */
+export interface CachedListPrefix {
+  readonly index: number;
+  readonly nodes: ListItemNode[];
+  readonly length: number;
+  /** `nodes` belongs to the open list, which extends it in place on the next append. */
+  readonly live: boolean;
+  readonly nodeCount: number;
+  readonly depth: number;
+  readonly references: readonly string[];
+}
+export declare function createMaterializeCache(): MaterializeCache;
+//#endregion
+//# sourceMappingURL=materialize-cache.d.mts.map

package/dist/parser/materialize-cache.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize-cache.d.mts","names":[],"sources":["../../src/parser/materialize-cache.ts"],"mappings":";;;iBAGiB,sBAAsB;WAC5B,MAAM;WACN;WACA;WACA;;;;;;;iBAQM;WACN,QAAQ,QAAQ,aAAa,sBAAsB;WACnD,OAAO,QAAQ,gBAAgB,sBAAsB;;WAErD,OAAO,QAAQ,gBAAgB;;;iBAIzB;WACN;WACA,OAAO;WACP;;WAEA;WACA;WACA;WACA;;wBAGK,0BAA0B"}

package/dist/parser/materialize-cache.mjs

@@ -0,0 +1,12 @@
+//#region src/parser/materialize-cache.ts
+function createMaterializeCache() {
+	return {
+		blocks: /* @__PURE__ */ new WeakMap(),
+		items: /* @__PURE__ */ new WeakMap(),
+		lists: /* @__PURE__ */ new WeakMap()
+	};
+}
+//#endregion
+export { createMaterializeCache };
+
+//# sourceMappingURL=materialize-cache.mjs.map

package/dist/parser/materialize-cache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize-cache.mjs","names":[],"sources":["../../src/parser/materialize-cache.ts"],"sourcesContent":["import type { FlowContent, ListItemNode } from \"../model.ts\";\nimport type { BlockSyntax, ListItemSyntax } from \"./block-syntax.ts\";\n\nexport interface CachedMaterialization<TNode> {\n  readonly node: TNode;\n  readonly nodeCount: number;\n  readonly depth: number;\n  readonly references: readonly string[];\n}\n\n/**\n * Materialized nodes keyed by parser output identity, for materialization that\n * keeps references. Resolving references depends on the definitions, so a\n * resolving materialization does not use a cache.\n */\nexport interface MaterializeCache {\n  readonly blocks: WeakMap<BlockSyntax, CachedMaterialization<FlowContent>>;\n  readonly items: WeakMap<ListItemSyntax, CachedMaterialization<ListItemNode>>;\n  /** A growing list's leading items, by the item they end with. */\n  readonly lists: WeakMap<ListItemSyntax, CachedListPrefix>;\n}\n\n/** The materialized first `index + 1` items of a list: the first `length` of `nodes`. */\nexport interface CachedListPrefix {\n  readonly index: number;\n  readonly nodes: ListItemNode[];\n  readonly length: number;\n  /** `nodes` belongs to the open list, which extends it in place on the next append. */\n  readonly live: boolean;\n  readonly nodeCount: number;\n  readonly depth: number;\n  readonly references: readonly string[];\n}\n\nexport function createMaterializeCache(): MaterializeCache {\n  return { blocks: new WeakMap(), items: new WeakMap(), lists: new WeakMap() };\n}\n"],"mappings":";AAkCA,SAAgB,yBAA2C;CACzD,OAAO;EAAE,wBAAQ,IAAI,QAAQ;EAAG,uBAAO,IAAI,QAAQ;EAAG,uBAAO,IAAI,QAAQ;CAAE;AAC7E"}

package/dist/parser/materialize-jsx.d.mts

@@ -0,0 +1,14 @@
+import { SourceRange } from "../ranges.mjs";
+import { JsxAttributeLike } from "../model.mjs";
+import { SourceFile } from "../source.mjs";
+//#region src/parser/materialize-jsx.d.ts
+/** Children that start on a new line are Markdown flow content; same-line children are phrasing. */
+export declare function isFlowJsxChildren(file: SourceFile, range: SourceRange): boolean;
+export interface JsxParts {
+  readonly attributes: readonly JsxAttributeLike[];
+  readonly children: SourceRange | undefined;
+  readonly name: string | undefined;
+}
+export declare function jsxParts(authored: string, sourceOffset: number): JsxParts;
+//#endregion
+//# sourceMappingURL=materialize-jsx.d.mts.map

package/dist/parser/materialize-jsx.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize-jsx.d.mts","names":[],"sources":["../../src/parser/materialize-jsx.ts"],"mappings":";;;;;wBAWgB,kBAAkB,MAAM,YAAY,OAAO;iBAI1C;WACN,qBAAqB;WACrB,UAAU;WACV;;wBAGK,SAAS,kBAAkB,uBAAuB"}

package/dist/parser/materialize-jsx.mjs

@@ -0,0 +1,76 @@
+import { CompileError } from "../errors.mjs";
+import { childNode, nodeArray, nodeValue } from "../javascript-ast.mjs";
+import { parseJavaScriptExpression } from "../javascript.mjs";
+import { isString } from "@temelj/value";
+//#region src/parser/materialize-jsx.ts
+/** Children that start on a new line are Markdown flow content; same-line children are phrasing. */
+function isFlowJsxChildren(file, range) {
+	return /^[ \t]*(?:\r\n|\r|\n)/u.test(file.slice(range));
+}
+function jsxParts(authored, sourceOffset) {
+	const element = parseJavaScriptExpression(authored);
+	const fragment = element.type === "JSXFragment";
+	const opening = childNode(nodeValue(element, fragment ? "openingFragment" : "openingElement"));
+	const closing = childNode(nodeValue(element, fragment ? "closingFragment" : "closingElement"));
+	if (opening === void 0) throw CompileError.jsxElementOpeningMissing();
+	const name = fragment ? void 0 : childNode(nodeValue(opening, "name"));
+	if (!fragment && name === void 0) throw CompileError.jsxElementNameMissing();
+	return {
+		attributes: nodeArray(opening, "attributes").map((attribute) => jsxAttribute(attribute, authored, sourceOffset)),
+		children: closing === void 0 ? void 0 : range(sourceOffset + opening.end, sourceOffset + closing.start),
+		name: name === void 0 ? void 0 : authored.slice(name.start, name.end)
+	};
+}
+function jsxAttribute(attribute, opening, sourceOffset) {
+	const origin = range(sourceOffset + attribute.start, sourceOffset + attribute.end);
+	if (attribute.type === "JSXSpreadAttribute") {
+		const argument = childNode(nodeValue(attribute, "argument"));
+		if (argument === void 0) throw CompileError.jsxSpreadArgumentMissing();
+		return {
+			kind: "jsxSpreadAttribute",
+			code: opening.slice(argument.start, argument.end),
+			origin
+		};
+	}
+	const nameNode = childNode(nodeValue(attribute, "name"));
+	const name = nameNode === void 0 ? void 0 : opening.slice(nameNode.start, nameNode.end);
+	const value = childNode(nodeValue(attribute, "value"));
+	if (name === void 0) throw CompileError.jsxAttributeNameMissing();
+	if (value === void 0) return {
+		kind: "jsxAttribute",
+		name,
+		origin
+	};
+	if (value.type === "JSXExpressionContainer") {
+		const expression = childNode(nodeValue(value, "expression"));
+		if (expression === void 0 || expression.type === "JSXEmptyExpression") throw CompileError.jsxAttributeExpressionEmpty();
+		return {
+			kind: "jsxAttribute",
+			name,
+			value: {
+				kind: "jsxAttributeValueExpression",
+				code: opening.slice(expression.start, expression.end),
+				origin: range(sourceOffset + value.start, sourceOffset + value.end)
+			},
+			origin
+		};
+	}
+	const literal = nodeValue(value, "value");
+	if (!isString(literal)) throw CompileError.jsxAttributeExpressionEmpty();
+	return {
+		kind: "jsxAttribute",
+		name,
+		value: literal,
+		origin
+	};
+}
+function range(start, end) {
+	return {
+		start,
+		end
+	};
+}
+//#endregion
+export { isFlowJsxChildren, jsxParts };
+
+//# sourceMappingURL=materialize-jsx.mjs.map

package/dist/parser/materialize-jsx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize-jsx.mjs","names":[],"sources":["../../src/parser/materialize-jsx.ts"],"sourcesContent":["import { isString } from \"@temelj/value\";\n\nimport type { JsxAttributeLike } from \"../model.ts\";\nimport type { SourceRange } from \"../ranges.ts\";\nimport type { SourceFile } from \"../source.ts\";\n\nimport { CompileError } from \"../errors.ts\";\nimport { childNode, nodeArray, nodeValue, type JavaScriptNode } from \"../javascript-ast.ts\";\nimport { parseJavaScriptExpression } from \"../javascript.ts\";\n\n/** Children that start on a new line are Markdown flow content; same-line children are phrasing. */\nexport function isFlowJsxChildren(file: SourceFile, range: SourceRange): boolean {\n  return /^[ \\t]*(?:\\r\\n|\\r|\\n)/u.test(file.slice(range));\n}\n\nexport interface JsxParts {\n  readonly attributes: readonly JsxAttributeLike[];\n  readonly children: SourceRange | undefined;\n  readonly name: string | undefined;\n}\n\nexport function jsxParts(authored: string, sourceOffset: number): JsxParts {\n  const element = parseJavaScriptExpression(authored);\n  const fragment = element.type === \"JSXFragment\";\n  const opening = childNode(nodeValue(element, fragment ? \"openingFragment\" : \"openingElement\"));\n  const closing = childNode(nodeValue(element, fragment ? \"closingFragment\" : \"closingElement\"));\n\n  if (opening === undefined) {\n    throw CompileError.jsxElementOpeningMissing();\n  }\n\n  const name = fragment ? undefined : childNode(nodeValue(opening, \"name\"));\n\n  if (!fragment && name === undefined) {\n    throw CompileError.jsxElementNameMissing();\n  }\n\n  return {\n    attributes: nodeArray(opening, \"attributes\").map((attribute) =>\n      jsxAttribute(attribute, authored, sourceOffset),\n    ),\n    children:\n      closing === undefined\n        ? undefined\n        : range(sourceOffset + opening.end, sourceOffset + closing.start),\n    name: name === undefined ? undefined : authored.slice(name.start, name.end),\n  };\n}\n\nfunction jsxAttribute(\n  attribute: JavaScriptNode,\n  opening: string,\n  sourceOffset: number,\n): JsxAttributeLike {\n  const origin = range(sourceOffset + attribute.start, sourceOffset + attribute.end);\n\n  if (attribute.type === \"JSXSpreadAttribute\") {\n    const argument = childNode(nodeValue(attribute, \"argument\"));\n\n    if (argument === undefined) {\n      throw CompileError.jsxSpreadArgumentMissing();\n    }\n\n    return {\n      kind: \"jsxSpreadAttribute\",\n      code: opening.slice(argument.start, argument.end),\n      origin,\n    };\n  }\n\n  const nameNode = childNode(nodeValue(attribute, \"name\"));\n  const name = nameNode === undefined ? undefined : opening.slice(nameNode.start, nameNode.end);\n  const value = childNode(nodeValue(attribute, \"value\"));\n\n  if (name === undefined) {\n    throw CompileError.jsxAttributeNameMissing();\n  }\n\n  if (value === undefined) {\n    return { kind: \"jsxAttribute\", name, origin };\n  }\n\n  if (value.type === \"JSXExpressionContainer\") {\n    const expression = childNode(nodeValue(value, \"expression\"));\n\n    if (expression === undefined || expression.type === \"JSXEmptyExpression\") {\n      throw CompileError.jsxAttributeExpressionEmpty();\n    }\n\n    return {\n      kind: \"jsxAttribute\",\n      name,\n      value: {\n        kind: \"jsxAttributeValueExpression\",\n        code: opening.slice(expression.start, expression.end),\n        origin: range(sourceOffset + value.start, sourceOffset + value.end),\n      },\n      origin,\n    };\n  }\n\n  // String literals keep JSX semantics, including decoded character references.\n  const literal = nodeValue(value, \"value\");\n\n  if (!isString(literal)) {\n    throw CompileError.jsxAttributeExpressionEmpty();\n  }\n\n  return { kind: \"jsxAttribute\", name, value: literal, origin };\n}\n\nfunction range(start: number, end: number): SourceRange {\n  return { start, end };\n}\n"],"mappings":";;;;;;AAWA,SAAgB,kBAAkB,MAAkB,OAA6B;CAC/E,OAAO,yBAAyB,KAAK,KAAK,MAAM,KAAK,CAAC;AACxD;AAQA,SAAgB,SAAS,UAAkB,cAAgC;CACzE,MAAM,UAAU,0BAA0B,QAAQ;CAClD,MAAM,WAAW,QAAQ,SAAS;CAClC,MAAM,UAAU,UAAU,UAAU,SAAS,WAAW,oBAAoB,gBAAgB,CAAC;CAC7F,MAAM,UAAU,UAAU,UAAU,SAAS,WAAW,oBAAoB,gBAAgB,CAAC;CAE7F,IAAI,YAAY,KAAA,GACd,MAAM,aAAa,yBAAyB;CAG9C,MAAM,OAAO,WAAW,KAAA,IAAY,UAAU,UAAU,SAAS,MAAM,CAAC;CAExE,IAAI,CAAC,YAAY,SAAS,KAAA,GACxB,MAAM,aAAa,sBAAsB;CAG3C,OAAO;EACL,YAAY,UAAU,SAAS,YAAY,CAAC,CAAC,KAAK,cAChD,aAAa,WAAW,UAAU,YAAY,CAChD;EACA,UACE,YAAY,KAAA,IACR,KAAA,IACA,MAAM,eAAe,QAAQ,KAAK,eAAe,QAAQ,KAAK;EACpE,MAAM,SAAS,KAAA,IAAY,KAAA,IAAY,SAAS,MAAM,KAAK,OAAO,KAAK,GAAG;CAC5E;AACF;AAEA,SAAS,aACP,WACA,SACA,cACkB;CAClB,MAAM,SAAS,MAAM,eAAe,UAAU,OAAO,eAAe,UAAU,GAAG;CAEjF,IAAI,UAAU,SAAS,sBAAsB;EAC3C,MAAM,WAAW,UAAU,UAAU,WAAW,UAAU,CAAC;EAE3D,IAAI,aAAa,KAAA,GACf,MAAM,aAAa,yBAAyB;EAG9C,OAAO;GACL,MAAM;GACN,MAAM,QAAQ,MAAM,SAAS,OAAO,SAAS,GAAG;GAChD;EACF;CACF;CAEA,MAAM,WAAW,UAAU,UAAU,WAAW,MAAM,CAAC;CACvD,MAAM,OAAO,aAAa,KAAA,IAAY,KAAA,IAAY,QAAQ,MAAM,SAAS,OAAO,SAAS,GAAG;CAC5F,MAAM,QAAQ,UAAU,UAAU,WAAW,OAAO,CAAC;CAErD,IAAI,SAAS,KAAA,GACX,MAAM,aAAa,wBAAwB;CAG7C,IAAI,UAAU,KAAA,GACZ,OAAO;EAAE,MAAM;EAAgB;EAAM;CAAO;CAG9C,IAAI,MAAM,SAAS,0BAA0B;EAC3C,MAAM,aAAa,UAAU,UAAU,OAAO,YAAY,CAAC;EAE3D,IAAI,eAAe,KAAA,KAAa,WAAW,SAAS,sBAClD,MAAM,aAAa,4BAA4B;EAGjD,OAAO;GACL,MAAM;GACN;GACA,OAAO;IACL,MAAM;IACN,MAAM,QAAQ,MAAM,WAAW,OAAO,WAAW,GAAG;IACpD,QAAQ,MAAM,eAAe,MAAM,OAAO,eAAe,MAAM,GAAG;GACpE;GACA;EACF;CACF;CAGA,MAAM,UAAU,UAAU,OAAO,OAAO;CAExC,IAAI,CAAC,SAAS,OAAO,GACnB,MAAM,aAAa,4BAA4B;CAGjD,OAAO;EAAE,MAAM;EAAgB;EAAM,OAAO;EAAS;CAAO;AAC9D;AAEA,SAAS,MAAM,OAAe,KAA0B;CACtD,OAAO;EAAE;EAAO;CAAI;AACtB"}

package/dist/parser/materialize.d.mts

@@ -0,0 +1,61 @@
+import { SourceRange } from "../ranges.mjs";
+import { ResolvedSyntaxOptions } from "../syntax-options.mjs";
+import { DocumentNode, FlowContent, PhrasingContent } from "../model.mjs";
+import { SourceFile } from "../source.mjs";
+import { Diagnostic } from "../diagnostics.mjs";
+import { ResolvedParserLimits } from "./config.mjs";
+import { BlockSyntax } from "./block-syntax.mjs";
+import { DefinitionLookup, InlineSyntax } from "./inline-syntax.mjs";
+import { MaterializeCache } from "./materialize-cache.mjs";
+//#region src/parser/materialize.d.ts
+export interface MaterializedBlock {
+  readonly references: readonly string[];
+  readonly nodeCount: number;
+  readonly node: FlowContent;
+}
+export interface MaterializeOptions {
+  /** Definitions already known to a stream, including definitions in other blocks. */
+  readonly definitionLookup?: DefinitionLookup;
+  /**
+   * Keeps references whose definitions are missing, for a stream where the
+   * definitions may still arrive. Otherwise they become authored text.
+   */
+  readonly keepReferences?: boolean;
+  /** Open embedded syntax at the end of the source is inert instead of invalid. */
+  readonly allowIncomplete?: boolean;
+  readonly cache?: MaterializeCache;
+  /**
+   * The range of a stream's open leaf. A stream renders that leaf itself, so it
+   * materializes as an empty placeholder with the same kind and origin.
+   */
+  readonly open?: SourceRange;
+}
+export type StrictMaterializeResult = Readonly<{
+  kind: "ok";
+  document: DocumentNode;
+  blocks: readonly MaterializedBlock[];
+  diagnostics: readonly Diagnostic[];
+}> | Readonly<{
+  kind: "invalid";
+  diagnostics: readonly [Diagnostic, ...Diagnostic[]];
+}> | Readonly<{
+  kind: "limitExceeded";
+  limit: "maximumNestingDepth" | "maximumNodes";
+  diagnostics: readonly [Diagnostic, ...Diagnostic[]];
+}>;
+export declare function materializeDocument(file: SourceFile, blocks: readonly BlockSyntax[], syntax: ResolvedSyntaxOptions, limits: ResolvedParserLimits, options?: MaterializeOptions): StrictMaterializeResult;
+export interface MaterializedPhrasing {
+  readonly nodes: readonly PhrasingContent[];
+  readonly nodeCount: number;
+}
+/** Materialized phrasing by inline syntax identity, valid while references are kept. */
+export type PhrasingCache = WeakMap<InlineSyntax, MaterializedPhrasing>;
+/**
+ * Materializes parsed inline syntax that a stream renders outside a block,
+ * keeping references.
+ */
+export declare function materializePhrasing(file: SourceFile, nodes: readonly InlineSyntax[], syntax: ResolvedSyntaxOptions, limits: ResolvedParserLimits): MaterializedPhrasing;
+/** Independent inline groups share one context while retaining their own node budgets. */
+export declare function materializePhrasingGroups(file: SourceFile, nodes: readonly InlineSyntax[], syntax: ResolvedSyntaxOptions, limits: ResolvedParserLimits, cache: PhrasingCache): readonly MaterializedPhrasing[];
+//#endregion
+//# sourceMappingURL=materialize.d.mts.map

package/dist/parser/materialize.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize.d.mts","names":[],"sources":["../../src/parser/materialize.ts"],"mappings":";;;;;;;;;;iBAuCiB;WACN;WACA;WACA,MAAM;;iBAGA;;WAEN,mBAAmB;;;;;WAKnB;;WAEA;WACA,QAAQ;;;;;WAKR,OAAO;;YAGN,0BACR;EACE;EACA,UAAU;EACV,iBAAiB;EACjB,sBAAsB;KAExB;EAAW;EAAiB,uBAAuB,eAAe;KAClE;EACE;EACA;EACA,uBAAuB,eAAe;;wBAgC5B,oBACd,MAAM,YACN,iBAAiB,eACjB,QAAQ,uBACR,QAAQ,sBACR,UAAS,qBACR;iBAkGc;WACN,gBAAgB;WAChB;;;YAIC,gBAAgB,QAAQ,cAAc;;;;;wBAMlC,oBACd,MAAM,YACN,gBAAgB,gBAChB,QAAQ,uBACR,QAAQ,uBACP;;wBAoBa,0BACd,MAAM,YACN,gBAAgB,gBAChB,QAAQ,uBACR,QAAQ,sBACR,OAAO,yBACG"}