@thomasfosterau/effect-parse 0.0.0 → 0.2.0

package/dist/Syntax.js

@@ -0,0 +1,717 @@
+import * as Predicate from "effect/Predicate";
+import { Fail, fromSource } from "./Input.js";
+import { described, isParser } from "./Parser.js";
+import * as Option from "effect/Option";
+import { dual } from "effect/Function";
+import * as ParseError from "./ParseError.js";
+import * as Stack from "./internal/stack.js";
+import { nodeOf } from "./internal/node.js";
+import { SyntaxState, absolute, errorKind } from "./internal/syntax.js";
+//#region src/Syntax.ts
+/**
+* Concrete syntax trees and incremental parsing, in the spirit of
+* [Tree-sitter](https://tree-sitter.github.io).
+*
+* Mark the rules of a grammar that should appear in the tree with
+* {@link node} (and, optionally, {@link token} and {@link field}). Outside
+* this module the marks change nothing: `Parser.parse` returns the same
+* values, and compiled parsers compile them away. {@link parse} runs the
+* grammar and returns a {@link Tree}: a tree of {@link SyntaxNode}s with
+* spans, parents and siblings, to search by position (`descendantAt`) or walk
+* with a {@link TreeCursor}. Each node also carries the value its parser
+* returned.
+*
+* Like Tree-sitter, a syntax parse always produces a tree. Failures handled
+* by `Parser.resumeAfter` and `Parser.retryAfter` become `ERROR` nodes over
+* the input they skipped, and so does any input after a fatal failure.
+*
+* After an edit, {@link reparse} (or {@link replace}) parses the new input
+* reusing every node of the old tree whose input is unchanged: only the
+* nodes that enclose the edit, or looked at the edited input, are parsed
+* again, and each reused node is stepped over whole.
+*
+* @example
+* ```ts
+* import { Ascii, Parser, Syntax, Token } from "@thomasfosterau/effect-parse"
+*
+* const ws = Ascii.multispace0
+* const number = Syntax.node(Ascii.decInt, "number")
+* const list = Syntax.node(
+*   Parser.delimited(
+*     Token.literal("["),
+*     Parser.separated(Parser.delimited(ws, number, ws), Token.literal(",")),
+*     Token.literal("]")
+*   ),
+*   "list"
+* )
+*
+* const tree = Syntax.parse(list, "[1, 2, 3]")
+* String(tree.root) // "(list (number) (number) (number))"
+* tree.root.descendantAt(4)?.text // "2"
+*
+* const edited = Syntax.replace(tree, 4, 5, "20") // "[1, 20, 3]"
+* edited.root.namedChild(1)?.value // 20
+* edited.reused // 2: only "20" was parsed again
+* ```
+*
+* @since 0.2.0
+*/
+const syntaxNode = (self, kind, named) => {
+	const step = self.step;
+	const key = {};
+	return described((state) => {
+		const builder = state.syntax;
+		return builder === void 0 ? step(state) : builder.node(state, step, key, kind, named);
+	}, self.name, {
+		_tag: "Syntax",
+		self,
+		kind,
+		named
+	});
+};
+/**
+* Marks a parser as a rule of the syntax tree: in a {@link parse}, each
+* match becomes a named node of the given kind, spanning the input it
+* consumed, with the nodes built inside it as children and its output as
+* its `value`. Outside {@link parse}, the parser is unchanged.
+*
+* A match that consumes nothing adds no node (as in Tree-sitter, where rules
+* can't match the empty string).
+*
+* For {@link reparse} to reuse a node, its parser's output must depend only
+* on the input from where the node starts: not on services, on state kept
+* in closures, or on absolute offsets (`Parser.location`, `Parser.span`),
+* which are not updated when the node moves. Use the node's `start` and
+* `end` instead.
+*
+* @since 0.2.0
+* @category annotations
+*/
+const node = /*#__PURE__*/ dual(2, (self, kind) => syntaxNode(self, kind, true));
+/**
+* Like {@link node}, but builds an *anonymous* node, Tree-sitter's name for
+* punctuation and keywords: anonymous nodes are left out of
+* `namedChildren` and of the tree's printed form. The kind defaults to the
+* literal for a `Token.literal` of a string, and to the parser's name
+* otherwise.
+*
+* @example
+* ```ts
+* import { Syntax, Token } from "@thomasfosterau/effect-parse"
+*
+* const comma = Syntax.token(Token.literal(",")) // kind ","
+* ```
+*
+* @since 0.2.0
+* @category annotations
+*/
+const token = /*#__PURE__*/ dual((args) => isParser(args[0]), (self, kind) => syntaxNode(self, kind ?? defaultTokenKind(self), false));
+const defaultTokenKind = (self) => {
+	const n = nodeOf(self);
+	if (n._tag === "Literal" && Predicate.isString(n.literal) && !n.caseless) return n.literal;
+	return self.name ?? "token";
+};
+/**
+* Gives the nodes built by a parser a field name in their parent, like
+* Tree-sitter's `field(name, rule)`: find them with `childByField` and
+* `childrenByField`. Outside {@link parse}, the parser is unchanged.
+*
+* @example
+* ```ts
+* import { Ascii, Parser, Syntax, Token } from "@thomasfosterau/effect-parse"
+*
+* const name = Syntax.node(Ascii.alpha1, "name")
+* const number = Syntax.node(Ascii.decInt, "number")
+* const pair = Syntax.node(
+*   Parser.separatedPair(Syntax.field(name, "key"), Token.literal("="), Syntax.field(number, "value")),
+*   "pair"
+* )
+* Syntax.parse(pair, "x=1").root.childByField("value")?.value // 1
+* ```
+*
+* @since 0.2.0
+* @category annotations
+*/
+const field = /*#__PURE__*/ dual(2, (self, name) => {
+	const step = self.step;
+	return described((state) => {
+		const builder = state.syntax;
+		return builder === void 0 ? step(state) : builder.field(state, step, name);
+	}, self.name, {
+		_tag: "Syntax",
+		self,
+		kind: void 0,
+		named: false
+	});
+});
+/**
+* The kind of the nodes that stand for input that could not be parsed.
+*
+* @since 0.2.0
+* @category models
+*/
+const ERROR = errorKind;
+/**
+* The result of a {@link parse}: a syntax tree over the whole input, the
+* grammar's output, and the errors met on the way.
+*
+* @since 0.2.0
+* @category models
+*/
+var Tree = class {
+	input;
+	value;
+	reused;
+	green;
+	config;
+	encoding;
+	/** The root node. It always spans the whole input. */
+	root;
+	lines;
+	errorList;
+	/** @internal */
+	constructor(input, value, reused, green, config, encoding) {
+		this.input = input;
+		this.value = value;
+		this.reused = reused;
+		this.green = green;
+		this.config = config;
+		this.encoding = encoding;
+		this.root = new SyntaxNode(this, green, 0, void 0, 0);
+	}
+	/**
+	* Every error of the parse, in input order: the failures recovered by
+	* `Parser.resumeAfter` and `Parser.retryAfter`, then the fatal one, if
+	* the parse failed. Each one belongs to an `ERROR` node.
+	*/
+	get errors() {
+		if (this.errorList === void 0) {
+			const out = [];
+			const visit = (green, start) => {
+				if (!green.hasError) return;
+				if (green.error !== void 0) out.push(this.toError(green.error, start));
+				for (let i = 0; i < green.children.length; i++) visit(green.children[i], start + green.offsets[i]);
+			};
+			visit(this.green, 0);
+			this.errorList = out;
+		}
+		return this.errorList;
+	}
+	/** Whether the tree has any `ERROR` node. */
+	get hasErrors() {
+		return this.green.hasError;
+	}
+	/** The smallest node containing `[start, end)` (see {@link SyntaxNode.descendantAt}). */
+	descendantAt(start, end) {
+		return this.root.descendantAt(start, end);
+	}
+	/** A cursor at the root. */
+	walk() {
+		return new TreeCursor(this.root);
+	}
+	/**
+	* The 1-based line and column (in code points) of an offset, as in
+	* `ParseError`. Lines of a string input are indexed once, so lookups take
+	* logarithmic time.
+	*/
+	lineColumn(offset) {
+		const input = this.input;
+		if (!Predicate.isString(input)) return ParseError.lineColumn(input, offset, this.encoding);
+		let lines = this.lines;
+		if (lines === void 0) {
+			lines = [0];
+			for (let i = input.indexOf("\n"); i >= 0; i = input.indexOf("\n", i + 1)) lines.push(i + 1);
+			this.lines = lines;
+		}
+		const at = Math.max(0, Math.min(offset, input.length));
+		let lo = 0;
+		let hi = lines.length - 1;
+		while (lo < hi) {
+			const mid = lo + hi + 1 >> 1;
+			if (lines[mid] <= at) lo = mid;
+			else hi = mid - 1;
+		}
+		const lineStart = lines[lo];
+		return {
+			line: lo + 1,
+			column: ParseError.lineColumn(input.slice(lineStart, at), at - lineStart).column
+		};
+	}
+	/** The root's S-expression (see {@link SyntaxNode.toString}). */
+	toString() {
+		return this.root.toString();
+	}
+	/** @internal */
+	toError(error, start) {
+		return ParseError.fromFailure(this.input, absolute(error.failure, start), error.mode, this.encoding);
+	}
+};
+/**
+* A node of a syntax tree: its kind, span and value, and its place in the
+* tree. Nodes are views built on demand; two views of the same node are
+* different objects but have the same `start`, `end` and `kind`.
+*
+* @since 0.2.0
+* @category models
+*/
+var SyntaxNode = class SyntaxNode {
+	tree;
+	green;
+	start;
+	parent;
+	index;
+	childList;
+	/** @internal */
+	constructor(tree, green, start, parent, index) {
+		this.tree = tree;
+		this.green = green;
+		this.start = start;
+		this.parent = parent;
+		this.index = index;
+	}
+	/** The node's kind: the name given to {@link node} or {@link token}, or `"ERROR"`. */
+	get kind() {
+		return this.green.kind;
+	}
+	/** `false` for the anonymous nodes built by {@link token}. */
+	get named() {
+		return this.green.named;
+	}
+	/** The field name given by {@link field}, if any. */
+	get field() {
+		return this.parent?.green.fields?.[this.index];
+	}
+	/** The offset where the node ends (exclusive). */
+	get end() {
+		return this.start + this.green.width;
+	}
+	/** The number of input units the node spans. */
+	get length() {
+		return this.green.width;
+	}
+	/** The output of the node's parser (`undefined` for `ERROR` nodes, and for a root that failed). */
+	get value() {
+		return this.green.value;
+	}
+	/** The input the node spans. */
+	get text() {
+		const input = this.tree.input;
+		return input instanceof Uint8Array ? input.subarray(this.start, this.end) : input.slice(this.start, this.end);
+	}
+	/** Whether this is an `ERROR` node. */
+	get isError() {
+		return this.green.error !== void 0;
+	}
+	/** Whether this node or a descendant is an `ERROR` node. */
+	get hasError() {
+		return this.green.hasError;
+	}
+	/** For an `ERROR` node, the error it stands for. */
+	get error() {
+		const error = this.green.error;
+		return error === void 0 ? void 0 : this.tree.toError(error, this.start);
+	}
+	/** The child nodes, named and anonymous, in input order. */
+	get children() {
+		if (this.childList === void 0) {
+			const green = this.green;
+			const out = new Array(green.children.length);
+			for (let i = 0; i < out.length; i++) out[i] = this.makeChild(i);
+			this.childList = out;
+		}
+		return this.childList;
+	}
+	/** The number of children. */
+	get childCount() {
+		return this.green.children.length;
+	}
+	/** The child at `index` (negative indices count from the end). */
+	child(index) {
+		const n = this.green.children.length;
+		const i = index < 0 ? n + index : index;
+		return i >= 0 && i < n ? this.children[i] : void 0;
+	}
+	/** The named children. */
+	get namedChildren() {
+		return this.children.filter((c) => c.named);
+	}
+	/** The named child at `index`. */
+	namedChild(index) {
+		return this.namedChildren[index];
+	}
+	/** The first child with the given field name. */
+	childByField(name) {
+		const fields = this.green.fields;
+		if (fields === void 0) return void 0;
+		const i = fields.indexOf(name);
+		return i < 0 ? void 0 : this.children[i];
+	}
+	/** The children with the given field name. */
+	childrenByField(name) {
+		const fields = this.green.fields;
+		if (fields === void 0) return [];
+		return this.children.filter((_, i) => fields[i] === name);
+	}
+	/** The next sibling, named or anonymous. */
+	get nextSibling() {
+		return this.parent?.children[this.index + 1];
+	}
+	/** The previous sibling, named or anonymous. */
+	get previousSibling() {
+		return this.index > 0 ? this.parent?.children[this.index - 1] : void 0;
+	}
+	/** The next named sibling. */
+	get nextNamedSibling() {
+		const siblings = this.parent?.children;
+		if (siblings === void 0) return void 0;
+		for (let i = this.index + 1; i < siblings.length; i++) if (siblings[i].named) return siblings[i];
+	}
+	/** The previous named sibling. */
+	get previousNamedSibling() {
+		const siblings = this.parent?.children;
+		if (siblings === void 0) return void 0;
+		for (let i = this.index - 1; i >= 0; i--) if (siblings[i].named) return siblings[i];
+	}
+	/**
+	* The index of the child containing the input unit at `offset`, or -1.
+	* Takes logarithmic time.
+	*/
+	childIndexAt(offset) {
+		const green = this.green;
+		const offsets = green.offsets;
+		const rel = offset - this.start;
+		let lo = 0;
+		let hi = offsets.length - 1;
+		let found = -1;
+		while (lo <= hi) {
+			const mid = lo + hi >> 1;
+			if (offsets[mid] <= rel) {
+				found = mid;
+				lo = mid + 1;
+			} else hi = mid - 1;
+		}
+		while (found >= 0 && green.children[found].width === 0 && offsets[found] === rel) found--;
+		return found >= 0 && rel < offsets[found] + green.children[found].width ? found : -1;
+	}
+	/** The child containing the input unit at `offset`. */
+	childAt(offset) {
+		const i = this.childIndexAt(offset);
+		return i < 0 ? void 0 : this.children[i];
+	}
+	/**
+	* The smallest node, this one or a descendant, that contains
+	* `[start, end)` (Tree-sitter's `descendant_for_byte_range`). With only
+	* `start`, the deepest node containing the input unit at `start`. Takes
+	* time proportional to the depth of the tree times the logarithm of the
+	* number of children.
+	*/
+	descendantAt(start, end = start + 1) {
+		return descendantOf(this, start, end);
+	}
+	/** Like {@link descendantAt}, but only stops at named nodes. */
+	namedDescendantAt(start, end = start + 1) {
+		let node = this.descendantAt(start, end);
+		while (!node.named && node !== this) node = node.parent ?? this;
+		return node;
+	}
+	/** This node and its descendants, in pre-order. */
+	*descendants() {
+		const cursor = this.walk();
+		while (true) {
+			yield cursor.node;
+			if (cursor.gotoFirstChild()) continue;
+			while (!cursor.gotoNextSibling()) if (!cursor.gotoParent()) return;
+		}
+	}
+	/** The descendants of the given kind, in pre-order. */
+	*descendantsOfKind(kind) {
+		for (const n of this.descendants()) if (n.kind === kind) yield n;
+	}
+	/** A cursor at this node, which cannot move above it. */
+	walk() {
+		return new TreeCursor(this);
+	}
+	/**
+	* The node as an S-expression of its named descendants, with field
+	* names, as Tree-sitter prints it: `(pair key: (name) value: (number))`.
+	*/
+	toString() {
+		let out = "";
+		const visit = (green, field) => {
+			if (green.named || green === this.green) {
+				if (out.length > 0) out += " ";
+				if (field !== void 0) out += `${field}: `;
+				out += `(${green.kind}`;
+				for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i]);
+				out += ")";
+			} else for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i]);
+		};
+		visit(this.green, this.field);
+		return out;
+	}
+	toJSON() {
+		return {
+			kind: this.kind,
+			start: this.start,
+			end: this.end
+		};
+	}
+	makeChild(i) {
+		const green = this.green;
+		return new SyntaxNode(this.tree, green.children[i], this.start + green.offsets[i], this, i);
+	}
+};
+/** The smallest node, `root` or a descendant, that contains `[start, end)` (see `SyntaxNode.descendantAt`). */
+const descendantOf = (root, start, end) => {
+	let node = root;
+	while (true) {
+		const i = node.childIndexAt(start);
+		if (i < 0) return node;
+		const child = node.children[i];
+		if (end > child.end) return node;
+		node = child;
+	}
+};
+/**
+* A cursor for walking a tree, as Tree-sitter's `TreeCursor`. It starts at
+* a node and cannot move above it.
+*
+* @since 0.2.0
+* @category models
+*/
+var TreeCursor = class {
+	current;
+	depth = 0;
+	/** @internal */
+	constructor(node) {
+		this.current = node;
+	}
+	/** The node at the cursor. */
+	get node() {
+		return this.current;
+	}
+	/** The field name of the node at the cursor, if any. */
+	get field() {
+		return this.depth === 0 ? void 0 : this.current.field;
+	}
+	/** Moves to the first child; `false` if there is none. */
+	gotoFirstChild() {
+		return this.goto(this.current.child(0));
+	}
+	/** Moves to the last child; `false` if there is none. */
+	gotoLastChild() {
+		return this.goto(this.current.child(-1));
+	}
+	/** Moves to the child containing the input unit at `offset`; `false` if there is none. */
+	gotoFirstChildForOffset(offset) {
+		return this.goto(this.current.childAt(offset));
+	}
+	/** Moves to the next sibling; `false` if there is none. */
+	gotoNextSibling() {
+		if (this.depth === 0) return false;
+		const next = this.current.nextSibling;
+		if (next === void 0) return false;
+		this.current = next;
+		return true;
+	}
+	/** Moves to the previous sibling; `false` if there is none. */
+	gotoPreviousSibling() {
+		if (this.depth === 0) return false;
+		const previous = this.current.previousSibling;
+		if (previous === void 0) return false;
+		this.current = previous;
+		return true;
+	}
+	/** Moves to the parent; `false` at the node the cursor started at. */
+	gotoParent() {
+		const parent = this.current.parent;
+		if (this.depth === 0 || parent === void 0) return false;
+		this.current = parent;
+		this.depth--;
+		return true;
+	}
+	/** Moves to the deepest node containing the input unit at `offset`. */
+	gotoDescendantAt(offset) {
+		while (this.gotoFirstChildForOffset(offset));
+	}
+	/** Starts again at `node`. */
+	reset(node) {
+		this.current = node;
+		this.depth = 0;
+	}
+	goto(node) {
+		if (node === void 0) return false;
+		this.current = node;
+		this.depth++;
+		return true;
+	}
+};
+const expectedEof = ["end of input"];
+const run = (config, input, previous) => {
+	const state = new SyntaxState(input, { context: config.context }, previous);
+	const a = Stack.run(config.inner.step, state);
+	if (state.encoding === void 0 && previous !== void 0) state.encoding = previous.encoding;
+	let fatal;
+	let value = Option.none();
+	if (a === Fail) fatal = {
+		failure: state.reportedFailure(),
+		mode: state.mode
+	};
+	else if (state.pos < state.end) {
+		state.backtrack("Eof", expectedEof);
+		fatal = {
+			failure: state.reportedFailure(),
+			mode: "Backtrack"
+		};
+	} else value = Option.some(a);
+	const green = state.finish(config.kind, Option.getOrUndefined(value), fatal, state.pos);
+	return new Tree(input, value, state.reused, green, config, state.encoding);
+};
+/**
+* Parses an input into a syntax {@link Tree}. The grammar's output is the
+* tree's `value`, and its {@link node}s are the tree's nodes. When the
+* grammar is itself a {@link node}, that node is the root; otherwise the
+* root is a node of kind `options.kind` (by default `"document"`).
+*
+* The parse never fails: recovered failures (see `Parser.resumeAfter`), a
+* fatal failure and unparsed input at the end all become `ERROR` nodes, and
+* are listed in `tree.errors`. The parse is interpreted, never compiled.
+*
+* @since 0.2.0
+* @category parsing
+*/
+const parse = (grammar, input, options) => {
+	const n = nodeOf(grammar);
+	const isRoot = n._tag === "Syntax" && n.kind !== void 0 && n.named;
+	const config = {
+		kind: isRoot ? n.kind : options?.kind ?? "document",
+		inner: isRoot ? n.self : grammar,
+		lookahead: options?.lookahead ?? 0,
+		context: options?.context
+	};
+	return run(config, fromSource(input), void 0);
+};
+/**
+* Parses the new version of a tree's input, reusing the nodes of the tree
+* that the edits leave unchanged (Tree-sitter's `ts_tree_edit` followed by
+* `ts_parser_parse` with the old tree). The result is the tree a fresh
+* {@link parse} of `input` would build, but only the parts of the tree
+* around the edits are parsed again. `tree.reused` says how many nodes were
+* reused.
+*
+* `edits` describe how the old input became the new one, applied in order,
+* each in the coordinates of the input as the previous edits left it. When
+* they are omitted, the edit is found by comparing the inputs (their common
+* prefix and suffix), which takes time linear in their length but much less
+* than parsing.
+*
+* Errors in the new tree are those a fresh parse reports, except that an
+* error just after a reused node may list fewer expected alternatives.
+*
+* @example
+* ```ts
+* import { Ascii, Syntax } from "@thomasfosterau/effect-parse"
+*
+* const number = Syntax.node(Ascii.decInt, "number")
+* const tree = Syntax.parse(number, "12")
+* Syntax.reparse(tree, "123", [{ start: 2, oldEnd: 2, newEnd: 3 }]).root.value // 123
+* ```
+*
+* @since 0.2.0
+* @category parsing
+*/
+const reparse = (tree, input, edits) => {
+	const next = fromSource(input);
+	const list = edits === void 0 ? diffList(tree.input, next) : "start" in edits ? [edits] : edits;
+	const previous = {
+		root: tree.green,
+		oldLength: tree.input.length,
+		newLength: next.length,
+		segments: segmentsOf(tree.input.length, next.length, list),
+		input: tree.input,
+		extra: tree.config.lookahead,
+		encoding: tree.encoding
+	};
+	return run(tree.config, next, previous);
+};
+/**
+* Replaces `[start, end)` of a tree's string input with `text` and parses
+* the result incrementally (see {@link reparse}).
+*
+* @since 0.2.0
+* @category parsing
+*/
+const replace = (tree, start, end, text) => {
+	const input = tree.input;
+	if (start < 0 || end < start || end > input.length) throw new RangeError(`invalid range [${start}, ${end}) of an input of length ${input.length}`);
+	return reparse(tree, input.slice(0, start) + text + input.slice(end), {
+		start,
+		oldEnd: end,
+		newEnd: start + text.length
+	});
+};
+/**
+* Finds the edit that turns `before` into `after`: the part between their
+* longest common prefix and suffix. `undefined` when they are equal.
+*
+* @since 0.2.0
+* @category parsing
+*/
+const diff = (before, after) => {
+	const a = before;
+	const b = after;
+	const at = Predicate.isString(a) ? (s, i) => s.charCodeAt(i) : (s, i) => s[i];
+	const max = Math.min(a.length, b.length);
+	let prefix = 0;
+	while (prefix < max && at(a, prefix) === at(b, prefix)) prefix++;
+	if (prefix === a.length && prefix === b.length) return void 0;
+	let suffix = 0;
+	while (suffix < max - prefix && at(a, a.length - 1 - suffix) === at(b, b.length - 1 - suffix)) suffix++;
+	return {
+		start: prefix,
+		oldEnd: a.length - suffix,
+		newEnd: b.length - suffix
+	};
+};
+const diffList = (before, after) => {
+	const edit = diff(before, after);
+	return edit === void 0 ? [] : [edit];
+};
+/** The stretches of the new input copied unchanged from the old one. */
+const segmentsOf = (oldLength, newLength, edits) => {
+	let segments = oldLength > 0 ? [{
+		newStart: 0,
+		oldStart: 0,
+		length: oldLength
+	}] : [];
+	let length = oldLength;
+	for (const { newEnd, oldEnd, start } of edits) {
+		if (!(start >= 0 && oldEnd >= start && oldEnd <= length && newEnd >= start)) throw new RangeError(`invalid edit { start: ${start}, oldEnd: ${oldEnd}, newEnd: ${newEnd} } of an input of length ${length}`);
+		const delta = newEnd - oldEnd;
+		const out = [];
+		for (const s of segments) {
+			const end = s.newStart + s.length;
+			if (s.newStart < start) out.push({
+				newStart: s.newStart,
+				oldStart: s.oldStart,
+				length: Math.min(end, start) - s.newStart
+			});
+			if (end > oldEnd) {
+				const from = Math.max(s.newStart, oldEnd);
+				out.push({
+					newStart: from + delta,
+					oldStart: s.oldStart + (from - s.newStart),
+					length: end - from
+				});
+			}
+		}
+		segments = out;
+		length += delta;
+	}
+	if (length !== newLength) throw new RangeError(`the edits give an input of length ${length}, but the new input has length ${newLength}`);
+	return segments;
+};
+//#endregion
+export { ERROR, SyntaxNode, Tree, TreeCursor, diff, field, node, parse, reparse, replace, token };
+
+//# sourceMappingURL=Syntax.js.map