@lezer/common 0.15.9 → 0.15.12

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.
@@ -302,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
@@ -310,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
@@ -481,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)
@@ -562,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) {
@@ -660,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
@@ -1317,6 +1345,9 @@ 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;
@@ -1360,7 +1391,7 @@ class MixedParse {
         let overlay = null;
         let covered = null;
         let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), 1 /* Full */);
-        scan: for (let nest, isCovered;;) {
+        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1368,7 +1399,7 @@ class MixedParse {
                     if (match)
                         for (let r of match.mount.overlay) {
                             let from = r.from + match.pos, to = r.to + match.pos;
-                            if (from >= cursor.from && to <= cursor.to)
+                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))
                                 overlay.ranges.push({ from, to });
                         }
                 }
@@ -1465,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

@@ -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.
@@ -298,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
@@ -306,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
@@ -477,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)
@@ -558,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) {
@@ -656,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
@@ -1313,6 +1341,9 @@ 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;
@@ -1356,7 +1387,7 @@ class MixedParse {
         let overlay = null;
         let covered = null;
         let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), 1 /* Full */);
-        scan: for (let nest, isCovered;;) {
+        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
                 if (overlay) {
@@ -1364,7 +1395,7 @@ class MixedParse {
                     if (match)
                         for (let r of match.mount.overlay) {
                             let from = r.from + match.pos, to = r.to + match.pos;
-                            if (from >= cursor.from && to <= cursor.to)
+                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))
                                 overlay.ranges.push({ from, to });
                         }
                 }
@@ -1461,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

@@ -128,6 +128,7 @@ export interface SyntaxNode {
     prevSibling: SyntaxNode | null;
     cursor: TreeCursor;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     tree: Tree | null;
     toTree(): Tree;
@@ -170,6 +171,7 @@ export declare class TreeNode implements SyntaxNode {
     get tree(): Tree;
     toTree(): Tree;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(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[];
@@ -204,6 +206,7 @@ declare class BufferNode implements SyntaxNode {
     get tree(): any;
     toTree(): Tree;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(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[];

package/package.json

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

package/dist/composite.d.ts

@@ -1,42 +0,0 @@
-import { Tree, SyntaxNode } from "./tree";
-import { Parser, PartialParse, TreeFragment, Input } from "./parse";
-export declare class SubtreeRange {
-    constructor(from: number, to: number, parser: Parser, cont?: any);
-}
-export declare class CompositeParser extends Parser {
-    private subtreeRanges;
-    private subtreeCache;
-    constructor(main: Parser, subtreeRanges: {
-        [nodeID: number]: (node: SyntaxNode, input: Input) => (readonly SubtreeRange[] | null);
-    });
-    startParseInner(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
-        from: number;
-        to: number;
-    }[]): CompositeParse;
-}
-declare class CompositeParse implements PartialParse {
-    readonly input: Input;
-    readonly fragments: readonly TreeFragment[];
-    readonly ranges: readonly {
-        from: number;
-        to: number;
-    }[];
-    readonly parser: CompositeParser;
-    main: PartialParse;
-    mainResult: Tree | null;
-    mainSub: Tree[];
-    inner: PartialParse[];
-    subtrees: Tree[];
-    stoppedAt: number | null;
-    constructor(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
-        from: number;
-        to: number;
-    }[], parser: CompositeParser);
-    advance(): Tree | null;
-    private startSub;
-    private startInner;
-    private reuseInner;
-    stopAt(pos: number): void;
-    get parsedPos(): number;
-}
-export {};

package/dist/frame.d.ts

@@ -1,25 +0,0 @@
-import { Parser, ParseSpec, FullParseSpec, PartialParse } from "./parse";
-import { Tree, NodeType } from "./tree";
-export declare class FramingParser extends Parser {
-    constructor(config: {
-        frame: Parser;
-        fill: Parser;
-        frameNodes: readonly NodeType[];
-    });
-    startParse(spec: ParseSpec): FramingParse;
-}
-declare class FramingParse implements PartialParse {
-    readonly parser: FramingParser;
-    readonly spec: FullParseSpec;
-    outerTree: Tree | null;
-    outer: PartialParse;
-    inner: PartialParse | null;
-    stoppedAt: null | number;
-    constructor(parser: FramingParser, spec: FullParseSpec);
-    get parsedPos(): number;
-    advance(): Tree;
-    stopAt(pos: number): void;
-    private startInner;
-    private finishParse;
-}
-export {};

package/dist/scaffold.d.ts

@@ -1,25 +0,0 @@
-import { Parser, ParseSpec, FullParseSpec, PartialParse } from "./parse";
-import { Tree, NodeType } from "./tree";
-export declare class ScaffoldParser extends Parser {
-    constructor(config: {
-        scaffold: Parser;
-        fill: Parser;
-        scaffoldNodes: readonly NodeType[];
-    });
-    startParse(spec: ParseSpec): ScaffoldParse;
-}
-declare class ScaffoldParse implements PartialParse {
-    readonly parser: ScaffoldParser;
-    readonly spec: FullParseSpec;
-    outerTree: Tree | null;
-    outer: PartialParse;
-    inner: PartialParse | null;
-    stoppedAt: null | number;
-    constructor(parser: ScaffoldParser, spec: FullParseSpec);
-    get parsedPos(): number;
-    advance(): Tree;
-    stopAt(pos: number): void;
-    private startInner;
-    private finishParse;
-}
-export {};