@lezer/common 0.15.11 → 0.16.1

package/dist/{tree.cjs → index.es.js}

@@ -1,7 +1,3 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 // FIXME profile adding a per-Tree TreeNode cache, validating it by
 // parent pointer
 /// The default maximum length of a `TreeBuffer` node (1024).
@@ -213,7 +209,29 @@ class NodeSet {
         return new NodeSet(newTypes);
     }
 }
-const CachedNode = new WeakMap();
+const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();
+/// Options that control iteration. Can be combined with the `|`
+/// operator to enable multiple ones.
+var IterMode;
+(function (IterMode) {
+    /// When enabled, iteration will only visit [`Tree`](#common.Tree)
+    /// objects, not nodes packed into
+    /// [`TreeBuffer`](#common.TreeBuffer)s.
+    IterMode[IterMode["ExcludeBuffers"] = 1] = "ExcludeBuffers";
+    /// Enable this to make iteration include anonymous nodes (such as
+    /// the nodes that wrap repeated grammar constructs into a balanced
+    /// tree).
+    IterMode[IterMode["IncludeAnonymous"] = 2] = "IncludeAnonymous";
+    /// By default, regular [mounted](#common.NodeProp^mounted) nodes
+    /// replace their base node in iteration. Enable this to ignore them
+    /// instead.
+    IterMode[IterMode["IgnoreMounts"] = 4] = "IgnoreMounts";
+    /// This option only applies in
+    /// [`enter`](#common.SyntaxNode.enter)-style methods. It tells the
+    /// library to not enter mounted overlays if one covers the given
+    /// position.
+    IterMode[IterMode["IgnoreOverlays"] = 8] = "IgnoreOverlays";
+})(IterMode || (IterMode = {}));
 /// 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.
@@ -272,25 +290,22 @@ class Tree {
             (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) +
                 (children.length ? "(" + children + ")" : "");
     }
-    /// 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;
+    /// Get a [tree cursor](#common.TreeCursor) positioned at the top of
+    /// the tree. Mode can be used to [control](#common.IterMode) which
+    /// nodes the cursor visits.
+    cursor(mode = 0) {
+        return new TreeCursor(this.topNode, mode);
+    }
+    /// Get a [tree cursor](#common.TreeCursor) pointing into this tree
+    /// at the given position and side (see
+    /// [`moveTo`](#common.TreeCursor.moveTo).
+    cursorAt(pos, side = 0, mode = 0) {
+        let scope = CachedNode.get(this) || this.topNode;
         let cursor = new TreeCursor(scope);
-        if (pos != null) {
-            cursor.moveTo(pos, side);
-            CachedNode.set(this, cursor._tree);
-        }
+        cursor.moveTo(pos, side);
+        CachedNode.set(this, cursor._tree);
         return cursor;
     }
-    /// 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, 1 /* Full */);
-    }
     /// Get a [syntax node](#common.SyntaxNode) object for the top of the
     /// tree.
     get topNode() {
@@ -302,7 +317,9 @@ class Tree {
     /// position. With 0, it'll only enter nodes that cover the position
     /// from both sides.
     resolve(pos, side = 0) {
-        return this.cursor(pos, side).node;
+        let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
+        CachedNode.set(this, node);
+        return node;
     }
     /// Like [`resolve`](#common.Tree.resolve), but will enter
     /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
@@ -310,13 +327,9 @@ class Tree {
     /// (with parent links going through all parent structure, including
     /// the host trees).
     resolveInner(pos, side = 0) {
-        let result = this.topNode;
-        for (;;) {
-            let inner = result.enter(pos, side);
-            if (!inner)
-                return result;
-            result = inner;
-        }
+        let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
+        CachedInnerNode.set(this, node);
+        return node;
     }
     /// Iterate over the tree and its children, calling `enter` for any
     /// node that touches the `from`/`to` region (if given) before
@@ -325,23 +338,21 @@ class Tree {
     /// 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(), get = () => c.node;;) {
-            let mustLeave = false;
-            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c.type, c.from, c.to, get) !== false)) {
+        for (let c = this.cursor((spec.mode || 0) | IterMode.IncludeAnonymous);;) {
+            let entered = false;
+            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c) !== false)) {
                 if (c.firstChild())
                     continue;
-                if (!c.type.isAnonymous)
-                    mustLeave = true;
+                entered = true;
             }
             for (;;) {
-                if (mustLeave && leave)
-                    leave(c.type, c.from, c.to, get);
-                mustLeave = c.type.isAnonymous;
+                if (entered && leave && !c.type.isAnonymous)
+                    leave(c);
                 if (c.nextSibling())
                     break;
                 if (!c.parent())
                     return;
-                mustLeave = true;
+                entered = true;
             }
         }
     }
@@ -481,59 +492,84 @@ function enterUnfinishedNodesBefore(node, pos) {
     }
     return node;
 }
+function resolveNode(node, pos, side, overlays) {
+    var _a;
+    // Move up to a node that actually holds the position, if possible
+    while (node.from == node.to ||
+        (side < 1 ? node.from >= pos : node.from > pos) ||
+        (side > -1 ? node.to <= pos : node.to < pos)) {
+        let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
+        if (!parent)
+            return node;
+        node = parent;
+    }
+    let mode = overlays ? 0 : IterMode.IgnoreOverlays;
+    // Must go up out of overlays when those do not overlap with pos
+    if (overlays)
+        for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
+            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
+                node = parent;
+        }
+    for (;;) {
+        let inner = node.enter(pos, side, mode);
+        if (!inner)
+            return node;
+        node = inner;
+    }
+}
 class TreeNode {
-    constructor(node, _from, 
+    constructor(_tree, 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._tree = _tree;
+        this.from = from;
         this.index = index;
         this._parent = _parent;
     }
-    get type() { return this.node.type; }
-    get name() { return this.node.type.name; }
-    get from() { return this._from; }
-    get to() { return this._from + this.node.length; }
+    get type() { return this._tree.type; }
+    get name() { return this._tree.type.name; }
+    get to() { return this.from + this._tree.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;
+            for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {
+                let next = children[i], start = positions[i] + parent.from;
                 if (!checkSide(side, pos, start, start + next.length))
                     continue;
                 if (next instanceof TreeBuffer) {
-                    if (mode & 2 /* NoEnterBuffer */)
+                    if (mode & IterMode.ExcludeBuffers)
                         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 ((mode & 1 /* Full */) || (!next.type.isAnonymous || hasChild(next))) {
+                else if ((mode & IterMode.IncludeAnonymous) || (!next.type.isAnonymous || hasChild(next))) {
                     let mounted;
-                    if (!(mode & 1 /* Full */) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
+                    if (!(mode & IterMode.IgnoreMounts) &&
+                        next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
                         return new TreeNode(mounted.tree, start, i, parent);
                     let inner = new TreeNode(next, start, i, parent);
-                    return (mode & 1 /* Full */) || !inner.type.isAnonymous ? inner
+                    return (mode & IterMode.IncludeAnonymous) || !inner.type.isAnonymous ? inner
                         : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
                 }
             }
-            if ((mode & 1 /* Full */) || !parent.type.isAnonymous)
+            if ((mode & IterMode.IncludeAnonymous) || !parent.type.isAnonymous)
                 return null;
             if (parent.index >= 0)
                 i = parent.index + dir;
             else
-                i = dir < 0 ? -1 : parent._parent.node.children.length;
+                i = dir < 0 ? -1 : parent._parent._tree.children.length;
             parent = parent._parent;
             if (!parent)
                 return null;
         }
     }
     get firstChild() { return this.nextChild(0, 1, 0, 4 /* DontCare */); }
-    get lastChild() { return this.nextChild(this.node.children.length - 1, -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.node.children.length - 1, -1, pos, -2 /* Before */); }
-    enter(pos, side, overlays = true, buffers = true) {
+    childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Before */); }
+    enter(pos, side, mode = 0) {
         let mounted;
-        if (overlays && (mounted = this.node.prop(NodeProp.mounted)) && mounted.overlay) {
+        if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
             let rPos = pos - this.from;
             for (let { from, to } of mounted.overlay) {
                 if ((side > 0 ? from <= rPos : from < rPos) &&
@@ -541,7 +577,7 @@ class TreeNode {
                     return new TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
             }
         }
-        return this.nextChild(0, 1, pos, side, buffers ? 0 : 2 /* NoEnterBuffer */);
+        return this.nextChild(0, 1, pos, side, mode);
     }
     nextSignificantParent() {
         let val = this;
@@ -558,11 +594,14 @@ class TreeNode {
     get prevSibling() {
         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; }
+    cursor(mode = 0) { return new TreeCursor(this, mode); }
+    get tree() { return this._tree; }
+    toTree() { return this._tree; }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     getChild(type, before = null, after = null) {
@@ -573,10 +612,12 @@ class TreeNode {
         return getChildren(this, type, before, after);
     }
     /// @internal
-    toString() { return this.node.toString(); }
+    toString() { return this._tree.toString(); }
+    get node() { return this; }
+    matchContext(context) { return matchNodeContext(this, context); }
 }
 function getChildren(node, type, before, after) {
-    let cur = node.cursor, result = [];
+    let cur = node.cursor(), result = [];
     if (!cur.firstChild())
         return result;
     if (before != null)
@@ -592,6 +633,18 @@ function getChildren(node, type, before, after) {
             return after == null ? result : [];
     }
 }
+function matchNodeContext(node, context, i = context.length - 1) {
+    for (let p = node.parent; i >= 0; p = p.parent) {
+        if (!p)
+            return false;
+        if (!p.type.isAnonymous) {
+            if (context[i] && context[i] != p.name)
+                return false;
+            i--;
+        }
+    }
+    return true;
+}
 class BufferContext {
     constructor(parent, buffer, index, start) {
         this.parent = parent;
@@ -619,8 +672,8 @@ class BufferNode {
     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)
+    enter(pos, side, mode = 0) {
+        if (mode & IterMode.ExcludeBuffers)
             return null;
         let { buffer } = this.context;
         let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
@@ -646,7 +699,7 @@ class BufferNode {
             return this.externalSibling(-1);
         return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* DontCare */));
     }
-    get cursor() { return new TreeCursor(this); }
+    cursor(mode = 0) { return new TreeCursor(this, mode); }
     get tree() { return null; }
     toTree() {
         let children = [], positions = [];
@@ -660,7 +713,10 @@ class BufferNode {
         return new Tree(this.type, children, positions, this.to - this.from);
     }
     resolve(pos, side = 0) {
-        return this.cursor.moveTo(pos, side).node;
+        return resolveNode(this, pos, side, false);
+    }
+    resolveInner(pos, side = 0) {
+        return resolveNode(this, pos, side, true);
     }
     enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); }
     /// @internal
@@ -672,6 +728,8 @@ class BufferNode {
     getChildren(type, before = null, after = null) {
         return getChildren(this, type, before, after);
     }
+    get node() { return this; }
+    matchContext(context) { return matchNodeContext(this, context); }
 }
 /// A tree cursor object focuses on a given node in a syntax tree, and
 /// allows you to move to adjacent nodes.
@@ -681,8 +739,10 @@ class TreeCursor {
     /// @internal
     mode = 0) {
         this.mode = mode;
+        /// @internal
         this.buffer = null;
         this.stack = [];
+        /// @internal
         this.index = 0;
         this.bufferNode = null;
         if (node instanceof TreeNode) {
@@ -733,7 +793,7 @@ class TreeCursor {
     /// @internal
     enterChild(dir, pos, side) {
         if (!this.buffer)
-            return this.yield(this._tree.nextChild(dir < 0 ? this._tree.node.children.length - 1 : 0, dir, pos, side, this.mode));
+            return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.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, pos - this.buffer.start, side);
         if (index < 0)
@@ -755,18 +815,18 @@ class TreeCursor {
     /// 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) {
+    enter(pos, side, mode = this.mode) {
         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;
+            return this.yield(this._tree.enter(pos, side, mode));
+        return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
     }
     /// 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);
+            return this.yieldNode((this.mode & IterMode.IncludeAnonymous) ? this._tree._parent : this._tree.parent);
         if (this.stack.length)
             return this.yieldBuf(this.stack.pop());
-        let parent = (this.mode & 1 /* Full */) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+        let parent = (this.mode & IterMode.IncludeAnonymous) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
         this.buffer = null;
         return this.yieldNode(parent);
     }
@@ -812,9 +872,12 @@ class TreeCursor {
         }
         for (; parent; { index, _parent: parent } = parent) {
             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))
+                for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {
+                    let child = parent._tree.children[i];
+                    if ((this.mode & IterMode.IncludeAnonymous) ||
+                        child instanceof TreeBuffer ||
+                        !child.type.isAnonymous ||
+                        hasChild(child))
                         return false;
                 }
         }
@@ -882,7 +945,55 @@ class TreeCursor {
     /// any. Will return null when the node is in a [tree
     /// buffer](#common.TreeBuffer).
     get tree() {
-        return this.buffer ? null : this._tree.node;
+        return this.buffer ? null : this._tree._tree;
+    }
+    /// Iterate over the current node and all its descendants, calling
+    /// `enter` when entering a node and `leave`, if given, when leaving
+    /// one. When `enter` returns `false`, any children of that node are
+    /// skipped, and `leave` isn't called for it.
+    iterate(enter, leave) {
+        for (let depth = 0;;) {
+            let mustLeave = false;
+            if (this.type.isAnonymous || enter(this) !== false) {
+                if (this.firstChild()) {
+                    depth++;
+                    continue;
+                }
+                if (!this.type.isAnonymous)
+                    mustLeave = true;
+            }
+            for (;;) {
+                if (mustLeave && leave)
+                    leave(this);
+                mustLeave = this.type.isAnonymous;
+                if (this.nextSibling())
+                    break;
+                if (!depth)
+                    return;
+                this.parent();
+                depth--;
+                mustLeave = true;
+            }
+        }
+    }
+    /// Test whether the current node matches a given context—a sequence
+    /// of direct parent node names. Empty strings in the context array
+    /// are treated as wildcards.
+    matchContext(context) {
+        if (!this.buffer)
+            return matchNodeContext(this.node, context);
+        let { buffer } = this.buffer, { types } = buffer.set;
+        for (let i = context.length - 1, d = this.stack.length - 1; i >= 0; d--) {
+            if (d < 0)
+                return matchNodeContext(this.node, context, i);
+            let type = types[buffer.buffer[this.stack[d]]];
+            if (!type.isAnonymous) {
+                if (context[i] && context[i] != type.name)
+                    return false;
+                i--;
+            }
+        }
+        return true;
     }
 }
 function hasChild(tree) {
@@ -1142,15 +1253,564 @@ mkTree) {
     divide(children, positions, from, to, 0);
     return (mkTop || mkTree)(localChildren, localPositions, length);
 }
+/// Provides a way to associate values with pieces of trees. As long
+/// as that part of the tree is reused, the associated values can be
+/// retrieved from an updated tree.
+class NodeWeakMap {
+    constructor() {
+        this.map = new WeakMap();
+    }
+    setBuffer(buffer, index, value) {
+        let inner = this.map.get(buffer);
+        if (!inner)
+            this.map.set(buffer, inner = new Map);
+        inner.set(index, value);
+    }
+    getBuffer(buffer, index) {
+        let inner = this.map.get(buffer);
+        return inner && inner.get(index);
+    }
+    /// Set the value for this syntax node.
+    set(node, value) {
+        if (node instanceof BufferNode)
+            this.setBuffer(node.context.buffer, node.index, value);
+        else if (node instanceof TreeNode)
+            this.map.set(node.tree, value);
+    }
+    /// Retrieve value for this syntax node, if it exists in the map.
+    get(node) {
+        return node instanceof BufferNode ? this.getBuffer(node.context.buffer, node.index)
+            : node instanceof TreeNode ? this.map.get(node.tree) : undefined;
+    }
+    /// Set the value for the node that a cursor currently points to.
+    cursorSet(cursor, value) {
+        if (cursor.buffer)
+            this.setBuffer(cursor.buffer.buffer, cursor.index, value);
+        else
+            this.map.set(cursor.tree, value);
+    }
+    /// Retrieve the value for the node that a cursor currently points
+    /// to.
+    cursorGet(cursor) {
+        return cursor.buffer ? this.getBuffer(cursor.buffer.buffer, cursor.index) : this.map.get(cursor.tree);
+    }
+}
+
+/// Tree fragments are used during [incremental
+/// parsing](#common.Parser.startParse) 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`](#common.TreeFragment^applyChanges) method to
+/// update fragments for document changes.
+class TreeFragment {
+    /// Construct a tree fragment.
+    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, openStart = false, openEnd = false) {
+        this.from = from;
+        this.to = to;
+        this.tree = tree;
+        this.offset = offset;
+        this.open = (openStart ? 1 /* Start */ : 0) | (openEnd ? 2 /* 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; }
+    /// 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; }
+    /// 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 resulting
+    /// fragment has [`openEnd`](#common.TreeFragment.openEnd) set to
+    /// true.
+    static addTree(tree, fragments = [], partial = false) {
+        let result = [new TreeFragment(0, tree.length, tree, 0, false, partial)];
+        for (let f of fragments)
+            if (f.to > tree.length)
+                result.push(f);
+        return result;
+    }
+    /// 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, !!nextC);
+                    }
+                    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;
+        }
+        return result;
+    }
+}
+/// A superclass that parsers should extend.
+class Parser {
+    /// Start a parse, returning a [partial parse](#common.PartialParse)
+    /// object. [`fragments`](#common.TreeFragment) can be passed in to
+    /// make the parse incremental.
+    ///
+    /// By default, the entire input is parsed. You can pass `ranges`,
+    /// which should be a sorted array of non-empty, non-overlapping
+    /// ranges, to parse only those ranges. The tree returned in that
+    /// case will start at `ranges[0].from`.
+    startParse(input, fragments, ranges) {
+        if (typeof input == "string")
+            input = new StringInput(input);
+        ranges = !ranges ? [new Range(0, input.length)] : ranges.length ? ranges.map(r => new Range(r.from, r.to)) : [new Range(0, 0)];
+        return this.createParse(input, fragments || [], ranges);
+    }
+    /// Run a full parse, returning the resulting tree.
+    parse(input, fragments, ranges) {
+        let parse = this.startParse(input, fragments, ranges);
+        for (;;) {
+            let done = parse.advance();
+            if (done)
+                return done;
+        }
+    }
+}
+class StringInput {
+    constructor(string) {
+        this.string = string;
+    }
+    get length() { return this.string.length; }
+    chunk(from) { return this.string.slice(from); }
+    get lineChunks() { return false; }
+    read(from, to) { return this.string.slice(from, to); }
+}
+
+/// Create a parse wrapper that, after the inner parse completes,
+/// scans its tree for mixed language regions with the `nest`
+/// function, runs the resulting [inner parses](#common.NestedParse),
+/// and then [mounts](#common.NodeProp^mounted) their results onto the
+/// tree.
+///
+/// The nesting function is passed a cursor to provide context for a
+/// node, but _should not_ move that cursor, only inspect its
+/// properties and optionally access its
+/// [node object](#common.TreeCursor.node).
+function parseMixed(nest) {
+    return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges);
+}
+class InnerParse {
+    constructor(parser, parse, overlay, target, ranges) {
+        this.parser = parser;
+        this.parse = parse;
+        this.overlay = overlay;
+        this.target = target;
+        this.ranges = ranges;
+    }
+}
+class ActiveOverlay {
+    constructor(parser, predicate, mounts, index, start, target, prev) {
+        this.parser = parser;
+        this.predicate = predicate;
+        this.mounts = mounts;
+        this.index = index;
+        this.start = start;
+        this.target = target;
+        this.prev = prev;
+        this.depth = 0;
+        this.ranges = [];
+    }
+}
+const stoppedInner = new NodeProp({ perNode: true });
+class MixedParse {
+    constructor(base, nest, input, fragments, ranges) {
+        this.nest = nest;
+        this.input = input;
+        this.fragments = fragments;
+        this.ranges = ranges;
+        this.inner = [];
+        this.innerDone = 0;
+        this.baseTree = null;
+        this.stoppedAt = null;
+        this.baseParse = base;
+    }
+    advance() {
+        if (this.baseParse) {
+            let done = this.baseParse.advance();
+            if (!done)
+                return null;
+            this.baseParse = null;
+            this.baseTree = done;
+            this.startInner();
+            if (this.stoppedAt != null)
+                for (let inner of this.inner)
+                    inner.parse.stopAt(this.stoppedAt);
+        }
+        if (this.innerDone == this.inner.length) {
+            let result = this.baseTree;
+            if (this.stoppedAt != null)
+                result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
+            return result;
+        }
+        let inner = this.inner[this.innerDone], done = inner.parse.advance();
+        if (done) {
+            this.innerDone++;
+            // This is a somewhat dodgy but super helpful hack where we
+            // patch up nodes created by the inner parse (and thus
+            // presumably not aliased anywhere else) to hold the information
+            // about the inner parse.
+            let props = Object.assign(Object.create(null), inner.target.props);
+            props[NodeProp.mounted.id] = new MountedTree(done, inner.overlay, inner.parser);
+            inner.target.props = props;
+        }
+        return null;
+    }
+    get parsedPos() {
+        if (this.baseParse)
+            return 0;
+        let pos = this.input.length;
+        for (let i = this.innerDone; i < this.inner.length; i++) {
+            if (this.inner[i].ranges[0].from < pos)
+                pos = Math.min(pos, this.inner[i].parse.parsedPos);
+        }
+        return pos;
+    }
+    stopAt(pos) {
+        this.stoppedAt = pos;
+        if (this.baseParse)
+            this.baseParse.stopAt(pos);
+        else
+            for (let i = this.innerDone; i < this.inner.length; i++)
+                this.inner[i].parse.stopAt(pos);
+    }
+    startInner() {
+        let fragmentCursor = new FragmentCursor(this.fragments);
+        let overlay = null;
+        let covered = null;
+        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
+        scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
+            let enter = true, range;
+            if (fragmentCursor.hasNode(cursor)) {
+                if (overlay) {
+                    let match = overlay.mounts.find(m => m.frag.from <= cursor.from && m.frag.to >= cursor.to && m.mount.overlay);
+                    if (match)
+                        for (let r of match.mount.overlay) {
+                            let from = r.from + match.pos, to = r.to + match.pos;
+                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))
+                                overlay.ranges.push({ from, to });
+                        }
+                }
+                enter = false;
+            }
+            else if (covered && (isCovered = checkCover(covered.ranges, cursor.from, cursor.to))) {
+                enter = isCovered != 2 /* Full */;
+            }
+            else if (!cursor.type.isAnonymous && cursor.from < cursor.to && (nest = this.nest(cursor, this.input))) {
+                if (!cursor.tree)
+                    materialize(cursor);
+                let oldMounts = fragmentCursor.findMounts(cursor.from, nest.parser);
+                if (typeof nest.overlay == "function") {
+                    overlay = new ActiveOverlay(nest.parser, nest.overlay, oldMounts, this.inner.length, cursor.from, cursor.tree, overlay);
+                }
+                else {
+                    let ranges = punchRanges(this.ranges, nest.overlay || [new Range(cursor.from, cursor.to)]);
+                    if (ranges.length)
+                        this.inner.push(new InnerParse(nest.parser, nest.parser.startParse(this.input, enterFragments(oldMounts, ranges), ranges), nest.overlay ? nest.overlay.map(r => new Range(r.from - cursor.from, r.to - cursor.from)) : null, cursor.tree, ranges));
+                    if (!nest.overlay)
+                        enter = false;
+                    else if (ranges.length)
+                        covered = { ranges, depth: 0, prev: covered };
+                }
+            }
+            else if (overlay && (range = overlay.predicate(cursor))) {
+                if (range === true)
+                    range = new Range(cursor.from, cursor.to);
+                if (range.from < range.to)
+                    overlay.ranges.push(range);
+            }
+            if (enter && cursor.firstChild()) {
+                if (overlay)
+                    overlay.depth++;
+                if (covered)
+                    covered.depth++;
+            }
+            else {
+                for (;;) {
+                    if (cursor.nextSibling())
+                        break;
+                    if (!cursor.parent())
+                        break scan;
+                    if (overlay && !--overlay.depth) {
+                        let ranges = punchRanges(this.ranges, overlay.ranges);
+                        if (ranges.length)
+                            this.inner.splice(overlay.index, 0, new InnerParse(overlay.parser, overlay.parser.startParse(this.input, enterFragments(overlay.mounts, ranges), ranges), overlay.ranges.map(r => new Range(r.from - overlay.start, r.to - overlay.start)), overlay.target, ranges));
+                        overlay = overlay.prev;
+                    }
+                    if (covered && !--covered.depth)
+                        covered = covered.prev;
+                }
+            }
+        }
+    }
+}
+function checkCover(covered, from, to) {
+    for (let range of covered) {
+        if (range.from >= to)
+            break;
+        if (range.to > from)
+            return range.from <= from && range.to >= to ? 2 /* Full */ : 1 /* Partial */;
+    }
+    return 0 /* 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));
+        positions.push(from - off);
+    }
+}
+// This function takes a node that's in a buffer, and converts it, and
+// its parent buffer nodes, into a Tree. This is again acting on the
+// assumption that the trees and buffers have been constructed by the
+// parse that was ran via the mix parser, and thus aren't shared with
+// any other code, making violations of the immutability safe.
+function materialize(cursor) {
+    let { node } = cursor, depth = 0;
+    // Scan up to the nearest tree
+    do {
+        cursor.parent();
+        depth++;
+    } while (!cursor.tree);
+    // Find the index of the buffer in that tree
+    let i = 0, base = cursor.tree, off = 0;
+    for (;; i++) {
+        off = base.positions[i] + cursor.from;
+        if (off <= node.from && off + base.children[i].length >= node.to)
+            break;
+    }
+    let buf = base.children[i], b = buf.buffer;
+    // Split a level in the buffer, putting the nodes before and after
+    // the child that contains `node` into new buffers.
+    function split(startI, endI, type, innerOffset, length) {
+        let i = startI;
+        while (b[i + 2] + off <= node.from)
+            i = b[i + 3];
+        let children = [], positions = [];
+        sliceBuf(buf, startI, i, children, positions, innerOffset);
+        let from = b[i + 1], to = b[i + 2];
+        let isTarget = from + off == node.from && to + off == node.to && b[i] == node.type.id;
+        children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], from, to - from));
+        positions.push(from - innerOffset);
+        sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
+        return new Tree(type, children, positions, length);
+    }
+    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
+    // Move the cursor back to the target node
+    for (let d = 0; d <= depth; d++)
+        cursor.childAfter(node.from);
+}
+class StructureCursor {
+    constructor(root, offset) {
+        this.offset = offset;
+        this.done = false;
+        this.cursor = root.cursor(IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
+    }
+    // Move to the first node (in pre-order) that starts at or after `pos`.
+    moveTo(pos) {
+        let { cursor } = this, p = pos - this.offset;
+        while (!this.done && cursor.from < p) {
+            if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers)) ;
+            else if (!cursor.next(false))
+                this.done = true;
+        }
+    }
+    hasNode(cursor) {
+        this.moveTo(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;
+                if (tree.children.length && tree.positions[0] == 0 && tree.children[0] instanceof Tree)
+                    tree = tree.children[0];
+                else
+                    break;
+            }
+        }
+        return false;
+    }
+}
+class FragmentCursor {
+    constructor(fragments) {
+        var _a;
+        this.fragments = fragments;
+        this.curTo = 0;
+        this.fragI = 0;
+        if (fragments.length) {
+            let first = this.curFrag = fragments[0];
+            this.curTo = (_a = first.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : first.to;
+            this.inner = new StructureCursor(first.tree, -first.offset);
+        }
+        else {
+            this.curFrag = this.inner = null;
+        }
+    }
+    hasNode(node) {
+        while (this.curFrag && node.from >= this.curTo)
+            this.nextFrag();
+        return this.curFrag && this.curFrag.from <= node.from && this.curTo >= node.to && this.inner.hasNode(node);
+    }
+    nextFrag() {
+        var _a;
+        this.fragI++;
+        if (this.fragI == this.fragments.length) {
+            this.curFrag = this.inner = null;
+        }
+        else {
+            let frag = this.curFrag = this.fragments[this.fragI];
+            this.curTo = (_a = frag.tree.prop(stoppedInner)) !== null && _a !== void 0 ? _a : frag.to;
+            this.inner = new StructureCursor(frag.tree, -frag.offset);
+        }
+    }
+    findMounts(pos, parser) {
+        var _a;
+        let result = [];
+        if (this.inner) {
+            this.inner.cursor.moveTo(pos, 1);
+            for (let pos = this.inner.cursor.node; pos; pos = pos.parent) {
+                let mount = (_a = pos.tree) === null || _a === void 0 ? void 0 : _a.prop(NodeProp.mounted);
+                if (mount && mount.parser == parser) {
+                    for (let i = this.fragI; i < this.fragments.length; i++) {
+                        let frag = this.fragments[i];
+                        if (frag.from >= pos.to)
+                            break;
+                        if (frag.tree == this.curFrag.tree)
+                            result.push({
+                                frag,
+                                pos: pos.from - frag.offset,
+                                mount
+                            });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+function punchRanges(outer, ranges) {
+    let copy = null, current = ranges;
+    for (let i = 1, j = 0; i < outer.length; i++) {
+        let gapFrom = outer[i - 1].to, gapTo = outer[i].from;
+        for (; j < current.length; j++) {
+            let r = current[j];
+            if (r.from >= gapTo)
+                break;
+            if (r.to <= gapFrom)
+                continue;
+            if (!copy)
+                current = copy = ranges.slice();
+            if (r.from < gapFrom) {
+                copy[j] = new Range(r.from, gapFrom);
+                if (r.to > gapTo)
+                    copy.splice(j + 1, 0, new Range(gapTo, r.to));
+            }
+            else if (r.to > gapTo) {
+                copy[j--] = new Range(gapTo, r.to);
+            }
+            else {
+                copy.splice(j--, 1);
+            }
+        }
+    }
+    return current;
+}
+function findCoverChanges(a, b, from, to) {
+    let iA = 0, iB = 0, inA = false, inB = false, pos = -1e9;
+    let result = [];
+    for (;;) {
+        let nextA = iA == a.length ? 1e9 : inA ? a[iA].to : a[iA].from;
+        let nextB = iB == b.length ? 1e9 : inB ? b[iB].to : b[iB].from;
+        if (inA != inB) {
+            let start = Math.max(pos, from), end = Math.min(nextA, nextB, to);
+            if (start < end)
+                result.push(new Range(start, end));
+        }
+        pos = Math.min(nextA, nextB);
+        if (pos == 1e9)
+            break;
+        if (nextA == pos) {
+            if (!inA)
+                inA = true;
+            else {
+                inA = false;
+                iA++;
+            }
+        }
+        if (nextB == pos) {
+            if (!inB)
+                inB = true;
+            else {
+                inB = false;
+                iB++;
+            }
+        }
+    }
+    return result;
+}
+// Given a number of fragments for the outer tree, and a set of ranges
+// to parse, find fragments for inner trees mounted around those
+// ranges, if any.
+function enterFragments(mounts, ranges) {
+    let result = [];
+    for (let { pos, mount, frag } of mounts) {
+        let startPos = pos + (mount.overlay ? mount.overlay[0].from : 0), endPos = startPos + mount.tree.length;
+        let from = Math.max(frag.from, startPos), to = Math.min(frag.to, endPos);
+        if (mount.overlay) {
+            let overlay = mount.overlay.map(r => new Range(r.from + pos, r.to + pos));
+            let changes = findCoverChanges(ranges, overlay, from, to);
+            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));
+                if (last)
+                    break;
+                pos = changes[i].to;
+            }
+        }
+        else {
+            result.push(new TreeFragment(from, to, mount.tree, -startPos, frag.from >= startPos, frag.to <= endPos));
+        }
+    }
+    return result;
+}
 
-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.TreeNode = TreeNode;
-//# sourceMappingURL=tree.cjs.map
+export { DefaultBufferLength, IterMode, MountedTree, NodeProp, NodeSet, NodeType, NodeWeakMap, Parser, Tree, TreeBuffer, TreeCursor, TreeFragment, parseMixed };