@lezer/common 0.15.9 → 0.15.10

package/dist/tree.cjs

@@ -2,46 +2,39 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/// The default maximum length of a `TreeBuffer` node.
+// FIXME profile adding a per-Tree TreeNode cache, validating it by
+// parent pointer
+/// The default maximum length of a `TreeBuffer` node (1024).
 const DefaultBufferLength = 1024;
 let nextPropID = 0;
-const CachedNode = new WeakMap();
-/// Each [node type](#tree.NodeType) can have metadata associated with
-/// it in props. Instances of this class represent prop names.
+class Range {
+    constructor(from, to) {
+        this.from = from;
+        this.to = to;
+    }
+}
+/// Each [node type](#common.NodeType) or [individual tree](#common.Tree)
+/// can have metadata associated with it in props. Instances of this
+/// class represent prop names.
 class NodeProp {
-    /// Create a new node prop type. You can optionally pass a
-    /// `deserialize` function.
-    constructor({ deserialize } = {}) {
+    /// Create a new node prop type.
+    constructor(config = {}) {
         this.id = nextPropID++;
-        this.deserialize = deserialize || (() => {
+        this.perNode = !!config.perNode;
+        this.deserialize = config.deserialize || (() => {
             throw new Error("This node type doesn't define a deserialize function");
         });
     }
-    /// Create a string-valued node prop whose deserialize function is
-    /// the identity function.
-    static string() { return new NodeProp({ deserialize: str => str }); }
-    /// Create a number-valued node prop whose deserialize function is
-    /// just `Number`.
-    static number() { return new NodeProp({ deserialize: Number }); }
-    /// Creates a boolean-valued node prop whose deserialize function
-    /// returns true for any input.
-    static flag() { return new NodeProp({ deserialize: () => true }); }
-    /// Store a value for this prop in the given object. This can be
-    /// useful when building up a prop object to pass to the
-    /// [`NodeType`](#tree.NodeType) constructor. Returns its first
-    /// argument.
-    set(propObj, value) {
-        propObj[this.id] = value;
-        return propObj;
-    }
     /// This is meant to be used with
-    /// [`NodeSet.extend`](#tree.NodeSet.extend) or
-    /// [`Parser.withProps`](#lezer.Parser.withProps) to compute prop
-    /// values for each node type in the set. Takes a [match
-    /// object](#tree.NodeType^match) or function that returns undefined
+    /// [`NodeSet.extend`](#common.NodeSet.extend) or
+    /// [`LRParser.configure`](#lr.ParserConfig.props) to compute
+    /// prop values for each node type in the set. Takes a [match
+    /// object](#common.NodeType^match) or function that returns undefined
     /// if the node type doesn't get this prop, and the prop's value if
     /// it does.
     add(match) {
+        if (this.perNode)
+            throw new RangeError("Can't add per-node props to node types");
         if (typeof match != "function")
             match = NodeType.match(match);
         return (type) => {
@@ -55,7 +48,7 @@ class NodeProp {
 /// space-separated string when declaring this prop in a grammar)
 /// for the node types of closing delimiters that match it.
 NodeProp.closedBy = new NodeProp({ deserialize: str => str.split(" ") });
-/// The inverse of [`closedBy`](#tree.NodeProp^closedBy). This is
+/// The inverse of [`closedBy`](#common.NodeProp^closedBy). This is
 /// attached to closing delimiters, holding an array of node names
 /// of types of matching opening delimiters.
 NodeProp.openedBy = new NodeProp({ deserialize: str => str.split(" ") });
@@ -63,6 +56,41 @@ NodeProp.openedBy = new NodeProp({ deserialize: str => str.split(" ") });
 /// types that represent an expression could be tagged with an
 /// `"Expression"` group).
 NodeProp.group = new NodeProp({ deserialize: str => str.split(" ") });
+/// The hash of the [context](#lr.ContextTracker.constructor)
+/// that the node was parsed in, if any. Used to limit reuse of
+/// contextual nodes.
+NodeProp.contextHash = new NodeProp({ perNode: true });
+/// The distance beyond the end of the node that the tokenizer
+/// looked ahead for any of the tokens inside the node. (The LR
+/// parser only stores this when it is larger than 25, for
+/// efficiency reasons.)
+NodeProp.lookAhead = new NodeProp({ perNode: true });
+/// This per-node prop is used to replace a given node, or part of a
+/// node, with another tree. This is useful to include trees from
+/// different languages.
+NodeProp.mounted = new NodeProp({ perNode: true });
+/// A mounted tree, which can be [stored](#common.NodeProp^mounted) on
+/// a tree node to indicate that parts of its content are
+/// represented by another tree.
+class MountedTree {
+    constructor(
+    /// The inner tree.
+    tree, 
+    /// If this is null, this tree replaces the entire node (it will
+    /// be included in the regular iteration instead of its host
+    /// node). If not, only the given ranges are considered to be
+    /// covered by this tree. This is used for trees that are mixed in
+    /// a way that isn't strictly hierarchical. Such mounted trees are
+    /// only entered by [`resolveInner`](#common.Tree.resolveInner)
+    /// and [`enter`](#common.SyntaxNode.enter).
+    overlay, 
+    /// The parser used to create this subtree.
+    parser) {
+        this.tree = tree;
+        this.overlay = overlay;
+        this.parser = parser;
+    }
+}
 const noProps = Object.create(null);
 /// Each node in a syntax tree has a node type associated with it.
 class NodeType {
@@ -94,8 +122,11 @@ class NodeType {
             for (let src of spec.props) {
                 if (!Array.isArray(src))
                     src = src(type);
-                if (src)
-                    src[0].set(props, src[1]);
+                if (src) {
+                    if (src[0].perNode)
+                        throw new RangeError("Can't store a per-node prop on a node type");
+                    props[src[0].id] = src[1];
+                }
             }
         return type;
     }
@@ -112,7 +143,7 @@ class NodeType {
     /// named node, for example because it is used to cache repetition.
     get isAnonymous() { return (this.flags & 8 /* Anonymous */) > 0; }
     /// Returns true when this node's name or one of its
-    /// [groups](#tree.NodeProp^group) matches the given string.
+    /// [groups](#common.NodeProp^group) matches the given string.
     is(name) {
         if (typeof name == 'string') {
             if (this.name == name)
@@ -124,8 +155,8 @@ class NodeType {
     }
     /// Create a function from node types to arbitrary values by
     /// specifying an object whose property names are node or
-    /// [group](#tree.NodeProp^group) names. Often useful with
-    /// [`NodeProp.add`](#tree.NodeProp.add). You can put multiple
+    /// [group](#common.NodeProp^group) names. Often useful with
+    /// [`NodeProp.add`](#common.NodeProp.add). You can put multiple
     /// names, separated by spaces, in a single property name to map
     /// multiple node names to a single value.
     static match(map) {
@@ -146,12 +177,11 @@ class NodeType {
 NodeType.none = new NodeType("", Object.create(null), 0, 8 /* 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 number array. Each parser
-/// [has](#lezer.Parser.nodeSet) a node set, and [tree
-/// buffers](#tree.TreeBuffer) can only store collections of nodes
-/// from the same set. A set can have a maximum of 2**16 (65536)
-/// node types in it, so that the ids fit into 16-bit typed array
-/// slots.
+/// full pointer to the type object, in a numeric array. Each parser
+/// [has](#lr.LRParser.nodeSet) a node set, and [tree
+/// buffers](#common.TreeBuffer) can only store collections of nodes
+/// from the same set. A set can have a maximum of 2**16 (65536) node
+/// types in it, so that the ids fit into 16-bit typed array slots.
 class NodeSet {
     /// Create a set with the given types. The `id` property of each
     /// type should correspond to its position within the array.
@@ -165,7 +195,7 @@ class NodeSet {
     }
     /// Create a copy of this set with some node properties added. The
     /// arguments to this method should be created with
-    /// [`NodeProp.add`](#tree.NodeProp.add).
+    /// [`NodeProp.add`](#common.NodeProp.add).
     extend(...props) {
         let newTypes = [];
         for (let type of this.types) {
@@ -175,7 +205,7 @@ class NodeSet {
                 if (add) {
                     if (!newProps)
                         newProps = Object.assign({}, type.props);
-                    add[0].set(newProps, add[1]);
+                    newProps[add[0].id] = add[1];
                 }
             }
             newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);
@@ -183,6 +213,7 @@ class NodeSet {
         return new NodeSet(newTypes);
     }
 }
+const CachedNode = 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.
@@ -193,36 +224,56 @@ class NodeSet {
 ///
 /// However, when you want to actually work with tree nodes, this
 /// representation is very awkward, so most client code will want to
-/// use the `TreeCursor` interface instead, which provides a view on
-/// some part of this data structure, and can be used to move around
-/// to adjacent nodes.
+/// use the [`TreeCursor`](#common.TreeCursor) or
+/// [`SyntaxNode`](#common.SyntaxNode) interface instead, which provides
+/// a view on some part of this data structure, and can be used to
+/// move around to adjacent nodes.
 class Tree {
-    /// Construct a new tree. You usually want to go through
-    /// [`Tree.build`](#tree.Tree^build) instead.
-    constructor(type, 
-    /// The tree's child nodes. Children small enough to fit in a
-    /// `TreeBuffer will be represented as such, other children can be
-    /// further `Tree` instances with their own internal structure.
+    /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+    constructor(
+    /// The type of the top node.
+    type, 
+    /// This node's child nodes.
     children, 
     /// The positions (offsets relative to the start of this tree) of
     /// the children.
     positions, 
     /// The total length of this tree
-    length) {
+    length, 
+    /// Per-node [node props](#common.NodeProp) to associate with this node.
+    props) {
         this.type = type;
         this.children = children;
         this.positions = positions;
         this.length = length;
+        /// @internal
+        this.props = null;
+        if (props && props.length) {
+            this.props = Object.create(null);
+            for (let [prop, value] of props)
+                this.props[typeof prop == "number" ? prop : prop.id] = value;
+        }
     }
     /// @internal
     toString() {
-        let children = this.children.map(c => c.toString()).join();
+        let mounted = this.prop(NodeProp.mounted);
+        if (mounted && !mounted.overlay)
+            return mounted.tree.toString();
+        let children = "";
+        for (let ch of this.children) {
+            let str = ch.toString();
+            if (str) {
+                if (children)
+                    children += ",";
+                children += str;
+            }
+        }
         return !this.type.name ? children :
             (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) +
                 (children.length ? "(" + children + ")" : "");
     }
-    /// Get a [tree cursor](#tree.TreeCursor) rooted at this tree. When
-    /// `pos` is given, the cursor is [moved](#tree.TreeCursor.moveTo)
+    /// Get a [tree cursor](#common.TreeCursor) rooted at this tree. When
+    /// `pos` is given, the cursor is [moved](#common.TreeCursor.moveTo)
     /// to the given position and side.
     cursor(pos, side = 0) {
         let scope = (pos != null && CachedNode.get(this)) || this.topNode;
@@ -233,18 +284,19 @@ class Tree {
         }
         return cursor;
     }
-    /// Get a [tree cursor](#tree.TreeCursor) that, unlike regular
-    /// cursors, doesn't skip [anonymous](#tree.NodeType.isAnonymous)
-    /// nodes.
+    /// Get a [tree cursor](#common.TreeCursor) that, unlike regular
+    /// cursors, doesn't skip through
+    /// [anonymous](#common.NodeType.isAnonymous) nodes and doesn't
+    /// automatically enter mounted nodes.
     fullCursor() {
-        return new TreeCursor(this.topNode, true);
+        return new TreeCursor(this.topNode, 1 /* Full */);
     }
-    /// Get a [syntax node](#tree.SyntaxNode) object for the top of the
+    /// Get a [syntax node](#common.SyntaxNode) object for the top of the
     /// tree.
     get topNode() {
         return new TreeNode(this, 0, 0, null);
     }
-    /// Get the [syntax node](#tree.SyntaxNode) at the given position.
+    /// Get the [syntax node](#common.SyntaxNode) at the given position.
     /// If `side` is -1, this will move into nodes that end at the
     /// position. If 1, it'll move into nodes that start at the
     /// position. With 0, it'll only enter nodes that cover the position
@@ -252,16 +304,30 @@ class Tree {
     resolve(pos, side = 0) {
         return this.cursor(pos, side).node;
     }
+    /// Like [`resolve`](#common.Tree.resolve), but will enter
+    /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
+    /// pointing into the innermost overlaid tree at the given position
+    /// (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;
+        }
+    }
     /// Iterate over the tree and its children, calling `enter` for any
     /// node that touches the `from`/`to` region (if given) before
     /// running over such a node's children, and `leave` (if given) when
-    /// leaving the node. When `enter` returns `false`, the given node
-    /// will not have its children iterated over (or `leave` called).
+    /// leaving the node. When `enter` returns `false`, that node will
+    /// not have its children iterated over (or `leave` called).
     iterate(spec) {
         let { enter, leave, from = 0, to = this.length } = spec;
-        for (let c = this.cursor();;) {
+        for (let c = this.cursor(), get = () => c.node;;) {
             let mustLeave = false;
-            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c.type, c.from, c.to) !== false)) {
+            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c.type, c.from, c.to, get) !== false)) {
                 if (c.firstChild())
                     continue;
                 if (!c.type.isAnonymous)
@@ -269,7 +335,7 @@ class Tree {
             }
             for (;;) {
                 if (mustLeave && leave)
-                    leave(c.type, c.from, c.to);
+                    leave(c.type, c.from, c.to, get);
                 mustLeave = c.type.isAnonymous;
                 if (c.nextSibling())
                     break;
@@ -279,10 +345,27 @@ class Tree {
             }
         }
     }
-    /// Balance the direct children of this tree.
-    balance(maxBufferLength = DefaultBufferLength) {
-        return this.children.length <= BalanceBranchFactor ? this
-            : balanceRange(this.type, NodeType.none, this.children, this.positions, 0, this.children.length, 0, maxBufferLength, this.length, 0);
+    /// Get the value of the given [node prop](#common.NodeProp) for this
+    /// node. Works with both per-node and per-type props.
+    prop(prop) {
+        return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : undefined;
+    }
+    /// Returns the node's [per-node props](#common.NodeProp.perNode) in a
+    /// format that can be passed to the [`Tree`](#common.Tree)
+    /// constructor.
+    get propValues() {
+        let result = [];
+        if (this.props)
+            for (let id in this.props)
+                result.push([+id, this.props[id]]);
+        return result;
+    }
+    /// Balance the direct children of this tree, producing a copy of
+    /// which may have children grouped into subtrees with type
+    /// [`NodeType.none`](#common.NodeType^none).
+    balance(config = {}) {
+        return this.children.length <= 8 /* 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,
     /// or a cursor over such a buffer.
@@ -290,35 +373,39 @@ class Tree {
 }
 /// The empty tree
 Tree.empty = new Tree(NodeType.none, [], [], 0);
-// For trees that need a context hash attached, we're using this
-// kludge which assigns an extra property directly after
-// initialization (creating a single new object shape).
-function withHash(tree, hash) {
-    if (hash)
-        tree.contextHash = hash;
-    return tree;
+class FlatBufferCursor {
+    constructor(buffer, index) {
+        this.buffer = buffer;
+        this.index = index;
+    }
+    get id() { return this.buffer[this.index - 4]; }
+    get start() { return this.buffer[this.index - 3]; }
+    get end() { return this.buffer[this.index - 2]; }
+    get size() { return this.buffer[this.index - 1]; }
+    get pos() { return this.index; }
+    next() { this.index -= 4; }
+    fork() { return new FlatBufferCursor(this.buffer, this.index); }
 }
 /// Tree buffers contain (type, start, end, endIndex) quads for each
 /// node. In such a buffer, nodes are stored in prefix order (parents
 /// before children, with the endIndex of the parent indicating which
 /// children belong to it)
 class TreeBuffer {
-    /// Create a tree buffer @internal
+    /// Create a tree buffer.
     constructor(
-    /// @internal
+    /// The buffer's content.
     buffer, 
     /// The total length of the group of nodes in the buffer.
     length, 
-    /// @internal
-    set, 
-    /// An optional repeat node type associated with the buffer.
-    type = NodeType.none) {
+    /// The node set used in this buffer.
+    set) {
         this.buffer = buffer;
         this.length = length;
         this.set = set;
-        this.type = type;
     }
     /// @internal
+    get type() { return NodeType.none; }
+    /// @internal
     toString() {
         let result = [];
         for (let index = 0; index < this.buffer.length;) {
@@ -344,25 +431,10 @@ class TreeBuffer {
         return result + "(" + children.join(",") + ")";
     }
     /// @internal
-    findChild(startIndex, endIndex, dir, after) {
+    findChild(startIndex, endIndex, dir, pos, side) {
         let { buffer } = this, pick = -1;
         for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {
-            if (after != -100000000 /* None */) {
-                let start = buffer[i + 1], end = buffer[i + 2];
-                if (dir > 0) {
-                    if (end > after)
-                        pick = i;
-                    if (end > after)
-                        break;
-                }
-                else {
-                    if (start < after)
-                        pick = i;
-                    if (end >= after)
-                        break;
-                }
-            }
-            else {
+            if (checkSide(side, pos, buffer[i + 1], buffer[i + 2])) {
                 pick = i;
                 if (dir > 0)
                     break;
@@ -370,45 +442,107 @@ class TreeBuffer {
         }
         return pick;
     }
+    /// @internal
+    slice(startI, endI, from, to) {
+        let b = this.buffer;
+        let copy = new Uint16Array(endI - startI);
+        for (let i = startI, j = 0; i < endI;) {
+            copy[j++] = b[i++];
+            copy[j++] = b[i++] - from;
+            copy[j++] = b[i++] - from;
+            copy[j++] = b[i++] - startI;
+        }
+        return new TreeBuffer(copy, to - from, 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;
+    }
+}
+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, _parent) {
+    constructor(node, _from, 
+    // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
+    index, _parent) {
         this.node = node;
-        this.from = from;
+        this._from = _from;
         this.index = index;
         this._parent = _parent;
     }
     get type() { return this.node.type; }
     get name() { return this.node.type.name; }
-    get to() { return this.from + this.node.length; }
-    nextChild(i, dir, after, full = false) {
+    get from() { return this._from; }
+    get to() { return this._from + this.node.length; }
+    nextChild(i, dir, pos, side, mode = 0) {
         for (let parent = this;;) {
             for (let { children, positions } = parent.node, e = dir > 0 ? children.length : -1; i != e; i += dir) {
-                let next = children[i], start = positions[i] + parent.from;
-                if (after != -100000000 /* None */ && (dir < 0 ? start >= after : start + next.length <= after))
+                let next = children[i], start = positions[i] + parent._from;
+                if (!checkSide(side, pos, start, start + next.length))
                     continue;
                 if (next instanceof TreeBuffer) {
-                    let index = next.findChild(0, next.buffer.length, dir, after == -100000000 /* None */ ? -100000000 /* None */ : after - start);
+                    if (mode & 2 /* NoEnterBuffer */)
+                        continue;
+                    let index = next.findChild(0, next.buffer.length, dir, pos - start, side);
                     if (index > -1)
                         return new BufferNode(new BufferContext(parent, next, i, start), null, index);
                 }
-                else if (full || (!next.type.isAnonymous || hasChild(next))) {
+                else if ((mode & 1 /* Full */) || (!next.type.isAnonymous || hasChild(next))) {
+                    let mounted;
+                    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 full || !inner.type.isAnonymous ? inner : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, after);
+                    return (mode & 1 /* Full */) || !inner.type.isAnonymous ? inner
+                        : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
                 }
             }
-            if (full || !parent.type.isAnonymous)
+            if ((mode & 1 /* Full */) || !parent.type.isAnonymous)
                 return null;
-            i = parent.index + dir;
+            if (parent.index >= 0)
+                i = parent.index + dir;
+            else
+                i = dir < 0 ? -1 : parent._parent.node.children.length;
             parent = parent._parent;
             if (!parent)
                 return null;
         }
     }
-    get firstChild() { return this.nextChild(0, 1, -100000000 /* None */); }
-    get lastChild() { return this.nextChild(this.node.children.length - 1, -1, -100000000 /* None */); }
-    childAfter(pos) { return this.nextChild(0, 1, pos); }
-    childBefore(pos) { return this.nextChild(this.node.children.length - 1, -1, pos); }
+    get firstChild() { return this.nextChild(0, 1, 0, 4 /* DontCare */); }
+    get lastChild() { return this.nextChild(this.node.children.length - 1, -1, 0, 4 /* DontCare */); }
+    childAfter(pos) { return this.nextChild(0, 1, pos, 2 /* After */); }
+    childBefore(pos) { return this.nextChild(this.node.children.length - 1, -1, pos, -2 /* Before */); }
+    enter(pos, side, overlays = true, buffers = true) {
+        let mounted;
+        if (overlays && (mounted = this.node.prop(NodeProp.mounted)) && mounted.overlay) {
+            let rPos = pos - this.from;
+            for (let { from, to } of mounted.overlay) {
+                if ((side > 0 ? from <= rPos : from < rPos) &&
+                    (side < 0 ? to >= rPos : to > rPos))
+                    return new TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
+            }
+        }
+        return this.nextChild(0, 1, pos, side, buffers ? 0 : 2 /* NoEnterBuffer */);
+    }
     nextSignificantParent() {
         let val = this;
         while (val.type.isAnonymous && val._parent)
@@ -419,15 +553,18 @@ class TreeNode {
         return this._parent ? this._parent.nextSignificantParent() : null;
     }
     get nextSibling() {
-        return this._parent ? this._parent.nextChild(this.index + 1, 1, -1) : null;
+        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index + 1, 1, 0, 4 /* DontCare */) : null;
     }
     get prevSibling() {
-        return this._parent ? this._parent.nextChild(this.index - 1, -1, -1) : null;
+        return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* DontCare */) : null;
     }
     get cursor() { return new TreeCursor(this); }
+    get tree() { return this.node; }
+    toTree() { return this.node; }
     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;
@@ -473,20 +610,27 @@ 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]; }
-    child(dir, after) {
+    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 */); }
+    enter(pos, side, overlays, buffers = true) {
+        if (!buffers)
+            return null;
         let { buffer } = this.context;
-        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, after == -100000000 /* None */ ? -100000000 /* None */ : after - this.context.start);
+        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
         return index < 0 ? null : new BufferNode(this.context, this, index);
     }
-    get firstChild() { return this.child(1, -100000000 /* None */); }
-    get lastChild() { return this.child(-1, -100000000 /* None */); }
-    childAfter(pos) { return this.child(1, pos); }
-    childBefore(pos) { return this.child(-1, pos); }
     get parent() {
         return this._parent || this.context.parent.nextSignificantParent();
     }
     externalSibling(dir) {
-        return this._parent ? null : this.context.parent.nextChild(this.context.index + dir, dir, -1);
+        return this._parent ? null : this.context.parent.nextChild(this.context.index + dir, dir, 0, 4 /* DontCare */);
     }
     get nextSibling() {
         let { buffer } = this.context;
@@ -500,12 +644,25 @@ 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, -100000000 /* None */));
+        return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* DontCare */));
     }
     get cursor() { return new TreeCursor(this); }
+    get tree() { return null; }
+    toTree() {
+        let children = [], positions = [];
+        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));
+            positions.push(0);
+        }
+        return new Tree(this.type, children, positions, this.to - this.from);
+    }
     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) {
@@ -520,8 +677,10 @@ class BufferNode {
 /// allows you to move to adjacent nodes.
 class TreeCursor {
     /// @internal
-    constructor(node, full = false) {
-        this.full = full;
+    constructor(node, 
+    /// @internal
+    mode = 0) {
+        this.mode = mode;
         this.buffer = null;
         this.stack = [];
         this.index = 0;
@@ -572,11 +731,11 @@ class TreeCursor {
         return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
     }
     /// @internal
-    enter(dir, after) {
+    enterChild(dir, pos, side) {
         if (!this.buffer)
-            return this.yield(this._tree.nextChild(dir < 0 ? this._tree.node.children.length - 1 : 0, dir, after, this.full));
+            return this.yield(this._tree.nextChild(dir < 0 ? this._tree.node.children.length - 1 : 0, dir, pos, side, this.mode));
         let { buffer } = this.buffer;
-        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, after == -100000000 /* None */ ? -100000000 /* None */ : after - this.buffer.start);
+        let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
         if (index < 0)
             return false;
         this.stack.push(this.index);
@@ -584,20 +743,30 @@ 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.enter(1, -100000000 /* None */); }
+    firstChild() { return this.enterChild(1, 0, 4 /* DontCare */); }
     /// Move the cursor to this node's last child.
-    lastChild() { return this.enter(-1, -100000000 /* None */); }
-    /// Move the cursor to the first child that starts at or after `pos`.
-    childAfter(pos) { return this.enter(1, pos); }
-    /// Move to the last child that ends at or before `pos`.
-    childBefore(pos) { return this.enter(-1, pos); }
-    /// Move the node's parent node, if this isn't the top node.
+    lastChild() { return this.enterChild(-1, 0, 4 /* DontCare */); }
+    /// Move the cursor to the first child that ends after `pos`.
+    childAfter(pos) { return this.enterChild(1, pos, 2 /* After */); }
+    /// Move to the last child that starts before `pos`.
+    childBefore(pos) { return this.enterChild(-1, pos, -2 /* 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)
+    /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is
+    /// set to false.
+    enter(pos, side, overlays = true, buffers = true) {
+        if (!this.buffer)
+            return this.yield(this._tree.enter(pos, side, overlays && !(this.mode & 1 /* Full */), buffers));
+        return buffers ? this.enterChild(1, pos, side) : false;
+    }
+    /// Move to the node's parent node, if this isn't the top node.
     parent() {
         if (!this.buffer)
-            return this.yieldNode(this.full ? this._tree._parent : this._tree.parent);
+            return this.yieldNode((this.mode & 1 /* Full */) ? this._tree._parent : this._tree.parent);
         if (this.stack.length)
             return this.yieldBuf(this.stack.pop());
-        let parent = this.full ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+        let parent = (this.mode & 1 /* Full */) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
         this.buffer = null;
         return this.yieldNode(parent);
     }
@@ -605,19 +774,20 @@ class TreeCursor {
     sibling(dir) {
         if (!this.buffer)
             return !this._tree._parent ? false
-                : this.yield(this._tree._parent.nextChild(this._tree.index + dir, dir, -100000000 /* None */, this.full));
+                : this.yield(this._tree.index < 0 ? null
+                    : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4 /* 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, -100000000 /* None */));
+                return this.yieldBuf(buffer.findChild(parentStart, this.index, -1, 0, 4 /* 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, -100000000 /* None */, this.full)) : false;
+        return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4 /* DontCare */, this.mode)) : false;
     }
     /// Move to this node's next sibling, if any.
     nextSibling() { return this.sibling(1); }
@@ -641,16 +811,17 @@ class TreeCursor {
             ({ index, _parent: parent } = this._tree);
         }
         for (; parent; { index, _parent: parent } = parent) {
-            for (let i = index + dir, e = dir < 0 ? -1 : parent.node.children.length; i != e; i += dir) {
-                let child = parent.node.children[i];
-                if (this.full || !child.type.isAnonymous || child instanceof TreeBuffer || hasChild(child))
-                    return false;
-            }
+            if (index > -1)
+                for (let i = index + dir, e = dir < 0 ? -1 : parent.node.children.length; i != e; i += dir) {
+                    let child = parent.node.children[i];
+                    if ((this.mode & 1 /* Full */) || child instanceof TreeBuffer || !child.type.isAnonymous || hasChild(child))
+                        return false;
+                }
         }
         return true;
     }
-    move(dir) {
-        if (this.enter(dir, -100000000 /* None */))
+    move(dir, enter) {
+        if (enter && this.enterChild(dir, 0, 4 /* DontCare */))
             return true;
         for (;;) {
             if (this.sibling(dir))
@@ -662,14 +833,14 @@ class TreeCursor {
     /// Move to the next node in a
     /// [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, its next sibling or the next sibling of
-    /// the first parent node that has one.
-    next() { return this.move(1); }
+    /// current node is empty or `enter` is false, its next sibling or
+    /// the next sibling of the first parent node that has one.
+    next(enter = true) { return this.move(1, enter); }
     /// Move to the next node in a last-to-first pre-order traveral. A
-    /// node is followed by ist last child or, if it has none, its
+    /// node is followed by its last child or, if it has none, its
     /// previous sibling or the previous sibling of the first parent
     /// node that has one.
-    prev() { return this.move(-1); }
+    prev(enter = true) { return this.move(-1, enter); }
     /// Move the cursor to the innermost node that covers `pos`. If
     /// `side` is -1, it will enter nodes that end at `pos`. If it is 1,
     /// it will enter nodes that start at `pos`.
@@ -681,19 +852,10 @@ class TreeCursor {
             if (!this.parent())
                 break;
         // Then scan down into child nodes as far as possible
-        for (;;) {
-            if (side < 0 ? !this.childBefore(pos) : !this.childAfter(pos))
-                break;
-            if (this.from == this.to ||
-                (side < 1 ? this.from >= pos : this.from > pos) ||
-                (side > -1 ? this.to <= pos : this.to < pos)) {
-                this.parent();
-                break;
-            }
-        }
+        while (this.enterChild(1, pos, side)) { }
         return this;
     }
-    /// Get a [syntax node](#tree.SyntaxNode) at the cursor's current
+    /// Get a [syntax node](#common.SyntaxNode) at the cursor's current
     /// position.
     get node() {
         if (!this.buffer)
@@ -716,58 +878,54 @@ class TreeCursor {
             result = new BufferNode(this.buffer, result, this.stack[i]);
         return this.bufferNode = new BufferNode(this.buffer, result, this.index);
     }
-    /// Get the [tree](#tree.Tree) that represents the current node, if
+    /// Get the [tree](#common.Tree) that represents the current node, if
     /// any. Will return null when the node is in a [tree
-    /// buffer](#tree.TreeBuffer).
+    /// buffer](#common.TreeBuffer).
     get tree() {
         return this.buffer ? null : this._tree.node;
     }
 }
 function hasChild(tree) {
-    return tree.children.some(ch => !ch.type.isAnonymous || ch instanceof TreeBuffer || hasChild(ch));
+    return tree.children.some(ch => ch instanceof TreeBuffer || !ch.type.isAnonymous || hasChild(ch));
 }
-class FlatBufferCursor {
-    constructor(buffer, index) {
-        this.buffer = buffer;
-        this.index = index;
-    }
-    get id() { return this.buffer[this.index - 4]; }
-    get start() { return this.buffer[this.index - 3]; }
-    get end() { return this.buffer[this.index - 2]; }
-    get size() { return this.buffer[this.index - 1]; }
-    get pos() { return this.index; }
-    next() { this.index -= 4; }
-    fork() { return new FlatBufferCursor(this.buffer, this.index); }
-}
-const BalanceBranchFactor = 8;
 function buildTree(data) {
     var _a;
-    let { buffer, nodeSet, topID = 0, maxBufferLength = DefaultBufferLength, reused = [], minRepeatType = nodeSet.types.length } = data;
+    let { buffer, nodeSet, maxBufferLength = DefaultBufferLength, reused = [], minRepeatType = nodeSet.types.length } = data;
     let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
     let types = nodeSet.types;
-    let contextHash = 0;
+    let contextHash = 0, lookAhead = 0;
     function takeNode(parentStart, minPos, children, positions, inRepeat) {
         let { id, start, end, size } = cursor;
-        let startPos = start - parentStart;
-        if (size < 0) {
-            if (size == -1) { // Reused node
-                children.push(reused[id]);
-                positions.push(startPos);
+        let lookAheadAtStart = lookAhead;
+        while (size < 0) {
+            cursor.next();
+            if (size == -1 /* Reuse */) {
+                let node = reused[id];
+                children.push(node);
+                positions.push(start - parentStart);
+                return;
             }
-            else { // Context change
+            else if (size == -3 /* ContextChange */) { // Context change
                 contextHash = id;
+                return;
+            }
+            else if (size == -4 /* LookAhead */) {
+                lookAhead = id;
+                return;
+            }
+            else {
+                throw new RangeError(`Unrecognized record size: ${size}`);
             }
-            cursor.next();
-            return;
         }
         let type = types[id], node, buffer;
+        let startPos = start - parentStart;
         if (end - start <= maxBufferLength && (buffer = findBufferSize(cursor.pos - minPos, inRepeat))) {
             // Small enough for a buffer, and no reused nodes inside
             let data = new Uint16Array(buffer.size - buffer.skip);
             let endPos = cursor.pos - buffer.size, index = data.length;
             while (cursor.pos > endPos)
-                index = copyToBuffer(buffer.start, data, index, inRepeat);
-            node = new TreeBuffer(data, end - buffer.start, nodeSet, inRepeat < 0 ? NodeType.none : types[inRepeat]);
+                index = copyToBuffer(buffer.start, data, index);
+            node = new TreeBuffer(data, end - buffer.start, nodeSet);
             startPos = buffer.start - parentStart;
         }
         else { // Make it a node
@@ -775,22 +933,67 @@ function buildTree(data) {
             cursor.next();
             let localChildren = [], localPositions = [];
             let localInRepeat = id >= minRepeatType ? id : -1;
+            let lastGroup = 0, lastEnd = end;
             while (cursor.pos > endPos) {
-                if (cursor.id == localInRepeat)
+                if (localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0) {
+                    if (cursor.end <= lastEnd - maxBufferLength) {
+                        makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart);
+                        lastGroup = localChildren.length;
+                        lastEnd = cursor.end;
+                    }
                     cursor.next();
-                else
+                }
+                else {
                     takeNode(start, endPos, localChildren, localPositions, localInRepeat);
+                }
             }
+            if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
+                makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart);
             localChildren.reverse();
             localPositions.reverse();
-            if (localInRepeat > -1 && localChildren.length > BalanceBranchFactor)
-                node = balanceRange(type, type, localChildren, localPositions, 0, localChildren.length, 0, maxBufferLength, end - start, contextHash);
-            else
-                node = withHash(new Tree(type, localChildren, localPositions, end - start), contextHash);
+            if (localInRepeat > -1 && lastGroup > 0) {
+                let make = makeBalanced(type);
+                node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);
+            }
+            else {
+                node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end);
+            }
         }
         children.push(node);
         positions.push(startPos);
     }
+    function makeBalanced(type) {
+        return (children, positions, length) => {
+            let lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;
+            if (lastI >= 0 && (last = children[lastI]) instanceof Tree) {
+                if (!lastI && last.type == type && last.length == length)
+                    return last;
+                if (lookAheadProp = last.prop(NodeProp.lookAhead))
+                    lookAhead = positions[lastI] + last.length + lookAheadProp;
+            }
+            return makeTree(type, children, positions, length, lookAhead);
+        };
+    }
+    function makeRepeatLeaf(children, positions, base, i, from, to, type, lookAhead) {
+        let localChildren = [], localPositions = [];
+        while (children.length > i) {
+            localChildren.push(children.pop());
+            localPositions.push(positions.pop() + base - from);
+        }
+        children.push(makeTree(nodeSet.types[type], localChildren, localPositions, to - from, lookAhead - to));
+        positions.push(from - base);
+    }
+    function makeTree(type, children, positions, length, lookAhead = 0, props) {
+        if (contextHash) {
+            let pair = [NodeProp.contextHash, contextHash];
+            props = props ? [pair].concat(props) : [pair];
+        }
+        if (lookAhead > 25) {
+            let pair = [NodeProp.lookAhead, lookAhead];
+            props = props ? [pair].concat(props) : [pair];
+        }
+        return new Tree(type, children, positions, length, props);
+    }
     function findBufferSize(maxSize, inRepeat) {
         // Scan through the buffer to find previous siblings that fit
         // together in a TreeBuffer, and don't contain any reused nodes
@@ -802,8 +1005,9 @@ function buildTree(data) {
         let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;
         let result = { size: 0, start: 0, skip: 0 };
         scan: for (let minPos = fork.pos - maxSize; fork.pos > minPos;) {
+            let nodeSize = fork.size;
             // Pretend nested repeat nodes of the same type don't exist
-            if (fork.id == inRepeat) {
+            if (fork.id == inRepeat && nodeSize >= 0) {
                 // Except that we store the current state as a valid return
                 // value.
                 result.size = size;
@@ -814,17 +1018,22 @@ function buildTree(data) {
                 fork.next();
                 continue;
             }
-            let nodeSize = fork.size, startPos = fork.pos - nodeSize;
+            let startPos = fork.pos - nodeSize;
             if (nodeSize < 0 || startPos < minPos || fork.start < minStart)
                 break;
             let localSkipped = fork.id >= minRepeatType ? 4 : 0;
             let nodeStart = fork.start;
             fork.next();
             while (fork.pos > startPos) {
-                if (fork.size < 0)
-                    break scan;
-                if (fork.id >= minRepeatType)
+                if (fork.size < 0) {
+                    if (fork.size == -3 /* ContextChange */)
+                        localSkipped += 4;
+                    else
+                        break scan;
+                }
+                else if (fork.id >= minRepeatType) {
                     localSkipped += 4;
+                }
                 fork.next();
             }
             start = nodeStart;
@@ -838,182 +1047,110 @@ function buildTree(data) {
         }
         return result.size > 4 ? result : undefined;
     }
-    function copyToBuffer(bufferStart, buffer, index, inRepeat) {
+    function copyToBuffer(bufferStart, buffer, index) {
         let { id, start, end, size } = cursor;
         cursor.next();
-        if (id == inRepeat)
-            return index;
-        let startIndex = index;
-        if (size > 4) {
-            let endPos = cursor.pos - (size - 4);
-            while (cursor.pos > endPos)
-                index = copyToBuffer(bufferStart, buffer, index, inRepeat);
-        }
-        if (id < minRepeatType) { // Don't copy repeat nodes into buffers
+        if (size >= 0 && id < minRepeatType) {
+            let startIndex = index;
+            if (size > 4) {
+                let endPos = cursor.pos - (size - 4);
+                while (cursor.pos > endPos)
+                    index = copyToBuffer(bufferStart, buffer, index);
+            }
             buffer[--index] = startIndex;
             buffer[--index] = end - bufferStart;
             buffer[--index] = start - bufferStart;
             buffer[--index] = id;
         }
+        else if (size == -3 /* ContextChange */) {
+            contextHash = id;
+        }
+        else if (size == -4 /* LookAhead */) {
+            lookAhead = id;
+        }
         return index;
     }
     let children = [], positions = [];
     while (cursor.pos > 0)
-        takeNode(data.start || 0, 0, children, positions, -1);
+        takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
     let length = (_a = data.length) !== null && _a !== void 0 ? _a : (children.length ? positions[0] + children[0].length : 0);
-    return new Tree(types[topID], children.reverse(), positions.reverse(), length);
+    return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
 }
-function balanceRange(outerType, innerType, children, positions, from, to, start, maxBufferLength, length, contextHash) {
-    let localChildren = [], localPositions = [];
-    if (length <= maxBufferLength) {
-        for (let i = from; i < to; i++) {
-            localChildren.push(children[i]);
-            localPositions.push(positions[i] - start);
+const nodeSizeCache = new WeakMap;
+function nodeSize(balanceType, node) {
+    if (!balanceType.isAnonymous || node instanceof TreeBuffer || node.type != balanceType)
+        return 1;
+    let size = nodeSizeCache.get(node);
+    if (size == null) {
+        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);
     }
-    else {
-        let maxChild = Math.max(maxBufferLength, Math.ceil(length * 1.5 / BalanceBranchFactor));
+    return size;
+}
+function balanceRange(
+// 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
+from, to, 
+// The start position of the nodes, relative to their parent.
+start, 
+// Length of the outer node
+length, 
+// Function to build the top node of the balanced tree
+mkTop, 
+// Function to build internal nodes for the balanced tree
+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 localChildren = [], localPositions = [];
+    function divide(children, positions, from, to, offset) {
         for (let i = from; i < to;) {
-            let groupFrom = i, groupStart = positions[i];
+            let groupFrom = i, groupStart = positions[i], groupSize = nodeSize(balanceType, children[i]);
             i++;
             for (; i < to; i++) {
-                let nextEnd = positions[i] + children[i].length;
-                if (nextEnd - groupStart > maxChild)
+                let nextSize = nodeSize(balanceType, children[i]);
+                if (groupSize + nextSize >= maxChild)
                     break;
+                groupSize += nextSize;
             }
             if (i == groupFrom + 1) {
-                let only = children[groupFrom];
-                if (only instanceof Tree && only.type == innerType && only.length > maxChild << 1) { // Too big, collapse
-                    for (let j = 0; j < only.children.length; j++) {
-                        localChildren.push(only.children[j]);
-                        localPositions.push(only.positions[j] + groupStart - start);
-                    }
+                if (groupSize > maxChild) {
+                    let only = children[groupFrom]; // Only trees can have a size > 1
+                    divide(only.children, only.positions, 0, only.children.length, positions[groupFrom] + offset);
                     continue;
                 }
-                localChildren.push(only);
-            }
-            else if (i == groupFrom + 1) {
                 localChildren.push(children[groupFrom]);
             }
             else {
-                let inner = balanceRange(innerType, innerType, children, positions, groupFrom, i, groupStart, maxBufferLength, positions[i - 1] + children[i - 1].length - groupStart, contextHash);
-                if (innerType != NodeType.none && !containsType(inner.children, innerType))
-                    inner = withHash(new Tree(NodeType.none, inner.children, inner.positions, inner.length), contextHash);
-                localChildren.push(inner);
+                let length = positions[i - 1] + children[i - 1].length - groupStart;
+                localChildren.push(balanceRange(balanceType, children, positions, groupFrom, i, groupStart, length, null, mkTree));
             }
-            localPositions.push(groupStart - start);
-        }
-    }
-    return withHash(new Tree(outerType, localChildren, localPositions, length), contextHash);
-}
-function containsType(nodes, type) {
-    for (let elt of nodes)
-        if (elt.type == type)
-            return true;
-    return false;
-}
-/// Tree fragments are used during [incremental
-/// parsing](#lezer.ParseOptions.fragments) to track parts of old
-/// trees that can be reused in a new parse. An array of fragments is
-/// used to track regions of an old tree whose nodes might be reused
-/// in new parses. Use the static
-/// [`applyChanges`](#tree.TreeFragment^applyChanges) method to update
-/// fragments for document changes.
-class TreeFragment {
-    constructor(
-    /// The start of the unchanged range pointed to by this fragment.
-    /// This refers to an offset in the _updated_ document (as opposed
-    /// to the original tree).
-    from, 
-    /// The end of the unchanged range.
-    to, 
-    /// The tree that this fragment is based on.
-    tree, 
-    /// The offset between the fragment's tree and the document that
-    /// this fragment can be used against. Add this when going from
-    /// document to tree positions, subtract it to go from tree to
-    /// document positions.
-    offset, open) {
-        this.from = from;
-        this.to = to;
-        this.tree = tree;
-        this.offset = offset;
-        this.open = open;
-    }
-    get openStart() { return (this.open & 1 /* Start */) > 0; }
-    get openEnd() { return (this.open & 2 /* End */) > 0; }
-    /// Apply a set of edits to an array of fragments, removing or
-    /// splitting fragments as necessary to remove edited ranges, and
-    /// adjusting offsets for fragments that moved.
-    static applyChanges(fragments, changes, minGap = 128) {
-        if (!changes.length)
-            return fragments;
-        let result = [];
-        let fI = 1, nextF = fragments.length ? fragments[0] : null;
-        for (let cI = 0, pos = 0, off = 0;; cI++) {
-            let nextC = cI < changes.length ? changes[cI] : null;
-            let nextPos = nextC ? nextC.fromA : 1e9;
-            if (nextPos - pos >= minGap)
-                while (nextF && nextF.from < nextPos) {
-                    let cut = nextF;
-                    if (pos >= cut.from || nextPos <= cut.to || off) {
-                        let fFrom = Math.max(cut.from, pos) - off, fTo = Math.min(cut.to, nextPos) - off;
-                        cut = fFrom >= fTo ? null :
-                            new TreeFragment(fFrom, fTo, cut.tree, cut.offset + off, (cI > 0 ? 1 /* Start */ : 0) | (nextC ? 2 /* End */ : 0));
-                    }
-                    if (cut)
-                        result.push(cut);
-                    if (nextF.to > nextPos)
-                        break;
-                    nextF = fI < fragments.length ? fragments[fI++] : null;
-                }
-            if (!nextC)
-                break;
-            pos = nextC.toA;
-            off = nextC.toA - nextC.toB;
+            localPositions.push(groupStart + offset - start);
         }
-        return result;
-    }
-    /// 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
-    /// true, the parse is treated as incomplete, and the token at its
-    /// end is not included in [`safeTo`](#tree.TreeFragment.safeTo).
-    static addTree(tree, fragments = [], partial = false) {
-        let result = [new TreeFragment(0, tree.length, tree, 0, partial ? 2 /* End */ : 0)];
-        for (let f of fragments)
-            if (f.to > tree.length)
-                result.push(f);
-        return result;
-    }
-}
-// Creates an `Input` that is backed by a single, flat string.
-function stringInput(input) { return new StringInput(input); }
-class StringInput {
-    constructor(string, length = string.length) {
-        this.string = string;
-        this.length = length;
-    }
-    get(pos) {
-        return pos < 0 || pos >= this.length ? -1 : this.string.charCodeAt(pos);
-    }
-    lineAfter(pos) {
-        if (pos < 0)
-            return "";
-        let end = this.string.indexOf("\n", pos);
-        return this.string.slice(pos, end < 0 ? this.length : Math.min(end, this.length));
     }
-    read(from, to) { return this.string.slice(from, Math.min(this.length, to)); }
-    clip(at) { return new StringInput(this.string, at); }
+    divide(children, positions, from, to, 0);
+    return (mkTop || mkTree)(localChildren, localPositions, length);
 }
 
 exports.DefaultBufferLength = DefaultBufferLength;
+exports.MountedTree = MountedTree;
 exports.NodeProp = NodeProp;
 exports.NodeSet = NodeSet;
 exports.NodeType = NodeType;
+exports.Range = Range;
 exports.Tree = Tree;
 exports.TreeBuffer = TreeBuffer;
 exports.TreeCursor = TreeCursor;
-exports.TreeFragment = TreeFragment;
-exports.stringInput = stringInput;
+exports.TreeNode = TreeNode;
 //# sourceMappingURL=tree.cjs.map