@lezer/common 0.15.6 → 0.15.10

package/dist/index.cjs

@@ -213,7 +213,7 @@ class NodeSet {
         return new NodeSet(newTypes);
     }
 }
-const CachedNode = new WeakMap();
+const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();
 /// A piece of syntax tree. There are two ways to approach these
 /// trees: the way they are actually stored in memory, and the
 /// convenient way.
@@ -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 */);
     }
@@ -301,7 +302,9 @@ class Tree {
     /// position. With 0, it'll only enter nodes that cover the position
     /// from both sides.
     resolve(pos, side = 0) {
-        return this.cursor(pos, side).node;
+        let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
+        CachedNode.set(this, node);
+        return node;
     }
     /// Like [`resolve`](#common.Tree.resolve), but will enter
     /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
@@ -309,13 +312,9 @@ class Tree {
     /// (with parent links going through all parent structure, including
     /// the host trees).
     resolveInner(pos, side = 0) {
-        let result = this.topNode;
-        for (;;) {
-            let inner = result.enter(pos, side);
-            if (!inner)
-                return result;
-            result = inner;
-        }
+        let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
+        CachedInnerNode.set(this, node);
+        return node;
     }
     /// Iterate over the tree and its children, calling `enter` for any
     /// node that touches the `from`/`to` region (if given) before
@@ -364,7 +363,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.
@@ -480,6 +479,30 @@ function enterUnfinishedNodesBefore(node, pos) {
     }
     return node;
 }
+function resolveNode(node, pos, side, overlays) {
+    var _a;
+    // Move up to a node that actually holds the position, if possible
+    while (node.from == node.to ||
+        (side < 1 ? node.from >= pos : node.from > pos) ||
+        (side > -1 ? node.to <= pos : node.to < pos)) {
+        let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
+        if (!parent)
+            return node;
+        node = parent;
+    }
+    // Must go up out of overlays when those do not overlap with pos
+    if (overlays)
+        for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
+            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, true)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
+                node = parent;
+        }
+    for (;;) {
+        let inner = node.enter(pos, side, overlays);
+        if (!inner)
+            return node;
+        node = inner;
+    }
+}
 class TreeNode {
     constructor(node, _from, 
     // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
@@ -508,7 +531,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
@@ -561,7 +584,10 @@ class TreeNode {
     get tree() { return this.node; }
     toTree() { return this.node; }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     getChild(type, before = null, after = null) {
@@ -659,7 +685,10 @@ class BufferNode {
         return new Tree(this.type, children, positions, this.to - this.from);
     }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     /// @internal
@@ -756,10 +785,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 +1110,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 +1139,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 +1162,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 +1303,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 +1324,7 @@ class ActiveOverlay {
         this.ranges = [];
     }
 }
+const stoppedInner = new NodeProp({ perNode: true });
 class MixedParse {
     constructor(base, nest, input, fragments, ranges) {
         this.nest = nest;
@@ -1308,9 +1345,16 @@ class MixedParse {
             this.baseParse = null;
             this.baseTree = done;
             this.startInner();
+            if (this.stoppedAt != null)
+                for (let inner of this.inner)
+                    inner.parse.stopAt(this.stoppedAt);
+        }
+        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;
         }
-        if (this.innerDone == this.inner.length)
-            return this.baseTree;
         let inner = this.inner[this.innerDone], done = inner.parse.advance();
         if (done) {
             this.innerDone++;
@@ -1327,8 +1371,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 +1390,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; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1369,7 +1418,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 +1446,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)
@@ -1497,10 +1546,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 +1560,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

@@ -209,7 +209,7 @@ class NodeSet {
         return new NodeSet(newTypes);
     }
 }
-const CachedNode = new WeakMap();
+const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();
 /// A piece of syntax tree. There are two ways to approach these
 /// trees: the way they are actually stored in memory, and the
 /// convenient way.
@@ -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 */);
     }
@@ -297,7 +298,9 @@ class Tree {
     /// position. With 0, it'll only enter nodes that cover the position
     /// from both sides.
     resolve(pos, side = 0) {
-        return this.cursor(pos, side).node;
+        let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
+        CachedNode.set(this, node);
+        return node;
     }
     /// Like [`resolve`](#common.Tree.resolve), but will enter
     /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
@@ -305,13 +308,9 @@ class Tree {
     /// (with parent links going through all parent structure, including
     /// the host trees).
     resolveInner(pos, side = 0) {
-        let result = this.topNode;
-        for (;;) {
-            let inner = result.enter(pos, side);
-            if (!inner)
-                return result;
-            result = inner;
-        }
+        let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
+        CachedInnerNode.set(this, node);
+        return node;
     }
     /// Iterate over the tree and its children, calling `enter` for any
     /// node that touches the `from`/`to` region (if given) before
@@ -360,7 +359,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.
@@ -476,6 +475,30 @@ function enterUnfinishedNodesBefore(node, pos) {
     }
     return node;
 }
+function resolveNode(node, pos, side, overlays) {
+    var _a;
+    // Move up to a node that actually holds the position, if possible
+    while (node.from == node.to ||
+        (side < 1 ? node.from >= pos : node.from > pos) ||
+        (side > -1 ? node.to <= pos : node.to < pos)) {
+        let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
+        if (!parent)
+            return node;
+        node = parent;
+    }
+    // Must go up out of overlays when those do not overlap with pos
+    if (overlays)
+        for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
+            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, true)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
+                node = parent;
+        }
+    for (;;) {
+        let inner = node.enter(pos, side, overlays);
+        if (!inner)
+            return node;
+        node = inner;
+    }
+}
 class TreeNode {
     constructor(node, _from, 
     // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
@@ -504,7 +527,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
@@ -557,7 +580,10 @@ class TreeNode {
     get tree() { return this.node; }
     toTree() { return this.node; }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     getChild(type, before = null, after = null) {
@@ -655,7 +681,10 @@ class BufferNode {
         return new Tree(this.type, children, positions, this.to - this.from);
     }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     /// @internal
@@ -752,10 +781,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 +1106,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 +1135,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 +1158,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 +1299,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 +1320,7 @@ class ActiveOverlay {
         this.ranges = [];
     }
 }
+const stoppedInner = new NodeProp({ perNode: true });
 class MixedParse {
     constructor(base, nest, input, fragments, ranges) {
         this.nest = nest;
@@ -1304,9 +1341,16 @@ class MixedParse {
             this.baseParse = null;
             this.baseTree = done;
             this.startInner();
+            if (this.stoppedAt != null)
+                for (let inner of this.inner)
+                    inner.parse.stopAt(this.stoppedAt);
+        }
+        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;
         }
-        if (this.innerDone == this.inner.length)
-            return this.baseTree;
         let inner = this.inner[this.innerDone], done = inner.parse.advance();
         if (done) {
             this.innerDone++;
@@ -1323,8 +1367,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 +1386,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; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1365,7 +1414,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 +1442,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)
@@ -1493,10 +1542,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 +1556,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);
         }
     }