@temelj/mdx 0.13.0 → 0.15.0

package/dist/source-map.mjs

@@ -0,0 +1,90 @@
+import { encodeBase64 } from "@temelj/string";
+//#region src/source-map.ts
+/** Private generated-text builder that records original MDX locations. */
+var CodeWriter = class {
+	chunks = [];
+	points = [];
+	column = 0;
+	line = 0;
+	size = 0;
+	sourceFile;
+	constructor(sourceFile) {
+		this.sourceFile = sourceFile;
+	}
+	get length() {
+		return this.size;
+	}
+	/** Writes generated code. `origin` maps it to a range in the source file. */
+	write(value, origin) {
+		if (value.length === 0) return;
+		if (origin !== void 0 && this.sourceFile !== void 0) {
+			const location = this.sourceFile.location(origin.start);
+			this.points.push({
+				generatedColumn: this.column,
+				generatedLine: this.line,
+				originalColumn: location.column - 1,
+				originalLine: location.line - 1
+			});
+		}
+		this.chunks.push(value);
+		this.size += value.length;
+		for (let index = 0; index < value.length; index++) if (value.charCodeAt(index) === 10) {
+			this.line++;
+			this.column = 0;
+		} else this.column++;
+	}
+	toString() {
+		return this.chunks.join("");
+	}
+	sourceMap(sourceName, outputName) {
+		const source = this.sourceFile;
+		return Object.freeze({
+			version: 3,
+			file: outputName,
+			names: Object.freeze([]),
+			sources: Object.freeze([sourceName]),
+			sourcesContent: Object.freeze([source?.text ?? ""]),
+			mappings: encodeMappings(this.points)
+		});
+	}
+};
+function encodeMappings(points) {
+	if (points.length === 0) return "";
+	const lines = [];
+	let generatedLine = 0;
+	let previousOriginalColumn = 0;
+	let previousOriginalLine = 0;
+	let previousSource = 0;
+	let index = 0;
+	while (index < points.length) {
+		const segments = [];
+		let previousGeneratedColumn = 0;
+		while (index < points.length && points[index].generatedLine === generatedLine) {
+			const point = points[index];
+			segments.push(encodeVlq(point.generatedColumn - previousGeneratedColumn) + encodeVlq(0 - previousSource) + encodeVlq(point.originalLine - previousOriginalLine) + encodeVlq(point.originalColumn - previousOriginalColumn));
+			previousGeneratedColumn = point.generatedColumn;
+			previousSource = 0;
+			previousOriginalLine = point.originalLine;
+			previousOriginalColumn = point.originalColumn;
+			index++;
+		}
+		lines.push(segments.join(","));
+		generatedLine++;
+	}
+	return lines.join(";");
+}
+function encodeVlq(value) {
+	let encoded = "";
+	let remaining = value < 0 ? -value << 1 | 1 : value << 1;
+	do {
+		let digit = remaining & 31;
+		remaining >>>= 5;
+		if (remaining > 0) digit |= 32;
+		encoded += encodeBase64(Uint8Array.of(digit << 2))[0];
+	} while (remaining > 0);
+	return encoded;
+}
+//#endregion
+export { CodeWriter };
+
+//# sourceMappingURL=source-map.mjs.map

package/dist/source-map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-map.mjs","names":[],"sources":["../src/source-map.ts"],"sourcesContent":["import { encodeBase64 } from \"@temelj/string\";\n\nimport type { SourceRange } from \"./ranges.ts\";\nimport type { SourceFile } from \"./source.ts\";\n\nexport interface SourceMap {\n  readonly file?: string;\n  readonly mappings: string;\n  readonly names: readonly string[];\n  readonly sources: readonly string[];\n  readonly sourcesContent: readonly string[];\n  readonly version: 3;\n}\n\ninterface MappingPoint {\n  readonly generatedColumn: number;\n  readonly generatedLine: number;\n  readonly originalColumn: number;\n  readonly originalLine: number;\n}\n\n/** Private generated-text builder that records original MDX locations. */\nexport class CodeWriter {\n  private readonly chunks: string[] = [];\n  private readonly points: MappingPoint[] = [];\n  private column = 0;\n  private line = 0;\n  private size = 0;\n  private readonly sourceFile: SourceFile | undefined;\n\n  public constructor(sourceFile: SourceFile | undefined) {\n    this.sourceFile = sourceFile;\n  }\n\n  public get length(): number {\n    return this.size;\n  }\n\n  /** Writes generated code. `origin` maps it to a range in the source file. */\n  public write(value: string, origin?: SourceRange): void {\n    if (value.length === 0) {\n      return;\n    }\n\n    if (origin !== undefined && this.sourceFile !== undefined) {\n      const location = this.sourceFile.location(origin.start);\n      this.points.push({\n        generatedColumn: this.column,\n        generatedLine: this.line,\n        originalColumn: location.column - 1,\n        originalLine: location.line - 1,\n      });\n    }\n\n    this.chunks.push(value);\n    this.size += value.length;\n\n    for (let index = 0; index < value.length; index++) {\n      const code = value.charCodeAt(index);\n\n      if (code === 10) {\n        this.line++;\n        this.column = 0;\n      } else {\n        this.column++;\n      }\n    }\n  }\n\n  public toString(): string {\n    return this.chunks.join(\"\");\n  }\n\n  public sourceMap(sourceName: string, outputName?: string): SourceMap {\n    const source = this.sourceFile;\n\n    return Object.freeze({\n      version: 3 as const,\n      file: outputName,\n      names: Object.freeze([]),\n      sources: Object.freeze([sourceName]),\n      sourcesContent: Object.freeze([source?.text ?? \"\"]),\n      mappings: encodeMappings(this.points),\n    });\n  }\n}\n\nfunction encodeMappings(points: readonly MappingPoint[]): string {\n  if (points.length === 0) {\n    return \"\";\n  }\n\n  const lines: string[] = [];\n  let generatedLine = 0;\n  let previousOriginalColumn = 0;\n  let previousOriginalLine = 0;\n  let previousSource = 0;\n  let index = 0;\n\n  while (index < points.length) {\n    const segments: string[] = [];\n    let previousGeneratedColumn = 0;\n\n    while (index < points.length && points[index].generatedLine === generatedLine) {\n      const point = points[index];\n      segments.push(\n        encodeVlq(point.generatedColumn - previousGeneratedColumn) +\n          encodeVlq(0 - previousSource) +\n          encodeVlq(point.originalLine - previousOriginalLine) +\n          encodeVlq(point.originalColumn - previousOriginalColumn),\n      );\n      previousGeneratedColumn = point.generatedColumn;\n      previousSource = 0;\n      previousOriginalLine = point.originalLine;\n      previousOriginalColumn = point.originalColumn;\n      index++;\n    }\n\n    lines.push(segments.join(\",\"));\n    generatedLine++;\n  }\n\n  return lines.join(\";\");\n}\n\nfunction encodeVlq(value: number): string {\n  let encoded = \"\";\n  let remaining = value < 0 ? (-value << 1) | 1 : value << 1;\n\n  do {\n    let digit = remaining & 31;\n    remaining >>>= 5;\n\n    if (remaining > 0) {\n      digit |= 32;\n    }\n\n    encoded += encodeBase64(Uint8Array.of(digit << 2))[0];\n  } while (remaining > 0);\n\n  return encoded;\n}\n"],"mappings":";;;AAsBA,IAAa,aAAb,MAAwB;CACtB,SAAoC,CAAC;CACrC,SAA0C,CAAC;CAC3C,SAAiB;CACjB,OAAe;CACf,OAAe;CACf;CAEA,YAAmB,YAAoC;EACrD,KAAK,aAAa;CACpB;CAEA,IAAW,SAAiB;EAC1B,OAAO,KAAK;CACd;;CAGA,MAAa,OAAe,QAA4B;EACtD,IAAI,MAAM,WAAW,GACnB;EAGF,IAAI,WAAW,KAAA,KAAa,KAAK,eAAe,KAAA,GAAW;GACzD,MAAM,WAAW,KAAK,WAAW,SAAS,OAAO,KAAK;GACtD,KAAK,OAAO,KAAK;IACf,iBAAiB,KAAK;IACtB,eAAe,KAAK;IACpB,gBAAgB,SAAS,SAAS;IAClC,cAAc,SAAS,OAAO;GAChC,CAAC;EACH;EAEA,KAAK,OAAO,KAAK,KAAK;EACtB,KAAK,QAAQ,MAAM;EAEnB,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAGxC,IAFa,MAAM,WAAW,KAEvB,MAAM,IAAI;GACf,KAAK;GACL,KAAK,SAAS;EAChB,OACE,KAAK;CAGX;CAEA,WAA0B;EACxB,OAAO,KAAK,OAAO,KAAK,EAAE;CAC5B;CAEA,UAAiB,YAAoB,YAAgC;EACnE,MAAM,SAAS,KAAK;EAEpB,OAAO,OAAO,OAAO;GACnB,SAAS;GACT,MAAM;GACN,OAAO,OAAO,OAAO,CAAC,CAAC;GACvB,SAAS,OAAO,OAAO,CAAC,UAAU,CAAC;GACnC,gBAAgB,OAAO,OAAO,CAAC,QAAQ,QAAQ,EAAE,CAAC;GAClD,UAAU,eAAe,KAAK,MAAM;EACtC,CAAC;CACH;AACF;AAEA,SAAS,eAAe,QAAyC;CAC/D,IAAI,OAAO,WAAW,GACpB,OAAO;CAGT,MAAM,QAAkB,CAAC;CACzB,IAAI,gBAAgB;CACpB,IAAI,yBAAyB;CAC7B,IAAI,uBAAuB;CAC3B,IAAI,iBAAiB;CACrB,IAAI,QAAQ;CAEZ,OAAO,QAAQ,OAAO,QAAQ;EAC5B,MAAM,WAAqB,CAAC;EAC5B,IAAI,0BAA0B;EAE9B,OAAO,QAAQ,OAAO,UAAU,OAAO,MAAM,CAAC,kBAAkB,eAAe;GAC7E,MAAM,QAAQ,OAAO;GACrB,SAAS,KACP,UAAU,MAAM,kBAAkB,uBAAuB,IACvD,UAAU,IAAI,cAAc,IAC5B,UAAU,MAAM,eAAe,oBAAoB,IACnD,UAAU,MAAM,iBAAiB,sBAAsB,CAC3D;GACA,0BAA0B,MAAM;GAChC,iBAAiB;GACjB,uBAAuB,MAAM;GAC7B,yBAAyB,MAAM;GAC/B;EACF;EAEA,MAAM,KAAK,SAAS,KAAK,GAAG,CAAC;EAC7B;CACF;CAEA,OAAO,MAAM,KAAK,GAAG;AACvB;AAEA,SAAS,UAAU,OAAuB;CACxC,IAAI,UAAU;CACd,IAAI,YAAY,QAAQ,IAAK,CAAC,SAAS,IAAK,IAAI,SAAS;CAEzD,GAAG;EACD,IAAI,QAAQ,YAAY;EACxB,eAAe;EAEf,IAAI,YAAY,GACd,SAAS;EAGX,WAAW,aAAa,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;CACrD,SAAS,YAAY;CAErB,OAAO;AACT"}

package/dist/source-text.d.mts

@@ -0,0 +1,35 @@
+//#region src/source-text.d.ts
+/**
+ * Immutable text in a few flat chunks, read by absolute offset. Appending makes
+ * a new text that shares the chunks before it, so a growing document is never
+ * copied whole. Chunks merge like a binary counter, so a text has O(log n)
+ * chunks and each character is copied O(log n) times in total.
+ */
+export declare class SourceText {
+  #private;
+  readonly length: number;
+  /** The text has no NUL, so the parser reads it as it is. */
+  readonly plain: boolean;
+  private constructor();
+  static of(this: void, text: string): SourceText;
+  /** The text the parser reads: NUL becomes U+FFFD. */
+  grammar(): SourceText;
+  /** The same text in one chunk, for complete-document reads. */
+  flatten(): SourceText;
+  append(text: string): SourceText;
+  /** The character at `offset`, or `undefined` outside the text. */
+  char(offset: number): string | undefined;
+  slice(start: number, end?: number): string;
+  /** The first `search` at or after `from`, scanning chunk by chunk. */
+  indexOf(search: string, from?: number): number;
+  /** Finds one matching code unit without joining the chunks. The pattern must be global. */
+  findCharacter(pattern: RegExp, from: number): number;
+  /** The last `search`, scanning chunks from the end. Matches may span chunks. */
+  lastIndexOf(search: string): number;
+  startsWith(search: string, position?: number): boolean;
+  /** The whole text. A text in several chunks joins them once. */
+  toString(): string;
+  private chunkAt;
+}
+//#endregion
+//# sourceMappingURL=source-text.d.mts.map

package/dist/source-text.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-text.d.mts","names":[],"sources":["../src/source-text.ts"],"mappings":";;;;;;;qBAMa;;WAGK;;WAEA;UAMT;SAaO,GAAG,YAAY,eAAe;;EAOrC,WAAW;;EAKX,WAAW;EAMX,OAAO,eAAe;;EA4BtB,KAAK;EAeL,MAAM,eAAe;;EA8BrB,QAAQ,gBAAgB;;EAsBxB,cAAc,SAAS,QAAQ;;EAe/B,YAAY;EAeZ,WAAW,gBAAgB;;EAK3B;UAQC"}

package/dist/source-text.mjs

@@ -0,0 +1,132 @@
+//#region src/source-text.ts
+/**
+* Immutable text in a few flat chunks, read by absolute offset. Appending makes
+* a new text that shares the chunks before it, so a growing document is never
+* copied whole. Chunks merge like a binary counter, so a text has O(log n)
+* chunks and each character is copied O(log n) times in total.
+*/
+var SourceText = class SourceText {
+	#chunks;
+	#starts;
+	length;
+	/** The text has no NUL, so the parser reads it as it is. */
+	plain;
+	#joined;
+	#single;
+	/** The chunk of the last read, since reads cluster around one offset. */
+	#hint = 0;
+	constructor(chunks, starts, length, plain) {
+		this.#chunks = chunks;
+		this.#starts = starts;
+		this.#single = chunks.length === 1 ? chunks[0] : void 0;
+		this.length = length;
+		this.plain = plain;
+	}
+	static of(text) {
+		return text.length === 0 ? new SourceText([], [], 0, true) : new SourceText([text], [0], text.length, !text.includes("\0"));
+	}
+	/** The text the parser reads: NUL becomes U+FFFD. */
+	grammar() {
+		return this.plain ? this : SourceText.of(this.toString().replaceAll("\0", "�"));
+	}
+	/** The same text in one chunk, for complete-document reads. */
+	flatten() {
+		return this.#chunks.length <= 1 ? this : new SourceText([this.toString()], [0], this.length, this.plain);
+	}
+	append(text) {
+		if (text.length === 0) return this;
+		const chunks = [...this.#chunks, text];
+		const starts = [...this.#starts, this.length];
+		while (chunks.length > 1 && chunks[chunks.length - 2].length <= chunks[chunks.length - 1].length) {
+			const last = chunks[chunks.length - 1];
+			chunks.length--;
+			starts.length--;
+			chunks[chunks.length - 1] = flat(chunks[chunks.length - 1] + last);
+		}
+		return new SourceText(chunks, starts, this.length + text.length, this.plain && !text.includes("\0"));
+	}
+	/** The character at `offset`, or `undefined` outside the text. */
+	char(offset) {
+		if (this.#single !== void 0) return this.#single[offset];
+		if (offset < 0 || offset >= this.length) return;
+		const index = this.chunkAt(offset);
+		return this.#chunks[index][offset - this.#starts[index]];
+	}
+	slice(start, end = this.length) {
+		if (this.#single !== void 0) return this.#single.slice(start, end);
+		const from = Math.max(0, Math.min(start, this.length));
+		const to = Math.max(from, Math.min(end, this.length));
+		if (from === to) return "";
+		let index = this.chunkAt(from);
+		let result = "";
+		while (index < this.#chunks.length && this.#starts[index] < to) {
+			const chunk = this.#chunks[index];
+			const chunkStart = this.#starts[index];
+			result += chunk.slice(Math.max(0, from - chunkStart), Math.min(chunk.length, to - chunkStart));
+			index++;
+		}
+		return result;
+	}
+	/** The first `search` at or after `from`, scanning chunk by chunk. */
+	indexOf(search, from = 0) {
+		const begin = Math.max(0, from);
+		if (begin >= this.length) return search.length === 0 ? this.length : -1;
+		for (let index = this.chunkAt(begin); index < this.#chunks.length; index++) {
+			const start = Math.max(begin, this.#starts[index]);
+			const end = this.#starts[index] + this.#chunks[index].length + search.length - 1;
+			const found = this.slice(start, end).indexOf(search);
+			if (found !== -1) return start + found;
+		}
+		return -1;
+	}
+	/** Finds one matching code unit without joining the chunks. The pattern must be global. */
+	findCharacter(pattern, from) {
+		for (let index = this.chunkAt(from); index < this.#chunks.length; index++) {
+			const start = this.#starts[index];
+			pattern.lastIndex = from - start;
+			if (pattern.test(this.#chunks[index])) return start + pattern.lastIndex - 1;
+		}
+		return this.length;
+	}
+	/** The last `search`, scanning chunks from the end. Matches may span chunks. */
+	lastIndexOf(search) {
+		for (let index = this.#chunks.length - 1; index >= 0; index--) {
+			const start = this.#starts[index];
+			const from = Math.max(0, start - search.length + 1);
+			const found = this.slice(from, start + this.#chunks[index].length).lastIndexOf(search);
+			if (found !== -1) return from + found;
+		}
+		return -1;
+	}
+	startsWith(search, position = 0) {
+		return this.slice(position, position + search.length) === search;
+	}
+	/** The whole text. A text in several chunks joins them once. */
+	toString() {
+		if (this.#joined === void 0) this.#joined = this.#chunks.length === 1 ? this.#chunks[0] : flat(this.#chunks.join(""));
+		return this.#joined;
+	}
+	chunkAt(offset) {
+		const starts = this.#starts;
+		const hint = this.#hint;
+		if (starts[hint] <= offset && (starts[hint + 1] ?? Infinity) > offset) return hint;
+		let low = 0;
+		let high = starts.length - 1;
+		while (low < high) {
+			const middle = low + high + 1 >> 1;
+			if (starts[middle] <= offset) low = middle;
+			else high = middle - 1;
+		}
+		this.#hint = low;
+		return low;
+	}
+};
+/** Reading one character makes the engine store a concatenated string flat. */
+function flat(value) {
+	value.charCodeAt(0);
+	return value;
+}
+//#endregion
+export { SourceText };
+
+//# sourceMappingURL=source-text.mjs.map

package/dist/source-text.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-text.mjs","names":[],"sources":["../src/source-text.ts"],"sourcesContent":["/**\n * Immutable text in a few flat chunks, read by absolute offset. Appending makes\n * a new text that shares the chunks before it, so a growing document is never\n * copied whole. Chunks merge like a binary counter, so a text has O(log n)\n * chunks and each character is copied O(log n) times in total.\n */\nexport class SourceText {\n  readonly #chunks: readonly string[];\n  readonly #starts: readonly number[];\n  public readonly length: number;\n  /** The text has no NUL, so the parser reads it as it is. */\n  public readonly plain: boolean;\n  #joined: string | undefined;\n  readonly #single: string | undefined;\n  /** The chunk of the last read, since reads cluster around one offset. */\n  #hint = 0;\n\n  private constructor(\n    chunks: readonly string[],\n    starts: readonly number[],\n    length: number,\n    plain: boolean,\n  ) {\n    this.#chunks = chunks;\n    this.#starts = starts;\n    this.#single = chunks.length === 1 ? chunks[0] : undefined;\n    this.length = length;\n    this.plain = plain;\n  }\n\n  public static of(this: void, text: string): SourceText {\n    return text.length === 0\n      ? new SourceText([], [], 0, true)\n      : new SourceText([text], [0], text.length, !text.includes(\"\\0\"));\n  }\n\n  /** The text the parser reads: NUL becomes U+FFFD. */\n  public grammar(): SourceText {\n    return this.plain ? this : SourceText.of(this.toString().replaceAll(\"\\0\", \"\\uFFFD\"));\n  }\n\n  /** The same text in one chunk, for complete-document reads. */\n  public flatten(): SourceText {\n    return this.#chunks.length <= 1\n      ? this\n      : new SourceText([this.toString()], [0], this.length, this.plain);\n  }\n\n  public append(text: string): SourceText {\n    if (text.length === 0) {\n      return this;\n    }\n\n    const chunks = [...this.#chunks, text];\n    const starts = [...this.#starts, this.length];\n\n    // Like a binary counter, a chunk merges into the one before it once it is as large.\n    while (\n      chunks.length > 1 &&\n      chunks[chunks.length - 2].length <= chunks[chunks.length - 1].length\n    ) {\n      const last = chunks[chunks.length - 1];\n      chunks.length--;\n      starts.length--;\n      chunks[chunks.length - 1] = flat(chunks[chunks.length - 1] + last);\n    }\n\n    return new SourceText(\n      chunks,\n      starts,\n      this.length + text.length,\n      this.plain && !text.includes(\"\\0\"),\n    );\n  }\n\n  /** The character at `offset`, or `undefined` outside the text. */\n  public char(offset: number): string | undefined {\n    // A complete document is one chunk, so batch parsing reads it like a string.\n    if (this.#single !== undefined) {\n      return this.#single[offset];\n    }\n\n    if (offset < 0 || offset >= this.length) {\n      return undefined;\n    }\n\n    const index = this.chunkAt(offset);\n\n    return this.#chunks[index][offset - this.#starts[index]];\n  }\n\n  public slice(start: number, end: number = this.length): string {\n    if (this.#single !== undefined) {\n      return this.#single.slice(start, end);\n    }\n\n    const from = Math.max(0, Math.min(start, this.length));\n    const to = Math.max(from, Math.min(end, this.length));\n\n    if (from === to) {\n      return \"\";\n    }\n\n    let index = this.chunkAt(from);\n    let result = \"\";\n\n    // Concatenation builds a rope, so a slice costs its chunk count until it is read.\n    while (index < this.#chunks.length && this.#starts[index] < to) {\n      const chunk = this.#chunks[index];\n      const chunkStart = this.#starts[index];\n      result += chunk.slice(\n        Math.max(0, from - chunkStart),\n        Math.min(chunk.length, to - chunkStart),\n      );\n      index++;\n    }\n\n    return result;\n  }\n\n  /** The first `search` at or after `from`, scanning chunk by chunk. */\n  public indexOf(search: string, from = 0): number {\n    const begin = Math.max(0, from);\n\n    if (begin >= this.length) {\n      return search.length === 0 ? this.length : -1;\n    }\n\n    for (let index = this.chunkAt(begin); index < this.#chunks.length; index++) {\n      const start = Math.max(begin, this.#starts[index]);\n      // Reach into the next chunk, so a match across the boundary is found.\n      const end = this.#starts[index] + this.#chunks[index].length + search.length - 1;\n      const found = this.slice(start, end).indexOf(search);\n\n      if (found !== -1) {\n        return start + found;\n      }\n    }\n\n    return -1;\n  }\n\n  /** Finds one matching code unit without joining the chunks. The pattern must be global. */\n  public findCharacter(pattern: RegExp, from: number): number {\n    for (let index = this.chunkAt(from); index < this.#chunks.length; index++) {\n      const start = this.#starts[index];\n      // RegExp clamps a negative cursor to zero for later chunks.\n      pattern.lastIndex = from - start;\n\n      if (pattern.test(this.#chunks[index])) {\n        return start + pattern.lastIndex - 1;\n      }\n    }\n\n    return this.length;\n  }\n\n  /** The last `search`, scanning chunks from the end. Matches may span chunks. */\n  public lastIndexOf(search: string): number {\n    for (let index = this.#chunks.length - 1; index >= 0; index--) {\n      const start = this.#starts[index];\n      // Include the end of the previous chunk, so a match across the boundary is found.\n      const from = Math.max(0, start - search.length + 1);\n      const found = this.slice(from, start + this.#chunks[index].length).lastIndexOf(search);\n\n      if (found !== -1) {\n        return from + found;\n      }\n    }\n\n    return -1;\n  }\n\n  public startsWith(search: string, position = 0): boolean {\n    return this.slice(position, position + search.length) === search;\n  }\n\n  /** The whole text. A text in several chunks joins them once. */\n  public toString(): string {\n    if (this.#joined === undefined) {\n      this.#joined = this.#chunks.length === 1 ? this.#chunks[0] : flat(this.#chunks.join(\"\"));\n    }\n\n    return this.#joined;\n  }\n\n  private chunkAt(offset: number): number {\n    const starts = this.#starts;\n    const hint = this.#hint;\n\n    if (starts[hint] <= offset && (starts[hint + 1] ?? Infinity) > offset) {\n      return hint;\n    }\n\n    let low = 0;\n    let high = starts.length - 1;\n\n    while (low < high) {\n      const middle = (low + high + 1) >> 1;\n\n      if (starts[middle] <= offset) {\n        low = middle;\n      } else {\n        high = middle - 1;\n      }\n    }\n\n    this.#hint = low;\n\n    return low;\n  }\n}\n\n/** Reading one character makes the engine store a concatenated string flat. */\nfunction flat(value: string): string {\n  void value.charCodeAt(0);\n\n  return value;\n}\n"],"mappings":"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"}

package/dist/source.d.mts

@@ -0,0 +1,86 @@
+import { SourceRange } from "./ranges.mjs";
+import { SourceText } from "./source-text.mjs";
+//#region src/source.d.ts
+export interface SourceFileInput {
+  readonly name?: string;
+  readonly text: string;
+}
+export interface SourceLocation {
+  readonly offset: number;
+  readonly line: number;
+  readonly column: number;
+}
+/** A range in a specific source file. Diagnostics carry spans because they outlive trees. */
+export interface SourceSpan {
+  readonly file: SourceFile;
+  readonly start: number;
+  readonly end: number;
+}
+export interface PhysicalLine {
+  readonly line: number;
+  readonly range: SourceRange;
+  readonly content: SourceRange;
+  readonly ending: "" | "\n" | "\r" | "\r\n";
+}
+/** The semantic character represented by NUL in parsed source. */
+export declare const REPLACEMENT_CHARACTER = "�";
+export declare function semanticCharacter(value: string): string;
+/** The column after a tab, with four-column tab stops. */
+export declare function nextTabColumn(column: number): number;
+/**
+ * Immutable authored source with UTF-16 offsets and exact physical line
+ * boundaries. Files from a `SourceBuffer` share text chunks and a line index,
+ * so reading a growing document never copies it whole.
+ */
+export declare class SourceFile {
+  #private;
+  readonly name: string;
+  constructor(input: string | SourceFileInput);
+  /** The whole text. Prefer `slice` and `length`, which do not join a growing text. */
+  get text(): string;
+  get length(): number;
+  /**
+   * Whether `other` is known to start with this file's text: both come from
+   * the same `SourceBuffer` with only appends between them.
+   */
+  isPrefixOf(other: SourceFile): boolean;
+  location(offset: number): SourceLocation;
+  lineStart(line: number): number | undefined;
+  get lineCount(): number;
+  line(line: number): PhysicalLine | undefined;
+  lineAt(offset: number): PhysicalLine;
+  character(offset: number): string | undefined;
+  slice(range: SourceRange): string;
+  semanticSlice(range: SourceRange): string;
+  private physicalLine;
+  private table;
+}
+/**
+ * Source that a stream owns and changes. Appends keep one line index, so
+ * successive files do not rescan their lines; an edit starts a new generation.
+ * Each change returns an immutable `SourceFile` for that version.
+ */
+export declare class SourceBuffer {
+  #private;
+  constructor(input: SourceFileInput);
+  get file(): SourceFile;
+  append(text: string): SourceFile;
+  /** Replaces `start..end` with `text`. Earlier files keep their own lines. */
+  replace(start: number, end: number, text: string): SourceFile;
+}
+/** The chunked text behind a file, for readers that index it by offset. */
+export declare function sourceText(file: SourceFile): SourceText;
+/** Incremental physical-line scanner. Each appended code unit is visited once. */
+export declare class PhysicalLineScanner {
+  #private;
+  constructor(options?: Readonly<{
+    offset?: number;
+    line?: number;
+  }>);
+  append(text: string): readonly PhysicalLine[];
+  clone(): PhysicalLineScanner;
+  complete(): readonly PhysicalLine[];
+  private emit;
+}
+//#endregion
+//# sourceMappingURL=source.d.mts.map

package/dist/source.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.mts","names":[],"sources":["../src/source.ts"],"mappings":";;;iBAQiB;WACN;WACA;;iBAGM;WACN;WACA;WACA;;;iBAIM;WACN,MAAM;WACN;WACA;;iBAGM;WACN;WACA,OAAO;WACP,SAAS;WACT;;;qBAIE;wBAEG,kBAAkB;;wBAKlB,cAAc;;;;;;qBAsCjB;;WAIK;EAchB,YAAmB,gBAAgB;;MAOxB;MAIA;;;;;EAQJ,WAAW,OAAO;EAOlB,SAAS,iBAAiB;EA2B1B,UAAU;MAIN;EAMJ,KAAK,eAAe;EAIpB,OAAO,iBAAiB;EAIxB,UAAU;EAUV,MAAM,OAAO;EAcb,cAAc,OAAO;UAIpB;UAMA;;;;;;;qBA8CG;;EAMX,YAAmB,OAAO;MAMf,QAAQ;EAIZ,OAAO,eAAe;;EAQtB,QAAQ,eAAe,aAAa,eAAe;;;wBAW5C,WAAW,MAAM,aAAa;;qBA0BjC;;EAOX,YAAmB,UAAS;IAAW;IAAiB;;EAajD,OAAO,wBAAwB;EA4C/B,SAAS;EAST,qBAAqB;UAkBpB"}

package/dist/source.mjs

@@ -0,0 +1,264 @@
+import { InputError } from "./errors.mjs";
+import { sourceRange } from "./ranges.mjs";
+import { SourceText } from "./source-text.mjs";
+import { isString } from "@temelj/value";
+//#region src/source.ts
+/** The semantic character represented by NUL in parsed source. */
+const REPLACEMENT_CHARACTER = "�";
+function semanticCharacter(value) {
+	return value === "\0" ? "�" : value;
+}
+/** The column after a tab, with four-column tab stops. */
+function nextTabColumn(column) {
+	return column + (4 - (column - 1) % 4);
+}
+/**
+* Physical lines of a text that only grows. The files of one buffer generation
+* share one index, which scans each character once instead of once per file.
+*/
+var LineIndex = class {
+	lines = [];
+	#scanner = new PhysicalLineScanner();
+	#length = 0;
+	/** Scans `text`, which extends every text scanned before, from where the last scan ended. */
+	extend(text) {
+		if (text.length > this.#length) {
+			this.lines.push(...this.#scanner.append(text.slice(this.#length)));
+			this.#length = text.length;
+		}
+	}
+};
+let createFile;
+let readText;
+/**
+* Immutable authored source with UTF-16 offsets and exact physical line
+* boundaries. Files from a `SourceBuffer` share text chunks and a line index,
+* so reading a growing document never copies it whole.
+*/
+var SourceFile = class SourceFile {
+	#source;
+	#index;
+	#table;
+	name;
+	static {
+		createFile = (name, text, index) => {
+			const file = new SourceFile({
+				name,
+				text: ""
+			});
+			file.#source = text;
+			file.#index = index;
+			return file;
+		};
+		readText = (file) => file.#source;
+	}
+	constructor(input) {
+		this.#source = SourceText.of(isString(input) ? input : input.text);
+		this.name = isString(input) ? "source.mdx" : input.name ?? "source.mdx";
+		Object.freeze(this);
+	}
+	/** The whole text. Prefer `slice` and `length`, which do not join a growing text. */
+	get text() {
+		return this.#source.toString();
+	}
+	get length() {
+		return this.#source.length;
+	}
+	/**
+	* Whether `other` is known to start with this file's text: both come from
+	* the same `SourceBuffer` with only appends between them.
+	*/
+	isPrefixOf(other) {
+		return this === other || this.#index !== void 0 && this.#index === other.#index && this.length <= other.length;
+	}
+	location(offset) {
+		if (!Number.isInteger(offset) || offset < 0 || offset > this.length) throw InputError.sourceOffsetOutsideFile(offset, this.length);
+		let low = 0;
+		let high = this.lineCount;
+		while (low + 1 < high) {
+			const middle = Math.floor((low + high) / 2);
+			if (this.physicalLine(middle).range.start <= offset) low = middle;
+			else high = middle;
+		}
+		let column = 1;
+		for (let index = this.physicalLine(low).range.start; index < offset; index++) column = this.#source.char(index) === "	" ? nextTabColumn(column) : column + 1;
+		return Object.freeze({
+			offset,
+			line: low + 1,
+			column
+		});
+	}
+	lineStart(line) {
+		return this.line(line)?.range.start;
+	}
+	get lineCount() {
+		const table = this.table();
+		return table.count + table.tail.length;
+	}
+	line(line) {
+		return line >= 1 && line <= this.lineCount ? this.physicalLine(line - 1) : void 0;
+	}
+	lineAt(offset) {
+		return this.physicalLine(this.location(offset).line - 1);
+	}
+	character(offset) {
+		if (!Number.isSafeInteger(offset) || offset < 0 || offset > this.length) throw InputError.sourceOffsetOutsideFile(offset, this.length);
+		const value = this.#source.char(offset);
+		return value === void 0 ? void 0 : semanticCharacter(value);
+	}
+	slice(range) {
+		if (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end > this.length) throw InputError.replacementRangeOutsideSource(range.start, range.end, this.length);
+		return this.#source.slice(range.start, range.end);
+	}
+	semanticSlice(range) {
+		return this.slice(range).replaceAll("\0", "�");
+	}
+	physicalLine(index) {
+		const table = this.table();
+		return index < table.count ? table.complete[index] : table.tail[index - table.count];
+	}
+	table() {
+		if (this.#table !== void 0) return this.#table;
+		const index = this.#index;
+		if (index === void 0) {
+			const lines = Object.freeze(indexLines(this.text));
+			this.#table = {
+				complete: lines,
+				count: lines.length,
+				tail: []
+			};
+			return this.#table;
+		}
+		index.extend(this.#source);
+		const { lines } = index;
+		let count = lines.length;
+		while (count > 0 && lines[count - 1].range.end > this.length) count--;
+		const last = lines[count - 1];
+		const scanner = new PhysicalLineScanner({
+			offset: last?.range.end ?? 0,
+			line: (last?.line ?? 0) + 1
+		});
+		const tail = Object.freeze([...scanner.append(this.#source.slice(last?.range.end ?? 0)), ...scanner.complete()]);
+		this.#table = {
+			complete: lines,
+			count,
+			tail
+		};
+		return this.#table;
+	}
+};
+/**
+* Source that a stream owns and changes. Appends keep one line index, so
+* successive files do not rescan their lines; an edit starts a new generation.
+* Each change returns an immutable `SourceFile` for that version.
+*/
+var SourceBuffer = class {
+	#name;
+	#index = new LineIndex();
+	#text;
+	#file;
+	constructor(input) {
+		this.#name = input.name ?? "source.mdx";
+		this.#text = SourceText.of(input.text);
+		this.#file = createFile(this.#name, this.#text, this.#index);
+	}
+	get file() {
+		return this.#file;
+	}
+	append(text) {
+		this.#text = this.#text.append(text);
+		this.#file = createFile(this.#name, this.#text, this.#index);
+		return this.#file;
+	}
+	/** Replaces `start..end` with `text`. Earlier files keep their own lines. */
+	replace(start, end, text) {
+		const previous = this.#text;
+		this.#text = SourceText.of(previous.slice(0, start) + text + previous.slice(end));
+		this.#index = new LineIndex();
+		this.#file = createFile(this.#name, this.#text, this.#index);
+		return this.#file;
+	}
+};
+/** The chunked text behind a file, for readers that index it by offset. */
+function sourceText(file) {
+	return readText(file);
+}
+function indexLines(source) {
+	const scanner = new PhysicalLineScanner();
+	return [...scanner.append(source), ...scanner.complete()];
+}
+function physicalLine(line, start, contentEnd, end, ending) {
+	return Object.freeze({
+		line,
+		range: sourceRange(start, end),
+		content: sourceRange(start, contentEnd),
+		ending
+	});
+}
+/** Incremental physical-line scanner. Each appended code unit is visited once. */
+var PhysicalLineScanner = class PhysicalLineScanner {
+	#complete = false;
+	#length;
+	#line;
+	#lineStart;
+	#pendingCarriageReturn;
+	constructor(options = {}) {
+		const offset = options.offset ?? 0;
+		const line = options.line ?? 1;
+		if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(line) || line < 1) throw new RangeError("Invalid physical-line scanner origin");
+		this.#length = offset;
+		this.#lineStart = offset;
+		this.#line = line;
+	}
+	append(text) {
+		if (this.#complete) throw new Error("Cannot append to a completed physical-line scanner");
+		const lines = [];
+		const endings = /\r\n|[\r\n]/gu;
+		if (text.length > 0 && this.#pendingCarriageReturn !== void 0) {
+			const offset = this.#pendingCarriageReturn;
+			if (text[0] === "\n") {
+				lines.push(this.emit(offset, this.#length + 1, "\r\n"));
+				endings.lastIndex = 1;
+			} else lines.push(this.emit(offset, offset + 1, "\r"));
+			this.#pendingCarriageReturn = void 0;
+		}
+		for (let match = endings.exec(text); match !== null; match = endings.exec(text)) {
+			const offset = this.#length + match.index;
+			const ending = match[0];
+			if (ending === "\r" && match.index === text.length - 1) this.#pendingCarriageReturn = offset;
+			else lines.push(this.emit(offset, offset + ending.length, ending === "\r\n" ? "\r\n" : ending === "\r" ? "\r" : "\n"));
+		}
+		this.#length += text.length;
+		return Object.freeze(lines);
+	}
+	clone() {
+		const copy = new PhysicalLineScanner({
+			offset: this.#length,
+			line: this.#line
+		});
+		copy.#complete = this.#complete;
+		copy.#lineStart = this.#lineStart;
+		copy.#pendingCarriageReturn = this.#pendingCarriageReturn;
+		return copy;
+	}
+	complete() {
+		if (this.#complete) throw new Error("Physical-line scanner is already complete");
+		this.#complete = true;
+		const lines = [];
+		if (this.#pendingCarriageReturn !== void 0) {
+			lines.push(this.emit(this.#pendingCarriageReturn, this.#pendingCarriageReturn + 1, "\r"));
+			this.#pendingCarriageReturn = void 0;
+		}
+		lines.push(physicalLine(this.#line, this.#lineStart, this.#length, this.#length, ""));
+		return Object.freeze(lines);
+	}
+	emit(contentEnd, end, ending) {
+		const line = physicalLine(this.#line++, this.#lineStart, contentEnd, end, ending);
+		this.#lineStart = end;
+		return line;
+	}
+};
+//#endregion
+export { PhysicalLineScanner, REPLACEMENT_CHARACTER, SourceBuffer, SourceFile, nextTabColumn, semanticCharacter, sourceText };
+
+//# sourceMappingURL=source.mjs.map