@lezer/common 0.15.4 → 0.15.8

package/README.md

@@ -1,6 +1,6 @@
 # @lezer/common
 
-[ [**WEBSITE**](http://lezer.codemirror.net) | [**ISSUES**](https://github.com/lezer-parser/lezer/issues) | [**FORUM**](https://discuss.codemirror.net/c/lezer) | [**CHANGELOG**](https://github.com/lezer-parser/lezer-tree/blob/master/CHANGELOG.md) ]
+[ [**WEBSITE**](http://lezer.codemirror.net) | [**ISSUES**](https://github.com/lezer-parser/lezer/issues) | [**FORUM**](https://discuss.codemirror.net/c/lezer) | [**CHANGELOG**](https://github.com/lezer-parser/common/blob/master/CHANGELOG.md) ]
 
 [Lezer](https://lezer.codemirror.net/) is an incremental parser system
 intended for use in an editor or similar system.

package/dist/index.cjs

@@ -364,7 +364,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.
@@ -464,6 +464,22 @@ function checkSide(side, pos, from, to) {
         case 4 /* DontCare */: return true;
     }
 }
+function enterUnfinishedNodesBefore(node, pos) {
+    let scan = node.childBefore(pos);
+    while (scan) {
+        let last = scan.lastChild;
+        if (!last || last.to != scan.to)
+            break;
+        if (last.type.isError && last.from == last.to) {
+            node = scan;
+            scan = last.prevSibling;
+        }
+        else {
+            scan = last;
+        }
+    }
+    return node;
+}
 class TreeNode {
     constructor(node, _from, 
     // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
@@ -547,6 +563,7 @@ class TreeNode {
     resolve(pos, side = 0) {
         return this.cursor.moveTo(pos, side).node;
     }
+    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     getChild(type, before = null, after = null) {
         let r = getChildren(this, type, before, after);
         return r.length ? r[0] : null;
@@ -644,6 +661,7 @@ class BufferNode {
     resolve(pos, side = 0) {
         return this.cursor.moveTo(pos, side).node;
     }
+    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     /// @internal
     toString() { return this.context.buffer.childString(this.index); }
     getChild(type, before = null, after = null) {
@@ -741,7 +759,7 @@ class TreeCursor {
             return this.yield(this._tree.enter(pos, side, overlays, 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);
@@ -1063,15 +1081,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
@@ -1086,22 +1110,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;
                 }
@@ -1109,7 +1133,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);
         }
@@ -1324,7 +1348,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) {
@@ -1464,7 +1489,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;

package/dist/index.js

@@ -360,7 +360,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.
@@ -460,6 +460,22 @@ function checkSide(side, pos, from, to) {
         case 4 /* DontCare */: return true;
     }
 }
+function enterUnfinishedNodesBefore(node, pos) {
+    let scan = node.childBefore(pos);
+    while (scan) {
+        let last = scan.lastChild;
+        if (!last || last.to != scan.to)
+            break;
+        if (last.type.isError && last.from == last.to) {
+            node = scan;
+            scan = last.prevSibling;
+        }
+        else {
+            scan = last;
+        }
+    }
+    return node;
+}
 class TreeNode {
     constructor(node, _from, 
     // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
@@ -543,6 +559,7 @@ class TreeNode {
     resolve(pos, side = 0) {
         return this.cursor.moveTo(pos, side).node;
     }
+    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     getChild(type, before = null, after = null) {
         let r = getChildren(this, type, before, after);
         return r.length ? r[0] : null;
@@ -640,6 +657,7 @@ class BufferNode {
     resolve(pos, side = 0) {
         return this.cursor.moveTo(pos, side).node;
     }
+    enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     /// @internal
     toString() { return this.context.buffer.childString(this.index); }
     getChild(type, before = null, after = null) {
@@ -737,7 +755,7 @@ class TreeCursor {
             return this.yield(this._tree.enter(pos, side, overlays, 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);
@@ -1059,15 +1077,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
@@ -1082,22 +1106,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;
                 }
@@ -1105,7 +1129,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);
         }
@@ -1320,7 +1344,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) {
@@ -1460,7 +1485,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;

package/dist/tree.d.ts

@@ -128,11 +128,86 @@ export interface SyntaxNode {
     prevSibling: SyntaxNode | null;
     cursor: TreeCursor;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     tree: Tree | null;
     toTree(): Tree;
     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.4",
+  "version": "0.15.8",
   "description": "Syntax tree data structure and parser interfaces for the lezer parser",
   "main": "dist/index.cjs",
   "type": "module",