@temelj/mdx 0.14.0 → 0.16.0

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

@@ -0,0 +1,34 @@
+import { SourceText } from "../source-text.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { InlineSyntax } from "./inline-syntax.mjs";
+//#region src/parser/inline-output.d.ts
+export interface Delimiter {
+  readonly canClose: boolean;
+  readonly canOpen: boolean;
+  readonly marker: "*" | "_" | "~";
+  readonly originalLength: number;
+  length: number;
+  start: number;
+}
+export interface Bracket {
+  active: boolean;
+  readonly image: boolean;
+  readonly start: number;
+}
+export type Output = InlineSyntax | Delimiter | Bracket;
+export interface InlineMatch {
+  readonly end: number;
+  readonly node: InlineSyntax;
+}
+export declare function convertOutput(input: InlineInput, output: readonly Output[], target?: InlineSyntax[]): InlineSyntax[];
+export declare function findUnescapedInline(value: SourceText, target: string, start: number): number | undefined;
+export declare function escapedAt(value: SourceText, offset: number, lowerBound: number): boolean;
+export declare function textNode(input: InlineInput, value: SourceText, start: number, end: number): InlineSyntax;
+export declare function delimiterText(input: InlineInput, delimiter: Delimiter): InlineSyntax;
+export declare function bracketText(input: InlineInput, bracket: Bracket): InlineSyntax;
+export declare function isDelimiter(output: Output): output is Delimiter;
+export declare function isBracket(output: Output): output is Bracket;
+export declare function markerRunEnd(value: SourceText, start: number, marker: string): number;
+export declare function mergeText(nodes: readonly InlineSyntax[], merged?: InlineSyntax[]): InlineSyntax[];
+//#endregion
+//# sourceMappingURL=inline-output.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-output.d.mts","names":[],"sources":["../../src/parser/inline-output.ts"],"mappings":";;;;iBAQiB;WACN;WACA;WACA;WACA;EACT;EACA;;iBAGe;EACf;WACS;WACA;;YAGC,SAAS,eAAe,YAAY;iBAE/B;WACN;WACA,MAAM;;wBAGD,cACd,OAAO,aACP,iBAAiB,UACjB,SAAQ,iBACP;wBAaa,oBACd,OAAO,YACP,gBACA;wBAWc,UAAU,OAAO,YAAY,gBAAgB;wBAU7C,SACd,OAAO,aACP,OAAO,YACP,eACA,cACC;wBAQa,cAAc,OAAO,aAAa,WAAW,YAAY;wBAQzD,YAAY,OAAO,aAAa,SAAS,UAAU;wBAUnD,YAAY,QAAQ,SAAS,UAAU;wBAIvC,UAAU,QAAQ,SAAS,UAAU;wBAIrC,aAAa,OAAO,YAAY,eAAe;wBAU/C,UACd,gBAAgB,gBAChB,SAAQ,iBACP"}

package/dist/parser/inline-output.mjs

@@ -0,0 +1,62 @@
+import { sourceRange } from "../ranges.mjs";
+//#region src/parser/inline-output.ts
+function convertOutput(input, output, target = []) {
+	return mergeText(output.map((entry) => isDelimiter(entry) ? delimiterText(input, entry) : isBracket(entry) ? bracketText(input, entry) : entry), target);
+}
+function findUnescapedInline(value, target, start) {
+	for (let offset = start; offset < value.length; offset++) if (value.char(offset) === target && !escapedAt(value, offset, start)) return offset;
+}
+function escapedAt(value, offset, lowerBound) {
+	let slashes = 0;
+	for (let index = offset - 1; index >= lowerBound && value.char(index) === "\\"; index--) slashes++;
+	return slashes % 2 === 1;
+}
+function textNode(input, value, start, end) {
+	return {
+		kind: "text",
+		range: input.sourceRange(start, end),
+		value: value.slice(start, end)
+	};
+}
+function delimiterText(input, delimiter) {
+	return {
+		kind: "text",
+		range: input.sourceRange(delimiter.start, delimiter.start + delimiter.length),
+		value: delimiter.marker.repeat(delimiter.length)
+	};
+}
+function bracketText(input, bracket) {
+	const end = bracket.start + (bracket.image ? 2 : 1);
+	return {
+		kind: "text",
+		range: input.sourceRange(bracket.start, end),
+		value: bracket.image ? "![" : "["
+	};
+}
+function isDelimiter(output) {
+	return "marker" in output;
+}
+function isBracket(output) {
+	return "active" in output;
+}
+function markerRunEnd(value, start, marker) {
+	let end = start;
+	while (value.char(end) === marker) end++;
+	return end;
+}
+function mergeText(nodes, merged = []) {
+	for (const node of nodes) {
+		const previous = merged.at(-1);
+		if (previous?.kind === "text" && node.kind === "text" && previous.range.end === node.range.start) merged[merged.length - 1] = {
+			kind: "text",
+			range: sourceRange(previous.range.start, node.range.end),
+			value: previous.value + node.value
+		};
+		else merged.push(node);
+	}
+	return merged;
+}
+//#endregion
+export { bracketText, convertOutput, delimiterText, escapedAt, findUnescapedInline, isBracket, isDelimiter, markerRunEnd, mergeText, textNode };
+
+//# sourceMappingURL=inline-output.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-output.mjs","names":[],"sources":["../../src/parser/inline-output.ts"],"sourcesContent":["import type { SourceText } from \"../source-text.ts\";\nimport type { InlineInput } from \"./inline-input.ts\";\nimport type { InlineSyntax } from \"./inline-syntax.ts\";\n\nimport { sourceRange } from \"../ranges.ts\";\n\n// The inline parser's output sequence: parsed nodes, delimiter runs, and brackets.\n\nexport interface Delimiter {\n  readonly canClose: boolean;\n  readonly canOpen: boolean;\n  readonly marker: \"*\" | \"_\" | \"~\";\n  readonly originalLength: number;\n  length: number;\n  start: number;\n}\n\nexport interface Bracket {\n  active: boolean;\n  readonly image: boolean;\n  readonly start: number;\n}\n\nexport type Output = InlineSyntax | Delimiter | Bracket;\n\nexport interface InlineMatch {\n  readonly end: number;\n  readonly node: InlineSyntax;\n}\n\nexport function convertOutput(\n  input: InlineInput,\n  output: readonly Output[],\n  target: InlineSyntax[] = [],\n): InlineSyntax[] {\n  return mergeText(\n    output.map((entry) =>\n      isDelimiter(entry)\n        ? delimiterText(input, entry)\n        : isBracket(entry)\n          ? bracketText(input, entry)\n          : entry,\n    ),\n    target,\n  );\n}\n\nexport function findUnescapedInline(\n  value: SourceText,\n  target: string,\n  start: number,\n): number | undefined {\n  for (let offset = start; offset < value.length; offset++) {\n    if (value.char(offset) === target && !escapedAt(value, offset, start)) {\n      return offset;\n    }\n  }\n\n  return;\n}\n\nexport function escapedAt(value: SourceText, offset: number, lowerBound: number): boolean {\n  let slashes = 0;\n\n  for (let index = offset - 1; index >= lowerBound && value.char(index) === \"\\\\\"; index--) {\n    slashes++;\n  }\n\n  return slashes % 2 === 1;\n}\n\nexport function textNode(\n  input: InlineInput,\n  value: SourceText,\n  start: number,\n  end: number,\n): InlineSyntax {\n  return {\n    kind: \"text\",\n    range: input.sourceRange(start, end),\n    value: value.slice(start, end),\n  };\n}\n\nexport function delimiterText(input: InlineInput, delimiter: Delimiter): InlineSyntax {\n  return {\n    kind: \"text\",\n    range: input.sourceRange(delimiter.start, delimiter.start + delimiter.length),\n    value: delimiter.marker.repeat(delimiter.length),\n  };\n}\n\nexport function bracketText(input: InlineInput, bracket: Bracket): InlineSyntax {\n  const end = bracket.start + (bracket.image ? 2 : 1);\n\n  return {\n    kind: \"text\",\n    range: input.sourceRange(bracket.start, end),\n    value: bracket.image ? \"![\" : \"[\",\n  };\n}\n\nexport function isDelimiter(output: Output): output is Delimiter {\n  return \"marker\" in output;\n}\n\nexport function isBracket(output: Output): output is Bracket {\n  return \"active\" in output;\n}\n\nexport function markerRunEnd(value: SourceText, start: number, marker: string): number {\n  let end = start;\n\n  while (value.char(end) === marker) {\n    end++;\n  }\n\n  return end;\n}\n\nexport function mergeText(\n  nodes: readonly InlineSyntax[],\n  merged: InlineSyntax[] = [],\n): InlineSyntax[] {\n  for (const node of nodes) {\n    const previous = merged.at(-1);\n\n    if (\n      previous?.kind === \"text\" &&\n      node.kind === \"text\" &&\n      previous.range.end === node.range.start\n    ) {\n      merged[merged.length - 1] = {\n        kind: \"text\",\n        range: sourceRange(previous.range.start, node.range.end),\n        value: previous.value + node.value,\n      };\n    } else {\n      merged.push(node);\n    }\n  }\n\n  return merged;\n}\n"],"mappings":";;AA8BA,SAAgB,cACd,OACA,QACA,SAAyB,CAAC,GACV;CAChB,OAAO,UACL,OAAO,KAAK,UACV,YAAY,KAAK,IACb,cAAc,OAAO,KAAK,IAC1B,UAAU,KAAK,IACb,YAAY,OAAO,KAAK,IACxB,KACR,GACA,MACF;AACF;AAEA,SAAgB,oBACd,OACA,QACA,OACoB;CACpB,KAAK,IAAI,SAAS,OAAO,SAAS,MAAM,QAAQ,UAC9C,IAAI,MAAM,KAAK,MAAM,MAAM,UAAU,CAAC,UAAU,OAAO,QAAQ,KAAK,GAClE,OAAO;AAKb;AAEA,SAAgB,UAAU,OAAmB,QAAgB,YAA6B;CACxF,IAAI,UAAU;CAEd,KAAK,IAAI,QAAQ,SAAS,GAAG,SAAS,cAAc,MAAM,KAAK,KAAK,MAAM,MAAM,SAC9E;CAGF,OAAO,UAAU,MAAM;AACzB;AAEA,SAAgB,SACd,OACA,OACA,OACA,KACc;CACd,OAAO;EACL,MAAM;EACN,OAAO,MAAM,YAAY,OAAO,GAAG;EACnC,OAAO,MAAM,MAAM,OAAO,GAAG;CAC/B;AACF;AAEA,SAAgB,cAAc,OAAoB,WAAoC;CACpF,OAAO;EACL,MAAM;EACN,OAAO,MAAM,YAAY,UAAU,OAAO,UAAU,QAAQ,UAAU,MAAM;EAC5E,OAAO,UAAU,OAAO,OAAO,UAAU,MAAM;CACjD;AACF;AAEA,SAAgB,YAAY,OAAoB,SAAgC;CAC9E,MAAM,MAAM,QAAQ,SAAS,QAAQ,QAAQ,IAAI;CAEjD,OAAO;EACL,MAAM;EACN,OAAO,MAAM,YAAY,QAAQ,OAAO,GAAG;EAC3C,OAAO,QAAQ,QAAQ,OAAO;CAChC;AACF;AAEA,SAAgB,YAAY,QAAqC;CAC/D,OAAO,YAAY;AACrB;AAEA,SAAgB,UAAU,QAAmC;CAC3D,OAAO,YAAY;AACrB;AAEA,SAAgB,aAAa,OAAmB,OAAe,QAAwB;CACrF,IAAI,MAAM;CAEV,OAAO,MAAM,KAAK,GAAG,MAAM,QACzB;CAGF,OAAO;AACT;AAEA,SAAgB,UACd,OACA,SAAyB,CAAC,GACV;CAChB,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,WAAW,OAAO,GAAG,EAAE;EAE7B,IACE,UAAU,SAAS,UACnB,KAAK,SAAS,UACd,SAAS,MAAM,QAAQ,KAAK,MAAM,OAElC,OAAO,OAAO,SAAS,KAAK;GAC1B,MAAM;GACN,OAAO,YAAY,SAAS,MAAM,OAAO,KAAK,MAAM,GAAG;GACvD,OAAO,SAAS,QAAQ,KAAK;EAC/B;OAEA,OAAO,KAAK,IAAI;CAEpB;CAEA,OAAO;AACT"}

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

@@ -0,0 +1,14 @@
+import { ResolvedSyntaxOptions } from "../syntax-options.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { DefinitionLookup, InlineParseResult } from "./inline-syntax.mjs";
+//#region src/parser/inline-parser.d.ts
+/** A paragraph owns its continuation; edits start a new parse. */
+export declare class InlineParser {
+  #private;
+  constructor(syntax: ResolvedSyntaxOptions);
+  parse(input: InlineInput, definitions?: DefinitionLookup): InlineParseResult;
+}
+/** Complete input uses the same grammar without retaining preview state. */
+export declare function parseInline(input: InlineInput, syntax: ResolvedSyntaxOptions, definitions?: DefinitionLookup): InlineParseResult;
+//#endregion
+//# sourceMappingURL=inline-parser.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-parser.d.mts","names":[],"sources":["../../src/parser/inline-parser.ts"],"mappings":";;;;;qBAsDa;;EAKX,YAAmB,QAAQ;EAIpB,MACL,OAAO,aACP,cAAa,mBACZ;;;wBAoBW,YACd,OAAO,aACP,QAAQ,uBACR,cAAa,mBACZ"}

package/dist/parser/inline-parser.mjs

@@ -0,0 +1,328 @@
+import { isAsciiPunctuation } from "./characters.mjs";
+import { convertOutput, markerRunEnd, textNode } from "./inline-output.mjs";
+import { matchLiteralAutolink } from "./inline-autolink.mjs";
+import { characterReference } from "./inline-character-reference.mjs";
+import { codeSpan } from "./inline-code.mjs";
+import { directiveUnfinished, inlineDirective } from "./inline-directive.mjs";
+import { angleNode, expressionNode } from "./inline-embedded.mjs";
+import { createDelimiter, resolveCloser, resolveDelimiters } from "./inline-emphasis.mjs";
+import { resolveBracket } from "./inline-link.mjs";
+import { dollarMath, dollarUnclosed, texMath } from "./inline-math.mjs";
+import { pendingInline } from "./inline-pending.mjs";
+//#region src/parser/inline-parser.ts
+/** A paragraph owns its continuation; edits start a new parse. */
+var InlineParser = class {
+	#syntax;
+	#state;
+	#definitions = emptyDefinitions;
+	constructor(syntax) {
+		this.#syntax = syntax;
+	}
+	parse(input, definitions = emptyDefinitions) {
+		const previous = this.#state;
+		const state = previous === void 0 || definitions === this.#definitions || previous.references.every((id) => definitions.has(id) === this.#definitions.has(id)) ? previous : void 0;
+		this.#definitions = definitions;
+		const resumed = state !== void 0 && input.extends(state.input) ? state : void 0;
+		const scan = new InlineScan(input, this.#syntax, resumed, true, definitions);
+		const parsed = scan.run();
+		this.#state = scan.state;
+		return parsed;
+	}
+};
+/** Complete input uses the same grammar without retaining preview state. */
+function parseInline(input, syntax, definitions = emptyDefinitions) {
+	return new InlineScan(input, syntax, void 0, false, definitions).run();
+}
+const emptyDefinitions = /* @__PURE__ */ new Set();
+const INLINE_MARKERS = /[\\\r\n \t![\]`&{<_*~:$hHwW]/gu;
+const EMAIL_MARKERS = /[\\\r\n \t![\]`&{<_*~:$A-Za-z\d.+-]/gu;
+/** One inline parse: the output sequence, the delimiter and bracket stacks, and the cursor. */
+var InlineScan = class {
+	state;
+	#input;
+	#value;
+	#syntax;
+	#resumed;
+	#preview;
+	#emailAutolinks;
+	#output;
+	#delimiters = [];
+	#brackets = [];
+	#invalid;
+	#definitions;
+	#references;
+	#openEmbedded;
+	#textStart;
+	#offset;
+	#safe;
+	/** A construct that failed only because input ended may still close, changing earlier output. */
+	#stable = true;
+	constructor(input, syntax, resumed, preview, definitions) {
+		const value = input.text();
+		this.#input = input;
+		this.#value = value;
+		this.#syntax = syntax;
+		this.#resumed = resumed;
+		this.#preview = preview;
+		this.#definitions = definitions;
+		this.#references = new Set(resumed?.references);
+		this.#output = resumed === void 0 ? [] : resumed.output;
+		this.#output.length = resumed?.outputLength ?? 0;
+		this.#invalid = resumed === void 0 ? [] : [...resumed.invalid];
+		this.#textStart = resumed?.textStart ?? 0;
+		this.#offset = resumed?.offset ?? 0;
+		this.#emailAutolinks = value.indexOf("@", this.#offset) !== -1;
+	}
+	run() {
+		while (this.#offset < this.#value.length) {
+			const character = this.#value.char(this.#offset) ?? "";
+			if (this.#preview) this.recordSafePoint(character);
+			if (!this.scanConstruct(character)) this.#offset = this.#value.findCharacter(this.#emailAutolinks ? EMAIL_MARKERS : INLINE_MARKERS, this.#offset + 1);
+		}
+		if (this.#preview) this.recordSafePoint();
+		this.flushText(this.#value.length);
+		resolveDelimiters(this.#input, this.#output, this.#delimiters, this.#syntax);
+		return this.result();
+	}
+	result() {
+		const input = this.#input;
+		const output = this.#output;
+		const resumed = this.#resumed;
+		const resumedLength = resumed?.outputLength ?? 0;
+		const unsettled = this.#preview ? pendingInline(input, this.#value, output, this.#openEmbedded, this.#syntax, resumed?.offset ?? 0, resumedLength, this.#safe?.offset) : void 0;
+		const pending = unsettled?.pending;
+		let safe = this.#safe;
+		if (safe !== void 0 && unsettled !== void 0 && unsettled.earliest < safe.offset) safe = void 0;
+		const nodes = resumed?.nodes ?? [];
+		let changedFrom = resumed?.nodesLength ?? 0;
+		if (resumed !== void 0) {
+			nodes.length = resumed.nodesLength;
+			if (resumed.lastNode !== void 0) {
+				nodes[nodes.length - 1] = resumed.lastNode;
+				if (resumed.lastNode.kind === "text") changedFrom--;
+			}
+		}
+		const end = safe?.output ?? resumedLength;
+		if (end > resumedLength) convertOutput(input, output.slice(resumedLength, end), nodes);
+		this.state = safe === void 0 ? resumed : {
+			offset: safe.offset,
+			textStart: safe.textStart,
+			input,
+			output,
+			outputLength: safe.output,
+			invalid: this.#invalid.slice(0, safe.invalid),
+			references: [...this.#references].slice(0, safe.references),
+			nodes,
+			nodesLength: nodes.length,
+			lastNode: nodes.at(-1)
+		};
+		convertOutput(input, end === 0 ? output : output.slice(end), nodes);
+		return {
+			nodes,
+			invalid: this.#invalid,
+			pending,
+			changedFrom,
+			references: [...this.#references]
+		};
+	}
+	/** Consumes the construct at the cursor, in CommonMark precedence order. */
+	scanConstruct(character) {
+		switch (character) {
+			case ":": return this.scanDirective();
+			case "\\": return this.scanTexMath() || this.scanBackslash();
+			case "$": return this.scanDollarMath();
+			case "\n":
+			case "\r": return this.scanSpaceBreak(character);
+			case "!":
+			case "[": return this.scanOpenBracket(character);
+			case "]": return this.scanCloseBracket();
+			case "`": return this.scanCodeSpan();
+			case "&": return this.scanCharacterReference();
+			case "{": return this.scanExpression();
+			case "<": return this.scanAngle();
+			case "_": return this.scanAutolink(character) || this.scanDelimiterRun(character);
+			case "*":
+			case "~": return this.scanDelimiterRun(character);
+			default: return this.scanAutolink(character);
+		}
+	}
+	/** Known whitespace ends a token; open constructs keep their earlier retry point. */
+	recordSafePoint(character) {
+		const previous = this.#value.char(this.#offset - 1);
+		if (this.#stable && this.#offset > (this.#resumed?.offset ?? 0) && (character === " " || character === "	" || previous === "\n" || previous === "\r" && character !== "\n") && this.#brackets.length === 0 && !this.#delimiters.some((delimiter) => delimiter.canOpen)) this.#safe = {
+			offset: this.#offset,
+			textStart: this.#textStart,
+			output: this.#output.length,
+			invalid: this.#invalid.length,
+			references: this.#references.size
+		};
+	}
+	scanDirective() {
+		if (!this.#syntax.directives) return false;
+		const directive = inlineDirective(this.#input, this.#value, this.#offset);
+		this.#stable &&= directive !== void 0 || !directiveUnfinished(this.#value, this.#offset);
+		return directive !== void 0 && this.emit(directive);
+	}
+	scanTexMath() {
+		if (this.#value.char(this.#offset + 1) !== "(" || !this.#syntax.math.includes("tex")) return false;
+		const math = texMath(this.#input, this.#value, this.#offset);
+		this.#stable &&= math !== void 0;
+		return math !== void 0 && this.emit(math);
+	}
+	scanDollarMath() {
+		if (!this.#syntax.math.includes("dollar")) return false;
+		const math = dollarMath(this.#input, this.#value, this.#offset);
+		this.#stable &&= math !== void 0 || !dollarUnclosed(this.#value, this.#offset);
+		return math !== void 0 && this.emit(math);
+	}
+	/** Two or more spaces before a line ending make a hard break. */
+	scanSpaceBreak(character) {
+		const value = this.#value;
+		let spaces = this.#offset;
+		while (spaces > this.#textStart && value.char(spaces - 1) === " ") spaces--;
+		if (this.#offset - spaces < 2) return false;
+		this.flushText(spaces);
+		const end = character === "\r" && value.char(this.#offset + 1) === "\n" ? this.#offset + 2 : this.#offset + 1;
+		this.#output.push({
+			kind: "hardBreak",
+			range: this.#input.sourceRange(spaces, end)
+		});
+		return this.advance(end);
+	}
+	scanAutolink(character) {
+		if (this.#brackets.length > 0) return false;
+		if (!this.#emailAutolinks && !"hHwW".includes(character)) return false;
+		const autolink = matchLiteralAutolink(this.#input, this.#value, this.#offset);
+		return autolink !== void 0 && this.emit(autolink);
+	}
+	scanOpenBracket(character) {
+		const image = character === "!" && this.#value.char(this.#offset + 1) === "[";
+		if (character !== "[" && !image) return false;
+		this.flushText(this.#offset);
+		const bracket = {
+			active: true,
+			image,
+			start: this.#offset
+		};
+		this.#output.push(bracket);
+		this.#brackets.push(bracket);
+		return this.advance(this.#offset + (image ? 2 : 1));
+	}
+	scanCloseBracket() {
+		const bracket = this.#brackets.at(-1);
+		if (bracket === void 0) return false;
+		this.flushText(this.#offset);
+		this.#brackets.pop();
+		const resolved = resolveBracket(this.#input, this.#value, this.#offset, bracket, this.#output, this.#delimiters, this.#syntax, this.#definitions, this.#references, this.#brackets.length > 0);
+		this.#stable &&= resolved !== void 0;
+		if (resolved === void 0) {
+			this.#output.push(textNode(this.#input, this.#value, this.#offset, this.#offset + 1));
+			return this.advance(this.#offset + 1);
+		}
+		if (resolved.link) {
+			for (const opener of this.#brackets) if (!opener.image) opener.active = false;
+		}
+		return this.advance(resolved.end);
+	}
+	/** A backslash before a line ending is a hard break; before punctuation, an escape. */
+	scanBackslash() {
+		const next = this.#value.char(this.#offset + 1);
+		if (next === "\n" || next === "\r") {
+			this.flushText(this.#offset);
+			const end = next === "\r" && this.#value.char(this.#offset + 2) === "\n" ? this.#offset + 3 : this.#offset + 2;
+			this.#output.push({
+				kind: "hardBreak",
+				range: this.#input.sourceRange(this.#offset, end)
+			});
+			return this.advance(end);
+		}
+		if (next === void 0 || !isAsciiPunctuation(next)) return false;
+		this.flushText(this.#offset);
+		this.#output.push(textNode(this.#input, this.#value, this.#offset + 1, this.#offset + 2));
+		return this.advance(this.#offset + 2);
+	}
+	scanCodeSpan() {
+		const code = codeSpan(this.#input, this.#value, this.#offset);
+		this.#stable &&= code !== void 0;
+		return code !== void 0 && this.emit(code);
+	}
+	scanCharacterReference() {
+		const reference = characterReference(this.#input, this.#value, this.#offset);
+		return reference !== void 0 && this.emit(reference);
+	}
+	scanExpression() {
+		const expression = expressionNode(this.#input, this.#value, this.#offset);
+		if (expression === void 0) return false;
+		const range = this.#input.sourceRange(this.#offset, expression.end);
+		this.flushText(this.#offset);
+		this.#stable &&= !expression.open;
+		if (expression.node === void 0) {
+			this.#invalid.push({
+				range,
+				syntax: "expression",
+				open: expression.open
+			});
+			if (expression.open) this.#openEmbedded = {
+				start: this.#offset,
+				pending: {
+					kind: "expression",
+					range
+				}
+			};
+			this.#output.push(textNode(this.#input, this.#value, this.#offset, expression.end));
+		} else this.#output.push(expression.node);
+		return this.advance(expression.end);
+	}
+	scanAngle() {
+		const angle = angleNode(this.#input, this.#value, this.#offset);
+		if (angle === void 0) return false;
+		const range = this.#input.sourceRange(this.#offset, angle.end);
+		this.flushText(this.#offset);
+		this.#stable &&= !angle.open;
+		if (angle.invalid) {
+			this.#invalid.push({
+				range,
+				syntax: "jsx",
+				open: angle.open
+			});
+			if (angle.open) this.#openEmbedded = {
+				start: this.#offset,
+				pending: {
+					kind: "jsx",
+					range
+				}
+			};
+		}
+		this.#output.push(angle.node);
+		return this.advance(angle.end);
+	}
+	scanDelimiterRun(character) {
+		const runEnd = markerRunEnd(this.#value, this.#offset, character);
+		if (character === "~" && runEnd - this.#offset < (this.#syntax.singleTilde ? 1 : 2)) return false;
+		this.flushText(this.#offset);
+		const delimiter = createDelimiter(this.#value, this.#offset, runEnd, character);
+		this.#output.push(delimiter);
+		this.#delimiters.push(delimiter);
+		resolveCloser(this.#input, this.#output, this.#delimiters, delimiter, this.#syntax, this.#brackets.at(-1)?.start ?? -1);
+		return this.advance(runEnd);
+	}
+	/** Appends a matched construct and moves the cursor after it. */
+	emit(match) {
+		this.flushText(this.#offset);
+		this.#output.push(match.node);
+		return this.advance(match.end);
+	}
+	advance(end) {
+		this.#offset = end;
+		this.#textStart = end;
+		return true;
+	}
+	flushText(end) {
+		if (end > this.#textStart) this.#output.push(textNode(this.#input, this.#value, this.#textStart, end));
+		this.#textStart = end;
+	}
+};
+//#endregion
+export { InlineParser, parseInline };
+
+//# sourceMappingURL=inline-parser.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-parser.mjs","names":[],"sources":["../../src/parser/inline-parser.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 { Bracket, Delimiter, InlineMatch, Output } from \"./inline-output.ts\";\nimport type { PendingCandidate } from \"./inline-pending.ts\";\nimport type {\n  DefinitionLookup,\n  InlineParseResult,\n  InlineSyntax,\n  InvalidInlineSyntax,\n} from \"./inline-syntax.ts\";\n\nimport { isAsciiPunctuation } from \"./characters.ts\";\nimport { matchLiteralAutolink } from \"./inline-autolink.ts\";\nimport { characterReference } from \"./inline-character-reference.ts\";\nimport { codeSpan } from \"./inline-code.ts\";\nimport { directiveUnfinished, inlineDirective } from \"./inline-directive.ts\";\nimport { angleNode, expressionNode } from \"./inline-embedded.ts\";\nimport { createDelimiter, resolveCloser, resolveDelimiters } from \"./inline-emphasis.ts\";\nimport { resolveBracket } from \"./inline-link.ts\";\nimport { dollarMath, dollarUnclosed, texMath } from \"./inline-math.ts\";\nimport { convertOutput, markerRunEnd, textNode } from \"./inline-output.ts\";\nimport { pendingInline } from \"./inline-pending.ts\";\n\n/** Private arrays retained before the suffix that future input can still change. */\ninterface ResumeState {\n  readonly offset: number;\n  readonly textStart: number;\n  /** The input the state came from. */\n  readonly input: InlineInput;\n  /**\n   * The parse's own output array with its length at the safe\n   * point. Entries before a safe point never change, so the next parse takes\n   * the arrays over and truncates them instead of copying.\n   */\n  readonly output: Output[];\n  readonly outputLength: number;\n  readonly invalid: readonly InvalidInlineSyntax[];\n  readonly references: readonly string[];\n  /** `output` as nodes, which resumed parses extend in place to keep node identities. */\n  readonly nodes: InlineSyntax[];\n  readonly nodesLength: number;\n  readonly lastNode: InlineSyntax | undefined;\n}\n\ninterface SafePoint {\n  readonly offset: number;\n  readonly textStart: number;\n  readonly output: number;\n  readonly invalid: number;\n  readonly references: number;\n}\n\n/** A paragraph owns its continuation; edits start a new parse. */\nexport class InlineParser {\n  readonly #syntax: ResolvedSyntaxOptions;\n  #state: ResumeState | undefined;\n  #definitions: DefinitionLookup = emptyDefinitions;\n\n  public constructor(syntax: ResolvedSyntaxOptions) {\n    this.#syntax = syntax;\n  }\n\n  public parse(\n    input: InlineInput,\n    definitions: DefinitionLookup = emptyDefinitions,\n  ): InlineParseResult {\n    const previous = this.#state;\n\n    const stable =\n      previous === undefined ||\n      definitions === this.#definitions ||\n      previous.references.every((id) => definitions.has(id) === this.#definitions.has(id));\n\n    const state = stable ? previous : undefined;\n    this.#definitions = definitions;\n    const resumed = state !== undefined && input.extends(state.input) ? state : undefined;\n    const scan = new InlineScan(input, this.#syntax, resumed, true, definitions);\n    const parsed = scan.run();\n    this.#state = scan.state;\n\n    return parsed;\n  }\n}\n\n/** Complete input uses the same grammar without retaining preview state. */\nexport function parseInline(\n  input: InlineInput,\n  syntax: ResolvedSyntaxOptions,\n  definitions: DefinitionLookup = emptyDefinitions,\n): InlineParseResult {\n  return new InlineScan(input, syntax, undefined, false, definitions).run();\n}\n\nconst emptyDefinitions: DefinitionLookup = new Set<string>();\n\nconst INLINE_MARKERS = /[\\\\\\r\\n \\t![\\]`&{<_*~:$hHwW]/gu;\n\nconst EMAIL_MARKERS = /[\\\\\\r\\n \\t![\\]`&{<_*~:$A-Za-z\\d.+-]/gu;\n\n/** One inline parse: the output sequence, the delimiter and bracket stacks, and the cursor. */\nclass InlineScan {\n  public state: ResumeState | undefined;\n  readonly #input: InlineInput;\n  readonly #value: SourceText;\n  readonly #syntax: ResolvedSyntaxOptions;\n  readonly #resumed: ResumeState | undefined;\n  readonly #preview: boolean;\n  readonly #emailAutolinks: boolean;\n  readonly #output: Output[];\n  readonly #delimiters: Delimiter[] = [];\n  readonly #brackets: Bracket[] = [];\n  readonly #invalid: InvalidInlineSyntax[];\n  readonly #definitions: DefinitionLookup;\n  readonly #references: Set<string>;\n  #openEmbedded: PendingCandidate | undefined;\n  #textStart: number;\n  #offset: number;\n  #safe: SafePoint | undefined;\n  /** A construct that failed only because input ended may still close, changing earlier output. */\n  #stable = true;\n\n  public constructor(\n    input: InlineInput,\n    syntax: ResolvedSyntaxOptions,\n    resumed: ResumeState | undefined,\n    preview: boolean,\n    definitions: DefinitionLookup,\n  ) {\n    const value = input.text();\n    this.#input = input;\n    this.#value = value;\n    this.#syntax = syntax;\n    this.#resumed = resumed;\n    this.#preview = preview;\n    this.#definitions = definitions;\n    this.#references = new Set(resumed?.references);\n    this.#output = resumed === undefined ? [] : resumed.output;\n    this.#output.length = resumed?.outputLength ?? 0;\n    this.#invalid = resumed === undefined ? [] : [...resumed.invalid];\n    this.#textStart = resumed?.textStart ?? 0;\n    this.#offset = resumed?.offset ?? 0;\n    this.#emailAutolinks = value.indexOf(\"@\", this.#offset) !== -1;\n  }\n\n  public run(): InlineParseResult {\n    while (this.#offset < this.#value.length) {\n      const character = this.#value.char(this.#offset) ?? \"\";\n\n      if (this.#preview) {\n        this.recordSafePoint(character);\n      }\n\n      if (!this.scanConstruct(character)) {\n        this.#offset = this.#value.findCharacter(\n          this.#emailAutolinks ? EMAIL_MARKERS : INLINE_MARKERS,\n          this.#offset + 1,\n        );\n      }\n    }\n\n    // Input that ends with a line ending can resume after it.\n    if (this.#preview) {\n      this.recordSafePoint();\n    }\n\n    this.flushText(this.#value.length);\n    resolveDelimiters(this.#input, this.#output, this.#delimiters, this.#syntax);\n\n    return this.result();\n  }\n\n  private result(): InlineParseResult {\n    const input = this.#input;\n    const output = this.#output;\n    const resumed = this.#resumed;\n    const resumedLength = resumed?.outputLength ?? 0;\n\n    const unsettled = this.#preview\n      ? pendingInline(\n          input,\n          this.#value,\n          output,\n          this.#openEmbedded,\n          this.#syntax,\n          resumed?.offset ?? 0,\n          resumedLength,\n          this.#safe?.offset,\n        )\n      : undefined;\n\n    const pending = unsettled?.pending;\n    let safe = this.#safe;\n\n    // Raw pending syntax can start inside a construct consumed by the grammar.\n    // Keep that candidate in the retry region rather than skipping it next time.\n    if (safe !== undefined && unsettled !== undefined && unsettled.earliest < safe.offset) {\n      safe = undefined;\n    }\n\n    const nodes = resumed?.nodes ?? [];\n    let changedFrom = resumed?.nodesLength ?? 0;\n\n    if (resumed !== undefined) {\n      nodes.length = resumed.nodesLength;\n\n      if (resumed.lastNode !== undefined) {\n        nodes[nodes.length - 1] = resumed.lastNode;\n\n        if (resumed.lastNode.kind === \"text\") {\n          changedFrom--;\n        }\n      }\n    }\n\n    const end = safe?.output ?? resumedLength;\n\n    if (end > resumedLength) {\n      convertOutput(input, output.slice(resumedLength, end), nodes);\n    }\n\n    this.state =\n      safe === undefined\n        ? resumed\n        : {\n            offset: safe.offset,\n            textStart: safe.textStart,\n            input,\n            output,\n            outputLength: safe.output,\n            invalid: this.#invalid.slice(0, safe.invalid),\n            references: [...this.#references].slice(0, safe.references),\n            nodes,\n            nodesLength: nodes.length,\n            lastNode: nodes.at(-1),\n          };\n\n    convertOutput(input, end === 0 ? output : output.slice(end), nodes);\n\n    return {\n      nodes,\n      invalid: this.#invalid,\n      pending,\n      changedFrom,\n      references: [...this.#references],\n    };\n  }\n\n  /** Consumes the construct at the cursor, in CommonMark precedence order. */\n  private scanConstruct(character: string): boolean {\n    switch (character) {\n      case \":\":\n        return this.scanDirective();\n      case \"\\\\\":\n        return this.scanTexMath() || this.scanBackslash();\n      case \"$\":\n        return this.scanDollarMath();\n      case \"\\n\":\n      case \"\\r\":\n        return this.scanSpaceBreak(character);\n      case \"!\":\n      case \"[\":\n        return this.scanOpenBracket(character);\n      case \"]\":\n        return this.scanCloseBracket();\n      case \"`\":\n        return this.scanCodeSpan();\n      case \"&\":\n        return this.scanCharacterReference();\n      case \"{\":\n        return this.scanExpression();\n      case \"<\":\n        return this.scanAngle();\n      case \"_\":\n        return this.scanAutolink(character) || this.scanDelimiterRun(character);\n      case \"*\":\n      case \"~\":\n        return this.scanDelimiterRun(character);\n      default:\n        return this.scanAutolink(character);\n    }\n  }\n\n  /** Known whitespace ends a token; open constructs keep their earlier retry point. */\n  private recordSafePoint(character?: string): void {\n    const previous = this.#value.char(this.#offset - 1);\n\n    if (\n      this.#stable &&\n      this.#offset > (this.#resumed?.offset ?? 0) &&\n      (character === \" \" ||\n        character === \"\\t\" ||\n        previous === \"\\n\" ||\n        (previous === \"\\r\" && character !== \"\\n\")) &&\n      this.#brackets.length === 0 &&\n      !this.#delimiters.some((delimiter) => delimiter.canOpen)\n    ) {\n      this.#safe = {\n        offset: this.#offset,\n        textStart: this.#textStart,\n        output: this.#output.length,\n        invalid: this.#invalid.length,\n        references: this.#references.size,\n      };\n    }\n  }\n\n  private scanDirective(): boolean {\n    if (!this.#syntax.directives) {\n      return false;\n    }\n\n    const directive = inlineDirective(this.#input, this.#value, this.#offset);\n    this.#stable &&= directive !== undefined || !directiveUnfinished(this.#value, this.#offset);\n\n    return directive !== undefined && this.emit(directive);\n  }\n\n  private scanTexMath(): boolean {\n    if (this.#value.char(this.#offset + 1) !== \"(\" || !this.#syntax.math.includes(\"tex\")) {\n      return false;\n    }\n\n    const math = texMath(this.#input, this.#value, this.#offset);\n    this.#stable &&= math !== undefined;\n\n    return math !== undefined && this.emit(math);\n  }\n\n  private scanDollarMath(): boolean {\n    if (!this.#syntax.math.includes(\"dollar\")) {\n      return false;\n    }\n\n    const math = dollarMath(this.#input, this.#value, this.#offset);\n    this.#stable &&= math !== undefined || !dollarUnclosed(this.#value, this.#offset);\n\n    return math !== undefined && this.emit(math);\n  }\n\n  /** Two or more spaces before a line ending make a hard break. */\n  private scanSpaceBreak(character: \"\\n\" | \"\\r\"): boolean {\n    const value = this.#value;\n    let spaces = this.#offset;\n\n    while (spaces > this.#textStart && value.char(spaces - 1) === \" \") {\n      spaces--;\n    }\n\n    if (this.#offset - spaces < 2) {\n      return false;\n    }\n\n    this.flushText(spaces);\n\n    const end =\n      character === \"\\r\" && value.char(this.#offset + 1) === \"\\n\"\n        ? this.#offset + 2\n        : this.#offset + 1;\n\n    this.#output.push({ kind: \"hardBreak\", range: this.#input.sourceRange(spaces, end) });\n\n    return this.advance(end);\n  }\n\n  private scanAutolink(character: string): boolean {\n    if (this.#brackets.length > 0) {\n      return false;\n    }\n\n    // Without an @, only HTTP and www prefixes can start a literal link.\n    if (!this.#emailAutolinks && !\"hHwW\".includes(character)) {\n      return false;\n    }\n\n    const autolink = matchLiteralAutolink(this.#input, this.#value, this.#offset);\n\n    return autolink !== undefined && this.emit(autolink);\n  }\n\n  private scanOpenBracket(character: \"!\" | \"[\"): boolean {\n    const image = character === \"!\" && this.#value.char(this.#offset + 1) === \"[\";\n\n    if (character !== \"[\" && !image) {\n      return false;\n    }\n\n    this.flushText(this.#offset);\n    const bracket: Bracket = { active: true, image, start: this.#offset };\n    this.#output.push(bracket);\n    this.#brackets.push(bracket);\n\n    return this.advance(this.#offset + (image ? 2 : 1));\n  }\n\n  private scanCloseBracket(): boolean {\n    const bracket = this.#brackets.at(-1);\n\n    if (bracket === undefined) {\n      return false;\n    }\n\n    this.flushText(this.#offset);\n    this.#brackets.pop();\n\n    const resolved = resolveBracket(\n      this.#input,\n      this.#value,\n      this.#offset,\n      bracket,\n      this.#output,\n      this.#delimiters,\n      this.#syntax,\n      this.#definitions,\n      this.#references,\n      this.#brackets.length > 0,\n    );\n\n    this.#stable &&= resolved !== undefined;\n\n    if (resolved === undefined) {\n      this.#output.push(textNode(this.#input, this.#value, this.#offset, this.#offset + 1));\n\n      return this.advance(this.#offset + 1);\n    }\n\n    // Links cannot contain links, so a link deactivates the open link brackets around it.\n    if (resolved.link) {\n      for (const opener of this.#brackets) {\n        if (!opener.image) {\n          opener.active = false;\n        }\n      }\n    }\n\n    return this.advance(resolved.end);\n  }\n\n  /** A backslash before a line ending is a hard break; before punctuation, an escape. */\n  private scanBackslash(): boolean {\n    const next = this.#value.char(this.#offset + 1);\n\n    if (next === \"\\n\" || next === \"\\r\") {\n      this.flushText(this.#offset);\n\n      const end =\n        next === \"\\r\" && this.#value.char(this.#offset + 2) === \"\\n\"\n          ? this.#offset + 3\n          : this.#offset + 2;\n\n      this.#output.push({ kind: \"hardBreak\", range: this.#input.sourceRange(this.#offset, end) });\n\n      return this.advance(end);\n    }\n\n    if (next === undefined || !isAsciiPunctuation(next)) {\n      return false;\n    }\n\n    this.flushText(this.#offset);\n    this.#output.push(textNode(this.#input, this.#value, this.#offset + 1, this.#offset + 2));\n\n    return this.advance(this.#offset + 2);\n  }\n\n  private scanCodeSpan(): boolean {\n    const code = codeSpan(this.#input, this.#value, this.#offset);\n    this.#stable &&= code !== undefined;\n\n    return code !== undefined && this.emit(code);\n  }\n\n  private scanCharacterReference(): boolean {\n    const reference = characterReference(this.#input, this.#value, this.#offset);\n\n    return reference !== undefined && this.emit(reference);\n  }\n\n  private scanExpression(): boolean {\n    const expression = expressionNode(this.#input, this.#value, this.#offset);\n\n    if (expression === undefined) {\n      return false;\n    }\n\n    const range = this.#input.sourceRange(this.#offset, expression.end);\n    this.flushText(this.#offset);\n    this.#stable &&= !expression.open;\n\n    if (expression.node === undefined) {\n      this.#invalid.push({ range, syntax: \"expression\", open: expression.open });\n\n      if (expression.open) {\n        this.#openEmbedded = { start: this.#offset, pending: { kind: \"expression\", range } };\n      }\n\n      this.#output.push(textNode(this.#input, this.#value, this.#offset, expression.end));\n    } else {\n      this.#output.push(expression.node);\n    }\n\n    return this.advance(expression.end);\n  }\n\n  private scanAngle(): boolean {\n    const angle = angleNode(this.#input, this.#value, this.#offset);\n\n    if (angle === undefined) {\n      return false;\n    }\n\n    const range = this.#input.sourceRange(this.#offset, angle.end);\n    this.flushText(this.#offset);\n    this.#stable &&= !angle.open;\n\n    if (angle.invalid) {\n      this.#invalid.push({ range, syntax: \"jsx\", open: angle.open });\n\n      if (angle.open) {\n        this.#openEmbedded = { start: this.#offset, pending: { kind: \"jsx\", range } };\n      }\n    }\n\n    this.#output.push(angle.node);\n\n    return this.advance(angle.end);\n  }\n\n  private scanDelimiterRun(character: \"*\" | \"_\" | \"~\"): boolean {\n    const runEnd = markerRunEnd(this.#value, this.#offset, character);\n\n    if (character === \"~\" && runEnd - this.#offset < (this.#syntax.singleTilde ? 1 : 2)) {\n      return false;\n    }\n\n    this.flushText(this.#offset);\n    const delimiter = createDelimiter(this.#value, this.#offset, runEnd, character);\n    this.#output.push(delimiter);\n    this.#delimiters.push(delimiter);\n    resolveCloser(\n      this.#input,\n      this.#output,\n      this.#delimiters,\n      delimiter,\n      this.#syntax,\n      this.#brackets.at(-1)?.start ?? -1,\n    );\n\n    return this.advance(runEnd);\n  }\n\n  /** Appends a matched construct and moves the cursor after it. */\n  private emit(match: InlineMatch): true {\n    this.flushText(this.#offset);\n    this.#output.push(match.node);\n\n    return this.advance(match.end);\n  }\n\n  private advance(end: number): true {\n    this.#offset = end;\n    this.#textStart = end;\n\n    return true;\n  }\n\n  private flushText(end: number): void {\n    if (end > this.#textStart) {\n      this.#output.push(textNode(this.#input, this.#value, this.#textStart, end));\n    }\n\n    this.#textStart = end;\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,23 @@
+import { ResolvedSyntaxOptions } from "../syntax-options.mjs";
+import { SourceText } from "../source-text.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { InlinePendingSyntax } from "./inline-syntax.mjs";
+import { Output } from "./inline-output.mjs";
+//#region src/parser/inline-pending.d.ts
+export interface PendingCandidate {
+  readonly start: number;
+  readonly pending: InlinePendingSyntax;
+}
+export interface PendingInlineResult {
+  readonly pending: InlinePendingSyntax | undefined;
+  /** Earliest raw syntax future input can change; the input length means none remains. */
+  readonly earliest: number;
+}
+/**
+ * The construct still open at the end of the input. Before `from`, a safe
+ * point, every construct is closed, so scans start there, and at `fromOutput`
+ * in the output.
+ */
+export declare function pendingInline(input: InlineInput, value: SourceText, output: readonly Output[], openEmbedded: PendingCandidate | undefined, syntax: ResolvedSyntaxOptions, from: number, fromOutput: number, checkpoint: number | undefined): PendingInlineResult;
+//#endregion
+//# sourceMappingURL=inline-pending.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-pending.d.mts","names":[],"sources":["../../src/parser/inline-pending.ts"],"mappings":";;;;;;iBAUiB;WACN;WACA,SAAS;;iBAGH;WACN,SAAS;;WAET;;;;;;;wBAQK,cACd,OAAO,aACP,OAAO,YACP,iBAAiB,UACjB,cAAc,8BACd,QAAQ,uBACR,cACA,oBACA,iCACC"}

package/dist/parser/inline-pending.mjs

@@ -0,0 +1,100 @@
+import { isUnicodeWhitespace } from "./characters.mjs";
+import { convertOutput, isDelimiter, markerRunEnd, textNode } from "./inline-output.mjs";
+import { codeSpan } from "./inline-code.mjs";
+//#region src/parser/inline-pending.ts
+/**
+* The construct still open at the end of the input. Before `from`, a safe
+* point, every construct is closed, so scans start there, and at `fromOutput`
+* in the output.
+*/
+function pendingInline(input, value, output, openEmbedded, syntax, from, fromOutput, checkpoint) {
+	const candidates = openEmbedded === void 0 ? [] : [openEmbedded];
+	let earliest = value.length;
+	for (let index = output.length - 1; index >= fromOutput; index--) {
+		const opener = output[index];
+		if (!isDelimiter(opener) || !opener.canOpen || index === output.length - 1) continue;
+		const kind = opener.marker === "~" ? opener.length >= (syntax.singleTilde ? 1 : 2) ? "delete" : void 0 : opener.length >= 2 ? "strong" : "emphasis";
+		if (kind === void 0 || isUnicodeWhitespace(value.char(opener.start + opener.length) ?? "")) continue;
+		candidates.push({
+			start: opener.start,
+			pending: {
+				kind,
+				range: input.sourceRange(opener.start, input.length),
+				children: convertOutput(input, output.slice(index + 1))
+			}
+		});
+		break;
+	}
+	for (let offset = value.indexOf("`", from); offset !== -1;) {
+		const matched = codeSpan(input, value, offset);
+		if (matched !== void 0) {
+			if (checkpoint !== void 0 && offset < checkpoint && matched.end > checkpoint) earliest = Math.min(earliest, offset);
+			offset = value.indexOf("`", matched.end);
+			continue;
+		}
+		const openingEnd = markerRunEnd(value, offset, "`");
+		earliest = Math.min(earliest, offset);
+		if (openingEnd < value.length) candidates.push({
+			start: offset,
+			pending: {
+				kind: "code",
+				range: input.sourceRange(offset, input.length),
+				value: value.slice(openingEnd).replace(/\r\n|[\r\n]/gu, " ")
+			}
+		});
+		break;
+	}
+	const suffix = value.slice(from);
+	const label = /!?\[[^\]]*\]?$/u.exec(suffix);
+	if (label !== null) earliest = Math.min(earliest, from + label.index);
+	const pendingLink = /(!?)\[([^\]]+)\]\(([^)]*)$/u.exec(suffix);
+	if (pendingLink !== null) {
+		const start = from + pendingLink.index;
+		const image = pendingLink[1] === "!";
+		candidates.push({
+			start,
+			pending: image ? {
+				kind: "image",
+				range: input.sourceRange(start, input.length),
+				alt: pendingLink[2]
+			} : {
+				kind: "link",
+				range: input.sourceRange(start, input.length),
+				children: [textNode(input, value, start + 1, start + 1 + pendingLink[2].length)]
+			}
+		});
+	}
+	if (syntax.math.includes("tex")) {
+		const start = value.lastIndexOf("\\(");
+		if (start !== -1 && value.indexOf("\\)", start + 2) === -1 && start + 2 < value.length) candidates.push({
+			start,
+			pending: {
+				kind: "math",
+				range: input.sourceRange(start, input.length),
+				value: value.slice(start + 2),
+				format: "tex"
+			}
+		});
+	}
+	if (syntax.math.includes("dollar")) {
+		const start = value.lastIndexOf("$");
+		if (start !== -1 && start + 1 < value.length && !isUnicodeWhitespace(value.char(start + 1) ?? "")) candidates.push({
+			start,
+			pending: {
+				kind: "math",
+				range: input.sourceRange(start, input.length),
+				value: value.slice(start + 1),
+				format: "dollar"
+			}
+		});
+	}
+	candidates.sort((left, right) => right.start - left.start);
+	return {
+		pending: candidates[0]?.pending,
+		earliest: Math.min(earliest, candidates.at(-1)?.start ?? value.length)
+	};
+}
+//#endregion
+export { pendingInline };
+
+//# sourceMappingURL=inline-pending.mjs.map