@lezer/common 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -116,8 +116,8 @@ class NodeType {
     /// Define a node type.
     static define(spec) {
         let props = spec.props && spec.props.length ? Object.create(null) : noProps;
-        let flags = (spec.top ? 1 /* Top */ : 0) | (spec.skipped ? 2 /* Skipped */ : 0) |
-            (spec.error ? 4 /* Error */ : 0) | (spec.name == null ? 8 /* Anonymous */ : 0);
+        let flags = (spec.top ? 1 /* NodeFlag.Top */ : 0) | (spec.skipped ? 2 /* NodeFlag.Skipped */ : 0) |
+            (spec.error ? 4 /* NodeFlag.Error */ : 0) | (spec.name == null ? 8 /* NodeFlag.Anonymous */ : 0);
         let type = new NodeType(spec.name || "", props, spec.id, flags);
         if (spec.props)
             for (let src of spec.props) {
@@ -135,14 +135,14 @@ class NodeType {
     /// the prop isn't present on this node.
     prop(prop) { return this.props[prop.id]; }
     /// True when this is the top node of a grammar.
-    get isTop() { return (this.flags & 1 /* Top */) > 0; }
+    get isTop() { return (this.flags & 1 /* NodeFlag.Top */) > 0; }
     /// True when this node is produced by a skip rule.
-    get isSkipped() { return (this.flags & 2 /* Skipped */) > 0; }
+    get isSkipped() { return (this.flags & 2 /* NodeFlag.Skipped */) > 0; }
     /// Indicates whether this is an error node.
-    get isError() { return (this.flags & 4 /* Error */) > 0; }
+    get isError() { return (this.flags & 4 /* NodeFlag.Error */) > 0; }
     /// When true, this node type doesn't correspond to a user-declared
     /// named node, for example because it is used to cache repetition.
-    get isAnonymous() { return (this.flags & 8 /* Anonymous */) > 0; }
+    get isAnonymous() { return (this.flags & 8 /* NodeFlag.Anonymous */) > 0; }
     /// Returns true when this node's name or one of its
     /// [groups](#common.NodeProp^group) matches the given string.
     is(name) {
@@ -175,7 +175,7 @@ class NodeType {
     }
 }
 /// An empty dummy node type to use when no actual type is available.
-NodeType.none = new NodeType("", Object.create(null), 0, 8 /* Anonymous */);
+NodeType.none = new NodeType("", Object.create(null), 0, 8 /* NodeFlag.Anonymous */);
 /// A node set holds a collection of node types. It is used to
 /// compactly represent trees by storing their type ids, rather than a
 /// full pointer to the type object, in a numeric array. Each parser
@@ -321,6 +321,10 @@ class Tree {
     /// position. If 1, it'll move into nodes that start at the
     /// position. With 0, it'll only enter nodes that cover the position
     /// from both sides.
+    ///
+    /// Note that this will not enter
+    /// [overlays](#common.MountedTree.overlay), and you often want
+    /// [`resolveInner`](#common.Tree.resolveInner) instead.
     resolve(pos, side = 0) {
         let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
         CachedNode.set(this, node);
@@ -380,7 +384,7 @@ class Tree {
     /// which may have children grouped into subtrees with type
     /// [`NodeType.none`](#common.NodeType^none).
     balance(config = {}) {
-        return this.children.length <= 8 /* BranchFactor */ ? this :
+        return this.children.length <= 8 /* Balance.BranchFactor */ ? this :
             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,
@@ -459,26 +463,27 @@ class TreeBuffer {
         return pick;
     }
     /// @internal
-    slice(startI, endI, from, to) {
+    slice(startI, endI, from) {
         let b = this.buffer;
-        let copy = new Uint16Array(endI - startI);
+        let copy = new Uint16Array(endI - startI), len = 0;
         for (let i = startI, j = 0; i < endI;) {
             copy[j++] = b[i++];
             copy[j++] = b[i++] - from;
-            copy[j++] = b[i++] - from;
+            let to = copy[j++] = b[i++] - from;
             copy[j++] = b[i++] - startI;
+            len = Math.max(len, to);
         }
-        return new TreeBuffer(copy, to - from, this.set);
+        return new TreeBuffer(copy, len, this.set);
     }
 }
 function checkSide(side, pos, from, to) {
     switch (side) {
-        case -2 /* Before */: return from < pos;
-        case -1 /* AtOrBefore */: return to >= pos && from < pos;
-        case 0 /* Around */: return from < pos && to > pos;
-        case 1 /* AtOrAfter */: return from <= pos && to > pos;
-        case 2 /* After */: return to > pos;
-        case 4 /* DontCare */: return true;
+        case -2 /* Side.Before */: return from < pos;
+        case -1 /* Side.AtOrBefore */: return to >= pos && from < pos;
+        case 0 /* Side.Around */: return from < pos && to > pos;
+        case 1 /* Side.AtOrAfter */: return from <= pos && to > pos;
+        case 2 /* Side.After */: return to > pos;
+        case 4 /* Side.DontCare */: return true;
     }
 }
 function enterUnfinishedNodesBefore(node, pos) {
@@ -568,10 +573,10 @@ class TreeNode {
                 return null;
         }
     }
-    get firstChild() { return this.nextChild(0, 1, 0, 4 /* DontCare */); }
-    get lastChild() { return this.nextChild(this._tree.children.length - 1, -1, 0, 4 /* DontCare */); }
-    childAfter(pos) { return this.nextChild(0, 1, pos, 2 /* After */); }
-    childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Before */); }
+    get firstChild() { return this.nextChild(0, 1, 0, 4 /* Side.DontCare */); }
+    get lastChild() { return this.nextChild(this._tree.children.length - 1, -1, 0, 4 /* Side.DontCare */); }
+    childAfter(pos) { return this.nextChild(0, 1, pos, 2 /* Side.After */); }
+    childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Side.Before */); }
     enter(pos, side, mode = 0) {
         let mounted;
         if (!(mode & exports.IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
@@ -594,10 +599,10 @@ class TreeNode {
         return this._parent ? this._parent.nextSignificantParent() : null;
     }
     get nextSibling() {
-        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index + 1, 1, 0, 4 /* DontCare */) : null;
+        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index + 1, 1, 0, 4 /* Side.DontCare */) : null;
     }
     get prevSibling() {
-        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* DontCare */) : null;
+        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* Side.DontCare */) : null;
     }
     cursor(mode = 0) { return new TreeCursor(this, mode); }
     get tree() { return this._tree; }
@@ -659,24 +664,24 @@ class BufferContext {
     }
 }
 class BufferNode {
+    get name() { return this.type.name; }
+    get from() { return this.context.start + this.context.buffer.buffer[this.index + 1]; }
+    get to() { return this.context.start + this.context.buffer.buffer[this.index + 2]; }
     constructor(context, _parent, index) {
         this.context = context;
         this._parent = _parent;
         this.index = index;
         this.type = context.buffer.set.types[context.buffer.buffer[index]];
     }
-    get name() { return this.type.name; }
-    get from() { return this.context.start + this.context.buffer.buffer[this.index + 1]; }
-    get to() { return this.context.start + this.context.buffer.buffer[this.index + 2]; }
     child(dir, pos, side) {
         let { buffer } = this.context;
         let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.context.start, side);
         return index < 0 ? null : new BufferNode(this.context, this, index);
     }
-    get firstChild() { return this.child(1, 0, 4 /* DontCare */); }
-    get lastChild() { return this.child(-1, 0, 4 /* DontCare */); }
-    childAfter(pos) { return this.child(1, pos, 2 /* After */); }
-    childBefore(pos) { return this.child(-1, pos, -2 /* Before */); }
+    get firstChild() { return this.child(1, 0, 4 /* Side.DontCare */); }
+    get lastChild() { return this.child(-1, 0, 4 /* Side.DontCare */); }
+    childAfter(pos) { return this.child(1, pos, 2 /* Side.After */); }
+    childBefore(pos) { return this.child(-1, pos, -2 /* Side.Before */); }
     enter(pos, side, mode = 0) {
         if (mode & exports.IterMode.ExcludeBuffers)
             return null;
@@ -688,7 +693,7 @@ class BufferNode {
         return this._parent || this.context.parent.nextSignificantParent();
     }
     externalSibling(dir) {
-        return this._parent ? null : this.context.parent.nextChild(this.context.index + dir, dir, 0, 4 /* DontCare */);
+        return this._parent ? null : this.context.parent.nextChild(this.context.index + dir, dir, 0, 4 /* Side.DontCare */);
     }
     get nextSibling() {
         let { buffer } = this.context;
@@ -702,7 +707,7 @@ class BufferNode {
         let parentStart = this._parent ? this._parent.index + 4 : 0;
         if (this.index == parentStart)
             return this.externalSibling(-1);
-        return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* DontCare */));
+        return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* Side.DontCare */));
     }
     cursor(mode = 0) { return new TreeCursor(this, mode); }
     get tree() { return null; }
@@ -711,8 +716,8 @@ class BufferNode {
         let { buffer } = this.context;
         let startI = this.index + 4, endI = buffer.buffer[this.index + 3];
         if (endI > startI) {
-            let from = buffer.buffer[this.index + 1], to = buffer.buffer[this.index + 2];
-            children.push(buffer.slice(startI, endI, from, to));
+            let from = buffer.buffer[this.index + 1];
+            children.push(buffer.slice(startI, endI, from));
             positions.push(0);
         }
         return new Tree(this.type, children, positions, this.to - this.from);
@@ -739,6 +744,8 @@ class BufferNode {
 /// A tree cursor object focuses on a given node in a syntax tree, and
 /// allows you to move to adjacent nodes.
 class TreeCursor {
+    /// Shorthand for `.type.name`.
+    get name() { return this.type.name; }
     /// @internal
     constructor(node, 
     /// @internal
@@ -762,8 +769,6 @@ class TreeCursor {
             this.yieldBuf(node.index);
         }
     }
-    /// Shorthand for `.type.name`.
-    get name() { return this.type.name; }
     yieldNode(node) {
         if (!node)
             return false;
@@ -808,13 +813,13 @@ class TreeCursor {
     }
     /// 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.
-    firstChild() { return this.enterChild(1, 0, 4 /* DontCare */); }
+    firstChild() { return this.enterChild(1, 0, 4 /* Side.DontCare */); }
     /// Move the cursor to this node's last child.
-    lastChild() { return this.enterChild(-1, 0, 4 /* DontCare */); }
+    lastChild() { return this.enterChild(-1, 0, 4 /* Side.DontCare */); }
     /// Move the cursor to the first child that ends after `pos`.
-    childAfter(pos) { return this.enterChild(1, pos, 2 /* After */); }
+    childAfter(pos) { return this.enterChild(1, pos, 2 /* Side.After */); }
     /// Move to the last child that starts before `pos`.
-    childBefore(pos) { return this.enterChild(-1, pos, -2 /* Before */); }
+    childBefore(pos) { return this.enterChild(-1, pos, -2 /* Side.Before */); }
     /// Move the cursor to the child around `pos`. If side is -1 the
     /// child may end at that position, when 1 it may start there. This
     /// will also enter [overlaid](#common.MountedTree.overlay)
@@ -840,19 +845,19 @@ class TreeCursor {
         if (!this.buffer)
             return !this._tree._parent ? false
                 : this.yield(this._tree.index < 0 ? null
-                    : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4 /* DontCare */, this.mode));
+                    : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4 /* Side.DontCare */, this.mode));
         let { buffer } = this.buffer, d = this.stack.length - 1;
         if (dir < 0) {
             let parentStart = d < 0 ? 0 : this.stack[d] + 4;
             if (this.index != parentStart)
-                return this.yieldBuf(buffer.findChild(parentStart, this.index, -1, 0, 4 /* DontCare */));
+                return this.yieldBuf(buffer.findChild(parentStart, this.index, -1, 0, 4 /* Side.DontCare */));
         }
         else {
             let after = buffer.buffer[this.index + 3];
             if (after < (d < 0 ? buffer.buffer.length : buffer.buffer[this.stack[d] + 3]))
                 return this.yieldBuf(after);
         }
-        return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4 /* DontCare */, this.mode)) : false;
+        return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4 /* Side.DontCare */, this.mode)) : false;
     }
     /// Move to this node's next sibling, if any.
     nextSibling() { return this.sibling(1); }
@@ -889,7 +894,7 @@ class TreeCursor {
         return true;
     }
     move(dir, enter) {
-        if (enter && this.enterChild(dir, 0, 4 /* DontCare */))
+        if (enter && this.enterChild(dir, 0, 4 /* Side.DontCare */))
             return true;
         for (;;) {
             if (this.sibling(dir))
@@ -899,7 +904,7 @@ class TreeCursor {
         }
     }
     /// Move to the next node in a
-    /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR))
+    /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
     /// traversal, going from a node to its first child or, if the
     /// current node is empty or `enter` is false, its next sibling or
     /// the next sibling of the first parent node that has one.
@@ -1015,17 +1020,17 @@ function buildTree(data) {
         let lookAheadAtStart = lookAhead;
         while (size < 0) {
             cursor.next();
-            if (size == -1 /* Reuse */) {
+            if (size == -1 /* SpecialRecord.Reuse */) {
                 let node = reused[id];
                 children.push(node);
                 positions.push(start - parentStart);
                 return;
             }
-            else if (size == -3 /* ContextChange */) { // Context change
+            else if (size == -3 /* SpecialRecord.ContextChange */) { // Context change
                 contextHash = id;
                 return;
             }
-            else if (size == -4 /* LookAhead */) {
+            else if (size == -4 /* SpecialRecord.LookAhead */) {
                 lookAhead = id;
                 return;
             }
@@ -1142,7 +1147,7 @@ function buildTree(data) {
             fork.next();
             while (fork.pos > startPos) {
                 if (fork.size < 0) {
-                    if (fork.size == -3 /* ContextChange */)
+                    if (fork.size == -3 /* SpecialRecord.ContextChange */)
                         localSkipped += 4;
                     else
                         break scan;
@@ -1178,10 +1183,10 @@ function buildTree(data) {
             buffer[--index] = start - bufferStart;
             buffer[--index] = id;
         }
-        else if (size == -3 /* ContextChange */) {
+        else if (size == -3 /* SpecialRecord.ContextChange */) {
             contextHash = id;
         }
-        else if (size == -4 /* LookAhead */) {
+        else if (size == -4 /* SpecialRecord.LookAhead */) {
             lookAhead = id;
         }
         return index;
@@ -1228,7 +1233,7 @@ mkTree) {
     let total = 0;
     for (let i = from; i < to; i++)
         total += nodeSize(balanceType, children[i]);
-    let maxChild = Math.ceil((total * 1.5) / 8 /* BranchFactor */);
+    let maxChild = Math.ceil((total * 1.5) / 8 /* Balance.BranchFactor */);
     let localChildren = [], localPositions = [];
     function divide(children, positions, from, to, offset) {
         for (let i = from; i < to;) {
@@ -1331,16 +1336,16 @@ class TreeFragment {
         this.to = to;
         this.tree = tree;
         this.offset = offset;
-        this.open = (openStart ? 1 /* Start */ : 0) | (openEnd ? 2 /* End */ : 0);
+        this.open = (openStart ? 1 /* Open.Start */ : 0) | (openEnd ? 2 /* Open.End */ : 0);
     }
     /// Whether the start of the fragment represents the start of a
     /// parse, or the end of a change. (In the second case, it may not
     /// be safe to reuse some nodes at the start, depending on the
     /// parsing algorithm.)
-    get openStart() { return (this.open & 1 /* Start */) > 0; }
+    get openStart() { return (this.open & 1 /* Open.Start */) > 0; }
     /// Whether the end of the fragment represents the end of a
     /// full-document parse, or the start of a change.
-    get openEnd() { return (this.open & 2 /* End */) > 0; }
+    get openEnd() { return (this.open & 2 /* Open.End */) > 0; }
     /// Create a set of fragments from a freshly parsed tree, or update
     /// an existing set of fragments by replacing the ones that overlap
     /// with a tree with content from the new tree. When `partial` is
@@ -1534,7 +1539,7 @@ class MixedParse {
                 enter = false;
             }
             else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
-                enter = isCovered != 2 /* Full */;
+                enter = isCovered != 2 /* Cover.Full */;
             }
             else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
                 if (!cursor.tree)
@@ -1589,16 +1594,16 @@ function checkCover(covered, from, to) {
         if (range.from >= to)
             break;
         if (range.to > from)
-            return range.from <= from && range.to >= to ? 2 /* Full */ : 1 /* Partial */;
+            return range.from <= from && range.to >= to ? 2 /* Cover.Full */ : 1 /* Cover.Partial */;
     }
-    return 0 /* None */;
+    return 0 /* Cover.None */;
 }
 // Take a piece of buffer and convert it into a stand-alone
 // TreeBuffer.
 function sliceBuf(buf, startI, endI, nodes, positions, off) {
     if (startI < endI) {
-        let from = buf.buffer[startI + 1], to = buf.buffer[endI - 2];
-        nodes.push(buf.slice(startI, endI, from, to));
+        let from = buf.buffer[startI + 1];
+        nodes.push(buf.slice(startI, endI, from));
         positions.push(from - off);
     }
 }
@@ -1803,14 +1808,14 @@ function enterFragments(mounts, ranges) {
             for (let i = 0, pos = from;; i++) {
                 let last = i == changes.length, end = last ? to : changes[i].from;
                 if (end > pos)
-                    result.push(new TreeFragment(pos, end, mount.tree, -startPos, frag.from >= pos, frag.to <= end));
+                    result.push(new TreeFragment(pos, end, mount.tree, -startPos, frag.from >= pos || frag.openStart, frag.to <= end || frag.openEnd));
                 if (last)
                     break;
                 pos = changes[i].to;
             }
         }
         else {
-            result.push(new TreeFragment(from, to, mount.tree, -startPos, frag.from >= startPos, frag.to <= endPos));
+            result.push(new TreeFragment(from, to, mount.tree, -startPos, frag.from >= startPos || frag.openStart, frag.to <= endPos || frag.openEnd));
         }
     }
     return result;