@temelj/mdx 0.14.0 → 0.16.0

package/dist/parser/inline-emphasis.mjs

@@ -0,0 +1,79 @@
+import { isUnicodePunctuation, isUnicodeWhitespace } from "./characters.mjs";
+import { bracketText, delimiterText, isBracket, isDelimiter, mergeText } from "./inline-output.mjs";
+//#region src/parser/inline-emphasis.ts
+function createDelimiter(value, start, end, marker) {
+	const before = value.char(start - 1);
+	const after = value.char(end);
+	const beforeWhitespace = before === void 0 || isUnicodeWhitespace(before);
+	const afterWhitespace = after === void 0 || isUnicodeWhitespace(after);
+	const beforePunctuation = before !== void 0 && isUnicodePunctuation(before);
+	const afterPunctuation = after !== void 0 && isUnicodePunctuation(after);
+	const leftFlanking = !afterWhitespace && (!afterPunctuation || beforeWhitespace || beforePunctuation);
+	const rightFlanking = !beforeWhitespace && (!beforePunctuation || afterWhitespace || afterPunctuation);
+	return {
+		marker,
+		length: end - start,
+		originalLength: end - start,
+		start,
+		canOpen: marker === "_" ? leftFlanking && (!rightFlanking || beforePunctuation) : leftFlanking,
+		canClose: marker === "_" ? rightFlanking && (!leftFlanking || afterPunctuation) : rightFlanking
+	};
+}
+function resolveCloser(input, output, delimiters, closer, syntax, after = -1) {
+	if (!closer.canClose) return;
+	while (closer.length > 0) {
+		const closerIndex = delimiters.lastIndexOf(closer);
+		let openerIndex = -1;
+		for (let index = closerIndex - 1; index >= 0; index--) {
+			const candidate = delimiters[index];
+			if (candidate.start <= after) break;
+			if (candidate.marker === closer.marker && candidate.canOpen && !violatesRuleOfThree(candidate, closer)) {
+				openerIndex = index;
+				break;
+			}
+		}
+		const opener = delimiters[openerIndex];
+		if (opener === void 0) return;
+		const use = closer.marker === "~" ? opener.length >= 2 && closer.length >= 2 ? 2 : syntax.singleTilde ? 1 : 2 : opener.length >= 2 && closer.length >= 2 ? 2 : 1;
+		if (opener.length < use || closer.length < use) return;
+		const closerOutput = output.lastIndexOf(closer);
+		const openerOutput = closerOutput === -1 ? -1 : output.lastIndexOf(opener, closerOutput - 1);
+		if (openerOutput === -1 || closerOutput === -1 || openerOutput >= closerOutput) throw new Error("Delimiter stack diverged from inline output");
+		const children = output.slice(openerOutput + 1, closerOutput).map((entry) => isDelimiter(entry) ? delimiterText(input, entry) : isBracket(entry) ? bracketText(input, entry) : entry);
+		opener.length -= use;
+		const nodeStart = opener.start + opener.length;
+		const nodeEnd = closer.start + use;
+		closer.start += use;
+		closer.length -= use;
+		const node = {
+			kind: closer.marker === "~" ? "delete" : use === 2 ? "strong" : "emphasis",
+			range: input.sourceRange(nodeStart, nodeEnd),
+			children: mergeText(children)
+		};
+		output.splice(openerOutput + 1, closerOutput - openerOutput - 1, node);
+		delimiters.splice(openerIndex + 1, closerIndex - openerIndex - 1);
+		let closerAt = openerOutput + 2;
+		if (opener.length === 0) {
+			output.splice(openerOutput, 1);
+			delimiters.splice(openerIndex, 1);
+			closerAt--;
+		}
+		if (closer.length === 0) {
+			output.splice(closerAt, 1);
+			delimiters.splice(delimiters.lastIndexOf(closer), 1);
+			return;
+		}
+	}
+}
+/** Resolves closers that were held behind a bracket boundary. */
+function resolveDelimiters(input, output, delimiters, syntax, after = -1) {
+	const closers = delimiters.slice();
+	for (const closer of closers) if (closer.start > after && delimiters.includes(closer)) resolveCloser(input, output, delimiters, closer, syntax, after);
+}
+function violatesRuleOfThree(opener, closer) {
+	return (opener.canClose || closer.canOpen) && (opener.originalLength + closer.originalLength) % 3 === 0 && (opener.originalLength % 3 !== 0 || closer.originalLength % 3 !== 0);
+}
+//#endregion
+export { createDelimiter, resolveCloser, resolveDelimiters };
+
+//# sourceMappingURL=inline-emphasis.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-emphasis.mjs","names":[],"sources":["../../src/parser/inline-emphasis.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 { Delimiter, Output } from \"./inline-output.ts\";\nimport type { InlineSyntax } from \"./inline-syntax.ts\";\n\nimport { isUnicodePunctuation, isUnicodeWhitespace } from \"./characters.ts\";\nimport { bracketText, delimiterText, isBracket, isDelimiter, mergeText } from \"./inline-output.ts\";\n\n// Emphasis, strong, and strikethrough from delimiter runs, resolved as closers arrive.\n\nexport function createDelimiter(\n  value: SourceText,\n  start: number,\n  end: number,\n  marker: Delimiter[\"marker\"],\n): Delimiter {\n  const before = value.char(start - 1);\n  const after = value.char(end);\n  const beforeWhitespace = before === undefined || isUnicodeWhitespace(before);\n  const afterWhitespace = after === undefined || isUnicodeWhitespace(after);\n  const beforePunctuation = before !== undefined && isUnicodePunctuation(before);\n  const afterPunctuation = after !== undefined && isUnicodePunctuation(after);\n\n  const leftFlanking =\n    !afterWhitespace && (!afterPunctuation || beforeWhitespace || beforePunctuation);\n\n  const rightFlanking =\n    !beforeWhitespace && (!beforePunctuation || afterWhitespace || afterPunctuation);\n\n  return {\n    marker,\n    length: end - start,\n    originalLength: end - start,\n    start,\n    canOpen: marker === \"_\" ? leftFlanking && (!rightFlanking || beforePunctuation) : leftFlanking,\n    canClose: marker === \"_\" ? rightFlanking && (!leftFlanking || afterPunctuation) : rightFlanking,\n  };\n}\n\nexport function resolveCloser(\n  input: InlineInput,\n  output: Output[],\n  delimiters: Delimiter[],\n  closer: Delimiter,\n  syntax: ResolvedSyntaxOptions,\n  after = -1,\n): void {\n  if (!closer.canClose) {\n    return;\n  }\n\n  while (closer.length > 0) {\n    const closerIndex = delimiters.lastIndexOf(closer);\n    let openerIndex = -1;\n\n    for (let index = closerIndex - 1; index >= 0; index--) {\n      const candidate = delimiters[index];\n\n      if (candidate.start <= after) {\n        break;\n      }\n\n      if (\n        candidate.marker === closer.marker &&\n        candidate.canOpen &&\n        !violatesRuleOfThree(candidate, closer)\n      ) {\n        openerIndex = index;\n        break;\n      }\n    }\n\n    const opener = delimiters[openerIndex];\n\n    if (opener === undefined) {\n      return;\n    }\n\n    const use =\n      closer.marker === \"~\"\n        ? opener.length >= 2 && closer.length >= 2\n          ? 2\n          : syntax.singleTilde\n            ? 1\n            : 2\n        : opener.length >= 2 && closer.length >= 2\n          ? 2\n          : 1;\n\n    if (opener.length < use || closer.length < use) {\n      return;\n    }\n\n    // The closer was just pushed and the opener precedes it, so both are found from the end.\n    const closerOutput = output.lastIndexOf(closer);\n    const openerOutput = closerOutput === -1 ? -1 : output.lastIndexOf(opener, closerOutput - 1);\n\n    if (openerOutput === -1 || closerOutput === -1 || openerOutput >= closerOutput) {\n      throw new Error(\"Delimiter stack diverged from inline output\");\n    }\n\n    const children = output\n      .slice(openerOutput + 1, closerOutput)\n      .map((entry) =>\n        isDelimiter(entry)\n          ? delimiterText(input, entry)\n          : isBracket(entry)\n            ? bracketText(input, entry)\n            : entry,\n      );\n\n    opener.length -= use;\n    const nodeStart = opener.start + opener.length;\n    const nodeEnd = closer.start + use;\n    closer.start += use;\n    closer.length -= use;\n\n    const node: InlineSyntax = {\n      kind: closer.marker === \"~\" ? \"delete\" : use === 2 ? \"strong\" : \"emphasis\",\n      range: input.sourceRange(nodeStart, nodeEnd),\n      children: mergeText(children),\n    };\n\n    output.splice(openerOutput + 1, closerOutput - openerOutput - 1, node);\n    // Delimiters between the pair are now inside the node.\n    delimiters.splice(openerIndex + 1, closerIndex - openerIndex - 1);\n    let closerAt = openerOutput + 2;\n\n    if (opener.length === 0) {\n      output.splice(openerOutput, 1);\n      delimiters.splice(openerIndex, 1);\n      closerAt--;\n    }\n\n    if (closer.length === 0) {\n      output.splice(closerAt, 1);\n      delimiters.splice(delimiters.lastIndexOf(closer), 1);\n\n      return;\n    }\n  }\n}\n\n/** Resolves closers that were held behind a bracket boundary. */\nexport function resolveDelimiters(\n  input: InlineInput,\n  output: Output[],\n  delimiters: Delimiter[],\n  syntax: ResolvedSyntaxOptions,\n  after = -1,\n): void {\n  // Resolving one closer removes entries from the stack.\n  const closers = delimiters.slice();\n\n  for (const closer of closers) {\n    if (closer.start > after && delimiters.includes(closer)) {\n      resolveCloser(input, output, delimiters, closer, syntax, after);\n    }\n  }\n}\n\nfunction violatesRuleOfThree(opener: Delimiter, closer: Delimiter): boolean {\n  return (\n    (opener.canClose || closer.canOpen) &&\n    (opener.originalLength + closer.originalLength) % 3 === 0 &&\n    (opener.originalLength % 3 !== 0 || closer.originalLength % 3 !== 0)\n  );\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,46 @@
+import { SourceRange } from "../ranges.mjs";
+import { SourceText } from "../source-text.mjs";
+import { SourceFile } from "../source.mjs";
+//#region src/parser/inline-input.d.ts
+export interface SourceInlineSegment {
+  readonly kind: "source";
+  readonly range: SourceRange;
+}
+export interface VirtualSpaceInlineSegment {
+  readonly kind: "virtualSpace";
+  readonly offset: number;
+  readonly columns: number;
+}
+export type InlineSegment = SourceInlineSegment | VirtualSpaceInlineSegment;
+/**
+ * Source-backed block content with explicit virtual indentation. Text is built
+ * once; segment boundaries map characters back to their source offsets.
+ */
+export declare class InlineInput {
+  #private;
+  readonly file: SourceFile;
+  /**
+   * `base` is an earlier input of the same growing text, such as the open
+   * paragraph before an append. When this input only adds text after it, the
+   * base's decoded text and segment boundaries are shared; only new text is decoded.
+   */
+  constructor(file: SourceFile, segments: readonly InlineSegment[], base?: InlineInput);
+  get length(): number;
+  sourceRange(start?: number, end?: number): SourceRange;
+  /** Source segments are contiguous; virtual indentation maps to one authored tab. */
+  private sourceOffset;
+  toString(): string;
+  /** The text in chunks, which an extended input shares instead of copying. */
+  text(): SourceText;
+  /** Whether this input was built by extending `other`, so it starts with the same text. */
+  extends(other: InlineInput): boolean;
+  /**
+   * The shared storage, when `segments` extend this input's: every segment is
+   * the same object except the last, which may only have grown at its end.
+   */
+  private extendable;
+  /** Decodes segments from `from` into the storage after `length` characters of `text`. */
+  private append;
+}
+//#endregion
+//# sourceMappingURL=inline-input.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-input.d.mts","names":[],"sources":["../../src/parser/inline-input.ts"],"mappings":";;;;iBAMiB;WACN;WACA,OAAO;;iBAGD;WACN;WACA;WACA;;YAGC,gBAAgB,sBAAsB;;;;;qBAmBrC;;WAGK,MAAM;;;;;;EAOtB,YAAmB,MAAM,YAAY,mBAAmB,iBAAiB,OAAO;MA6BrE;EAIJ,YAAY,gBAAW,eAAoB;;UAqB1C;EAsBD;;EAKA,QAAQ;;EAKR,QAAQ,OAAO;;;;;UAQd;;UAgCA"}

package/dist/parser/inline-input.mjs

@@ -0,0 +1,137 @@
+import { sourceRange } from "../ranges.mjs";
+import { SourceText } from "../source-text.mjs";
+//#region src/parser/inline-input.ts
+/**
+* Segments that successive inputs of one growing text share. Each
+* input reads its own prefix; only the newest input may extend the storage, and
+* it only ever writes past every existing input's end.
+*/
+var InputStorage = class {
+	/** The segments as given, compared by identity when a later input extends this one. */
+	inputs = [];
+	/** Text length after each segment. */
+	ends = [];
+	tip;
+};
+/**
+* Source-backed block content with explicit virtual indentation. Text is built
+* once; segment boundaries map characters back to their source offsets.
+*/
+var InlineInput = class {
+	#storage;
+	#text;
+	file;
+	/**
+	* `base` is an earlier input of the same growing text, such as the open
+	* paragraph before an append. When this input only adds text after it, the
+	* base's decoded text and segment boundaries are shared; only new text is decoded.
+	*/
+	constructor(file, segments, base) {
+		this.file = file;
+		const storage = base === void 0 ? void 0 : base.extendable(file, segments);
+		if (base === void 0 || storage === void 0) {
+			this.#storage = new InputStorage();
+			this.#text = this.append(segments, 0, 0, SourceText.of(""));
+		} else {
+			this.#storage = storage;
+			const last = segments.length === 0 ? -1 : storage.inputs.length - 1;
+			const grown = segments[last];
+			const previous = storage.inputs[last];
+			let text = base.#text;
+			if (grown?.kind === "source" && previous?.kind === "source" && grown !== previous) {
+				const start = previous.range.end;
+				const part = file.semanticSlice({
+					start,
+					end: grown.range.end
+				});
+				text = text.append(part);
+				storage.inputs[last] = grown;
+				storage.ends[last] = text.length;
+			}
+			this.#text = this.append(segments, last + 1, text.length, text);
+		}
+		this.#storage.tip = this;
+	}
+	get length() {
+		return this.#text.length;
+	}
+	sourceRange(start = 0, end = this.length) {
+		if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start) throw new RangeError(`Invalid inline range ${start}..${end}`);
+		if (end > this.length) throw new RangeError(`Inline range ${start}..${end} exceeds input length ${this.length}`);
+		if (start === this.length) {
+			const offset = this.length === 0 ? 0 : this.sourceOffset(this.length - 1);
+			return sourceRange(offset, offset);
+		}
+		const first = this.sourceOffset(start);
+		return sourceRange(first, (end === 0 ? first : this.sourceOffset(end - 1)) + 1);
+	}
+	/** Source segments are contiguous; virtual indentation maps to one authored tab. */
+	sourceOffset(offset) {
+		const { inputs, ends } = this.#storage;
+		let low = 0;
+		let high = inputs.length - 1;
+		while (low < high) {
+			const middle = low + high >> 1;
+			if (offset < ends[middle]) high = middle;
+			else low = middle + 1;
+		}
+		const segment = inputs[low];
+		return segment.kind === "virtualSpace" ? segment.offset : segment.range.start + offset - (low === 0 ? 0 : ends[low - 1]);
+	}
+	toString() {
+		return this.#text.toString();
+	}
+	/** The text in chunks, which an extended input shares instead of copying. */
+	text() {
+		return this.#text;
+	}
+	/** Whether this input was built by extending `other`, so it starts with the same text. */
+	extends(other) {
+		return this.#storage === other.#storage && this.length >= other.length;
+	}
+	/**
+	* The shared storage, when `segments` extend this input's: every segment is
+	* the same object except the last, which may only have grown at its end.
+	*/
+	extendable(file, segments) {
+		const storage = this.#storage;
+		const count = storage.inputs.length;
+		if (storage.tip !== this || !this.file.isPrefixOf(file) || segments.length < count) return;
+		for (let index = Math.max(0, count - 3); index < count - 1; index++) if (!sameSegment(storage.inputs[index], segments[index])) return;
+		const previous = storage.inputs[count - 1];
+		const next = segments[count - 1];
+		return (previous === next || previous?.kind === "source" && next?.kind === "source" && next.range.start === previous.range.start && next.range.end >= previous.range.end) && count > 0 ? storage : void 0;
+	}
+	/** Decodes segments from `from` into the storage after `length` characters of `text`. */
+	append(segments, from, length, text) {
+		const storage = this.#storage;
+		const parts = [];
+		let index = length;
+		for (let position = from; position < segments.length; position++) {
+			const segment = validateSegment(segments[position]);
+			const part = segment.kind === "source" ? this.file.semanticSlice(segment.range) : " ".repeat(segment.columns);
+			index += part.length;
+			parts.push(part);
+			storage.inputs[position] = segments[position];
+			storage.ends[position] = index;
+		}
+		return text.length === 0 ? SourceText.of(parts.join("")) : parts.reduce((result, part) => result.append(part), text);
+	}
+};
+function sameSegment(left, right) {
+	if (left === right) return true;
+	if (left?.kind === "source" && right?.kind === "source") return left.range.start === right.range.start && left.range.end === right.range.end;
+	return left?.kind === "virtualSpace" && right?.kind === "virtualSpace" && left.offset === right.offset && left.columns === right.columns;
+}
+function validateSegment(segment) {
+	if (segment.kind === "source") return {
+		kind: "source",
+		range: sourceRange(segment.range.start, segment.range.end)
+	};
+	if (!Number.isSafeInteger(segment.offset) || !Number.isSafeInteger(segment.columns) || segment.offset < 0 || segment.columns < 1) throw new RangeError("Invalid virtual inline indentation");
+	return { ...segment };
+}
+//#endregion
+export { InlineInput };
+
+//# sourceMappingURL=inline-input.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-input.mjs","names":[],"sources":["../../src/parser/inline-input.ts"],"sourcesContent":["import type { SourceRange } from \"../ranges.ts\";\nimport type { SourceFile } from \"../source.ts\";\n\nimport { sourceRange } from \"../ranges.ts\";\nimport { SourceText } from \"../source-text.ts\";\n\nexport interface SourceInlineSegment {\n  readonly kind: \"source\";\n  readonly range: SourceRange;\n}\n\nexport interface VirtualSpaceInlineSegment {\n  readonly kind: \"virtualSpace\";\n  readonly offset: number;\n  readonly columns: number;\n}\n\nexport type InlineSegment = SourceInlineSegment | VirtualSpaceInlineSegment;\n\n/**\n * Segments that successive inputs of one growing text share. Each\n * input reads its own prefix; only the newest input may extend the storage, and\n * it only ever writes past every existing input's end.\n */\nclass InputStorage {\n  /** The segments as given, compared by identity when a later input extends this one. */\n  readonly inputs: InlineSegment[] = [];\n  /** Text length after each segment. */\n  readonly ends: number[] = [];\n  tip: InlineInput | undefined;\n}\n\n/**\n * Source-backed block content with explicit virtual indentation. Text is built\n * once; segment boundaries map characters back to their source offsets.\n */\nexport class InlineInput {\n  readonly #storage: InputStorage;\n  readonly #text: SourceText;\n  public readonly file: SourceFile;\n\n  /**\n   * `base` is an earlier input of the same growing text, such as the open\n   * paragraph before an append. When this input only adds text after it, the\n   * base's decoded text and segment boundaries are shared; only new text is decoded.\n   */\n  public constructor(file: SourceFile, segments: readonly InlineSegment[], base?: InlineInput) {\n    this.file = file;\n    const storage = base === undefined ? undefined : base.extendable(file, segments);\n\n    if (base === undefined || storage === undefined) {\n      this.#storage = new InputStorage();\n      this.#text = this.append(segments, 0, 0, SourceText.of(\"\"));\n    } else {\n      this.#storage = storage;\n      // The base's last segment may have grown on the same line, so it is decoded past its old end.\n      const last = segments.length === 0 ? -1 : storage.inputs.length - 1;\n      const grown = segments[last];\n      const previous = storage.inputs[last];\n      let text = base.#text;\n\n      if (grown?.kind === \"source\" && previous?.kind === \"source\" && grown !== previous) {\n        const start = previous.range.end;\n        const part = file.semanticSlice({ start, end: grown.range.end });\n        text = text.append(part);\n        storage.inputs[last] = grown;\n        storage.ends[last] = text.length;\n      }\n\n      this.#text = this.append(segments, last + 1, text.length, text);\n    }\n\n    this.#storage.tip = this;\n  }\n\n  public get length(): number {\n    return this.#text.length;\n  }\n\n  public sourceRange(start = 0, end = this.length): SourceRange {\n    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start) {\n      throw new RangeError(`Invalid inline range ${start}..${end}`);\n    }\n\n    if (end > this.length) {\n      throw new RangeError(`Inline range ${start}..${end} exceeds input length ${this.length}`);\n    }\n\n    if (start === this.length) {\n      const offset = this.length === 0 ? 0 : this.sourceOffset(this.length - 1);\n\n      return sourceRange(offset, offset);\n    }\n\n    const first = this.sourceOffset(start);\n\n    return sourceRange(first, (end === 0 ? first : this.sourceOffset(end - 1)) + 1);\n  }\n\n  /** Source segments are contiguous; virtual indentation maps to one authored tab. */\n  private sourceOffset(offset: number): number {\n    const { inputs, ends } = this.#storage;\n    let low = 0;\n    let high = inputs.length - 1;\n\n    while (low < high) {\n      const middle = (low + high) >> 1;\n\n      if (offset < ends[middle]) {\n        high = middle;\n      } else {\n        low = middle + 1;\n      }\n    }\n\n    const segment = inputs[low];\n\n    return segment.kind === \"virtualSpace\"\n      ? segment.offset\n      : segment.range.start + offset - (low === 0 ? 0 : ends[low - 1]);\n  }\n\n  public toString(): string {\n    return this.#text.toString();\n  }\n\n  /** The text in chunks, which an extended input shares instead of copying. */\n  public text(): SourceText {\n    return this.#text;\n  }\n\n  /** Whether this input was built by extending `other`, so it starts with the same text. */\n  public extends(other: InlineInput): boolean {\n    return this.#storage === other.#storage && this.length >= other.length;\n  }\n\n  /**\n   * The shared storage, when `segments` extend this input's: every segment is\n   * the same object except the last, which may only have grown at its end.\n   */\n  private extendable(\n    file: SourceFile,\n    segments: readonly InlineSegment[],\n  ): InputStorage | undefined {\n    const storage = this.#storage;\n    const count = storage.inputs.length;\n\n    if (storage.tip !== this || !this.file.isPrefixOf(file) || segments.length < count) {\n      return undefined;\n    }\n\n    // The file only grew, so complete lines keep their segments; the open line can be rebuilt.\n    for (let index = Math.max(0, count - 3); index < count - 1; index++) {\n      if (!sameSegment(storage.inputs[index], segments[index])) {\n        return undefined;\n      }\n    }\n\n    const previous = storage.inputs[count - 1];\n    const next = segments[count - 1];\n\n    const grows =\n      previous === next ||\n      (previous?.kind === \"source\" &&\n        next?.kind === \"source\" &&\n        next.range.start === previous.range.start &&\n        next.range.end >= previous.range.end);\n\n    return grows && count > 0 ? storage : undefined;\n  }\n\n  /** Decodes segments from `from` into the storage after `length` characters of `text`. */\n  private append(\n    segments: readonly InlineSegment[],\n    from: number,\n    length: number,\n    text: SourceText,\n  ): SourceText {\n    const storage = this.#storage;\n    const parts: string[] = [];\n    let index = length;\n\n    for (let position = from; position < segments.length; position++) {\n      const segment = validateSegment(segments[position]);\n\n      const part =\n        segment.kind === \"source\"\n          ? this.file.semanticSlice(segment.range)\n          : \" \".repeat(segment.columns);\n\n      index += part.length;\n      parts.push(part);\n      storage.inputs[position] = segments[position];\n      storage.ends[position] = index;\n    }\n\n    // A fresh input joins its parts once; an extension appends the few new ones.\n    return text.length === 0\n      ? SourceText.of(parts.join(\"\"))\n      : parts.reduce((result, part) => result.append(part), text);\n  }\n}\n\nfunction sameSegment(left: InlineSegment | undefined, right: InlineSegment | undefined): boolean {\n  if (left === right) {\n    return true;\n  }\n\n  if (left?.kind === \"source\" && right?.kind === \"source\") {\n    return left.range.start === right.range.start && left.range.end === right.range.end;\n  }\n\n  return (\n    left?.kind === \"virtualSpace\" &&\n    right?.kind === \"virtualSpace\" &&\n    left.offset === right.offset &&\n    left.columns === right.columns\n  );\n}\n\nfunction validateSegment(segment: InlineSegment): InlineSegment {\n  if (segment.kind === \"source\") {\n    return {\n      kind: \"source\",\n      range: sourceRange(segment.range.start, segment.range.end),\n    };\n  }\n\n  if (\n    !Number.isSafeInteger(segment.offset) ||\n    !Number.isSafeInteger(segment.columns) ||\n    segment.offset < 0 ||\n    segment.columns < 1\n  ) {\n    throw new RangeError(\"Invalid virtual inline indentation\");\n  }\n\n  return { ...segment };\n}\n"],"mappings":";;;;;;;;AAwBA,IAAM,eAAN,MAAmB;;CAEjB,SAAmC,CAAC;;CAEpC,OAA0B,CAAC;CAC3B;AACF;;;;;AAMA,IAAa,cAAb,MAAyB;CACvB;CACA;CACA;;;;;;CAOA,YAAmB,MAAkB,UAAoC,MAAoB;EAC3F,KAAK,OAAO;EACZ,MAAM,UAAU,SAAS,KAAA,IAAY,KAAA,IAAY,KAAK,WAAW,MAAM,QAAQ;EAE/E,IAAI,SAAS,KAAA,KAAa,YAAY,KAAA,GAAW;GAC/C,KAAK,WAAW,IAAI,aAAa;GACjC,KAAK,QAAQ,KAAK,OAAO,UAAU,GAAG,GAAG,WAAW,GAAG,EAAE,CAAC;EAC5D,OAAO;GACL,KAAK,WAAW;GAEhB,MAAM,OAAO,SAAS,WAAW,IAAI,KAAK,QAAQ,OAAO,SAAS;GAClE,MAAM,QAAQ,SAAS;GACvB,MAAM,WAAW,QAAQ,OAAO;GAChC,IAAI,OAAO,KAAK;GAEhB,IAAI,OAAO,SAAS,YAAY,UAAU,SAAS,YAAY,UAAU,UAAU;IACjF,MAAM,QAAQ,SAAS,MAAM;IAC7B,MAAM,OAAO,KAAK,cAAc;KAAE;KAAO,KAAK,MAAM,MAAM;IAAI,CAAC;IAC/D,OAAO,KAAK,OAAO,IAAI;IACvB,QAAQ,OAAO,QAAQ;IACvB,QAAQ,KAAK,QAAQ,KAAK;GAC5B;GAEA,KAAK,QAAQ,KAAK,OAAO,UAAU,OAAO,GAAG,KAAK,QAAQ,IAAI;EAChE;EAEA,KAAK,SAAS,MAAM;CACtB;CAEA,IAAW,SAAiB;EAC1B,OAAO,KAAK,MAAM;CACpB;CAEA,YAAmB,QAAQ,GAAG,MAAM,KAAK,QAAqB;EAC5D,IAAI,CAAC,OAAO,cAAc,KAAK,KAAK,CAAC,OAAO,cAAc,GAAG,KAAK,QAAQ,KAAK,MAAM,OACnF,MAAM,IAAI,WAAW,wBAAwB,MAAM,IAAI,KAAK;EAG9D,IAAI,MAAM,KAAK,QACb,MAAM,IAAI,WAAW,gBAAgB,MAAM,IAAI,IAAI,wBAAwB,KAAK,QAAQ;EAG1F,IAAI,UAAU,KAAK,QAAQ;GACzB,MAAM,SAAS,KAAK,WAAW,IAAI,IAAI,KAAK,aAAa,KAAK,SAAS,CAAC;GAExE,OAAO,YAAY,QAAQ,MAAM;EACnC;EAEA,MAAM,QAAQ,KAAK,aAAa,KAAK;EAErC,OAAO,YAAY,QAAQ,QAAQ,IAAI,QAAQ,KAAK,aAAa,MAAM,CAAC,KAAK,CAAC;CAChF;;CAGA,aAAqB,QAAwB;EAC3C,MAAM,EAAE,QAAQ,SAAS,KAAK;EAC9B,IAAI,MAAM;EACV,IAAI,OAAO,OAAO,SAAS;EAE3B,OAAO,MAAM,MAAM;GACjB,MAAM,SAAU,MAAM,QAAS;GAE/B,IAAI,SAAS,KAAK,SAChB,OAAO;QAEP,MAAM,SAAS;EAEnB;EAEA,MAAM,UAAU,OAAO;EAEvB,OAAO,QAAQ,SAAS,iBACpB,QAAQ,SACR,QAAQ,MAAM,QAAQ,UAAU,QAAQ,IAAI,IAAI,KAAK,MAAM;CACjE;CAEA,WAA0B;EACxB,OAAO,KAAK,MAAM,SAAS;CAC7B;;CAGA,OAA0B;EACxB,OAAO,KAAK;CACd;;CAGA,QAAe,OAA6B;EAC1C,OAAO,KAAK,aAAa,MAAM,YAAY,KAAK,UAAU,MAAM;CAClE;;;;;CAMA,WACE,MACA,UAC0B;EAC1B,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,QAAQ,OAAO;EAE7B,IAAI,QAAQ,QAAQ,QAAQ,CAAC,KAAK,KAAK,WAAW,IAAI,KAAK,SAAS,SAAS,OAC3E;EAIF,KAAK,IAAI,QAAQ,KAAK,IAAI,GAAG,QAAQ,CAAC,GAAG,QAAQ,QAAQ,GAAG,SAC1D,IAAI,CAAC,YAAY,QAAQ,OAAO,QAAQ,SAAS,MAAM,GACrD;EAIJ,MAAM,WAAW,QAAQ,OAAO,QAAQ;EACxC,MAAM,OAAO,SAAS,QAAQ;EAS9B,QANE,aAAa,QACZ,UAAU,SAAS,YAClB,MAAM,SAAS,YACf,KAAK,MAAM,UAAU,SAAS,MAAM,SACpC,KAAK,MAAM,OAAO,SAAS,MAAM,QAErB,QAAQ,IAAI,UAAU,KAAA;CACxC;;CAGA,OACE,UACA,MACA,QACA,MACY;EACZ,MAAM,UAAU,KAAK;EACrB,MAAM,QAAkB,CAAC;EACzB,IAAI,QAAQ;EAEZ,KAAK,IAAI,WAAW,MAAM,WAAW,SAAS,QAAQ,YAAY;GAChE,MAAM,UAAU,gBAAgB,SAAS,SAAS;GAElD,MAAM,OACJ,QAAQ,SAAS,WACb,KAAK,KAAK,cAAc,QAAQ,KAAK,IACrC,IAAI,OAAO,QAAQ,OAAO;GAEhC,SAAS,KAAK;GACd,MAAM,KAAK,IAAI;GACf,QAAQ,OAAO,YAAY,SAAS;GACpC,QAAQ,KAAK,YAAY;EAC3B;EAGA,OAAO,KAAK,WAAW,IACnB,WAAW,GAAG,MAAM,KAAK,EAAE,CAAC,IAC5B,MAAM,QAAQ,QAAQ,SAAS,OAAO,OAAO,IAAI,GAAG,IAAI;CAC9D;AACF;AAEA,SAAS,YAAY,MAAiC,OAA2C;CAC/F,IAAI,SAAS,OACX,OAAO;CAGT,IAAI,MAAM,SAAS,YAAY,OAAO,SAAS,UAC7C,OAAO,KAAK,MAAM,UAAU,MAAM,MAAM,SAAS,KAAK,MAAM,QAAQ,MAAM,MAAM;CAGlF,OACE,MAAM,SAAS,kBACf,OAAO,SAAS,kBAChB,KAAK,WAAW,MAAM,UACtB,KAAK,YAAY,MAAM;AAE3B;AAEA,SAAS,gBAAgB,SAAuC;CAC9D,IAAI,QAAQ,SAAS,UACnB,OAAO;EACL,MAAM;EACN,OAAO,YAAY,QAAQ,MAAM,OAAO,QAAQ,MAAM,GAAG;CAC3D;CAGF,IACE,CAAC,OAAO,cAAc,QAAQ,MAAM,KACpC,CAAC,OAAO,cAAc,QAAQ,OAAO,KACrC,QAAQ,SAAS,KACjB,QAAQ,UAAU,GAElB,MAAM,IAAI,WAAW,oCAAoC;CAG3D,OAAO,EAAE,GAAG,QAAQ;AACtB"}

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

@@ -0,0 +1,12 @@
+import { ResolvedSyntaxOptions } from "../syntax-options.mjs";
+import { SourceText } from "../source-text.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { DefinitionLookup } from "./inline-syntax.mjs";
+import { Bracket, Delimiter, Output } from "./inline-output.mjs";
+//#region src/parser/inline-link.d.ts
+export declare function resolveBracket(input: InlineInput, value: SourceText, close: number, bracket: Bracket, output: Output[], delimiters: Delimiter[], syntax: ResolvedSyntaxOptions, definitions: DefinitionLookup, references: Set<string>, nested: boolean): Readonly<{
+  end: number;
+  link: boolean;
+}> | undefined;
+//#endregion
+//# sourceMappingURL=inline-link.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-link.d.mts","names":[],"sources":["../../src/parser/inline-link.ts"],"mappings":";;;;;;wBAgCgB,eACd,OAAO,aACP,OAAO,YACP,eACA,SAAS,SACT,QAAQ,UACR,YAAY,aACZ,QAAQ,uBACR,aAAa,kBACb,YAAY,aACZ,kBACC;EAAW;EAAa"}

package/dist/parser/inline-link.mjs

@@ -0,0 +1,187 @@
+import { decodeNamedCharacterReference, decodeNumericCharacterReference } from "../character-reference.mjs";
+import { normalizeIdentifier } from "../identifier.mjs";
+import { isUnicodeWhitespace } from "./characters.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { bracketText, delimiterText, escapedAt, findUnescapedInline, isBracket, isDelimiter, mergeText, textNode } from "./inline-output.mjs";
+import { matchLiteralAutolink } from "./inline-autolink.mjs";
+import { resolveDelimiters } from "./inline-emphasis.mjs";
+//#region src/parser/inline-link.ts
+function resolveBracket(input, value, close, bracket, output, delimiters, syntax, definitions, references, nested) {
+	const outputIndex = output.lastIndexOf(bracket);
+	if (outputIndex === -1) throw new Error("Bracket stack diverged from inline output");
+	if (!bracket.active) {
+		output[outputIndex] = bracketText(input, bracket);
+		return;
+	}
+	const labelStart = bracket.start + (bracket.image ? 2 : 1);
+	const label = value.slice(labelStart, close);
+	if (!bracket.image && label.startsWith("^") && !label.slice(1).includes("[") && !label.slice(1).includes("]")) {
+		output.splice(outputIndex, output.length - outputIndex, {
+			kind: "footnoteReference",
+			range: input.sourceRange(bracket.start, close + 1),
+			identifier: normalizeIdentifier(label.slice(1))
+		});
+		removeDetachedDelimiters(delimiters, bracket);
+		return {
+			end: close + 1,
+			link: true
+		};
+	}
+	const inline = value.char(close + 1) === "(" ? linkDestination(value, close + 2) : void 0;
+	const reference = inline === void 0 ? referenceSuffix(value, close + 1) : void 0;
+	const identifier = normalizeIdentifier(reference?.label || label);
+	const defined = definitions.has(identifier);
+	if (inline === void 0) {
+		if (identifier !== "" && (nested || /(?:https?:\/\/|www\.|@)/iu.test(label))) references.add(identifier);
+		if (identifier === "" || nested && !defined) {
+			output[outputIndex] = bracketText(input, bracket);
+			return;
+		}
+	}
+	resolveDelimiters(input, output, delimiters, syntax, bracket.start);
+	const children = output.slice(outputIndex + 1).map((entry) => isDelimiter(entry) ? delimiterText(input, entry) : isBracket(entry) ? bracketText(input, entry) : entry);
+	if (inline !== void 0) {
+		const destination = decodeLinkString(inline.destination);
+		const node = bracket.image ? {
+			kind: "image",
+			range: input.sourceRange(bracket.start, inline.end),
+			destination,
+			title: inline.title === void 0 ? void 0 : decodeLinkString(inline.title),
+			alt: inlinePlainText(children)
+		} : {
+			kind: "link",
+			range: input.sourceRange(bracket.start, inline.end),
+			destination,
+			title: inline.title === void 0 ? void 0 : decodeLinkString(inline.title),
+			children: mergeText(children)
+		};
+		output.splice(outputIndex, output.length - outputIndex, node);
+		removeDetachedDelimiters(delimiters, bracket);
+		return {
+			end: inline.end,
+			link: !bracket.image
+		};
+	}
+	const end = reference?.end ?? close + 1;
+	const autolinks = !defined && !bracket.image ? fallbackAutolinks(input, children) : void 0;
+	if (autolinks !== void 0) output.splice(outputIndex, output.length - outputIndex, bracketText(input, bracket), ...autolinks, textNode(input, value, close, end));
+	else output.splice(outputIndex, output.length - outputIndex, {
+		kind: "reference",
+		range: input.sourceRange(bracket.start, end),
+		identifier,
+		referenceKind: reference === void 0 ? "shortcut" : reference.label === "" ? "collapsed" : "full",
+		image: bracket.image,
+		children: mergeText(children)
+	});
+	removeDetachedDelimiters(delimiters, bracket);
+	return {
+		end,
+		link: defined && !bracket.image
+	};
+}
+/** Literal labels resume normal autolinking when no reference definition exists. */
+function fallbackAutolinks(input, children) {
+	const output = [];
+	let changed = false;
+	for (const child of children) {
+		if (child.kind !== "text" || !/(?:https?:\/\/|www\.|@)/iu.test(child.value)) {
+			output.push(child);
+			continue;
+		}
+		const part = new InlineInput(input.file, [{
+			kind: "source",
+			range: child.range
+		}]);
+		const value = part.text();
+		if (value.toString() !== child.value) {
+			output.push(child);
+			continue;
+		}
+		let start = 0;
+		for (let offset = 0; offset < value.length; offset++) {
+			const match = matchLiteralAutolink(part, value, offset);
+			if (match === void 0) continue;
+			if (start < offset) output.push(textNode(part, value, start, offset));
+			output.push(match.node);
+			offset = match.end - 1;
+			start = match.end;
+			changed = true;
+		}
+		if (start < value.length) output.push(textNode(part, value, start, value.length));
+	}
+	return changed ? output : void 0;
+}
+function linkDestination(value, start) {
+	let cursor = start;
+	while (value.char(cursor) === " " || value.char(cursor) === "	" || value.char(cursor) === "\n") cursor++;
+	let destination = "";
+	if (value.char(cursor) === "<") {
+		const end = findUnescapedInline(value, ">", cursor + 1);
+		if (end === void 0 || /[\r\n<]/u.test(value.slice(cursor + 1, end))) return;
+		destination = value.slice(cursor + 1, end);
+		cursor = end + 1;
+	} else {
+		const destinationStart = cursor;
+		let depth = 0;
+		while (cursor < value.length) {
+			const character = value.char(cursor);
+			if (isUnicodeWhitespace(character ?? "")) break;
+			if (character === "(" && !escapedAt(value, cursor, destinationStart)) {
+				if (++depth > 32) return;
+			} else if (character === ")" && !escapedAt(value, cursor, destinationStart)) {
+				if (depth === 0) break;
+				depth--;
+			}
+			cursor++;
+		}
+		if (depth !== 0) return;
+		destination = value.slice(destinationStart, cursor);
+	}
+	const beforeWhitespace = cursor;
+	while (isUnicodeWhitespace(value.char(cursor) ?? "")) cursor++;
+	let title;
+	if (cursor !== beforeWhitespace && value.char(cursor) !== ")") {
+		const opener = value.char(cursor);
+		const closer = opener === "(" ? ")" : opener === "'" ? "'" : opener === "\"" ? "\"" : void 0;
+		if (closer === void 0) return;
+		const titleEnd = findUnescapedInline(value, closer, cursor + 1);
+		if (titleEnd === void 0) return;
+		title = value.slice(cursor + 1, titleEnd);
+		cursor = titleEnd + 1;
+		while (isUnicodeWhitespace(value.char(cursor) ?? "")) cursor++;
+	}
+	return value.char(cursor) === ")" ? {
+		destination,
+		end: cursor + 1,
+		title
+	} : void 0;
+}
+function referenceSuffix(value, start) {
+	if (value.char(start) !== "[") return;
+	const end = findUnescapedInline(value, "]", start + 1);
+	if (end === void 0 || end - start > 1e3 || value.slice(start + 1, end).includes("[")) return;
+	return {
+		end: end + 1,
+		label: value.slice(start + 1, end)
+	};
+}
+function decodeLinkString(value) {
+	return value.replace(/\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|[xX][\dA-Fa-f]{1,6})|[A-Za-z][\dA-Za-z]{1,30});/gu, (match, escaped, reference) => {
+		if (escaped !== void 0) return escaped;
+		if (reference === void 0) return match;
+		if (!reference.startsWith("#")) return decodeNamedCharacterReference(reference) ?? match;
+		const hexadecimal = reference[1] === "x" || reference[1] === "X";
+		return decodeNumericCharacterReference(reference.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
+	});
+}
+function inlinePlainText(nodes) {
+	return nodes.map((node) => node.kind === "text" || node.kind === "code" || node.kind === "rawHtml" ? node.value : "children" in node ? inlinePlainText(node.children) : "").join("");
+}
+/** Delimiters after a resolved bracket are inside its node. */
+function removeDetachedDelimiters(delimiters, bracket) {
+	while ((delimiters.at(-1)?.start ?? -1) > bracket.start) delimiters.pop();
+}
+//#endregion
+export { resolveBracket };
+
+//# sourceMappingURL=inline-link.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-link.mjs","names":[],"sources":["../../src/parser/inline-link.ts"],"sourcesContent":["import type { SourceText } from \"../source-text.ts\";\nimport type { ResolvedSyntaxOptions } from \"../syntax-options.ts\";\nimport type { Bracket, Delimiter, Output } from \"./inline-output.ts\";\nimport type { DefinitionLookup, InlineSyntax } from \"./inline-syntax.ts\";\n\nimport {\n  decodeNamedCharacterReference,\n  decodeNumericCharacterReference,\n} from \"../character-reference.ts\";\nimport { normalizeIdentifier } from \"../identifier.ts\";\nimport { isUnicodeWhitespace } from \"./characters.ts\";\nimport { matchLiteralAutolink } from \"./inline-autolink.ts\";\nimport { resolveDelimiters } from \"./inline-emphasis.ts\";\nimport { InlineInput } from \"./inline-input.ts\";\nimport {\n  bracketText,\n  delimiterText,\n  escapedAt,\n  findUnescapedInline,\n  isBracket,\n  isDelimiter,\n  mergeText,\n  textNode,\n} from \"./inline-output.ts\";\n\n// Links, images, references, and footnote references, resolved at a closing bracket.\n\ninterface ReferenceSuffix {\n  readonly end: number;\n  readonly label: string;\n}\n\nexport function resolveBracket(\n  input: InlineInput,\n  value: SourceText,\n  close: number,\n  bracket: Bracket,\n  output: Output[],\n  delimiters: Delimiter[],\n  syntax: ResolvedSyntaxOptions,\n  definitions: DefinitionLookup,\n  references: Set<string>,\n  nested: boolean,\n): Readonly<{ end: number; link: boolean }> | undefined {\n  const outputIndex = output.lastIndexOf(bracket);\n\n  if (outputIndex === -1) {\n    throw new Error(\"Bracket stack diverged from inline output\");\n  }\n\n  if (!bracket.active) {\n    output[outputIndex] = bracketText(input, bracket);\n\n    return;\n  }\n\n  const labelStart = bracket.start + (bracket.image ? 2 : 1);\n  const label = value.slice(labelStart, close);\n\n  if (\n    !bracket.image &&\n    label.startsWith(\"^\") &&\n    !label.slice(1).includes(\"[\") &&\n    !label.slice(1).includes(\"]\")\n  ) {\n    output.splice(outputIndex, output.length - outputIndex, {\n      kind: \"footnoteReference\",\n      range: input.sourceRange(bracket.start, close + 1),\n      identifier: normalizeIdentifier(label.slice(1)),\n    });\n    removeDetachedDelimiters(delimiters, bracket);\n\n    return { end: close + 1, link: true };\n  }\n\n  const inline = value.char(close + 1) === \"(\" ? linkDestination(value, close + 2) : undefined;\n  const reference = inline === undefined ? referenceSuffix(value, close + 1) : undefined;\n  const identifier = normalizeIdentifier(reference?.label || label);\n  const defined = definitions.has(identifier);\n\n  if (inline === undefined) {\n    if (identifier !== \"\" && (nested || /(?:https?:\\/\\/|www\\.|@)/iu.test(label))) {\n      references.add(identifier);\n    }\n\n    // Missing inner references remain label text. A later definition reparses their dependents.\n    if (identifier === \"\" || (nested && !defined)) {\n      output[outputIndex] = bracketText(input, bracket);\n\n      return;\n    }\n  }\n\n  resolveDelimiters(input, output, delimiters, syntax, bracket.start);\n\n  const children = output\n    .slice(outputIndex + 1)\n    .map((entry) =>\n      isDelimiter(entry)\n        ? delimiterText(input, entry)\n        : isBracket(entry)\n          ? bracketText(input, entry)\n          : entry,\n    );\n\n  if (inline !== undefined) {\n    const destination = decodeLinkString(inline.destination);\n\n    const node: InlineSyntax = bracket.image\n      ? {\n          kind: \"image\",\n          range: input.sourceRange(bracket.start, inline.end),\n          destination,\n          title: inline.title === undefined ? undefined : decodeLinkString(inline.title),\n          alt: inlinePlainText(children),\n        }\n      : {\n          kind: \"link\",\n          range: input.sourceRange(bracket.start, inline.end),\n          destination,\n          title: inline.title === undefined ? undefined : decodeLinkString(inline.title),\n          children: mergeText(children),\n        };\n\n    output.splice(outputIndex, output.length - outputIndex, node);\n    removeDetachedDelimiters(delimiters, bracket);\n\n    return { end: inline.end, link: !bracket.image };\n  }\n\n  const end = reference?.end ?? close + 1;\n  const autolinks = !defined && !bracket.image ? fallbackAutolinks(input, children) : undefined;\n\n  if (autolinks !== undefined) {\n    output.splice(\n      outputIndex,\n      output.length - outputIndex,\n      bracketText(input, bracket),\n      ...autolinks,\n      textNode(input, value, close, end),\n    );\n  } else {\n    output.splice(outputIndex, output.length - outputIndex, {\n      kind: \"reference\",\n      range: input.sourceRange(bracket.start, end),\n      identifier,\n      referenceKind:\n        reference === undefined ? \"shortcut\" : reference.label === \"\" ? \"collapsed\" : \"full\",\n      image: bracket.image,\n      children: mergeText(children),\n    });\n  }\n\n  removeDetachedDelimiters(delimiters, bracket);\n\n  return { end, link: defined && !bracket.image };\n}\n\n/** Literal labels resume normal autolinking when no reference definition exists. */\nfunction fallbackAutolinks(\n  input: InlineInput,\n  children: readonly InlineSyntax[],\n): InlineSyntax[] | undefined {\n  const output: InlineSyntax[] = [];\n  let changed = false;\n\n  for (const child of children) {\n    if (child.kind !== \"text\" || !/(?:https?:\\/\\/|www\\.|@)/iu.test(child.value)) {\n      output.push(child);\n      continue;\n    }\n\n    const part = new InlineInput(input.file, [{ kind: \"source\", range: child.range }]);\n    const value = part.text();\n\n    if (value.toString() !== child.value) {\n      output.push(child);\n      continue;\n    }\n\n    let start = 0;\n\n    for (let offset = 0; offset < value.length; offset++) {\n      const match = matchLiteralAutolink(part, value, offset);\n\n      if (match === undefined) {\n        continue;\n      }\n\n      if (start < offset) {\n        output.push(textNode(part, value, start, offset));\n      }\n\n      output.push(match.node);\n      offset = match.end - 1;\n      start = match.end;\n      changed = true;\n    }\n\n    if (start < value.length) {\n      output.push(textNode(part, value, start, value.length));\n    }\n  }\n\n  return changed ? output : undefined;\n}\n\ninterface LinkDestinationResult {\n  readonly destination: string;\n  readonly end: number;\n  readonly title: string | undefined;\n}\n\nfunction linkDestination(value: SourceText, start: number): LinkDestinationResult | undefined {\n  let cursor = start;\n\n  while (value.char(cursor) === \" \" || value.char(cursor) === \"\\t\" || value.char(cursor) === \"\\n\") {\n    cursor++;\n  }\n\n  let destination = \"\";\n\n  if (value.char(cursor) === \"<\") {\n    const end = findUnescapedInline(value, \">\", cursor + 1);\n\n    if (end === undefined || /[\\r\\n<]/u.test(value.slice(cursor + 1, end))) {\n      return;\n    }\n\n    destination = value.slice(cursor + 1, end);\n    cursor = end + 1;\n  } else {\n    const destinationStart = cursor;\n    let depth = 0;\n\n    while (cursor < value.length) {\n      const character = value.char(cursor);\n\n      if (isUnicodeWhitespace(character ?? \"\")) {\n        break;\n      }\n\n      if (character === \"(\" && !escapedAt(value, cursor, destinationStart)) {\n        if (++depth > 32) {\n          return;\n        }\n      } else if (character === \")\" && !escapedAt(value, cursor, destinationStart)) {\n        if (depth === 0) {\n          break;\n        }\n\n        depth--;\n      }\n\n      cursor++;\n    }\n\n    if (depth !== 0) {\n      return;\n    }\n\n    destination = value.slice(destinationStart, cursor);\n  }\n\n  const beforeWhitespace = cursor;\n\n  while (isUnicodeWhitespace(value.char(cursor) ?? \"\")) {\n    cursor++;\n  }\n\n  let title: string | undefined;\n\n  if (cursor !== beforeWhitespace && value.char(cursor) !== \")\") {\n    const opener = value.char(cursor);\n    const closer = opener === \"(\" ? \")\" : opener === \"'\" ? \"'\" : opener === '\"' ? '\"' : undefined;\n\n    if (closer === undefined) {\n      return;\n    }\n\n    const titleEnd = findUnescapedInline(value, closer, cursor + 1);\n\n    if (titleEnd === undefined) {\n      return;\n    }\n\n    title = value.slice(cursor + 1, titleEnd);\n    cursor = titleEnd + 1;\n\n    while (isUnicodeWhitespace(value.char(cursor) ?? \"\")) {\n      cursor++;\n    }\n  }\n\n  return value.char(cursor) === \")\" ? { destination, end: cursor + 1, title } : undefined;\n}\n\nfunction referenceSuffix(value: SourceText, start: number): ReferenceSuffix | undefined {\n  if (value.char(start) !== \"[\") {\n    return;\n  }\n\n  const end = findUnescapedInline(value, \"]\", start + 1);\n\n  if (end === undefined || end - start > 1000 || value.slice(start + 1, end).includes(\"[\")) {\n    return;\n  }\n\n  return { end: end + 1, label: value.slice(start + 1, end) };\n}\n\nfunction decodeLinkString(value: string): string {\n  return value.replace(\n    /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|[xX][\\dA-Fa-f]{1,6})|[A-Za-z][\\dA-Za-z]{1,30});/gu,\n    (match, escaped: string | undefined, reference: string | undefined) => {\n      if (escaped !== undefined) {\n        return escaped;\n      }\n\n      if (reference === undefined) {\n        return match;\n      }\n\n      if (!reference.startsWith(\"#\")) {\n        return decodeNamedCharacterReference(reference) ?? match;\n      }\n\n      const hexadecimal = reference[1] === \"x\" || reference[1] === \"X\";\n\n      return decodeNumericCharacterReference(\n        reference.slice(hexadecimal ? 2 : 1),\n        hexadecimal ? 16 : 10,\n      );\n    },\n  );\n}\n\nfunction inlinePlainText(nodes: readonly InlineSyntax[]): string {\n  return nodes\n    .map((node) =>\n      node.kind === \"text\" || node.kind === \"code\" || node.kind === \"rawHtml\"\n        ? node.value\n        : \"children\" in node\n          ? inlinePlainText(node.children)\n          : \"\",\n    )\n    .join(\"\");\n}\n\n/** Delimiters after a resolved bracket are inside its node. */\nfunction removeDetachedDelimiters(delimiters: Delimiter[], bracket: Bracket): void {\n  while ((delimiters.at(-1)?.start ?? -1) > bracket.start) {\n    delimiters.pop();\n  }\n}\n"],"mappings":";;;;;;;;AAgCA,SAAgB,eACd,OACA,OACA,OACA,SACA,QACA,YACA,QACA,aACA,YACA,QACsD;CACtD,MAAM,cAAc,OAAO,YAAY,OAAO;CAE9C,IAAI,gBAAgB,IAClB,MAAM,IAAI,MAAM,2CAA2C;CAG7D,IAAI,CAAC,QAAQ,QAAQ;EACnB,OAAO,eAAe,YAAY,OAAO,OAAO;EAEhD;CACF;CAEA,MAAM,aAAa,QAAQ,SAAS,QAAQ,QAAQ,IAAI;CACxD,MAAM,QAAQ,MAAM,MAAM,YAAY,KAAK;CAE3C,IACE,CAAC,QAAQ,SACT,MAAM,WAAW,GAAG,KACpB,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,SAAS,GAAG,KAC5B,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,SAAS,GAAG,GAC5B;EACA,OAAO,OAAO,aAAa,OAAO,SAAS,aAAa;GACtD,MAAM;GACN,OAAO,MAAM,YAAY,QAAQ,OAAO,QAAQ,CAAC;GACjD,YAAY,oBAAoB,MAAM,MAAM,CAAC,CAAC;EAChD,CAAC;EACD,yBAAyB,YAAY,OAAO;EAE5C,OAAO;GAAE,KAAK,QAAQ;GAAG,MAAM;EAAK;CACtC;CAEA,MAAM,SAAS,MAAM,KAAK,QAAQ,CAAC,MAAM,MAAM,gBAAgB,OAAO,QAAQ,CAAC,IAAI,KAAA;CACnF,MAAM,YAAY,WAAW,KAAA,IAAY,gBAAgB,OAAO,QAAQ,CAAC,IAAI,KAAA;CAC7E,MAAM,aAAa,oBAAoB,WAAW,SAAS,KAAK;CAChE,MAAM,UAAU,YAAY,IAAI,UAAU;CAE1C,IAAI,WAAW,KAAA,GAAW;EACxB,IAAI,eAAe,OAAO,UAAU,4BAA4B,KAAK,KAAK,IACxE,WAAW,IAAI,UAAU;EAI3B,IAAI,eAAe,MAAO,UAAU,CAAC,SAAU;GAC7C,OAAO,eAAe,YAAY,OAAO,OAAO;GAEhD;EACF;CACF;CAEA,kBAAkB,OAAO,QAAQ,YAAY,QAAQ,QAAQ,KAAK;CAElE,MAAM,WAAW,OACd,MAAM,cAAc,CAAC,CAAC,CACtB,KAAK,UACJ,YAAY,KAAK,IACb,cAAc,OAAO,KAAK,IAC1B,UAAU,KAAK,IACb,YAAY,OAAO,KAAK,IACxB,KACR;CAEF,IAAI,WAAW,KAAA,GAAW;EACxB,MAAM,cAAc,iBAAiB,OAAO,WAAW;EAEvD,MAAM,OAAqB,QAAQ,QAC/B;GACE,MAAM;GACN,OAAO,MAAM,YAAY,QAAQ,OAAO,OAAO,GAAG;GAClD;GACA,OAAO,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY,iBAAiB,OAAO,KAAK;GAC7E,KAAK,gBAAgB,QAAQ;EAC/B,IACA;GACE,MAAM;GACN,OAAO,MAAM,YAAY,QAAQ,OAAO,OAAO,GAAG;GAClD;GACA,OAAO,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY,iBAAiB,OAAO,KAAK;GAC7E,UAAU,UAAU,QAAQ;EAC9B;EAEJ,OAAO,OAAO,aAAa,OAAO,SAAS,aAAa,IAAI;EAC5D,yBAAyB,YAAY,OAAO;EAE5C,OAAO;GAAE,KAAK,OAAO;GAAK,MAAM,CAAC,QAAQ;EAAM;CACjD;CAEA,MAAM,MAAM,WAAW,OAAO,QAAQ;CACtC,MAAM,YAAY,CAAC,WAAW,CAAC,QAAQ,QAAQ,kBAAkB,OAAO,QAAQ,IAAI,KAAA;CAEpF,IAAI,cAAc,KAAA,GAChB,OAAO,OACL,aACA,OAAO,SAAS,aAChB,YAAY,OAAO,OAAO,GAC1B,GAAG,WACH,SAAS,OAAO,OAAO,OAAO,GAAG,CACnC;MAEA,OAAO,OAAO,aAAa,OAAO,SAAS,aAAa;EACtD,MAAM;EACN,OAAO,MAAM,YAAY,QAAQ,OAAO,GAAG;EAC3C;EACA,eACE,cAAc,KAAA,IAAY,aAAa,UAAU,UAAU,KAAK,cAAc;EAChF,OAAO,QAAQ;EACf,UAAU,UAAU,QAAQ;CAC9B,CAAC;CAGH,yBAAyB,YAAY,OAAO;CAE5C,OAAO;EAAE;EAAK,MAAM,WAAW,CAAC,QAAQ;CAAM;AAChD;;AAGA,SAAS,kBACP,OACA,UAC4B;CAC5B,MAAM,SAAyB,CAAC;CAChC,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,UAAU;EAC5B,IAAI,MAAM,SAAS,UAAU,CAAC,4BAA4B,KAAK,MAAM,KAAK,GAAG;GAC3E,OAAO,KAAK,KAAK;GACjB;EACF;EAEA,MAAM,OAAO,IAAI,YAAY,MAAM,MAAM,CAAC;GAAE,MAAM;GAAU,OAAO,MAAM;EAAM,CAAC,CAAC;EACjF,MAAM,QAAQ,KAAK,KAAK;EAExB,IAAI,MAAM,SAAS,MAAM,MAAM,OAAO;GACpC,OAAO,KAAK,KAAK;GACjB;EACF;EAEA,IAAI,QAAQ;EAEZ,KAAK,IAAI,SAAS,GAAG,SAAS,MAAM,QAAQ,UAAU;GACpD,MAAM,QAAQ,qBAAqB,MAAM,OAAO,MAAM;GAEtD,IAAI,UAAU,KAAA,GACZ;GAGF,IAAI,QAAQ,QACV,OAAO,KAAK,SAAS,MAAM,OAAO,OAAO,MAAM,CAAC;GAGlD,OAAO,KAAK,MAAM,IAAI;GACtB,SAAS,MAAM,MAAM;GACrB,QAAQ,MAAM;GACd,UAAU;EACZ;EAEA,IAAI,QAAQ,MAAM,QAChB,OAAO,KAAK,SAAS,MAAM,OAAO,OAAO,MAAM,MAAM,CAAC;CAE1D;CAEA,OAAO,UAAU,SAAS,KAAA;AAC5B;AAQA,SAAS,gBAAgB,OAAmB,OAAkD;CAC5F,IAAI,SAAS;CAEb,OAAO,MAAM,KAAK,MAAM,MAAM,OAAO,MAAM,KAAK,MAAM,MAAM,OAAQ,MAAM,KAAK,MAAM,MAAM,MACzF;CAGF,IAAI,cAAc;CAElB,IAAI,MAAM,KAAK,MAAM,MAAM,KAAK;EAC9B,MAAM,MAAM,oBAAoB,OAAO,KAAK,SAAS,CAAC;EAEtD,IAAI,QAAQ,KAAA,KAAa,WAAW,KAAK,MAAM,MAAM,SAAS,GAAG,GAAG,CAAC,GACnE;EAGF,cAAc,MAAM,MAAM,SAAS,GAAG,GAAG;EACzC,SAAS,MAAM;CACjB,OAAO;EACL,MAAM,mBAAmB;EACzB,IAAI,QAAQ;EAEZ,OAAO,SAAS,MAAM,QAAQ;GAC5B,MAAM,YAAY,MAAM,KAAK,MAAM;GAEnC,IAAI,oBAAoB,aAAa,EAAE,GACrC;GAGF,IAAI,cAAc,OAAO,CAAC,UAAU,OAAO,QAAQ,gBAAgB,GAC7D;QAAA,EAAE,QAAQ,IACZ;GAAA,OAEG,IAAI,cAAc,OAAO,CAAC,UAAU,OAAO,QAAQ,gBAAgB,GAAG;IAC3E,IAAI,UAAU,GACZ;IAGF;GACF;GAEA;EACF;EAEA,IAAI,UAAU,GACZ;EAGF,cAAc,MAAM,MAAM,kBAAkB,MAAM;CACpD;CAEA,MAAM,mBAAmB;CAEzB,OAAO,oBAAoB,MAAM,KAAK,MAAM,KAAK,EAAE,GACjD;CAGF,IAAI;CAEJ,IAAI,WAAW,oBAAoB,MAAM,KAAK,MAAM,MAAM,KAAK;EAC7D,MAAM,SAAS,MAAM,KAAK,MAAM;EAChC,MAAM,SAAS,WAAW,MAAM,MAAM,WAAW,MAAM,MAAM,WAAW,OAAM,OAAM,KAAA;EAEpF,IAAI,WAAW,KAAA,GACb;EAGF,MAAM,WAAW,oBAAoB,OAAO,QAAQ,SAAS,CAAC;EAE9D,IAAI,aAAa,KAAA,GACf;EAGF,QAAQ,MAAM,MAAM,SAAS,GAAG,QAAQ;EACxC,SAAS,WAAW;EAEpB,OAAO,oBAAoB,MAAM,KAAK,MAAM,KAAK,EAAE,GACjD;CAEJ;CAEA,OAAO,MAAM,KAAK,MAAM,MAAM,MAAM;EAAE;EAAa,KAAK,SAAS;EAAG;CAAM,IAAI,KAAA;AAChF;AAEA,SAAS,gBAAgB,OAAmB,OAA4C;CACtF,IAAI,MAAM,KAAK,KAAK,MAAM,KACxB;CAGF,MAAM,MAAM,oBAAoB,OAAO,KAAK,QAAQ,CAAC;CAErD,IAAI,QAAQ,KAAA,KAAa,MAAM,QAAQ,OAAQ,MAAM,MAAM,QAAQ,GAAG,GAAG,CAAC,CAAC,SAAS,GAAG,GACrF;CAGF,OAAO;EAAE,KAAK,MAAM;EAAG,OAAO,MAAM,MAAM,QAAQ,GAAG,GAAG;CAAE;AAC5D;AAEA,SAAS,iBAAiB,OAAuB;CAC/C,OAAO,MAAM,QACX,uFACC,OAAO,SAA6B,cAAkC;EACrE,IAAI,YAAY,KAAA,GACd,OAAO;EAGT,IAAI,cAAc,KAAA,GAChB,OAAO;EAGT,IAAI,CAAC,UAAU,WAAW,GAAG,GAC3B,OAAO,8BAA8B,SAAS,KAAK;EAGrD,MAAM,cAAc,UAAU,OAAO,OAAO,UAAU,OAAO;EAE7D,OAAO,gCACL,UAAU,MAAM,cAAc,IAAI,CAAC,GACnC,cAAc,KAAK,EACrB;CACF,CACF;AACF;AAEA,SAAS,gBAAgB,OAAwC;CAC/D,OAAO,MACJ,KAAK,SACJ,KAAK,SAAS,UAAU,KAAK,SAAS,UAAU,KAAK,SAAS,YAC1D,KAAK,QACL,cAAc,OACZ,gBAAgB,KAAK,QAAQ,IAC7B,EACR,CAAC,CACA,KAAK,EAAE;AACZ;;AAGA,SAAS,yBAAyB,YAAyB,SAAwB;CACjF,QAAQ,WAAW,GAAG,EAAE,CAAC,EAAE,SAAS,MAAM,QAAQ,OAChD,WAAW,IAAI;AAEnB"}

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

@@ -0,0 +1,10 @@
+import { SourceText } from "../source-text.mjs";
+import { InlineInput } from "./inline-input.mjs";
+import { InlineMatch } from "./inline-output.mjs";
+//#region src/parser/inline-math.d.ts
+export declare function texMath(input: InlineInput, value: SourceText, start: number): InlineMatch | undefined;
+export declare function dollarMath(input: InlineInput, value: SourceText, start: number): InlineMatch | undefined;
+/** An opening dollar that later input could still close. */
+export declare function dollarUnclosed(value: SourceText, start: number): boolean;
+//#endregion
+//# sourceMappingURL=inline-math.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-math.d.mts","names":[],"sources":["../../src/parser/inline-math.ts"],"mappings":";;;;wBASgB,QACd,OAAO,aACP,OAAO,YACP,gBACC;wBAwBa,WACd,OAAO,aACP,OAAO,YACP,gBACC;;wBA6Ba,eAAe,OAAO,YAAY"}

package/dist/parser/inline-math.mjs

@@ -0,0 +1,46 @@
+import { isUnicodeWhitespace } from "./characters.mjs";
+import { escapedAt } from "./inline-output.mjs";
+//#region src/parser/inline-math.ts
+function texMath(input, value, start) {
+	let close = value.indexOf("\\)", start + 2);
+	while (close !== -1 && escapedAt(value, close, start + 2)) close = value.indexOf("\\)", close + 2);
+	if (close === -1) return;
+	const end = close + 2;
+	return {
+		end,
+		node: {
+			kind: "math",
+			range: input.sourceRange(start, end),
+			value: value.slice(start + 2, close),
+			format: "tex"
+		}
+	};
+}
+function dollarMath(input, value, start) {
+	if (value.char(start + 1) === void 0 || isUnicodeWhitespace(value.char(start + 1) ?? "")) return;
+	let close = value.indexOf("$", start + 1);
+	while (close !== -1 && escapedAt(value, close, start + 1)) close = value.indexOf("$", close + 1);
+	if (close === -1 || close === start + 1 || isUnicodeWhitespace(value.char(close - 1) ?? "")) return;
+	const end = close + 1;
+	return {
+		end,
+		node: {
+			kind: "math",
+			range: input.sourceRange(start, end),
+			value: value.slice(start + 1, close),
+			format: "dollar"
+		}
+	};
+}
+/** An opening dollar that later input could still close. */
+function dollarUnclosed(value, start) {
+	if (value.char(start + 1) === void 0) return true;
+	if (isUnicodeWhitespace(value.char(start + 1) ?? "")) return false;
+	let close = value.indexOf("$", start + 1);
+	while (close !== -1 && escapedAt(value, close, start + 1)) close = value.indexOf("$", close + 1);
+	return close === -1;
+}
+//#endregion
+export { dollarMath, dollarUnclosed, texMath };
+
+//# sourceMappingURL=inline-math.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inline-math.mjs","names":[],"sources":["../../src/parser/inline-math.ts"],"sourcesContent":["import type { SourceText } from \"../source-text.ts\";\nimport type { InlineInput } from \"./inline-input.ts\";\nimport type { InlineMatch } from \"./inline-output.ts\";\n\nimport { isUnicodeWhitespace } from \"./characters.ts\";\nimport { escapedAt } from \"./inline-output.ts\";\n\n// Inline TeX and dollar math.\n\nexport function texMath(\n  input: InlineInput,\n  value: SourceText,\n  start: number,\n): InlineMatch | undefined {\n  let close = value.indexOf(\"\\\\)\", start + 2);\n\n  while (close !== -1 && escapedAt(value, close, start + 2)) {\n    close = value.indexOf(\"\\\\)\", close + 2);\n  }\n\n  if (close === -1) {\n    return;\n  }\n\n  const end = close + 2;\n\n  return {\n    end,\n    node: {\n      kind: \"math\",\n      range: input.sourceRange(start, end),\n      value: value.slice(start + 2, close),\n      format: \"tex\",\n    },\n  };\n}\n\nexport function dollarMath(\n  input: InlineInput,\n  value: SourceText,\n  start: number,\n): InlineMatch | undefined {\n  if (value.char(start + 1) === undefined || isUnicodeWhitespace(value.char(start + 1) ?? \"\")) {\n    return;\n  }\n\n  let close = value.indexOf(\"$\", start + 1);\n\n  while (close !== -1 && escapedAt(value, close, start + 1)) {\n    close = value.indexOf(\"$\", close + 1);\n  }\n\n  if (close === -1 || close === start + 1 || isUnicodeWhitespace(value.char(close - 1) ?? \"\")) {\n    return;\n  }\n\n  const end = close + 1;\n\n  return {\n    end,\n    node: {\n      kind: \"math\",\n      range: input.sourceRange(start, end),\n      value: value.slice(start + 1, close),\n      format: \"dollar\",\n    },\n  };\n}\n\n/** An opening dollar that later input could still close. */\nexport function dollarUnclosed(value: SourceText, start: number): boolean {\n  if (value.char(start + 1) === undefined) {\n    return true;\n  }\n\n  if (isUnicodeWhitespace(value.char(start + 1) ?? \"\")) {\n    return false;\n  }\n\n  let close = value.indexOf(\"$\", start + 1);\n\n  while (close !== -1 && escapedAt(value, close, start + 1)) {\n    close = value.indexOf(\"$\", close + 1);\n  }\n\n  return close === -1;\n}\n"],"mappings":";;;AASA,SAAgB,QACd,OACA,OACA,OACyB;CACzB,IAAI,QAAQ,MAAM,QAAQ,OAAO,QAAQ,CAAC;CAE1C,OAAO,UAAU,MAAM,UAAU,OAAO,OAAO,QAAQ,CAAC,GACtD,QAAQ,MAAM,QAAQ,OAAO,QAAQ,CAAC;CAGxC,IAAI,UAAU,IACZ;CAGF,MAAM,MAAM,QAAQ;CAEpB,OAAO;EACL;EACA,MAAM;GACJ,MAAM;GACN,OAAO,MAAM,YAAY,OAAO,GAAG;GACnC,OAAO,MAAM,MAAM,QAAQ,GAAG,KAAK;GACnC,QAAQ;EACV;CACF;AACF;AAEA,SAAgB,WACd,OACA,OACA,OACyB;CACzB,IAAI,MAAM,KAAK,QAAQ,CAAC,MAAM,KAAA,KAAa,oBAAoB,MAAM,KAAK,QAAQ,CAAC,KAAK,EAAE,GACxF;CAGF,IAAI,QAAQ,MAAM,QAAQ,KAAK,QAAQ,CAAC;CAExC,OAAO,UAAU,MAAM,UAAU,OAAO,OAAO,QAAQ,CAAC,GACtD,QAAQ,MAAM,QAAQ,KAAK,QAAQ,CAAC;CAGtC,IAAI,UAAU,MAAM,UAAU,QAAQ,KAAK,oBAAoB,MAAM,KAAK,QAAQ,CAAC,KAAK,EAAE,GACxF;CAGF,MAAM,MAAM,QAAQ;CAEpB,OAAO;EACL;EACA,MAAM;GACJ,MAAM;GACN,OAAO,MAAM,YAAY,OAAO,GAAG;GACnC,OAAO,MAAM,MAAM,QAAQ,GAAG,KAAK;GACnC,QAAQ;EACV;CACF;AACF;;AAGA,SAAgB,eAAe,OAAmB,OAAwB;CACxE,IAAI,MAAM,KAAK,QAAQ,CAAC,MAAM,KAAA,GAC5B,OAAO;CAGT,IAAI,oBAAoB,MAAM,KAAK,QAAQ,CAAC,KAAK,EAAE,GACjD,OAAO;CAGT,IAAI,QAAQ,MAAM,QAAQ,KAAK,QAAQ,CAAC;CAExC,OAAO,UAAU,MAAM,UAAU,OAAO,OAAO,QAAQ,CAAC,GACtD,QAAQ,MAAM,QAAQ,KAAK,QAAQ,CAAC;CAGtC,OAAO,UAAU;AACnB"}