@lezer/common 0.15.10 → 0.15.11

package/dist/index.cjs

@@ -1496,20 +1496,20 @@ function materialize(cursor) {
     let buf = base.children[i], b = buf.buffer;
     // Split a level in the buffer, putting the nodes before and after
     // the child that contains `node` into new buffers.
-    function split(startI, endI, type, innerOffset) {
+    function split(startI, endI, type, innerOffset, length) {
         let i = startI;
         while (b[i + 2] + off <= node.from)
             i = b[i + 3];
         let children = [], positions = [];
         sliceBuf(buf, startI, i, children, positions, innerOffset);
-        let isTarget = b[i + 1] + off == node.from && b[i + 2] + off == node.to && b[i] == node.type.id;
-        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], b[i + 1]));
-        positions.push(b[i + 1] - innerOffset);
+        let from = b[i + 1], to = b[i + 2];
+        let isTarget = from + off == node.from && to + off == node.to && b[i] == node.type.id;
+        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], from, to - from));
+        positions.push(from - innerOffset);
         sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
-        let last = children.length - 1;
-        return new Tree(type, children, positions, positions[last] + children[last].length);
+        return new Tree(type, children, positions, length);
     }
-    base.children[i] = split(0, b.length, NodeType.none, 0);
+    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
     // Move the cursor back to the target node
     for (let d = 0; d <= depth; d++)
         cursor.childAfter(node.from);

package/dist/index.js

@@ -1492,20 +1492,20 @@ function materialize(cursor) {
     let buf = base.children[i], b = buf.buffer;
     // Split a level in the buffer, putting the nodes before and after
     // the child that contains `node` into new buffers.
-    function split(startI, endI, type, innerOffset) {
+    function split(startI, endI, type, innerOffset, length) {
         let i = startI;
         while (b[i + 2] + off <= node.from)
             i = b[i + 3];
         let children = [], positions = [];
         sliceBuf(buf, startI, i, children, positions, innerOffset);
-        let isTarget = b[i + 1] + off == node.from && b[i + 2] + off == node.to && b[i] == node.type.id;
-        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], b[i + 1]));
-        positions.push(b[i + 1] - innerOffset);
+        let from = b[i + 1], to = b[i + 2];
+        let isTarget = from + off == node.from && to + off == node.to && b[i] == node.type.id;
+        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], from, to - from));
+        positions.push(from - innerOffset);
         sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
-        let last = children.length - 1;
-        return new Tree(type, children, positions, positions[last] + children[last].length);
+        return new Tree(type, children, positions, length);
     }
-    base.children[i] = split(0, b.length, NodeType.none, 0);
+    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
     // Move the cursor back to the target node
     for (let d = 0; d <= depth; d++)
         cursor.childAfter(node.from);

package/dist/tree.d.ts

@@ -72,8 +72,8 @@ export declare class Tree {
     cursor(pos?: number, side?: -1 | 0 | 1): TreeCursor;
     fullCursor(): TreeCursor;
     get topNode(): SyntaxNode;
-    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
-    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolve(pos: number, side?: -1 | 0 | 1): any;
+    resolveInner(pos: number, side?: -1 | 0 | 1): any;
     iterate(spec: {
         enter(type: NodeType, from: number, to: number, get: () => SyntaxNode): false | void;
         leave?(type: NodeType, from: number, to: number, get: () => SyntaxNode): void;
@@ -170,8 +170,8 @@ export declare class TreeNode implements SyntaxNode {
     get cursor(): TreeCursor;
     get tree(): Tree;
     toTree(): Tree;
-    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
-    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolve(pos: number, side?: -1 | 0 | 1): any;
+    resolveInner(pos: number, side?: -1 | 0 | 1): any;
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
@@ -205,8 +205,8 @@ declare class BufferNode implements SyntaxNode {
     get cursor(): TreeCursor;
     get tree(): any;
     toTree(): Tree;
-    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
-    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolve(pos: number, side?: -1 | 0 | 1): any;
+    resolveInner(pos: number, side?: -1 | 0 | 1): any;
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lezer/common",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "description": "Syntax tree data structure and parser interfaces for the lezer parser",
   "main": "dist/index.cjs",
   "type": "module",