@lezer/common 0.15.5 → 0.15.9

package/dist/index.cjs

@@ -286,7 +286,8 @@ class Tree {
     }
     /// Get a [tree cursor](#common.TreeCursor) that, unlike regular
     /// cursors, doesn't skip through
-    /// [anonymous](#common.NodeType.isAnonymous) nodes.
+    /// [anonymous](#common.NodeType.isAnonymous) nodes and doesn't
+    /// automatically enter mounted nodes.
     fullCursor() {
         return new TreeCursor(this.topNode, 1 /* Full */);
     }
@@ -364,7 +365,7 @@ class Tree {
     /// [`NodeType.none`](#common.NodeType^none).
     balance(config = {}) {
         return this.children.length <= 8 /* BranchFactor */ ? this :
-            balanceRange(this.type, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
+            balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
     }
     /// Build a tree from a postfix-ordered buffer of node information,
     /// or a cursor over such a buffer.
@@ -508,7 +509,7 @@ class TreeNode {
                 }
                 else if ((mode & 1 /* Full */) || (!next.type.isAnonymous || hasChild(next))) {
                     let mounted;
-                    if (next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
+                    if (!(mode & 1 /* Full */) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
                         return new TreeNode(mounted.tree, start, i, parent);
                     let inner = new TreeNode(next, start, i, parent);
                     return (mode & 1 /* Full */) || !inner.type.isAnonymous ? inner
@@ -756,10 +757,10 @@ class TreeCursor {
     /// set to false.
     enter(pos, side, overlays = true, buffers = true) {
         if (!this.buffer)
-            return this.yield(this._tree.enter(pos, side, overlays, buffers));
+            return this.yield(this._tree.enter(pos, side, overlays && !(this.mode & 1 /* Full */), buffers));
         return buffers ? this.enterChild(1, pos, side) : false;
     }
-    /// Move the node's parent node, if this isn't the top node.
+    /// Move to the node's parent node, if this isn't the top node.
     parent() {
         if (!this.buffer)
             return this.yieldNode((this.mode & 1 /* Full */) ? this._tree._parent : this._tree.parent);
@@ -1081,15 +1082,21 @@ function nodeSize(balanceType, node) {
         return 1;
     let size = nodeSizeCache.get(node);
     if (size == null) {
-        size = node.children.reduce((s, ch) => s + nodeSize(balanceType, ch), 1);
+        size = 1;
+        for (let child of node.children) {
+            if (child.type != balanceType || !(child instanceof Tree)) {
+                size = 1;
+                break;
+            }
+            size += nodeSize(balanceType, child);
+        }
         nodeSizeCache.set(node, size);
     }
     return size;
 }
 function balanceRange(
-// The type to tag the resulting tree with. Will also be used for
-// internal nodes when it is an anonymous type
-type, 
+// The type the balanced tree's inner nodes.
+balanceType, 
 // The direct children and their positions
 children, positions, 
 // The index range in children/positions to use
@@ -1104,22 +1111,22 @@ mkTop,
 mkTree) {
     let total = 0;
     for (let i = from; i < to; i++)
-        total += nodeSize(type, children[i]);
+        total += nodeSize(balanceType, children[i]);
     let maxChild = Math.ceil((total * 1.5) / 8 /* BranchFactor */);
     let localChildren = [], localPositions = [];
     function divide(children, positions, from, to, offset) {
         for (let i = from; i < to;) {
-            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(type, children[i]);
+            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(balanceType, children[i]);
             i++;
             for (; i < to; i++) {
-                let nextSize = nodeSize(type, children[i]);
+                let nextSize = nodeSize(balanceType, children[i]);
                 if (groupSize + nextSize >= maxChild)
                     break;
                 groupSize += nextSize;
             }
             if (i == groupFrom + 1) {
                 if (groupSize > maxChild) {
-                    let only = children[groupFrom];
+                    let only = children[groupFrom]; // Only trees can have a size > 1
                     divide(only.children, only.positions, 0, only.children.length, positions[groupFrom] + offset);
                     continue;
                 }
@@ -1127,7 +1134,7 @@ mkTree) {
             }
             else {
                 let length = positions[i - 1] + children[i - 1].length - groupStart;
-                localChildren.push(balanceRange(type, children, positions, groupFrom, i, groupStart, length, null, mkTree));
+                localChildren.push(balanceRange(balanceType, children, positions, groupFrom, i, groupStart, length, null, mkTree));
             }
             localPositions.push(groupStart + offset - start);
         }
@@ -1268,11 +1275,12 @@ function parseMixed(nest) {
     return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
 }
 class InnerParse {
-    constructor(parser, parse, overlay, target) {
+    constructor(parser, parse, overlay, target, ranges) {
         this.parser = parser;
         this.parse = parse;
         this.overlay = overlay;
         this.target = target;
+        this.ranges = ranges;
     }
 }
 class ActiveOverlay {
@@ -1288,6 +1296,7 @@ class ActiveOverlay {
         this.ranges = [];
     }
 }
+const stoppedInner = new NodeProp({ perNode: true });
 class MixedParse {
     constructor(base, nest, input, fragments, ranges) {
         this.nest = nest;
@@ -1309,8 +1318,12 @@ class MixedParse {
             this.baseTree = done;
             this.startInner();
         }
-        if (this.innerDone == this.inner.length)
-            return this.baseTree;
+        if (this.innerDone == this.inner.length) {
+            let result = this.baseTree;
+            if (this.stoppedAt != null)
+                result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
+            return result;
+        }
         let inner = this.inner[this.innerDone], done = inner.parse.advance();
         if (done) {
             this.innerDone++;
@@ -1327,8 +1340,12 @@ class MixedParse {
     get parsedPos() {
         if (this.baseParse)
             return 0;
-        let next = this.inner[this.innerDone];
-        return next ? next.parse.parsedPos : this.input.length;
+        let pos = this.input.length;
+        for (let i = this.innerDone; i < this.inner.length; i++) {
+            if (this.inner[i].ranges[0].from < pos)
+                pos = Math.min(pos, this.inner[i].parse.parsedPos);
+        }
+        return pos;
     }
     stopAt(pos) {
         this.stoppedAt = pos;
@@ -1342,7 +1359,8 @@ class MixedParse {
         let fragmentCursor = new FragmentCursor(this.fragments);
         let overlay = null;
         let covered = null;
-        scan: for (let cursor = this.baseTree.fullCursor(), nest, isCovered;;) {
+        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), 1 /* Full */);
+        scan: for (let nest, isCovered;;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1369,7 +1387,7 @@ class MixedParse {
                 else {
                     let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
                     if (ranges.length)
-                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree));
+                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));
                     if (!nest.overlay)
                         enter = false;
                     else if (ranges.length)
@@ -1397,7 +1415,7 @@ class MixedParse {
                     if (overlay && !--overlay.depth) {
                         let ranges = punchRanges(this.ranges, overlay.ranges);
                         if (ranges.length)
-                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target));
+                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));
                         overlay = overlay.prev;
                     }
                     if (covered && !--covered.depth)
@@ -1482,7 +1500,7 @@ class StructureCursor {
     }
     hasNode(cursor) {
         this.moveTo(cursor.from);
-        if (!this.done && this.cursor.from + this.offset == cursor.from) {
+        if (!this.done && this.cursor.from + this.offset == cursor.from && this.cursor.tree) {
             for (let tree = this.cursor.tree;;) {
                 if (tree == cursor.tree)
                     return true;
@@ -1497,10 +1515,13 @@ class StructureCursor {
 }
 class FragmentCursor {
     constructor(fragments) {
+        var _a;
         this.fragments = fragments;
+        this.curTo = 0;
         this.fragI = 0;
         if (fragments.length) {
             let first = this.curFrag = fragments[0];
+            this.curTo = (_a = first.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : first.to;
             this.inner = new StructureCursor(first.tree, -first.offset);
         }
         else {
@@ -1508,17 +1529,19 @@ class FragmentCursor {
         }
     }
     hasNode(node) {
-        while (this.curFrag && node.from >= this.curFrag.to)
+        while (this.curFrag && node.from >= this.curTo)
             this.nextFrag();
-        return this.curFrag && this.curFrag.from <= node.from && this.curFrag.to >= node.to && this.inner.hasNode(node);
+        return this.curFrag && this.curFrag.from <= node.from && this.curTo >= node.to && this.inner.hasNode(node);
     }
     nextFrag() {
+        var _a;
         this.fragI++;
         if (this.fragI == this.fragments.length) {
             this.curFrag = this.inner = null;
         }
         else {
             let frag = this.curFrag = this.fragments[this.fragI];
+            this.curTo = (_a = frag.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : frag.to;
             this.inner = new StructureCursor(frag.tree, -frag.offset);
         }
     }

package/dist/index.js

@@ -282,7 +282,8 @@ class Tree {
     }
     /// Get a [tree cursor](#common.TreeCursor) that, unlike regular
     /// cursors, doesn't skip through
-    /// [anonymous](#common.NodeType.isAnonymous) nodes.
+    /// [anonymous](#common.NodeType.isAnonymous) nodes and doesn't
+    /// automatically enter mounted nodes.
     fullCursor() {
         return new TreeCursor(this.topNode, 1 /* Full */);
     }
@@ -360,7 +361,7 @@ class Tree {
     /// [`NodeType.none`](#common.NodeType^none).
     balance(config = {}) {
         return this.children.length <= 8 /* BranchFactor */ ? this :
-            balanceRange(this.type, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
+            balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
     }
     /// Build a tree from a postfix-ordered buffer of node information,
     /// or a cursor over such a buffer.
@@ -504,7 +505,7 @@ class TreeNode {
                 }
                 else if ((mode & 1 /* Full */) || (!next.type.isAnonymous || hasChild(next))) {
                     let mounted;
-                    if (next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
+                    if (!(mode & 1 /* Full */) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
                         return new TreeNode(mounted.tree, start, i, parent);
                     let inner = new TreeNode(next, start, i, parent);
                     return (mode & 1 /* Full */) || !inner.type.isAnonymous ? inner
@@ -752,10 +753,10 @@ class TreeCursor {
     /// set to false.
     enter(pos, side, overlays = true, buffers = true) {
         if (!this.buffer)
-            return this.yield(this._tree.enter(pos, side, overlays, buffers));
+            return this.yield(this._tree.enter(pos, side, overlays && !(this.mode & 1 /* Full */), buffers));
         return buffers ? this.enterChild(1, pos, side) : false;
     }
-    /// Move the node's parent node, if this isn't the top node.
+    /// Move to the node's parent node, if this isn't the top node.
     parent() {
         if (!this.buffer)
             return this.yieldNode((this.mode & 1 /* Full */) ? this._tree._parent : this._tree.parent);
@@ -1077,15 +1078,21 @@ function nodeSize(balanceType, node) {
         return 1;
     let size = nodeSizeCache.get(node);
     if (size == null) {
-        size = node.children.reduce((s, ch) => s + nodeSize(balanceType, ch), 1);
+        size = 1;
+        for (let child of node.children) {
+            if (child.type != balanceType || !(child instanceof Tree)) {
+                size = 1;
+                break;
+            }
+            size += nodeSize(balanceType, child);
+        }
         nodeSizeCache.set(node, size);
     }
     return size;
 }
 function balanceRange(
-// The type to tag the resulting tree with. Will also be used for
-// internal nodes when it is an anonymous type
-type, 
+// The type the balanced tree's inner nodes.
+balanceType, 
 // The direct children and their positions
 children, positions, 
 // The index range in children/positions to use
@@ -1100,22 +1107,22 @@ mkTop,
 mkTree) {
     let total = 0;
     for (let i = from; i < to; i++)
-        total += nodeSize(type, children[i]);
+        total += nodeSize(balanceType, children[i]);
     let maxChild = Math.ceil((total * 1.5) / 8 /* BranchFactor */);
     let localChildren = [], localPositions = [];
     function divide(children, positions, from, to, offset) {
         for (let i = from; i < to;) {
-            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(type, children[i]);
+            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(balanceType, children[i]);
             i++;
             for (; i < to; i++) {
-                let nextSize = nodeSize(type, children[i]);
+                let nextSize = nodeSize(balanceType, children[i]);
                 if (groupSize + nextSize >= maxChild)
                     break;
                 groupSize += nextSize;
             }
             if (i == groupFrom + 1) {
                 if (groupSize > maxChild) {
-                    let only = children[groupFrom];
+                    let only = children[groupFrom]; // Only trees can have a size > 1
                     divide(only.children, only.positions, 0, only.children.length, positions[groupFrom] + offset);
                     continue;
                 }
@@ -1123,7 +1130,7 @@ mkTree) {
             }
             else {
                 let length = positions[i - 1] + children[i - 1].length - groupStart;
-                localChildren.push(balanceRange(type, children, positions, groupFrom, i, groupStart, length, null, mkTree));
+                localChildren.push(balanceRange(balanceType, children, positions, groupFrom, i, groupStart, length, null, mkTree));
             }
             localPositions.push(groupStart + offset - start);
         }
@@ -1264,11 +1271,12 @@ function parseMixed(nest) {
     return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
 }
 class InnerParse {
-    constructor(parser, parse, overlay, target) {
+    constructor(parser, parse, overlay, target, ranges) {
         this.parser = parser;
         this.parse = parse;
         this.overlay = overlay;
         this.target = target;
+        this.ranges = ranges;
     }
 }
 class ActiveOverlay {
@@ -1284,6 +1292,7 @@ class ActiveOverlay {
         this.ranges = [];
     }
 }
+const stoppedInner = new NodeProp({ perNode: true });
 class MixedParse {
     constructor(base, nest, input, fragments, ranges) {
         this.nest = nest;
@@ -1305,8 +1314,12 @@ class MixedParse {
             this.baseTree = done;
             this.startInner();
         }
-        if (this.innerDone == this.inner.length)
-            return this.baseTree;
+        if (this.innerDone == this.inner.length) {
+            let result = this.baseTree;
+            if (this.stoppedAt != null)
+                result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
+            return result;
+        }
         let inner = this.inner[this.innerDone], done = inner.parse.advance();
         if (done) {
             this.innerDone++;
@@ -1323,8 +1336,12 @@ class MixedParse {
     get parsedPos() {
         if (this.baseParse)
             return 0;
-        let next = this.inner[this.innerDone];
-        return next ? next.parse.parsedPos : this.input.length;
+        let pos = this.input.length;
+        for (let i = this.innerDone; i < this.inner.length; i++) {
+            if (this.inner[i].ranges[0].from < pos)
+                pos = Math.min(pos, this.inner[i].parse.parsedPos);
+        }
+        return pos;
     }
     stopAt(pos) {
         this.stoppedAt = pos;
@@ -1338,7 +1355,8 @@ class MixedParse {
         let fragmentCursor = new FragmentCursor(this.fragments);
         let overlay = null;
         let covered = null;
-        scan: for (let cursor = this.baseTree.fullCursor(), nest, isCovered;;) {
+        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), 1 /* Full */);
+        scan: for (let nest, isCovered;;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1365,7 +1383,7 @@ class MixedParse {
                 else {
                     let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
                     if (ranges.length)
-                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree));
+                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));
                     if (!nest.overlay)
                         enter = false;
                     else if (ranges.length)
@@ -1393,7 +1411,7 @@ class MixedParse {
                     if (overlay && !--overlay.depth) {
                         let ranges = punchRanges(this.ranges, overlay.ranges);
                         if (ranges.length)
-                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target));
+                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));
                         overlay = overlay.prev;
                     }
                     if (covered && !--covered.depth)
@@ -1478,7 +1496,7 @@ class StructureCursor {
     }
     hasNode(cursor) {
         this.moveTo(cursor.from);
-        if (!this.done && this.cursor.from + this.offset == cursor.from) {
+        if (!this.done && this.cursor.from + this.offset == cursor.from && this.cursor.tree) {
             for (let tree = this.cursor.tree;;) {
                 if (tree == cursor.tree)
                     return true;
@@ -1493,10 +1511,13 @@ class StructureCursor {
 }
 class FragmentCursor {
     constructor(fragments) {
+        var _a;
         this.fragments = fragments;
+        this.curTo = 0;
         this.fragI = 0;
         if (fragments.length) {
             let first = this.curFrag = fragments[0];
+            this.curTo = (_a = first.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : first.to;
             this.inner = new StructureCursor(first.tree, -first.offset);
         }
         else {
@@ -1504,17 +1525,19 @@ class FragmentCursor {
         }
     }
     hasNode(node) {
-        while (this.curFrag && node.from >= this.curFrag.to)
+        while (this.curFrag && node.from >= this.curTo)
             this.nextFrag();
-        return this.curFrag && this.curFrag.from <= node.from && this.curFrag.to >= node.to && this.inner.hasNode(node);
+        return this.curFrag && this.curFrag.from <= node.from && this.curTo >= node.to && this.inner.hasNode(node);
     }
     nextFrag() {
+        var _a;
         this.fragI++;
         if (this.fragI == this.fragments.length) {
             this.curFrag = this.inner = null;
         }
         else {
             let frag = this.curFrag = this.fragments[this.fragI];
+            this.curTo = (_a = frag.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : frag.to;
             this.inner = new StructureCursor(frag.tree, -frag.offset);
         }
     }

package/dist/tree.d.ts

@@ -134,6 +134,80 @@ export interface SyntaxNode {
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode | null;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
 }
+declare const enum Side {
+    Before = -2,
+    AtOrBefore = -1,
+    Around = 0,
+    AtOrAfter = 1,
+    After = 2,
+    DontCare = 4
+}
+export declare const enum Mode {
+    Full = 1,
+    NoEnterBuffer = 2
+}
+export declare class TreeNode implements SyntaxNode {
+    readonly node: Tree;
+    readonly _from: number;
+    readonly index: number;
+    readonly _parent: TreeNode | null;
+    constructor(node: Tree, _from: number, index: number, _parent: TreeNode | null);
+    get type(): NodeType;
+    get name(): string;
+    get from(): number;
+    get to(): number;
+    nextChild(i: number, dir: 1 | -1, pos: number, side: Side, mode?: Mode): TreeNode | BufferNode | null;
+    get firstChild(): TreeNode | BufferNode;
+    get lastChild(): TreeNode | BufferNode;
+    childAfter(pos: number): TreeNode | BufferNode;
+    childBefore(pos: number): TreeNode | BufferNode;
+    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): TreeNode | BufferNode;
+    nextSignificantParent(): TreeNode;
+    get parent(): TreeNode;
+    get nextSibling(): TreeNode | BufferNode;
+    get prevSibling(): TreeNode | BufferNode;
+    get cursor(): TreeCursor;
+    get tree(): Tree;
+    toTree(): Tree;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    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[];
+}
+declare class BufferContext {
+    readonly parent: TreeNode;
+    readonly buffer: TreeBuffer;
+    readonly index: number;
+    readonly start: number;
+    constructor(parent: TreeNode, buffer: TreeBuffer, index: number, start: number);
+}
+declare class BufferNode implements SyntaxNode {
+    readonly context: BufferContext;
+    readonly _parent: BufferNode | null;
+    readonly index: number;
+    type: NodeType;
+    get name(): string;
+    get from(): number;
+    get to(): number;
+    constructor(context: BufferContext, _parent: BufferNode | null, index: number);
+    child(dir: 1 | -1, pos: number, side: Side): BufferNode | null;
+    get firstChild(): BufferNode;
+    get lastChild(): BufferNode;
+    childAfter(pos: number): BufferNode;
+    childBefore(pos: number): BufferNode;
+    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): BufferNode;
+    get parent(): TreeNode | BufferNode;
+    externalSibling(dir: 1 | -1): TreeNode | BufferNode;
+    get nextSibling(): SyntaxNode | null;
+    get prevSibling(): SyntaxNode | null;
+    get cursor(): TreeCursor;
+    get tree(): any;
+    toTree(): Tree;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    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[];
+}
 export declare class TreeCursor {
     type: NodeType;
     get name(): string;

package/package.json

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