@lezer/common 1.1.0 → 1.1.2

package/dist/index.cjs

@@ -885,8 +885,6 @@ class BufferNode extends BaseNode {
 function iterStack(heads) {
     if (!heads.length)
         return null;
-    if (heads.length == 1)
-        return heads[0];
     let pick = 0, picked = heads[0];
     for (let i = 1; i < heads.length; i++) {
         let node = heads[i];
@@ -922,7 +920,7 @@ function stackIterator(tree, pos, side) {
             let mount = MountedTree.get(scan.tree);
             // Relevant overlay branching off
             if (mount && mount.overlay && mount.overlay[0].from <= pos && mount.overlay[mount.overlay.length - 1].to >= pos) {
-                let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, 0, null);
+                let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, -1, scan);
                 (layers || (layers = [inner])).push(resolveNode(root, pos, side, false));
             }
         }
@@ -986,6 +984,9 @@ class TreeCursor {
         this.to = start + buffer.buffer[index + 2];
         return true;
     }
+    /**
+    @internal
+    */
     yield(node) {
         if (!node)
             return false;
@@ -1251,7 +1252,7 @@ function buildTree(data) {
     let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
     let types = nodeSet.types;
     let contextHash = 0, lookAhead = 0;
-    function takeNode(parentStart, minPos, children, positions, inRepeat) {
+    function takeNode(parentStart, minPos, children, positions, inRepeat, depth) {
         let { id, start, end, size } = cursor;
         let lookAheadAtStart = lookAhead;
         while (size < 0) {
@@ -1300,8 +1301,11 @@ function buildTree(data) {
                     }
                     cursor.next();
                 }
+                else if (depth > 2500 /* CutOff.Depth */) {
+                    takeFlatNode(start, endPos, localChildren, localPositions);
+                }
                 else {
-                    takeNode(start, endPos, localChildren, localPositions, localInRepeat);
+                    takeNode(start, endPos, localChildren, localPositions, localInRepeat, depth + 1);
                 }
             }
             if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
@@ -1319,6 +1323,38 @@ function buildTree(data) {
         children.push(node);
         positions.push(startPos);
     }
+    function takeFlatNode(parentStart, minPos, children, positions) {
+        let nodes = []; // Temporary, inverted array of leaf nodes found, with absolute positions
+        let nodeCount = 0, stopAt = -1;
+        while (cursor.pos > minPos) {
+            let { id, start, end, size } = cursor;
+            if (size > 4) { // Not a leaf
+                cursor.next();
+            }
+            else if (stopAt > -1 && start < stopAt) {
+                break;
+            }
+            else {
+                if (stopAt < 0)
+                    stopAt = end - maxBufferLength;
+                nodes.push(id, start, end);
+                nodeCount++;
+                cursor.next();
+            }
+        }
+        if (nodeCount) {
+            let buffer = new Uint16Array(nodeCount * 4);
+            let start = nodes[nodes.length - 2];
+            for (let i = nodes.length - 3, j = 0; i >= 0; i -= 3) {
+                buffer[j++] = nodes[i];
+                buffer[j++] = nodes[i + 1] - start;
+                buffer[j++] = nodes[i + 2] - start;
+                buffer[j++] = j;
+            }
+            children.push(new TreeBuffer(buffer, nodes[2] - start, nodeSet));
+            positions.push(start - parentStart);
+        }
+    }
     function makeBalanced(type) {
         return (children, positions, length) => {
             let lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;
@@ -1429,7 +1465,7 @@ function buildTree(data) {
     }
     let children = [], positions = [];
     while (cursor.pos > 0)
-        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
+        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1, 0);
     let length = (_a = data.length) !== null && _a !== void 0 ? _a : (children.length ? positions[0] + children[0].length : 0);
     return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
 }
@@ -1710,16 +1746,18 @@ function parseMixed(nest) {
     return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
 }
 class InnerParse {
-    constructor(parser, parse, overlay, target, ranges) {
+    constructor(parser, parse, overlay, target, from) {
         this.parser = parser;
         this.parse = parse;
         this.overlay = overlay;
         this.target = target;
-        this.ranges = ranges;
-        if (!ranges.length || ranges.some(r => r.from >= r.to))
-            throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
+        this.from = from;
     }
 }
+function checkRanges(ranges) {
+    if (!ranges.length || ranges.some(r => r.from >= r.to))
+        throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
+}
 class ActiveOverlay {
     constructor(parser, predicate, mounts, index, start, target, prev) {
         this.parser = parser;
@@ -1782,7 +1820,7 @@ class MixedParse {
             return 0;
         let pos = this.input.length;
         for (let i = this.innerDone; i < this.inner.length; i++) {
-            if (this.inner[i].ranges[0].from < pos)
+            if (this.inner[i].from < pos)
                 pos = Math.min(pos, this.inner[i].parse.parsedPos);
         }
         return pos;
@@ -1800,9 +1838,12 @@ class MixedParse {
         let overlay = null;
         let covered = null;
         let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), exports.IterMode.IncludeAnonymous | exports.IterMode.IgnoreMounts);
-        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
+        scan: for (let nest, isCovered;;) {
             let enter = true, range;
-            if (fragmentCursor.hasNode(cursor)) {
+            if (this.stoppedAt != null && cursor.from >= this.stoppedAt) {
+                enter = false;
+            }
+            else if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
                     let match = overlay.mounts.find(m => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
                     if (match)
@@ -1817,7 +1858,8 @@ class MixedParse {
             else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
                 enter = isCovered != 2 /* Cover.Full */;
             }
-            else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
+            else if (!cursor.type.isAnonymous && (nest = this.nest(cursor, this.input)) &&
+                (cursor.from < cursor.to || !nest.overlay)) {
                 if (!cursor.tree)
                     materialize(cursor);
                 let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
@@ -1825,9 +1867,13 @@ class MixedParse {
                     overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);
                 }
                 else {
-                    let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
+                    let ranges = punchRanges(this.ranges, nest.overlay ||
+                        (cursor.from < cursor.to ? [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, ranges));
+                        checkRanges(ranges);
+                    if (ranges.length || !nest.overlay)
+                        this.inner.push(new InnerParse(nest.parser, ranges.length ? nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges)
+                            : nest.parser.startParse(""), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges.length ? ranges[0].from : cursor.from));
                     if (!nest.overlay)
                         enter = false;
                     else if (ranges.length)
@@ -1854,8 +1900,10 @@ class MixedParse {
                         break scan;
                     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, ranges));
+                        if (ranges.length) {
+                            checkRanges(ranges);
+                            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[0].from));
+                        }
                         overlay = overlay.prev;
                     }
                     if (covered && !--covered.depth)
@@ -1889,39 +1937,38 @@ function sliceBuf(buf, startI, endI, nodes, positions, off) {
 // parse that was ran via the mix parser, and thus aren't shared with
 // any other code, making violations of the immutability safe.
 function materialize(cursor) {
-    let { node } = cursor, depth = 0;
+    let { node } = cursor, stack = [];
+    let buffer = node.context.buffer;
     // Scan up to the nearest tree
     do {
+        stack.push(cursor.index);
         cursor.parent();
-        depth++;
     } while (!cursor.tree);
     // Find the index of the buffer in that tree
-    let i = 0, base = cursor.tree, off = 0;
-    for (;; i++) {
-        off = base.positions[i] + cursor.from;
-        if (off <= node.from && off + base.children[i].length >= node.to)
-            break;
-    }
-    let buf = base.children[i], b = buf.buffer;
+    let base = cursor.tree, i = base.children.indexOf(buffer);
+    let buf = base.children[i], b = buf.buffer, newStack = [i];
     // 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, length) {
-        let i = startI;
-        while (b[i + 2] + off <= node.from)
-            i = b[i + 3];
+    function split(startI, endI, type, innerOffset, length, stackPos) {
+        let targetI = stack[stackPos];
         let children = [], positions = [];
-        sliceBuf(buf, startI, i, children, positions, 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));
+        sliceBuf(buf, startI, targetI, children, positions, innerOffset);
+        let from = b[targetI + 1], to = b[targetI + 2];
+        newStack.push(children.length);
+        let child = stackPos
+            ? split(targetI + 4, b[targetI + 3], buf.set.types[b[targetI]], from, to - from, stackPos - 1)
+            : node.toTree();
+        children.push(child);
         positions.push(from - innerOffset);
-        sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
+        sliceBuf(buf, b[targetI + 3], endI, children, positions, innerOffset);
         return new Tree(type, children, positions, length);
     }
-    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
+    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length, stack.length - 1);
     // Move the cursor back to the target node
-    for (let d = 0; d <= depth; d++)
-        cursor.childAfter(node.from);
+    for (let index of newStack) {
+        let tree = cursor.tree.children[index], pos = cursor.tree.positions[index];
+        cursor.yield(new TreeNode(tree, pos + cursor.from, index, cursor._tree));
+    }
 }
 class StructureCursor {
     constructor(root, offset) {

package/dist/index.d.cts

@@ -964,7 +964,6 @@ declare class TreeCursor implements SyntaxNodeRef {
     private bufferNode;
     private yieldNode;
     private yieldBuf;
-    private yield;
     /**
     Move the cursor to this node's first child. When this returns
     false, the node has no child, and the cursor has not been moved.

package/dist/index.d.ts

@@ -964,7 +964,6 @@ declare class TreeCursor implements SyntaxNodeRef {
     private bufferNode;
     private yieldNode;
     private yieldBuf;
-    private yield;
     /**
     Move the cursor to this node's first child. When this returns
     false, the node has no child, and the cursor has not been moved.

package/dist/index.js

@@ -883,8 +883,6 @@ class BufferNode extends BaseNode {
 function iterStack(heads) {
     if (!heads.length)
         return null;
-    if (heads.length == 1)
-        return heads[0];
     let pick = 0, picked = heads[0];
     for (let i = 1; i < heads.length; i++) {
         let node = heads[i];
@@ -920,7 +918,7 @@ function stackIterator(tree, pos, side) {
             let mount = MountedTree.get(scan.tree);
             // Relevant overlay branching off
             if (mount && mount.overlay && mount.overlay[0].from <= pos && mount.overlay[mount.overlay.length - 1].to >= pos) {
-                let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, 0, null);
+                let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, -1, scan);
                 (layers || (layers = [inner])).push(resolveNode(root, pos, side, false));
             }
         }
@@ -984,6 +982,9 @@ class TreeCursor {
         this.to = start + buffer.buffer[index + 2];
         return true;
     }
+    /**
+    @internal
+    */
     yield(node) {
         if (!node)
             return false;
@@ -1249,7 +1250,7 @@ function buildTree(data) {
     let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
     let types = nodeSet.types;
     let contextHash = 0, lookAhead = 0;
-    function takeNode(parentStart, minPos, children, positions, inRepeat) {
+    function takeNode(parentStart, minPos, children, positions, inRepeat, depth) {
         let { id, start, end, size } = cursor;
         let lookAheadAtStart = lookAhead;
         while (size < 0) {
@@ -1298,8 +1299,11 @@ function buildTree(data) {
                     }
                     cursor.next();
                 }
+                else if (depth > 2500 /* CutOff.Depth */) {
+                    takeFlatNode(start, endPos, localChildren, localPositions);
+                }
                 else {
-                    takeNode(start, endPos, localChildren, localPositions, localInRepeat);
+                    takeNode(start, endPos, localChildren, localPositions, localInRepeat, depth + 1);
                 }
             }
             if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
@@ -1317,6 +1321,38 @@ function buildTree(data) {
         children.push(node);
         positions.push(startPos);
     }
+    function takeFlatNode(parentStart, minPos, children, positions) {
+        let nodes = []; // Temporary, inverted array of leaf nodes found, with absolute positions
+        let nodeCount = 0, stopAt = -1;
+        while (cursor.pos > minPos) {
+            let { id, start, end, size } = cursor;
+            if (size > 4) { // Not a leaf
+                cursor.next();
+            }
+            else if (stopAt > -1 && start < stopAt) {
+                break;
+            }
+            else {
+                if (stopAt < 0)
+                    stopAt = end - maxBufferLength;
+                nodes.push(id, start, end);
+                nodeCount++;
+                cursor.next();
+            }
+        }
+        if (nodeCount) {
+            let buffer = new Uint16Array(nodeCount * 4);
+            let start = nodes[nodes.length - 2];
+            for (let i = nodes.length - 3, j = 0; i >= 0; i -= 3) {
+                buffer[j++] = nodes[i];
+                buffer[j++] = nodes[i + 1] - start;
+                buffer[j++] = nodes[i + 2] - start;
+                buffer[j++] = j;
+            }
+            children.push(new TreeBuffer(buffer, nodes[2] - start, nodeSet));
+            positions.push(start - parentStart);
+        }
+    }
     function makeBalanced(type) {
         return (children, positions, length) => {
             let lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;
@@ -1427,7 +1463,7 @@ function buildTree(data) {
     }
     let children = [], positions = [];
     while (cursor.pos > 0)
-        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
+        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1, 0);
     let length = (_a = data.length) !== null && _a !== void 0 ? _a : (children.length ? positions[0] + children[0].length : 0);
     return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
 }
@@ -1708,16 +1744,18 @@ function parseMixed(nest) {
     return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
 }
 class InnerParse {
-    constructor(parser, parse, overlay, target, ranges) {
+    constructor(parser, parse, overlay, target, from) {
         this.parser = parser;
         this.parse = parse;
         this.overlay = overlay;
         this.target = target;
-        this.ranges = ranges;
-        if (!ranges.length || ranges.some(r => r.from >= r.to))
-            throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
+        this.from = from;
     }
 }
+function checkRanges(ranges) {
+    if (!ranges.length || ranges.some(r => r.from >= r.to))
+        throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges));
+}
 class ActiveOverlay {
     constructor(parser, predicate, mounts, index, start, target, prev) {
         this.parser = parser;
@@ -1780,7 +1818,7 @@ class MixedParse {
             return 0;
         let pos = this.input.length;
         for (let i = this.innerDone; i < this.inner.length; i++) {
-            if (this.inner[i].ranges[0].from < pos)
+            if (this.inner[i].from < pos)
                 pos = Math.min(pos, this.inner[i].parse.parsedPos);
         }
         return pos;
@@ -1798,9 +1836,12 @@ class MixedParse {
         let overlay = null;
         let covered = null;
         let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
-        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
+        scan: for (let nest, isCovered;;) {
             let enter = true, range;
-            if (fragmentCursor.hasNode(cursor)) {
+            if (this.stoppedAt != null && cursor.from >= this.stoppedAt) {
+                enter = false;
+            }
+            else if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
                     let match = overlay.mounts.find(m => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
                     if (match)
@@ -1815,7 +1856,8 @@ class MixedParse {
             else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
                 enter = isCovered != 2 /* Cover.Full */;
             }
-            else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
+            else if (!cursor.type.isAnonymous && (nest = this.nest(cursor, this.input)) &&
+                (cursor.from < cursor.to || !nest.overlay)) {
                 if (!cursor.tree)
                     materialize(cursor);
                 let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
@@ -1823,9 +1865,13 @@ class MixedParse {
                     overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);
                 }
                 else {
-                    let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
+                    let ranges = punchRanges(this.ranges, nest.overlay ||
+                        (cursor.from < cursor.to ? [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, ranges));
+                        checkRanges(ranges);
+                    if (ranges.length || !nest.overlay)
+                        this.inner.push(new InnerParse(nest.parser, ranges.length ? nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges)
+                            : nest.parser.startParse(""), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges.length ? ranges[0].from : cursor.from));
                     if (!nest.overlay)
                         enter = false;
                     else if (ranges.length)
@@ -1852,8 +1898,10 @@ class MixedParse {
                         break scan;
                     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, ranges));
+                        if (ranges.length) {
+                            checkRanges(ranges);
+                            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[0].from));
+                        }
                         overlay = overlay.prev;
                     }
                     if (covered && !--covered.depth)
@@ -1887,39 +1935,38 @@ function sliceBuf(buf, startI, endI, nodes, positions, off) {
 // parse that was ran via the mix parser, and thus aren't shared with
 // any other code, making violations of the immutability safe.
 function materialize(cursor) {
-    let { node } = cursor, depth = 0;
+    let { node } = cursor, stack = [];
+    let buffer = node.context.buffer;
     // Scan up to the nearest tree
     do {
+        stack.push(cursor.index);
         cursor.parent();
-        depth++;
     } while (!cursor.tree);
     // Find the index of the buffer in that tree
-    let i = 0, base = cursor.tree, off = 0;
-    for (;; i++) {
-        off = base.positions[i] + cursor.from;
-        if (off <= node.from && off + base.children[i].length >= node.to)
-            break;
-    }
-    let buf = base.children[i], b = buf.buffer;
+    let base = cursor.tree, i = base.children.indexOf(buffer);
+    let buf = base.children[i], b = buf.buffer, newStack = [i];
     // 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, length) {
-        let i = startI;
-        while (b[i + 2] + off <= node.from)
-            i = b[i + 3];
+    function split(startI, endI, type, innerOffset, length, stackPos) {
+        let targetI = stack[stackPos];
         let children = [], positions = [];
-        sliceBuf(buf, startI, i, children, positions, 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));
+        sliceBuf(buf, startI, targetI, children, positions, innerOffset);
+        let from = b[targetI + 1], to = b[targetI + 2];
+        newStack.push(children.length);
+        let child = stackPos
+            ? split(targetI + 4, b[targetI + 3], buf.set.types[b[targetI]], from, to - from, stackPos - 1)
+            : node.toTree();
+        children.push(child);
         positions.push(from - innerOffset);
-        sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
+        sliceBuf(buf, b[targetI + 3], endI, children, positions, innerOffset);
         return new Tree(type, children, positions, length);
     }
-    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
+    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length, stack.length - 1);
     // Move the cursor back to the target node
-    for (let d = 0; d <= depth; d++)
-        cursor.childAfter(node.from);
+    for (let index of newStack) {
+        let tree = cursor.tree.children[index], pos = cursor.tree.positions[index];
+        cursor.yield(new TreeNode(tree, pos + cursor.from, index, cursor._tree));
+    }
 }
 class StructureCursor {
     constructor(root, offset) {

package/package.json

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