@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/internal/syntax.js

@@ -0,0 +1,305 @@
+import * as Predicate from "effect/Predicate";
+import { Fail, Failure, State } from "../Input.js";
+//#region src/internal/syntax.ts
+/**
+* The tree builder behind the `Syntax` module (see `docs/DESIGN.md`,
+* "Syntax trees").
+*
+* Trees are stored as *green* nodes, as in Roslyn and rust-analyzer: a green
+* node knows its kind, its width and its children's offsets relative to its
+* own start, but not where it is in the input or who its parent is. A subtree
+* that an edit doesn't touch can therefore be shared, unchanged, by the tree
+* before the edit and the tree after it. `Syntax.SyntaxNode` is the *red*
+* view: a green node, its absolute start and its parent, built lazily while
+* navigating.
+*
+* While parsing, completed nodes wait on a stack until the node around them
+* completes and adopts them. Nodes built by an attempt that is later
+* abandoned must not end up in the tree. Every combinator that abandons an
+* attempt moves the cursor back to (or before) where the attempt started,
+* and every node has a positive width, so the nodes of an abandoned attempt
+* are exactly those that end after the position the cursor moves back to:
+* the `pos` setter of {@link SyntaxState} drops them. This also covers
+* lookahead (`peek`, `not`) and custom parsers written with `Parser.make`.
+*
+* For incremental parsing, every node records how far its parse looked: the
+* furthest position the cursor reached and the furthest failure recorded
+* while it was being parsed (its *lookahead*). A node from the previous tree
+* is reused at a position when it was built by the same `Syntax.node`, and
+* the input it looked at, plus a margin for the tokens that read a little
+* past where they stop, is unchanged.
+*/
+/** A position-independent syntax tree node. */
+var Green = class {
+	kind;
+	named;
+	key;
+	width;
+	lookahead;
+	children;
+	offsets;
+	fields;
+	value;
+	error;
+	hasError;
+	diagnostics;
+	constructor(kind, named, key, width, lookahead, children, offsets, fields, value, error, hasError, diagnostics) {
+		this.kind = kind;
+		this.named = named;
+		this.key = key;
+		this.width = width;
+		this.lookahead = lookahead;
+		this.children = children;
+		this.offsets = offsets;
+		this.fields = fields;
+		this.value = value;
+		this.error = error;
+		this.hasError = hasError;
+		this.diagnostics = diagnostics;
+	}
+};
+/** A completed node waiting for its parent, at an absolute position. */
+var Child = class {
+	green;
+	start;
+	end;
+	field;
+	constructor(green, start, end, field) {
+		this.green = green;
+		this.start = start;
+		this.end = end;
+		this.field = field;
+	}
+};
+const errorKind = "ERROR";
+const rebase = (f, start) => new Failure(f.offset - start, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, f.needed);
+/** Moves a failure stored relative to a node back to absolute offsets. */
+const absolute = (f, start) => rebase(f, -start);
+/**
+* Builds a green node over `[start, end)` from the children waiting on the
+* stack.
+*/
+const build = (kind, named, key, start, end, lookahead, entries, value, error, diagnostics) => {
+	const n = entries.length;
+	const children = new Array(n);
+	const offsets = new Array(n);
+	let fields;
+	let hasError = error !== void 0;
+	for (let i = 0; i < n; i++) {
+		const e = entries[i];
+		children[i] = e.green;
+		offsets[i] = e.start - start;
+		if (e.green.hasError) hasError = true;
+		if (e.field !== void 0) (fields ??= new Array(n).fill(void 0))[i] = e.field;
+	}
+	return new Green(kind, named, key, end - start, Math.max(lookahead, end) - start, children, offsets, fields, value, error, hasError, diagnostics);
+};
+/** The parse state of a `Syntax` parse. */
+var SyntaxState = class extends State {
+	static {
+		Object.defineProperty(this.prototype, "pos", {
+			get() {
+				return this.cursor;
+			},
+			set(p) {
+				if (p < this.cursor) {
+					const stack = this.stack;
+					while (stack.length > 0 && stack[stack.length - 1].end > p) stack.pop();
+				}
+				if (p > this.highWater) this.highWater = p;
+				this.cursor = p;
+			},
+			configurable: true,
+			enumerable: true
+		});
+	}
+	constructor(source, options, previous) {
+		super(source, { context: options.context });
+		this.highWater = this.cursor;
+		this.stack = [];
+		this.previous = previous;
+		this.reused = 0;
+		this.lastParent = void 0;
+		this.lastParentStart = 0;
+		this.syntax = this;
+		this.recovered = [];
+	}
+	failWith(mode, failure) {
+		if (failure.offset > this.highWater) this.highWater = failure.offset;
+		return super.failWith(mode, failure);
+	}
+	setHint(offset, expected) {
+		if (offset > this.highWater) this.highWater = offset;
+		super.setHint(offset, expected);
+	}
+	node(state, step, key, kind, named) {
+		const start = this.cursor;
+		const stack = this.stack;
+		if (this.previous !== void 0) {
+			const green = this.reusable(this.previous, key, start);
+			if (green !== void 0) {
+				this.reused++;
+				const end = start + green.width;
+				state.pos = end;
+				const looked = start + green.lookahead;
+				if (looked > this.highWater) this.highWater = looked;
+				const d = green.diagnostics;
+				if (d !== void 0) {
+					if (d.deepest !== void 0) this.deepen(start === d.base ? d.deepest : rebase(d.deepest, d.base - start));
+					if (d.hintExpected !== void 0) this.setHint(start + d.hintOffset, d.hintExpected);
+				}
+				stack.push(new Child(green, start, end, void 0));
+				return green.value;
+			}
+		}
+		const mark = stack.length;
+		const outer = this.highWater;
+		const outerDeepest = this.deepest;
+		const hintOffset = this.hintOffset;
+		const hintExpected = this.hintExpected;
+		this.highWater = start;
+		this.deepest = void 0;
+		const a = step(state);
+		const looked = this.highWater;
+		if (outer > looked) this.highWater = outer;
+		const deepest = this.deepest;
+		this.deepest = outerDeepest;
+		if (deepest !== void 0) this.deepen(deepest);
+		if (a === Fail) {
+			if (stack.length > mark) stack.length = mark;
+			return a;
+		}
+		const end = this.cursor;
+		if (end === start) return a;
+		const hinted = this.hintOffset !== hintOffset || this.hintExpected !== hintExpected;
+		const diagnostics = deepest === void 0 && !hinted ? void 0 : {
+			deepest,
+			base: start,
+			hintOffset: this.hintOffset - start,
+			hintExpected: hinted ? this.hintExpected : void 0
+		};
+		const entries = stack.splice(mark);
+		stack.push(new Child(build(kind, named, key, start, end, looked, entries, a, void 0, diagnostics), start, end, void 0));
+		return a;
+	}
+	read(end) {
+		if (end - 1 > this.highWater) this.highWater = end - 1;
+	}
+	/** Records `failure` as the furthest failure if it is, as `failWith` does. */
+	deepen(failure) {
+		if (this.deepest === void 0 || failure.offset >= this.deepest.offset) this.deepest = failure;
+	}
+	field(state, step, name) {
+		const stack = this.stack;
+		const mark = stack.length;
+		const a = step(state);
+		if (a !== Fail) for (let i = mark; i < stack.length; i++) stack[i].field = name;
+		return a;
+	}
+	skipped(start, failure, mode) {
+		const stack = this.stack;
+		let i = stack.length;
+		while (i > 0 && stack[i - 1].start >= start && stack[i - 1].end > start) i--;
+		const end = this.cursor;
+		const green = build(errorKind, true, void 0, start, end, this.highWater, stack.splice(i), void 0, {
+			failure: rebase(failure, start),
+			mode
+		});
+		stack.push(new Child(green, start, end, void 0));
+	}
+	/**
+	* Builds the root over the whole input from the nodes left on the stack.
+	* When the parse failed, or stopped before the end, the rest of the input
+	* becomes an `ERROR` node.
+	*/
+	finish(kind, value, fatal, errorStart) {
+		const entries = this.stack.splice(0);
+		const end = this.end;
+		if (fatal !== void 0) {
+			const last = entries.length > 0 ? entries[entries.length - 1].end : 0;
+			const start = Math.max(Math.min(errorStart, end), last);
+			const error = build(errorKind, true, void 0, start, end, end, [], void 0, {
+				failure: rebase(fatal.failure, start),
+				mode: fatal.mode
+			});
+			entries.push(new Child(error, start, end, void 0));
+		}
+		return build(kind, true, void 0, 0, end, Math.max(end, this.highWater), entries, value, void 0);
+	}
+	/**
+	* The outermost node of the previous tree built by `key` that starts at
+	* `offset`. Reused nodes are mostly siblings, found one after the other,
+	* so the search starts from the parent of the last one found when
+	* `offset` lies inside it: no ancestor of that parent can start there.
+	*/
+	find(root, offset, key) {
+		let node = root;
+		let start = 0;
+		const last = this.lastParent;
+		if (last !== void 0 && offset > this.lastParentStart && offset < this.lastParentStart + last.width) {
+			node = last;
+			start = this.lastParentStart;
+		}
+		while (true) {
+			const offsets = node.offsets;
+			let lo = 0;
+			let hi = offsets.length - 1;
+			let found = -1;
+			while (lo <= hi) {
+				const mid = lo + hi >> 1;
+				if (start + offsets[mid] <= offset) {
+					found = mid;
+					lo = mid + 1;
+				} else hi = mid - 1;
+			}
+			if (found < 0) return void 0;
+			const child = node.children[found];
+			const childStart = start + offsets[found];
+			if (offset >= childStart + child.width) return void 0;
+			if (childStart === offset && child.key === key) {
+				this.lastParent = node;
+				this.lastParentStart = start;
+				return child;
+			}
+			node = child;
+			start = childStart;
+		}
+	}
+	/** The node of the previous tree built by `key` at `pos` (in the new input), if it can be reused. */
+	reusable(previous, key, pos) {
+		const segments = previous.segments;
+		let lo = 0;
+		let hi = segments.length - 1;
+		while (lo <= hi) {
+			const mid = lo + hi >> 1;
+			const seg = segments[mid];
+			if (pos < seg.newStart) hi = mid - 1;
+			else if (pos >= seg.newStart + seg.length) lo = mid + 1;
+			else {
+				const old = seg.oldStart + (pos - seg.newStart);
+				const green = this.find(previous.root, old, key);
+				if (green === void 0) return void 0;
+				const segEnd = seg.oldStart + seg.length;
+				if (old + green.lookahead + tokenWidth(previous.input, old + green.lookahead) + previous.extra <= segEnd) return green;
+				if (segEnd === previous.oldLength && seg.newStart + seg.length === previous.newLength) return green;
+				return;
+			}
+		}
+	}
+};
+/**
+* How many units a token parser may read at `offset`, where a parse
+* stopped looking: one code point. Of a string, that is two units at a high
+* surrogate. Of bytes in an unknown encoding, up to four.
+*/
+const tokenWidth = (input, offset) => {
+	if (Predicate.isString(input)) {
+		const c = input.charCodeAt(offset);
+		return c >= 55296 && c <= 56319 ? 2 : 1;
+	}
+	return input instanceof Uint8Array ? 4 : 1;
+};
+//#endregion
+export { Green, SyntaxState, absolute, errorKind };
+
+//# sourceMappingURL=syntax.js.map

package/dist/internal/syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.js","names":[],"sources":["../../src/internal/syntax.ts"],"sourcesContent":["/**\n * The tree builder behind the `Syntax` module (see `docs/DESIGN.md`,\n * \"Syntax trees\").\n *\n * Trees are stored as *green* nodes, as in Roslyn and rust-analyzer: a green\n * node knows its kind, its width and its children's offsets relative to its\n * own start, but not where it is in the input or who its parent is. A subtree\n * that an edit doesn't touch can therefore be shared, unchanged, by the tree\n * before the edit and the tree after it. `Syntax.SyntaxNode` is the *red*\n * view: a green node, its absolute start and its parent, built lazily while\n * navigating.\n *\n * While parsing, completed nodes wait on a stack until the node around them\n * completes and adopts them. Nodes built by an attempt that is later\n * abandoned must not end up in the tree. Every combinator that abandons an\n * attempt moves the cursor back to (or before) where the attempt started,\n * and every node has a positive width, so the nodes of an abandoned attempt\n * are exactly those that end after the position the cursor moves back to:\n * the `pos` setter of {@link SyntaxState} drops them. This also covers\n * lookahead (`peek`, `not`) and custom parsers written with `Parser.make`.\n *\n * For incremental parsing, every node records how far its parse looked: the\n * furthest position the cursor reached and the furthest failure recorded\n * while it was being parsed (its *lookahead*). A node from the previous tree\n * is reused at a position when it was built by the same `Syntax.node`, and\n * the input it looked at, plus a margin for the tokens that read a little\n * past where they stop, is unchanged.\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Context from \"effect/Context\"\nimport type { Encoding } from \"../Encoding.js\"\nimport type { ErrMode, Input, Source } from \"../Input.js\"\nimport { Fail, Failure, State } from \"../Input.js\"\n\n/** What a failure inside an `ERROR` node was. Offsets are relative to the node. */\nexport interface ErrorInfo {\n  readonly failure: Failure\n  readonly mode: ErrMode\n}\n\n/** A position-independent syntax tree node. */\nexport class Green {\n  constructor(\n    readonly kind: string,\n    readonly named: boolean,\n    /** The `Syntax.node` that built it; `undefined` for roots and errors, which are never reused alone. */\n    readonly key: object | undefined,\n    readonly width: number,\n    /** How far its parse looked, relative to its start (at least `width`). */\n    readonly lookahead: number,\n    readonly children: ReadonlyArray<Green>,\n    /** The children's starts, relative to this node's start. */\n    readonly offsets: ReadonlyArray<number>,\n    /** The children's field names, when any child has one. */\n    readonly fields: ReadonlyArray<string | undefined> | undefined,\n    readonly value: unknown,\n    /** Set on `ERROR` nodes. */\n    readonly error: ErrorInfo | undefined,\n    /** Whether this node or a descendant is an `ERROR` node. */\n    readonly hasError: boolean,\n    /** What its parse left behind for error reporting, replayed when it is reused. */\n    readonly diagnostics: Diagnostics | undefined\n  ) {}\n}\n\n/**\n * The error-reporting state a node's parse leaves behind (see\n * `State.deepest` and `State.setHint`). A reused node replays it, so that\n * a reparse reports the errors a fresh parse does.\n */\nexport interface Diagnostics {\n  /** The furthest failure, at its offset in the parse that built the node... */\n  readonly deepest: Failure | undefined\n  /** ...which started the node at `base`. */\n  readonly base: number\n  /** Relative to the node's start. */\n  readonly hintOffset: number\n  readonly hintExpected: ReadonlyArray<string> | undefined\n}\n\n/** A completed node waiting for its parent, at an absolute position. */\nclass Child {\n  constructor(\n    readonly green: Green,\n    readonly start: number,\n    readonly end: number,\n    public field: string | undefined\n  ) {}\n}\n\nexport const errorKind = \"ERROR\"\n\nconst rebase = (f: Failure, start: number): Failure =>\n  new Failure(f.offset - start, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, f.needed)\n\n/** Moves a failure stored relative to a node back to absolute offsets. */\nexport const absolute = (f: Failure, start: number): Failure => rebase(f, -start)\n\n/**\n * Builds a green node over `[start, end)` from the children waiting on the\n * stack.\n */\nconst build = (\n  kind: string,\n  named: boolean,\n  key: object | undefined,\n  start: number,\n  end: number,\n  lookahead: number,\n  entries: ReadonlyArray<Child>,\n  value: unknown,\n  error: ErrorInfo | undefined,\n  diagnostics?: Diagnostics\n): Green => {\n  const n = entries.length\n  const children = new Array<Green>(n)\n  const offsets = new Array<number>(n)\n  let fields: Array<string | undefined> | undefined\n  let hasError = error !== undefined\n  for (let i = 0; i < n; i++) {\n    const e = entries[i]\n    children[i] = e.green\n    offsets[i] = e.start - start\n    if (e.green.hasError) hasError = true\n    if (e.field !== undefined) (fields ??= new Array(n).fill(undefined))[i] = e.field\n  }\n  const width = end - start\n  const looked = Math.max(lookahead, end) - start\n  return new Green(kind, named, key, width, looked, children, offsets, fields, value, error, hasError, diagnostics)\n}\n\n/**\n * A stretch of the new input copied unchanged from the previous one:\n * `[newStart, newStart + length)` is `[oldStart, oldStart + length)`.\n */\nexport interface Segment {\n  readonly newStart: number\n  readonly oldStart: number\n  readonly length: number\n}\n\n/** What a reparse may reuse. */\nexport interface Previous {\n  readonly root: Green\n  readonly oldLength: number\n  readonly newLength: number\n  readonly segments: ReadonlyArray<Segment>\n  readonly input: Input\n  /** How far past its lookahead a parser may have read, besides a token at the lookahead. */\n  readonly extra: number\n  readonly encoding: Encoding<any> | undefined\n}\n\n/** The hooks that `Syntax` combinators and `Parser.resumeAfter`/`retryAfter` call. */\nexport interface Builder {\n  node(state: State<any>, step: (state: State<any>) => unknown, key: object, kind: string, named: boolean): unknown\n  field(state: State<any>, step: (state: State<any>) => unknown, name: string): unknown\n  /** After error recovery: `[start, pos)` was skipped after `failure`. */\n  skipped(start: number, failure: Failure, mode: ErrMode): void\n  /**\n   * Called by token parsers that read input up to `end` (exclusive) beyond\n   * where they leave the cursor or record a failure.\n   */\n  read(end: number): void\n}\n\n/** The parse state of a `Syntax` parse. */\nexport class SyntaxState<I extends Input = Input> extends State<I> implements Builder {\n  // Declared, not defined: `State`'s constructor sets `pos` through the\n  // accessor below before these could be initialized\n  declare cursor: number\n  /** The furthest position the cursor reached, or failure recorded, since the innermost open node started. */\n  declare highWater: number\n  /** Completed nodes waiting for their parent, in input order. */\n  declare stack: Array<Child>\n  declare previous: Previous | undefined\n  /** How many nodes were reused from the previous tree. */\n  declare reused: number\n  /** Where {@link find} found the last node it found. */\n  declare lastParent: Green | undefined\n  declare lastParentStart: number\n\n  static {\n    Object.defineProperty(this.prototype, \"pos\", {\n      get(this: SyntaxState) {\n        return this.cursor\n      },\n      set(this: SyntaxState, p: number) {\n        if (p < this.cursor) {\n          // An attempt was abandoned (or a lookahead finished): drop its nodes\n          const stack = this.stack\n          while (stack.length > 0 && stack[stack.length - 1].end > p) stack.pop()\n        }\n        if (p > this.highWater) this.highWater = p\n        this.cursor = p\n      },\n      configurable: true,\n      enumerable: true\n    })\n  }\n\n  constructor(\n    source: I | Source<I>,\n    options: {\n      readonly context?: Context.Context<never> | undefined\n    },\n    previous: Previous | undefined\n  ) {\n    super(source, { context: options.context })\n    this.highWater = this.cursor\n    this.stack = []\n    this.previous = previous\n    this.reused = 0\n    this.lastParent = undefined\n    this.lastParentStart = 0\n    this.syntax = this\n    // Error recovery is always on: like Tree-sitter, a syntax parse always produces a tree\n    this.recovered = []\n  }\n\n  override failWith(mode: ErrMode, failure: Failure): Fail {\n    if (failure.offset > this.highWater) this.highWater = failure.offset\n    return super.failWith(mode, failure)\n  }\n\n  override setHint(offset: number, expected: ReadonlyArray<string>): void {\n    if (offset > this.highWater) this.highWater = offset\n    super.setHint(offset, expected)\n  }\n\n  node(state: State<any>, step: (state: State<any>) => unknown, key: object, kind: string, named: boolean): unknown {\n    const start = this.cursor\n    const stack = this.stack\n    if (this.previous !== undefined) {\n      const green = this.reusable(this.previous, key, start)\n      if (green !== undefined) {\n        this.reused++\n        const end = start + green.width\n        state.pos = end\n        const looked = start + green.lookahead\n        if (looked > this.highWater) this.highWater = looked\n        const d = green.diagnostics\n        if (d !== undefined) {\n          if (d.deepest !== undefined) this.deepen(start === d.base ? d.deepest : rebase(d.deepest, d.base - start))\n          if (d.hintExpected !== undefined) this.setHint(start + d.hintOffset, d.hintExpected)\n        }\n        stack.push(new Child(green, start, end, undefined))\n        return green.value\n      }\n    }\n    const mark = stack.length\n    const outer = this.highWater\n    const outerDeepest = this.deepest\n    const hintOffset = this.hintOffset\n    const hintExpected = this.hintExpected\n    this.highWater = start\n    // Collect the furthest failure of this node alone, then merge it as `failWith` would have\n    this.deepest = undefined\n    const a = step(state)\n    const looked = this.highWater\n    if (outer > looked) this.highWater = outer\n    const deepest = this.deepest as Failure | undefined\n    this.deepest = outerDeepest\n    if (deepest !== undefined) this.deepen(deepest)\n    if (a === Fail) {\n      if (stack.length > mark) stack.length = mark\n      return a\n    }\n    const end = this.cursor\n    // Like Tree-sitter's rules, nodes are never empty: an empty match adds nothing to the tree\n    if (end === start) return a\n    const hinted = this.hintOffset !== hintOffset || this.hintExpected !== hintExpected\n    const diagnostics: Diagnostics | undefined =\n      deepest === undefined && !hinted\n        ? undefined\n        : {\n            deepest,\n            base: start,\n            hintOffset: this.hintOffset - start,\n            hintExpected: hinted ? this.hintExpected : undefined\n          }\n    const entries = stack.splice(mark)\n    stack.push(\n      new Child(build(kind, named, key, start, end, looked, entries, a, undefined, diagnostics), start, end, undefined)\n    )\n    return a\n  }\n\n  read(end: number): void {\n    // `highWater` is the last position looked at, `end` is exclusive\n    if (end - 1 > this.highWater) this.highWater = end - 1\n  }\n\n  /** Records `failure` as the furthest failure if it is, as `failWith` does. */\n  private deepen(failure: Failure): void {\n    if (this.deepest === undefined || failure.offset >= this.deepest.offset) this.deepest = failure\n  }\n\n  field(state: State<any>, step: (state: State<any>) => unknown, name: string): unknown {\n    const stack = this.stack\n    const mark = stack.length\n    const a = step(state)\n    if (a !== Fail) for (let i = mark; i < stack.length; i++) stack[i].field = name\n    return a\n  }\n\n  skipped(start: number, failure: Failure, mode: ErrMode): void {\n    const stack = this.stack\n    let i = stack.length\n    while (i > 0 && stack[i - 1].start >= start && stack[i - 1].end > start) i--\n    const end = this.cursor\n    const green = build(errorKind, true, undefined, start, end, this.highWater, stack.splice(i), undefined, {\n      failure: rebase(failure, start),\n      mode\n    })\n    stack.push(new Child(green, start, end, undefined))\n  }\n\n  /**\n   * Builds the root over the whole input from the nodes left on the stack.\n   * When the parse failed, or stopped before the end, the rest of the input\n   * becomes an `ERROR` node.\n   */\n  finish(kind: string, value: unknown, fatal: ErrorInfo | undefined, errorStart: number): Green {\n    const entries = this.stack.splice(0)\n    const end = this.end\n    if (fatal !== undefined) {\n      const last = entries.length > 0 ? entries[entries.length - 1].end : 0\n      const start = Math.max(Math.min(errorStart, end), last)\n      const error = build(errorKind, true, undefined, start, end, end, [], undefined, {\n        failure: rebase(fatal.failure, start),\n        mode: fatal.mode\n      })\n      entries.push(new Child(error, start, end, undefined))\n    }\n    return build(kind, true, undefined, 0, end, Math.max(end, this.highWater), entries, value, undefined)\n  }\n\n  /**\n   * The outermost node of the previous tree built by `key` that starts at\n   * `offset`. Reused nodes are mostly siblings, found one after the other,\n   * so the search starts from the parent of the last one found when\n   * `offset` lies inside it: no ancestor of that parent can start there.\n   */\n  private find(root: Green, offset: number, key: object): Green | undefined {\n    let node = root\n    let start = 0\n    const last = this.lastParent\n    if (last !== undefined && offset > this.lastParentStart && offset < this.lastParentStart + last.width) {\n      node = last\n      start = this.lastParentStart\n    }\n    while (true) {\n      const offsets = node.offsets\n      // The last child starting at or before `offset`\n      let lo = 0\n      let hi = offsets.length - 1\n      let found = -1\n      while (lo <= hi) {\n        const mid = (lo + hi) >> 1\n        if (start + offsets[mid] <= offset) {\n          found = mid\n          lo = mid + 1\n        } else {\n          hi = mid - 1\n        }\n      }\n      if (found < 0) return undefined\n      const child = node.children[found]\n      const childStart = start + offsets[found]\n      if (offset >= childStart + child.width) return undefined\n      if (childStart === offset && child.key === key) {\n        this.lastParent = node\n        this.lastParentStart = start\n        return child\n      }\n      node = child\n      start = childStart\n    }\n  }\n\n  /** The node of the previous tree built by `key` at `pos` (in the new input), if it can be reused. */\n  private reusable(previous: Previous, key: object, pos: number): Green | undefined {\n    const segments = previous.segments\n    // The segment containing `pos`\n    let lo = 0\n    let hi = segments.length - 1\n    while (lo <= hi) {\n      const mid = (lo + hi) >> 1\n      const seg = segments[mid]\n      if (pos < seg.newStart) hi = mid - 1\n      else if (pos >= seg.newStart + seg.length) lo = mid + 1\n      else {\n        const old = seg.oldStart + (pos - seg.newStart)\n        const green = this.find(previous.root, old, key)\n        if (green === undefined) return undefined\n        const segEnd = seg.oldStart + seg.length\n        // The input it looked at must be unchanged; past the end of both inputs counts as unchanged\n        if (old + green.lookahead + tokenWidth(previous.input, old + green.lookahead) + previous.extra <= segEnd) {\n          return green\n        }\n        if (segEnd === previous.oldLength && seg.newStart + seg.length === previous.newLength) return green\n        return undefined\n      }\n    }\n    return undefined\n  }\n}\n\n/**\n * How many units a token parser may read at `offset`, where a parse\n * stopped looking: one code point. Of a string, that is two units at a high\n * surrogate. Of bytes in an unknown encoding, up to four.\n */\nconst tokenWidth = (input: Input, offset: number): number => {\n  if (Predicate.isString(input)) {\n    const c = input.charCodeAt(offset)\n    return c >= 0xd800 && c <= 0xdbff ? 2 : 1\n  }\n  return input instanceof Uint8Array ? 4 : 1\n}\n"],"mappings":"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"}

package/dist/internal/text.d.ts

@@ -1,5 +1,6 @@
-import type { Encoding } from "../Encoding.js";
-import type { Fail, State } from "../Input.js";
+import { Fail, State } from "../Input.js";
+import { Encoding } from "../Encoding.js";
+//#region src/internal/text.d.ts
 /** `Encoding.decode`: the input is malformed. */
 export declare const Invalid = -1;
 /** `Encoding.decode`: the input ends inside a sequence. */
@@ -8,6 +9,12 @@ export declare const Truncated = -2;
 export declare const End = -3;
 /** @internal */
 export declare const fastLimit: (enc: Encoding<any>) => number;
+/**
+ * The code point that starts `s`: for a string known to hold one, such as
+ * one element of `Array.from(string)`. On an empty string it is `NaN`, which,
+ * like the `undefined` of `codePointAt(0)`, matches no code point.
+ */
+export declare const firstCodePoint: (s: string) => number;
 /** `String.fromCodePoint`, with the ASCII characters cached. */
 export declare const charOf: (cp: number) => string;
 /**
@@ -69,4 +76,5 @@ export declare const fold: (cp: number) => number;
 export declare const walk: (enc: Encoding<any>, input: string | Uint8Array, start: number, end: number, f: (cp: number, offset: number, width: number) => boolean | void) => void;
 /** Decodes `[start, end)`, replacing malformed sequences with U+FFFD. */
 export declare const lenientText: (enc: Encoding<any>, input: string | Uint8Array, start: number, end: number) => string;
+//#endregion
 //# sourceMappingURL=text.d.ts.map

package/dist/internal/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/internal/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAM9C,iDAAiD;AACjD,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,2DAA2D;AAC3D,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,mCAAmC;AACnC,eAAO,MAAM,GAAG,KAAK,CAAA;AAYrB,gBAAgB;AAChB,eAAO,MAAM,SAAS,QAAS,QAAQ,CAAC,GAAG,CAAC,KAAG,MACgC,CAAA;AAI/E,gEAAgE;AAChE,eAAO,MAAM,MAAM,OAAQ,MAAM,KAAG,MAC4D,CAAA;AAahG;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,MAAM,CASf,CAAA;AAmDrB,mBAAmB;AACnB,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,UAAU,CAuBrC,CAAA;AA0CD,mCAAmC;AACnC,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAmB,CAAA;AAE5D,gCAAgC;AAChC,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAoB,CAAA;AAE7D,kEAAkE;AAClE,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,UAAU,CAuBf,CAAA;AAMzB,uEAAuE;AACvE,eAAO,IAAI,KAAK,QAAI,CAAA;AAEpB;;;;;GAKG;AACH,eAAO,MAAM,IAAI,QAAS,QAAQ,CAAC,GAAG,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,QAAO,MAAM,KAAe,MASrF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,UACV,KAAK,CAAC,GAAG,CAAC,MACb,MAAM,QACJ,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,YAC7B,aAAa,CAAC,MAAM,CAAC,WACvB,MAAM,KACb,IAIF,CAAA;AAGD,iDAAiD;AACjD,eAAO,IAAI,UAAU,QAAI,CAAA;AACzB,gEAAgE;AAChE,eAAO,IAAI,SAAS,QAAI,CAAA;AACxB;;;GAGG;AACH,eAAO,IAAI,QAAQ,QAAI,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,IAAI,QACV,QAAQ,CAAC,GAAG,CAAC,SACX,KAAK,CAAC,GAAG,CAAC,QACX,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,UACrB,OAAO,OACV,MAAM,QACN,MAAM,SACL,MAAM,KACX,IAsDF,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,QAAQ,QAAS,QAAQ,CAAC,GAAG,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,SAAS,MAAM,OAAO,MAAM,KAAG,MAS5F,CAAA;AAaD;;;;GAIG;AACH,eAAO,MAAM,IAAI,OAAQ,MAAM,KAAG,MAYjC,CAAA;AAMD;;;GAGG;AACH,eAAO,MAAM,IAAI,QACV,QAAQ,CAAC,GAAG,CAAC,SACX,MAAM,GAAG,UAAU,SACnB,MAAM,OACR,MAAM,KACR,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,KAC/D,IAcF,CAAA;AAED,yEAAyE;AACzE,eAAO,MAAM,WAAW,QAAS,QAAQ,CAAC,GAAG,CAAC,SAAS,MAAM,GAAG,UAAU,SAAS,MAAM,OAAO,MAAM,KAAG,MAMxG,CAAA"}
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../src/internal/text.ts"],"mappings":";;;;qBAQa;;qBAEA;;qBAEA;;qBAaA,YAAa,KAAK;;;;;;qBAUlB,iBAAkB;;qBAGlB,SAAU;;;;;qBAkBV,QAAQ;;qBA6DR,MAAM,SAAS;;qBAkEf,SAAS,SAAS;;qBAGlB,SAAS,SAAS;;qBAGlB,QAAQ,SAAS;;mBA8BnB;;;;;;;qBAQE,OAAQ,KAAK,eAAe,OAAO,YAAY;;;;;qBAe/C,SACX,OAAO,YACP,YACA,MAAM,WAAW,wBACjB,UAAU,uBACV,oBACC;;mBAQQ;;mBAEA;;;;;mBAKA;;;;;qBAME,OACX,KAAK,eACL,OAAO,YACP,OAAO,wBACP,iBACA,aACA,cACA;;;;;qBA+DW,WAAY,KAAK,eAAe,OAAO,YAAY,eAAe;;;;;;qBA2BlE,OAAQ;;;;;qBAsBR,OACX,KAAK,eACL,gBAAgB,YAChB,eACA,aACA,IAAI,YAAY,gBAAgB;;qBAkBrB,cAAe,KAAK,eAAe,gBAAgB,YAAY,eAAe"}