chrome-devtools-frontend 1.0.1669021 → 1.0.1672388

package/front_end/third_party/codemirror.next/codemirror.next.d.ts

@@ -2,7 +2,7 @@
 The [`TreeFragment.applyChanges`](#common.TreeFragment^applyChanges)
 method expects changed ranges in this format.
 */
-interface ChangedRange {
+interface ChangedRange$1 {
     /**
     The start of the change in the start document
     */
@@ -29,7 +29,7 @@ parses. Use the static
 [`applyChanges`](#common.TreeFragment^applyChanges) method to
 update fragments for document changes.
 */
-declare class TreeFragment {
+declare class TreeFragment$1 {
     /**
     The start of the unchanged range pointed to by this fragment.
     This refers to an offset in the _updated_ document (as opposed
@@ -43,7 +43,7 @@ declare class TreeFragment {
     /**
     The tree that this fragment is based on.
     */
-    readonly tree: Tree;
+    readonly tree: Tree$1;
     /**
     The offset between the fragment's tree and the document that
     this fragment can be used against. Add this when going from
@@ -71,7 +71,7 @@ declare class TreeFragment {
     /**
     The tree that this fragment is based on.
     */
-    tree: Tree,
+    tree: Tree$1,
     /**
     The offset between the fragment's tree and the document that
     this fragment can be used against. Add this when going from
@@ -99,24 +99,24 @@ declare class TreeFragment {
     fragment has [`openEnd`](#common.TreeFragment.openEnd) set to
     true.
     */
-    static addTree(tree: Tree, fragments?: readonly TreeFragment[], partial?: boolean): readonly TreeFragment[];
+    static addTree(tree: Tree$1, fragments?: readonly TreeFragment$1[], partial?: boolean): readonly TreeFragment$1[];
     /**
     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: readonly TreeFragment[], changes: readonly ChangedRange[], minGap?: number): readonly TreeFragment[];
+    static applyChanges(fragments: readonly TreeFragment$1[], changes: readonly ChangedRange$1[], minGap?: number): readonly TreeFragment$1[];
 }
 /**
 Interface used to represent an in-progress parse, which can be
 moved forward piece-by-piece.
 */
-interface PartialParse {
+interface PartialParse$1 {
     /**
     Advance the parse state by some amount. Will return the finished
     syntax tree when the parse completes.
     */
-    advance(): Tree | null;
+    advance(): Tree$1 | null;
     /**
     The position up to which the document has been parsed. Note
     that, in multi-pass parsers, this will stay back until the last
@@ -141,16 +141,16 @@ interface PartialParse {
 /**
 A superclass that parsers should extend.
 */
-declare abstract class Parser {
+declare abstract class Parser$1 {
     /**
     Start a parse for a single tree. This is the method concrete
     parser implementations must implement. Called by `startParse`,
     with the optional arguments resolved.
     */
-    abstract createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
+    abstract createParse(input: Input$1, fragments: readonly TreeFragment$1[], ranges: readonly {
         from: number;
         to: number;
-    }[]): PartialParse;
+    }[]): PartialParse$1;
     /**
     Start a parse, returning a [partial parse](#common.PartialParse)
     object. [`fragments`](#common.TreeFragment) can be passed in to
@@ -161,24 +161,24 @@ declare abstract class Parser {
     ranges, to parse only those ranges. The tree returned in that
     case will start at `ranges[0].from`.
     */
-    startParse(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {
+    startParse(input: Input$1 | string, fragments?: readonly TreeFragment$1[], ranges?: readonly {
         from: number;
         to: number;
-    }[]): PartialParse;
+    }[]): PartialParse$1;
     /**
     Run a full parse, returning the resulting tree.
     */
-    parse(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {
+    parse(input: Input$1 | string, fragments?: readonly TreeFragment$1[], ranges?: readonly {
         from: number;
         to: number;
-    }[]): Tree;
+    }[]): Tree$1;
 }
 /**
 This is the interface parsers use to access the document. To run
 Lezer directly on your own document data structure, you have to
 write an implementation of it.
 */
-interface Input {
+interface Input$1 {
     /**
     The length of the document.
     */
@@ -206,16 +206,16 @@ interface Input {
 Parse wrapper functions are supported by some parsers to inject
 additional parsing logic.
 */
-type ParseWrapper = (inner: PartialParse, input: Input, fragments: readonly TreeFragment[], ranges: readonly {
+type ParseWrapper$1 = (inner: PartialParse$1, input: Input$1, fragments: readonly TreeFragment$1[], ranges: readonly {
     from: number;
     to: number;
-}[]) => PartialParse;
+}[]) => PartialParse$1;
 /**
 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.
 */
-declare class NodeProp<T> {
+declare class NodeProp$1<T> {
     /**
     Indicates whether this prop is stored per [node
     type](#common.NodeType) or per [tree node](#common.Tree).
@@ -258,26 +258,26 @@ declare class NodeProp<T> {
     */
     add(match: {
         [selector: string]: T;
-    } | ((type: NodeType) => T | undefined)): NodePropSource;
+    } | ((type: NodeType$1) => T | undefined)): NodePropSource$1;
     /**
     Prop that is used to describe matching delimiters. For opening
     delimiters, this holds an array of node names (written as a
     space-separated string when declaring this prop in a grammar)
     for the node types of closing delimiters that match it.
     */
-    static closedBy: NodeProp<readonly string[]>;
+    static closedBy: NodeProp$1<readonly string[]>;
     /**
     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.
     */
-    static openedBy: NodeProp<readonly string[]>;
+    static openedBy: NodeProp$1<readonly string[]>;
     /**
     Used to assign node types to groups (for example, all node
     types that represent an expression could be tagged with an
     `"Expression"` group).
     */
-    static group: NodeProp<readonly string[]>;
+    static group: NodeProp$1<readonly string[]>;
     /**
     Attached to nodes to indicate these should be
     [displayed](https://codemirror.net/docs/ref/#language.syntaxTree)
@@ -289,37 +289,37 @@ declare class NodeProp<T> {
     not given a value, in a grammar declaration, defaults to
     `"auto"`.
     */
-    static isolate: NodeProp<"rtl" | "ltr" | "auto">;
+    static isolate: NodeProp$1<"rtl" | "ltr" | "auto">;
     /**
     The hash of the [context](#lr.ContextTracker.constructor)
     that the node was parsed in, if any. Used to limit reuse of
     contextual nodes.
     */
-    static contextHash: NodeProp<number>;
+    static contextHash: NodeProp$1<number>;
     /**
     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.)
     */
-    static lookAhead: NodeProp<number>;
+    static lookAhead: NodeProp$1<number>;
     /**
     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 in mixed-language parsers.
     */
-    static mounted: NodeProp<MountedTree>;
+    static mounted: NodeProp$1<MountedTree$1>;
 }
 /**
 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.
 */
-declare class MountedTree {
+declare class MountedTree$1 {
     /**
     The inner tree.
     */
-    readonly tree: Tree;
+    readonly tree: Tree$1;
     /**
     If this is null, this tree replaces the entire node (it will
     be included in the regular iteration instead of its host
@@ -336,12 +336,12 @@ declare class MountedTree {
     /**
     The parser used to create this subtree.
     */
-    readonly parser: Parser;
+    readonly parser: Parser$1;
     constructor(
     /**
     The inner tree.
     */
-    tree: Tree,
+    tree: Tree$1,
     /**
     If this is null, this tree replaces the entire node (it will
     be included in the regular iteration instead of its host
@@ -358,18 +358,18 @@ declare class MountedTree {
     /**
     The parser used to create this subtree.
     */
-    parser: Parser);
+    parser: Parser$1);
 }
 /**
 Type returned by [`NodeProp.add`](#common.NodeProp.add). Describes
 whether a prop should be added to a given node type in a node set,
 and what value it should have.
 */
-type NodePropSource = (type: NodeType) => null | [NodeProp<any>, any];
+type NodePropSource$1 = (type: NodeType$1) => null | [NodeProp$1<any>, any];
 /**
 Each node in a syntax tree has a node type associated with it.
 */
-declare class NodeType {
+declare class NodeType$1 {
     /**
     The name of the node type. Not necessarily unique, but if the
     grammar was written properly, different node types with the
@@ -401,7 +401,7 @@ declare class NodeType {
         [Node props](#common.NodeProp) to assign to the type. The value
         given for any given prop should correspond to the prop's type.
         */
-        props?: readonly ([NodeProp<any>, any] | NodePropSource)[];
+        props?: readonly ([NodeProp$1<any>, any] | NodePropSource$1)[];
         /**
         Whether this is a [top node](#common.NodeType.isTop).
         */
@@ -416,12 +416,12 @@ declare class NodeType {
         node.
         */
         skipped?: boolean;
-    }): NodeType;
+    }): NodeType$1;
     /**
     Retrieves a node prop for this type. Will return `undefined` if
     the prop isn't present on this node.
     */
-    prop<T>(prop: NodeProp<T>): T | undefined;
+    prop<T>(prop: NodeProp$1<T>): T | undefined;
     /**
     True when this is the top node of a grammar.
     */
@@ -447,7 +447,7 @@ declare class NodeType {
     /**
     An empty dummy node type to use when no actual type is available.
     */
-    static none: NodeType;
+    static none: NodeType$1;
     /**
     Create a function from node types to arbitrary values by
     specifying an object whose property names are node or
@@ -458,7 +458,7 @@ declare class NodeType {
     */
     static match<T>(map: {
         [selector: string]: T;
-    }): (node: NodeType) => T | undefined;
+    }): (node: NodeType$1) => T | undefined;
 }
 /**
 A node set holds a collection of node types. It is used to
@@ -469,11 +469,11 @@ 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.
 */
-declare class NodeSet {
+declare class NodeSet$1 {
     /**
     The node types in this set, by id.
     */
-    readonly types: readonly NodeType[];
+    readonly types: readonly NodeType$1[];
     /**
     Create a set with the given types. The `id` property of each
     type should correspond to its position within the array.
@@ -482,19 +482,19 @@ declare class NodeSet {
     /**
     The node types in this set, by id.
     */
-    types: readonly NodeType[]);
+    types: readonly NodeType$1[]);
     /**
     Create a copy of this set with some node properties added. The
     arguments to this method can be created with
     [`NodeProp.add`](#common.NodeProp.add).
     */
-    extend(...props: NodePropSource[]): NodeSet;
+    extend(...props: NodePropSource$1[]): NodeSet$1;
 }
 /**
 Options that control iteration. Can be combined with the `|`
 operator to enable multiple ones.
 */
-declare enum IterMode {
+declare enum IterMode$1 {
     /**
     When enabled, iteration will only visit [`Tree`](#common.Tree)
     objects, not nodes packed into
@@ -537,15 +537,15 @@ use the [`TreeCursor`](#common.TreeCursor) or
 a view on some part of this data structure, and can be used to
 move around to adjacent nodes.
 */
-declare class Tree {
+declare class Tree$1 {
     /**
     The type of the top node.
     */
-    readonly type: NodeType;
+    readonly type: NodeType$1;
     /**
     This node's child nodes.
     */
-    readonly children: readonly (Tree | TreeBuffer)[];
+    readonly children: readonly (Tree$1 | TreeBuffer$1)[];
     /**
     The positions (offsets relative to the start of this tree) of
     the children.
@@ -562,11 +562,11 @@ declare class Tree {
     /**
     The type of the top node.
     */
-    type: NodeType,
+    type: NodeType$1,
     /**
     This node's child nodes.
     */
-    children: readonly (Tree | TreeBuffer)[],
+    children: readonly (Tree$1 | TreeBuffer$1)[],
     /**
     The positions (offsets relative to the start of this tree) of
     the children.
@@ -579,28 +579,28 @@ declare class Tree {
     /**
     Per-node [node props](#common.NodeProp) to associate with this node.
     */
-    props?: readonly [NodeProp<any> | number, any][]);
+    props?: readonly [NodeProp$1<any> | number, any][]);
     /**
     The empty tree
     */
-    static empty: Tree;
+    static empty: Tree$1;
     /**
     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?: IterMode): TreeCursor;
+    cursor(mode?: IterMode$1): TreeCursor$1;
     /**
     Get a [tree cursor](#common.TreeCursor) pointing into this tree
     at the given position and side (see
     [`moveTo`](#common.TreeCursor.moveTo).
     */
-    cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode): TreeCursor;
+    cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode$1): TreeCursor$1;
     /**
     Get a [syntax node](#common.SyntaxNode) object for the top of the
     tree.
     */
-    get topNode(): SyntaxNode;
+    get topNode(): SyntaxNode$1;
     /**
     Get the [syntax node](#common.SyntaxNode) at the given position.
     If `side` is -1, this will move into nodes that end at the
@@ -612,7 +612,7 @@ declare class Tree {
     [overlays](#common.MountedTree.overlay), and you often want
     [`resolveInner`](#common.Tree.resolveInner) instead.
     */
-    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode$1;
     /**
     Like [`resolve`](#common.Tree.resolve), but will enter
     [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
@@ -620,7 +620,7 @@ declare class Tree {
     (with parent links going through all parent structure, including
     the host trees).
     */
-    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode$1;
     /**
     In some situations, it can be useful to iterate through all
     nodes around a position, including those in overlays that don't
@@ -628,7 +628,7 @@ declare class Tree {
     that will produce all nodes, from small to big, around the given
     position.
     */
-    resolveStack(pos: number, side?: -1 | 0 | 1): NodeIterator;
+    resolveStack(pos: number, side?: -1 | 0 | 1): NodeIterator$1;
     /**
     Iterate over the tree and its children, calling `enter` for any
     node that touches the `from`/`to` region (if given) before
@@ -637,23 +637,23 @@ declare class Tree {
     not have its children iterated over (or `leave` called).
     */
     iterate(spec: {
-        enter(node: SyntaxNodeRef): boolean | void;
-        leave?(node: SyntaxNodeRef): void;
+        enter(node: SyntaxNodeRef$1): boolean | void;
+        leave?(node: SyntaxNodeRef$1): void;
         from?: number;
         to?: number;
-        mode?: IterMode;
+        mode?: IterMode$1;
     }): void;
     /**
     Get the value of the given [node prop](#common.NodeProp) for this
     node. Works with both per-node and per-type props.
     */
-    prop<T>(prop: NodeProp<T>): T | undefined;
+    prop<T>(prop: NodeProp$1<T>): T | 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(): readonly [NodeProp<any> | number, any][];
+    get propValues(): readonly [NodeProp$1<any> | number, any][];
     /**
     Balance the direct children of this tree, producing a copy of
     which may have children grouped into subtrees with type
@@ -663,22 +663,22 @@ declare class Tree {
         /**
         Function to create the newly balanced subtrees.
         */
-        makeTree?: (children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number) => Tree;
-    }): Tree;
+        makeTree?: (children: readonly (Tree$1 | TreeBuffer$1)[], positions: readonly number[], length: number) => Tree$1;
+    }): Tree$1;
     /**
     Build a tree from a postfix-ordered buffer of node information,
     or a cursor over such a buffer.
     */
-    static build(data: BuildData): Tree;
+    static build(data: BuildData$1): Tree$1;
 }
 /**
 Represents a sequence of nodes.
 */
-type NodeIterator = {
-    node: SyntaxNode;
-    next: NodeIterator | null;
+type NodeIterator$1 = {
+    node: SyntaxNode$1;
+    next: NodeIterator$1 | null;
 };
-type BuildData = {
+type BuildData$1 = {
     /**
     The buffer or buffer cursor to read the node data from.
 
@@ -701,11 +701,11 @@ type BuildData = {
 
         [11, 0, 1, 4, 12, 2, 4, 4, 10, 0, 4, 12]
     */
-    buffer: BufferCursor | readonly number[];
+    buffer: BufferCursor$1 | readonly number[];
     /**
     The node types to use.
     */
-    nodeSet: NodeSet;
+    nodeSet: NodeSet$1;
     /**
     The id of the top node type.
     */
@@ -733,7 +733,7 @@ type BuildData = {
     An optional array holding reused nodes that the buffer can refer
     to.
     */
-    reused?: readonly Tree[];
+    reused?: readonly Tree$1[];
     /**
     The first node type that indicates repeat constructs in this
     grammar.
@@ -746,7 +746,7 @@ a tree buffer. A cursor initially points at the very last element
 in the buffer. Every time `next()` is called it moves on to the
 previous one.
 */
-interface BufferCursor {
+interface BufferCursor$1 {
     /**
     The current buffer position (four times the number of nodes
     remaining).
@@ -776,7 +776,7 @@ interface BufferCursor {
     /**
     Create a copy of this cursor.
     */
-    fork(): BufferCursor;
+    fork(): BufferCursor$1;
 }
 /**
 Tree buffers contain (type, start, end, endIndex) quads for each
@@ -784,7 +784,7 @@ 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).
 */
-declare class TreeBuffer {
+declare class TreeBuffer$1 {
     /**
     The buffer's content.
     */
@@ -796,7 +796,7 @@ declare class TreeBuffer {
     /**
     The node set used in this buffer.
     */
-    readonly set: NodeSet;
+    readonly set: NodeSet$1;
     /**
     Create a tree buffer.
     */
@@ -812,7 +812,7 @@ declare class TreeBuffer {
     /**
     The node set used in this buffer.
     */
-    set: NodeSet);
+    set: NodeSet$1);
 }
 /**
 The set of properties provided by both [`SyntaxNode`](#common.SyntaxNode)
@@ -820,7 +820,7 @@ and [`TreeCursor`](#common.TreeCursor). Note that, if you need
 an object that is guaranteed to stay stable in the future, you
 need to use the [`node`](#common.SyntaxNodeRef.node) accessor.
 */
-interface SyntaxNodeRef {
+interface SyntaxNodeRef$1 {
     /**
     The start position of the node.
     */
@@ -832,7 +832,7 @@ interface SyntaxNodeRef {
     /**
     The type of the node.
     */
-    readonly type: NodeType;
+    readonly type: NodeType$1;
     /**
     The name of the node (`.type.name`).
     */
@@ -842,12 +842,12 @@ interface SyntaxNodeRef {
     if any. Will return null when the node is in a [tree
     buffer](#common.TreeBuffer).
     */
-    readonly tree: Tree | null;
+    readonly tree: Tree$1 | null;
     /**
     Retrieve a stable [syntax node](#common.SyntaxNode) at this
     position.
     */
-    readonly node: SyntaxNode;
+    readonly node: SyntaxNode$1;
     /**
     Test whether the node matches a given context—a sequence of
     direct parent nodes. Empty strings in the context array act as
@@ -861,27 +861,27 @@ tree. When iterating over large amounts of nodes, you may want to
 use a mutable [cursor](#common.TreeCursor) instead, which is more
 efficient.
 */
-interface SyntaxNode extends SyntaxNodeRef {
+interface SyntaxNode$1 extends SyntaxNodeRef$1 {
     /**
     The node's parent node, if any.
     */
-    parent: SyntaxNode | null;
+    parent: SyntaxNode$1 | null;
     /**
     The first child, if the node has children.
     */
-    firstChild: SyntaxNode | null;
+    firstChild: SyntaxNode$1 | null;
     /**
     The node's last child, if available.
     */
-    lastChild: SyntaxNode | null;
+    lastChild: SyntaxNode$1 | null;
     /**
     The first child that ends after `pos`.
     */
-    childAfter(pos: number): SyntaxNode | null;
+    childAfter(pos: number): SyntaxNode$1 | null;
     /**
     The last child that starts before `pos`.
     */
-    childBefore(pos: number): SyntaxNode | null;
+    childBefore(pos: number): SyntaxNode$1 | null;
     /**
     Enter the child at the given position. If side is -1 the child
     may end at that position, when 1 it may start there.
@@ -896,41 +896,41 @@ interface SyntaxNode extends SyntaxNodeRef {
     is mostly useful when looking for props, which cannot exist on
     buffer-allocated nodes).
     */
-    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): SyntaxNode | null;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode$1): SyntaxNode$1 | null;
     /**
     This node's next sibling, if any.
     */
-    nextSibling: SyntaxNode | null;
+    nextSibling: SyntaxNode$1 | null;
     /**
     This node's previous sibling.
     */
-    prevSibling: SyntaxNode | null;
+    prevSibling: SyntaxNode$1 | null;
     /**
     A [tree cursor](#common.TreeCursor) starting at this node.
     */
-    cursor(mode?: IterMode): TreeCursor;
+    cursor(mode?: IterMode$1): TreeCursor$1;
     /**
     Find the node around, before (if `side` is -1), or after (`side`
     is 1) the given position. Will look in parent nodes if the
     position is outside this node.
     */
-    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode$1;
     /**
     Similar to `resolve`, but enter
     [overlaid](#common.MountedTree.overlay) nodes.
     */
-    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode$1;
     /**
     Move the position to the innermost node before `pos` that looks
     like it is unfinished (meaning it ends in an error node or has a
     child ending in an error node right at its end).
     */
-    enterUnfinishedNodesBefore(pos: number): SyntaxNode;
+    enterUnfinishedNodesBefore(pos: number): SyntaxNode$1;
     /**
     Get a [tree](#common.Tree) for this node. Will allocate one if it
     points into a buffer.
     */
-    toTree(): Tree;
+    toTree(): Tree$1;
     /**
     Get the first child of the given type (which may be a [node
     name](#common.NodeType.name) or a [group
@@ -939,22 +939,22 @@ interface SyntaxNode extends SyntaxNodeRef {
     or group. If `after` is non-null, only return children that
     occur somewhere before a node with that name or group.
     */
-    getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode | null;
+    getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode$1 | null;
     /**
     Like [`getChild`](#common.SyntaxNode.getChild), but return all
     matching children, not just the first.
     */
-    getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
+    getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode$1[];
 }
 /**
 A tree cursor object focuses on a given node in a syntax tree, and
 allows you to move to adjacent nodes.
 */
-declare class TreeCursor implements SyntaxNodeRef {
+declare class TreeCursor$1 implements SyntaxNodeRef$1 {
     /**
     The node's type.
     */
-    type: NodeType;
+    type: NodeType$1;
     /**
     Shorthand for `.type.name`.
     */
@@ -995,7 +995,7 @@ declare class TreeCursor implements SyntaxNodeRef {
     [mounted](#common.NodeProp^mounted) trees unless `overlays` is
     set to false.
     */
-    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): boolean;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode$1): boolean;
     /**
     Move to the node's parent node, if this isn't the top node.
     */
@@ -1035,20 +1035,20 @@ declare class TreeCursor implements SyntaxNodeRef {
     Get a [syntax node](#common.SyntaxNode) at the cursor's current
     position.
     */
-    get node(): SyntaxNode;
+    get node(): SyntaxNode$1;
     /**
     Get the [tree](#common.Tree) that represents the current node, if
     any. Will return null when the node is in a [tree
     buffer](#common.TreeBuffer).
     */
-    get tree(): Tree | null;
+    get tree(): Tree$1 | null;
     /**
     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: (node: SyntaxNodeRef) => boolean | void, leave?: (node: SyntaxNodeRef) => void): void;
+    iterate(enter: (node: SyntaxNodeRef$1) => boolean | void, leave?: (node: SyntaxNodeRef$1) => void): void;
     /**
     Test whether the current node matches a given context—a sequence
     of direct parent node names. Empty strings in the context array
@@ -1229,7 +1229,7 @@ declare class ContextTracker<T> {
         Update the context when the parser reuses a node from a tree
         fragment.
         */
-        reuse?(context: T, node: Tree, stack: Stack, input: InputStream): T;
+        reuse?(context: T, node: Tree$1, stack: Stack, input: InputStream): T;
         /**
         Reduce a context value to a number (for cheap storage and
         comparison). Only needed for strict contexts.
@@ -1252,7 +1252,7 @@ interface ParserConfig {
     /**
     Node prop values to add to the parser's node set.
     */
-    props?: readonly NodePropSource[];
+    props?: readonly NodePropSource$1[];
     /**
     The name of the `@top` declaration to parse from. If not
     specified, the first top rule declaration in the grammar is
@@ -1292,7 +1292,7 @@ interface ParserConfig {
     with additional logic (usually used to add
     [mixed-language](#common.parseMixed) parsing).
     */
-    wrap?: ParseWrapper;
+    wrap?: ParseWrapper$1;
     /**
     The maximum length of the TreeBuffers generated in the output
     tree. Defaults to 1024.
@@ -1304,15 +1304,15 @@ Holds the parse tables for a given grammar, as generated by
 `lezer-generator`, and provides [methods](#common.Parser) to parse
 content with.
 */
-declare class LRParser extends Parser {
+declare class LRParser extends Parser$1 {
     /**
     The nodes used in the trees emitted by this parser.
     */
-    readonly nodeSet: NodeSet;
-    createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
+    readonly nodeSet: NodeSet$1;
+    createParse(input: Input$1, fragments: readonly TreeFragment$1[], ranges: readonly {
         from: number;
         to: number;
-    }[]): PartialParse;
+    }[]): PartialParse$1;
     /**
     Configure the parser. Returns a new parser instance that has the
     given settings modified. Settings not provided in `config` are
@@ -1334,7 +1334,7 @@ declare class LRParser extends Parser {
     /**
     The type of top node produced by the parser.
     */
-    get topNode(): NodeType;
+    get topNode(): NodeType$1;
     /**
     Used by the output of the parser generator. Not available to
     user code. @hide
@@ -1565,12 +1565,13 @@ declare class ChangeDesc {
     position pointing into the new document.
 
     `assoc` indicates which side the position should be associated
-    with. When it is negative or zero, the mapping will try to keep
-    the position close to the character before it (if any), and will
+    with. When it is negative, the mapping will try to keep the
+    position close to the character before it (if any), and will
     move it before insertions at that point or replacements across
-    that point. When it is positive, the position is associated with
-    the character after it, and will be moved forward for insertions
-    at or replacements across the position. Defaults to -1.
+    that point. When it is zero or positive, the position is associated
+    with the character after it, and will be moved forward for
+    */
+    /**
 
     `mode` determines whether deletions should be
     [reported](https://codemirror.net/6/docs/ref/#state.MapMode). It defaults to
@@ -1701,6 +1702,13 @@ declare class SelectionRange {
     */
     readonly to: number;
     private flags;
+    /**
+    The goal column (stored vertical offset) associated with a
+    cursor. This is used to preserve the vertical position when
+    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
+    lines of different length.
+    */
+    readonly goalColumn: number | undefined;
     private constructor();
     /**
     The anchor of the range—the side that doesn't move when you
@@ -1724,18 +1732,19 @@ declare class SelectionRange {
     */
     get assoc(): -1 | 0 | 1;
     /**
+    A flag that, when set, makes some selection-extending commands
+    treat the range's head and anchor as exchangeable, so that for
+    example Shift-ArrowUp will make the lower side of the selection
+    the anchor, even if that was the head before. Used to implement
+    MacOS-style undirectional selections.
+    */
+    get undirectional(): boolean;
+    /**
     The bidirectional text level associated with this cursor, if
     any.
     */
     get bidiLevel(): number | null;
     /**
-    The goal column (stored vertical offset) associated with a
-    cursor. This is used to preserve the vertical position when
-    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
-    lines of different length.
-    */
-    get goalColumn(): number | undefined;
-    /**
     Map this range through a change, producing a valid range in the
     updated document.
     */
@@ -1743,7 +1752,7 @@ declare class SelectionRange {
     /**
     Extend this range to cover at least `from` to `to`.
     */
-    extend(from: number, to?: number): SelectionRange;
+    extend(from: number, to?: number, assoc?: number): SelectionRange;
     /**
     Compare this range to another range.
     */
@@ -1831,7 +1840,12 @@ declare class EditorSelection {
     /**
     Create a selection range.
     */
-    static range(anchor: number, head: number, goalColumn?: number, bidiLevel?: number): SelectionRange;
+    static range(anchor: number, head: number, goalColumn?: number, bidiLevel?: number, assoc?: number): SelectionRange;
+    /**
+    Create an [undirectional](https://codemirror.net/6/docs/ref/#state.SelectionRange.undirectional)
+    selection range.
+    */
+    static undirectionalRange(from: number, to: number): SelectionRange;
 }
 
 type FacetConfig<Input, Output> = {
@@ -2601,9 +2615,9 @@ declare class EditorState {
     A facet used to register [language
     data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) providers.
     */
-    static languageData: Facet<(state: EditorState, pos: number, side: 0 | 1 | -1) => readonly {
+    static languageData: Facet<(state: EditorState, pos: number, side: -1 | 0 | 1) => readonly {
         [name: string]: any;
-    }[], readonly ((state: EditorState, pos: number, side: 0 | 1 | -1) => readonly {
+    }[], readonly ((state: EditorState, pos: number, side: -1 | 0 | 1) => readonly {
         [name: string]: any;
     }[])[]>;
     /**
@@ -2818,7 +2832,11 @@ interface RangeCursor<T> {
     /**
     Move the iterator forward.
     */
-    next: () => void;
+    next(): void;
+    /**
+    Jump the cursor to the given position.
+    */
+    goto(pos: number): void;
     /**
     The next range's value. Holds `null` when the cursor has reached
     its end.
@@ -2832,6 +2850,11 @@ interface RangeCursor<T> {
     The next end position.
     */
     to: number;
+    /**
+    The position of the set that this range comes from in the array
+    of sets being iterated over.
+    */
+    rank: number;
 }
 type RangeSetUpdate<T extends RangeValue> = {
     /**
@@ -4940,7 +4963,7 @@ interface Highlighter {
     whose [top](#common.NodeType.isTop) node this predicate returns
     true.
     */
-    scope?(node: NodeType): boolean;
+    scope?(node: NodeType$1): boolean;
 }
 /**
 Highlight the given [tree](#common.Tree) with the given
@@ -4948,7 +4971,7 @@ Highlight the given [tree](#common.Tree) with the given
 [`highlightCode`](#highlight.highlightCode) function is easier to
 use.
 */
-declare function highlightTree(tree: Tree, highlighter: Highlighter | readonly Highlighter[],
+declare function highlightTree(tree: Tree$1, highlighter: Highlighter | readonly Highlighter[],
 /**
 Assign styling to a region of the text. Will be called, in order
 of position, for any ranges where more than zero classes apply.
@@ -5379,7 +5402,7 @@ declare class Language {
     The parser object. Can be useful when using this as a [nested
     parser](https://lezer.codemirror.net/docs/ref#common.Parser).
     */
-    parser: Parser;
+    parser: Parser$1;
     /**
     Construct a language object. If you need to invoke this
     directly, first define a data facet with
@@ -5394,7 +5417,7 @@ declare class Language {
     */
     data: Facet<{
         [name: string]: any;
-    }>, parser: Parser, extraExtensions?: Extension[],
+    }>, parser: Parser$1, extraExtensions?: Extension[],
     /**
     A language name.
     */
@@ -5461,13 +5484,13 @@ incomplete) parse tree of the active
 [language](https://codemirror.net/6/docs/ref/#language.Language), or the empty tree if there is no
 language available.
 */
-declare function syntaxTree(state: EditorState): Tree;
+declare function syntaxTree(state: EditorState): Tree$1;
 /**
 Try to get a parse tree that spans at least up to `upto`. The
 method will do at most `timeout` milliseconds of work to parse
 up to that point if the tree isn't already available.
 */
-declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree | null;
+declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree$1 | null;
 /**
 Move parsing forward, and update the editor state afterwards to
 reflect the new tree. Will work for at most `timeout`
@@ -5815,7 +5838,7 @@ declare class HighlightStyle implements Highlighter {
     */
     readonly module: StyleModule | null;
     readonly style: (tags: readonly Tag[]) => string | null;
-    readonly scope: ((type: NodeType) => boolean) | undefined;
+    readonly scope: ((type: NodeType$1) => boolean) | undefined;
     private constructor();
     /**
     Create a highlighter style that associates the given styles to
@@ -5838,7 +5861,7 @@ declare class HighlightStyle implements Highlighter {
         scope them to a single language by providing the language
         object or a language's top node type here.
         */
-        scope?: Language | NodeType;
+        scope?: Language | NodeType$1;
         /**
         Add a style to _all_ content. Probably only useful in
         combination with `scope`.
@@ -6325,7 +6348,7 @@ declare class CompletionContext {
         from: number;
         to: number;
         text: string;
-        type: NodeType;
+        type: NodeType$1;
     } | null;
     /**
     Get the match of the given expression directly before the
@@ -6763,7 +6786,7 @@ declare namespace _codemirror_lang_vue {
   export { vue$1 as vue, _codemirror_lang_vue_vueLanguage as vueLanguage };
 }
 
-declare const parser: Parser
+declare const parser: Parser$1
 
 declare const svelteLanguage: LRLanguage;
 declare function svelte$1(): LanguageSupport;
@@ -6858,94 +6881,1189 @@ declare namespace _codemirror_lang_php {
 }
 
 /**
-Data structure used to accumulate a block's content during [leaf
-block parsing](#BlockParser.leaf).
+The [`TreeFragment.applyChanges`](#common.TreeFragment^applyChanges)
+method expects changed ranges in this format.
 */
-declare class LeafBlock {
+interface ChangedRange {
     /**
-    The start position of the block.
+    The start of the change in the start document
     */
-    readonly start: number;
+    fromA: number;
     /**
-    The block's text content.
+    The end of the change in the start document
     */
-    content: string;
+    toA: number;
     /**
-    The block parsers active for this block.
+    The start of the replacement in the new document
     */
-    parsers: LeafBlockParser[];
+    fromB: number;
+    /**
+    The end of the replacement in the new document
+    */
+    toB: number;
 }
 /**
-Data structure used during block-level per-line parsing.
+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.
 */
-declare class Line {
+declare class TreeFragment {
     /**
-    The line's full text.
+    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).
     */
-    text: string;
+    readonly from: number;
     /**
-    The base indent provided by the composite contexts (that have
-    been handled so far).
+    The end of the unchanged range.
     */
-    baseIndent: number;
+    readonly to: number;
     /**
-    The string position corresponding to the base indent.
+    The tree that this fragment is based on.
     */
-    basePos: number;
+    readonly tree: Tree;
     /**
-    The position of the next non-whitespace character beyond any
-    list, blockquote, or other composite block markers.
+    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.
     */
-    pos: number;
+    readonly offset: number;
     /**
-    The column of the next non-whitespace character.
+    Construct a tree fragment. You'll usually want to use
+    [`addTree`](#common.TreeFragment^addTree) and
+    [`applyChanges`](#common.TreeFragment^applyChanges) instead of
+    calling this directly.
     */
-    indent: number;
+    constructor(
     /**
-    The character code of the character after `pos`.
+    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).
     */
-    next: number;
+    from: number,
     /**
-    Skip whitespace after the given position, return the position of
-    the next non-space character or the end of the line if there's
-    only space after `from`.
+    The end of the unchanged range.
     */
-    skipSpace(from: number): number;
+    to: number,
     /**
-    Move the line's base position forward to the given position.
-    This should only be called by composite [block
-    parsers](#BlockParser.parse) or [markup skipping
-    functions](#NodeSpec.composite).
+    The tree that this fragment is based on.
     */
-    moveBase(to: number): void;
+    tree: Tree,
     /**
-    Move the line's base position forward to the given _column_.
+    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.
     */
-    moveBaseColumn(indent: number): void;
+    offset: number, openStart?: boolean, openEnd?: boolean);
     /**
-    Store a composite-block-level marker. Should be called from
-    [markup skipping functions](#NodeSpec.composite) when they
-    consume any non-whitespace characters.
+    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.)
     */
-    addMarker(elt: Element$1): void;
+    get openStart(): boolean;
     /**
-    Find the column position at `to`, optionally starting at a given
-    position and column.
+    Whether the end of the fragment represents the end of a
+    full-document parse, or the start of a change.
     */
-    countIndent(to: number, from?: number, indent?: number): number;
+    get openEnd(): boolean;
     /**
-    Find the position corresponding to the given column.
+    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.
     */
-    findColumn(goal: number): number;
+    static addTree(tree: Tree, fragments?: readonly TreeFragment[], partial?: boolean): readonly TreeFragment[];
+    /**
+    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: readonly TreeFragment[], changes: readonly ChangedRange[], minGap?: number): readonly TreeFragment[];
 }
-type BlockResult = boolean | null;
 /**
-Block-level parsing functions get access to this context object.
+Interface used to represent an in-progress parse, which can be
+moved forward piece-by-piece.
 */
-declare class BlockContext implements PartialParse {
+interface PartialParse {
     /**
-    The parser configuration used.
-    */
+    Advance the parse state by some amount. Will return the finished
+    syntax tree when the parse completes.
+    */
+    advance(): Tree | null;
+    /**
+    The position up to which the document has been parsed. Note
+    that, in multi-pass parsers, this will stay back until the last
+    pass has moved past a given position.
+    */
+    readonly parsedPos: number;
+    /**
+    Tell the parse to not advance beyond the given position.
+    `advance` will return a tree when the parse has reached the
+    position. Note that, depending on the parser algorithm and the
+    state of the parse when `stopAt` was called, that tree may
+    contain nodes beyond the position. It is an error to call
+    `stopAt` with a higher position than it's [current
+    value](#common.PartialParse.stoppedAt).
+    */
+    stopAt(pos: number): void;
+    /**
+    Reports whether `stopAt` has been called on this parse.
+    */
+    readonly stoppedAt: number | null;
+}
+/**
+A superclass that parsers should extend.
+*/
+declare abstract class Parser {
+    /**
+    Start a parse for a single tree. This is the method concrete
+    parser implementations must implement. Called by `startParse`,
+    with the optional arguments resolved.
+    */
+    abstract createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
+        from: number;
+        to: number;
+    }[]): PartialParse;
+    /**
+    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: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {
+        from: number;
+        to: number;
+    }[]): PartialParse;
+    /**
+    Run a full parse, returning the resulting tree.
+    */
+    parse(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {
+        from: number;
+        to: number;
+    }[]): Tree;
+}
+/**
+This is the interface parsers use to access the document. To run
+Lezer directly on your own document data structure, you have to
+write an implementation of it.
+*/
+interface Input {
+    /**
+    The length of the document.
+    */
+    readonly length: number;
+    /**
+    Get the chunk after the given position. The returned string
+    should start at `from` and, if that isn't the end of the
+    document, may be of any length greater than zero.
+    */
+    chunk(from: number): string;
+    /**
+    Indicates whether the chunks already end at line breaks, so that
+    client code that wants to work by-line can avoid re-scanning
+    them for line breaks. When this is true, the result of `chunk()`
+    should either be a single line break, or the content between
+    `from` and the next line break.
+    */
+    readonly lineChunks: boolean;
+    /**
+    Read the part of the document between the given positions.
+    */
+    read(from: number, to: number): string;
+}
+/**
+Parse wrapper functions are supported by some parsers to inject
+additional parsing logic.
+*/
+type ParseWrapper = (inner: PartialParse, input: Input, fragments: readonly TreeFragment[], ranges: readonly {
+    from: number;
+    to: number;
+}[]) => PartialParse;
+/**
+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.
+*/
+declare class NodeProp<T> {
+    /**
+    Indicates whether this prop is stored per [node
+    type](#common.NodeType) or per [tree node](#common.Tree).
+    */
+    perNode: boolean;
+    /**
+    A method that deserializes a value of this prop from a string.
+    Can be used to allow a prop to be directly written in a grammar
+    file.
+    */
+    deserialize: (str: string) => T;
+    /**
+    Create a new node prop type.
+    */
+    constructor(config?: {
+        /**
+        The [deserialize](#common.NodeProp.deserialize) function to
+        use for this prop, used for example when directly providing
+        the prop from a grammar file. Defaults to a function that
+        raises an error.
+        */
+        deserialize?: (str: string) => T;
+        /**
+        If configuring another value for this prop when it already
+        exists on a node should combine the old and new values, rather
+        than overwrite the old value, you can pass a function that
+        does the combining here.
+        */
+        combine?: (a: T, b: T) => T;
+        /**
+        By default, node props are stored in the [node
+        type](#common.NodeType). It can sometimes be useful to directly
+        store information (usually related to the parsing algorithm)
+        in [nodes](#common.Tree) themselves. Set this to true to enable
+        that for this prop.
+        */
+        perNode?: boolean;
+    });
+    /**
+    This is meant to be used with
+    [`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: {
+        [selector: string]: T;
+    } | ((type: NodeType) => T | undefined)): NodePropSource;
+    /**
+    Prop that is used to describe matching delimiters. For opening
+    delimiters, this holds an array of node names (written as a
+    space-separated string when declaring this prop in a grammar)
+    for the node types of closing delimiters that match it.
+    */
+    static closedBy: NodeProp<readonly string[]>;
+    /**
+    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.
+    */
+    static openedBy: NodeProp<readonly string[]>;
+    /**
+    Used to assign node types to groups (for example, all node
+    types that represent an expression could be tagged with an
+    `"Expression"` group).
+    */
+    static group: NodeProp<readonly string[]>;
+    /**
+    Attached to nodes to indicate these should be
+    [displayed](https://codemirror.net/docs/ref/#language.syntaxTree)
+    in a bidirectional text isolate, so that direction-neutral
+    characters on their sides don't incorrectly get associated with
+    surrounding text. You'll generally want to set this for nodes
+    that contain arbitrary text, like strings and comments, and for
+    nodes that appear _inside_ arbitrary text, like HTML tags. When
+    not given a value, in a grammar declaration, defaults to
+    `"auto"`.
+    */
+    static isolate: NodeProp<"rtl" | "ltr" | "auto">;
+    /**
+    The hash of the [context](#lr.ContextTracker.constructor)
+    that the node was parsed in, if any. Used to limit reuse of
+    contextual nodes.
+    */
+    static contextHash: NodeProp<number>;
+    /**
+    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.)
+    */
+    static lookAhead: NodeProp<number>;
+    /**
+    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 in mixed-language parsers.
+    */
+    static mounted: NodeProp<MountedTree>;
+}
+/**
+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.
+*/
+declare class MountedTree {
+    /**
+    The inner tree.
+    */
+    readonly 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).
+    */
+    readonly overlay: readonly {
+        from: number;
+        to: number;
+    }[] | null;
+    /**
+    The parser used to create this subtree.
+    */
+    readonly parser: Parser;
+    /**
+    [Indicates](#common.IterMode.EnterBracketed) that the nested
+    content is delineated with some kind
+    of bracket token.
+    */
+    readonly bracketed: boolean;
+    constructor(
+    /**
+    The inner tree.
+    */
+    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: readonly {
+        from: number;
+        to: number;
+    }[] | null,
+    /**
+    The parser used to create this subtree.
+    */
+    parser: Parser,
+    /**
+    [Indicates](#common.IterMode.EnterBracketed) that the nested
+    content is delineated with some kind
+    of bracket token.
+    */
+    bracketed?: boolean);
+}
+/**
+Type returned by [`NodeProp.add`](#common.NodeProp.add). Describes
+whether a prop should be added to a given node type in a node set,
+and what value it should have.
+*/
+type NodePropSource = (type: NodeType) => null | [NodeProp<any>, any];
+/**
+Each node in a syntax tree has a node type associated with it.
+*/
+declare class NodeType {
+    /**
+    The name of the node type. Not necessarily unique, but if the
+    grammar was written properly, different node types with the
+    same name within a node set should play the same semantic
+    role.
+    */
+    readonly name: string;
+    /**
+    The id of this node in its set. Corresponds to the term ids
+    used in the parser.
+    */
+    readonly id: number;
+    /**
+    Define a node type.
+    */
+    static define(spec: {
+        /**
+        The ID of the node type. When this type is used in a
+        [set](#common.NodeSet), the ID must correspond to its index in
+        the type array.
+        */
+        id: number;
+        /**
+        The name of the node type. Leave empty to define an anonymous
+        node.
+        */
+        name?: string;
+        /**
+        [Node props](#common.NodeProp) to assign to the type. The value
+        given for any given prop should correspond to the prop's type.
+        */
+        props?: readonly ([NodeProp<any>, any] | NodePropSource)[];
+        /**
+        Whether this is a [top node](#common.NodeType.isTop).
+        */
+        top?: boolean;
+        /**
+        Whether this node counts as an [error
+        node](#common.NodeType.isError).
+        */
+        error?: boolean;
+        /**
+        Whether this node is a [skipped](#common.NodeType.isSkipped)
+        node.
+        */
+        skipped?: boolean;
+    }): NodeType;
+    /**
+    Retrieves a node prop for this type. Will return `undefined` if
+    the prop isn't present on this node.
+    */
+    prop<T>(prop: NodeProp<T>): T | undefined;
+    /**
+    True when this is the top node of a grammar.
+    */
+    get isTop(): boolean;
+    /**
+    True when this node is produced by a skip rule.
+    */
+    get isSkipped(): boolean;
+    /**
+    Indicates whether this is an error node.
+    */
+    get isError(): boolean;
+    /**
+    When true, this node type doesn't correspond to a user-declared
+    named node, for example because it is used to cache repetition.
+    */
+    get isAnonymous(): boolean;
+    /**
+    Returns true when this node's name or one of its
+    [groups](#common.NodeProp^group) matches the given string.
+    */
+    is(name: string | number): boolean;
+    /**
+    An empty dummy node type to use when no actual type is available.
+    */
+    static none: NodeType;
+    /**
+    Create a function from node types to arbitrary values by
+    specifying an object whose property names are node or
+    [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<T>(map: {
+        [selector: string]: T;
+    }): (node: NodeType) => T | undefined;
+}
+/**
+A node set holds a collection of node types. It is used to
+compactly represent trees by storing their type ids, rather than a
+full pointer to the type object, in a numeric array. Each parser
+[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.
+*/
+declare class NodeSet {
+    /**
+    The node types in this set, by id.
+    */
+    readonly types: readonly NodeType[];
+    /**
+    Create a set with the given types. The `id` property of each
+    type should correspond to its position within the array.
+    */
+    constructor(
+    /**
+    The node types in this set, by id.
+    */
+    types: readonly NodeType[]);
+    /**
+    Create a copy of this set with some node properties added. The
+    arguments to this method can be created with
+    [`NodeProp.add`](#common.NodeProp.add).
+    */
+    extend(...props: NodePropSource[]): NodeSet;
+}
+/**
+Options that control iteration. Can be combined with the `|`
+operator to enable multiple ones.
+*/
+declare enum IterMode {
+    /**
+    When enabled, iteration will only visit [`Tree`](#common.Tree)
+    objects, not nodes packed into
+    [`TreeBuffer`](#common.TreeBuffer)s.
+    */
+    ExcludeBuffers = 1,
+    /**
+    Enable this to make iteration include anonymous nodes (such as
+    the nodes that wrap repeated grammar constructs into a balanced
+    tree).
+    */
+    IncludeAnonymous = 2,
+    /**
+    By default, regular [mounted](#common.NodeProp^mounted) nodes
+    replace their base node in iteration. Enable this to ignore them
+    instead.
+    */
+    IgnoreMounts = 4,
+    /**
+    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.
+    */
+    IgnoreOverlays = 8,
+    /**
+    When set, positions on the boundary of a mounted overlay tree
+    that has its [`bracketed`](#common.NestedParse.bracketed) flag
+    set will enter that tree regardless of side. Only supported in
+    [`enter`](#common.SyntaxNode.enter), not in cursors.
+    */
+    EnterBracketed = 16
+}
+/**
+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.
+
+Syntax trees are stored as a tree of `Tree` and `TreeBuffer`
+objects. By packing detail information into `TreeBuffer` leaf
+nodes, the representation is made a lot more memory-efficient.
+
+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`](#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.
+*/
+declare class Tree {
+    /**
+    The type of the top node.
+    */
+    readonly type: NodeType;
+    /**
+    This node's child nodes.
+    */
+    readonly children: readonly (Tree | TreeBuffer)[];
+    /**
+    The positions (offsets relative to the start of this tree) of
+    the children.
+    */
+    readonly positions: readonly number[];
+    /**
+    The total length of this tree
+    */
+    readonly length: number;
+    /**
+    Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+    */
+    constructor(
+    /**
+    The type of the top node.
+    */
+    type: NodeType,
+    /**
+    This node's child nodes.
+    */
+    children: readonly (Tree | TreeBuffer)[],
+    /**
+    The positions (offsets relative to the start of this tree) of
+    the children.
+    */
+    positions: readonly number[],
+    /**
+    The total length of this tree
+    */
+    length: number,
+    /**
+    Per-node [node props](#common.NodeProp) to associate with this node.
+    */
+    props?: readonly [NodeProp<any> | number, any][]);
+    /**
+    The empty tree
+    */
+    static empty: Tree;
+    /**
+    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?: IterMode): TreeCursor;
+    /**
+    Get a [tree cursor](#common.TreeCursor) pointing into this tree
+    at the given position and side (see
+    [`moveTo`](#common.TreeCursor.moveTo).
+    */
+    cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode): TreeCursor;
+    /**
+    Get a [syntax node](#common.SyntaxNode) object for the top of the
+    tree.
+    */
+    get topNode(): SyntaxNode;
+    /**
+    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
+    from both sides.
+
+    Note that this will not enter
+    [overlays](#common.MountedTree.overlay), and you often want
+    [`resolveInner`](#common.Tree.resolveInner) instead.
+    */
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    /**
+    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: number, side?: -1 | 0 | 1): SyntaxNode;
+    /**
+    In some situations, it can be useful to iterate through all
+    nodes around a position, including those in overlays that don't
+    directly cover the position. This method gives you an iterator
+    that will produce all nodes, from small to big, around the given
+    position.
+    */
+    resolveStack(pos: number, side?: -1 | 0 | 1): NodeIterator;
+    /**
+    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`, that node will
+    not have its children iterated over (or `leave` called).
+    */
+    iterate(spec: {
+        enter(node: SyntaxNodeRef): boolean | void;
+        leave?(node: SyntaxNodeRef): void;
+        from?: number;
+        to?: number;
+        mode?: IterMode;
+    }): void;
+    /**
+    Get the value of the given [node prop](#common.NodeProp) for this
+    node. Works with both per-node and per-type props.
+    */
+    prop<T>(prop: NodeProp<T>): T | 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(): readonly [NodeProp<any> | number, any][];
+    /**
+    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?: {
+        /**
+        Function to create the newly balanced subtrees.
+        */
+        makeTree?: (children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number) => Tree;
+    }): Tree;
+    /**
+    Build a tree from a postfix-ordered buffer of node information,
+    or a cursor over such a buffer.
+    */
+    static build(data: BuildData): Tree;
+}
+/**
+Represents a sequence of nodes.
+*/
+type NodeIterator = {
+    node: SyntaxNode;
+    next: NodeIterator | null;
+};
+type BuildData = {
+    /**
+    The buffer or buffer cursor to read the node data from.
+
+    When this is an array, it should contain four values for every
+    node in the tree.
+
+     - The first holds the node's type, as a node ID pointing into
+       the given `NodeSet`.
+     - The second holds the node's start offset.
+     - The third the end offset.
+     - The fourth the amount of space taken up in the array by this
+       node and its children. Since there's four values per node,
+       this is the total number of nodes inside this node (children
+       and transitive children) plus one for the node itself, times
+       four.
+
+    Parent nodes should appear _after_ child nodes in the array. As
+    an example, a node of type 10 spanning positions 0 to 4, with
+    two children, of type 11 and 12, might look like this:
+
+        [11, 0, 1, 4, 12, 2, 4, 4, 10, 0, 4, 12]
+    */
+    buffer: BufferCursor | readonly number[];
+    /**
+    The node types to use.
+    */
+    nodeSet: NodeSet;
+    /**
+    The id of the top node type.
+    */
+    topID: number;
+    /**
+    The position the tree should start at. Defaults to 0.
+    */
+    start?: number;
+    /**
+    The position in the buffer where the function should stop
+    reading. Defaults to 0.
+    */
+    bufferStart?: number;
+    /**
+    The length of the wrapping node. The end offset of the last
+    child is used when not provided.
+    */
+    length?: number;
+    /**
+    The maximum buffer length to use. Defaults to
+    [`DefaultBufferLength`](#common.DefaultBufferLength).
+    */
+    maxBufferLength?: number;
+    /**
+    An optional array holding reused nodes that the buffer can refer
+    to.
+    */
+    reused?: readonly Tree[];
+    /**
+    The first node type that indicates repeat constructs in this
+    grammar.
+    */
+    minRepeatType?: number;
+};
+/**
+This is used by `Tree.build` as an abstraction for iterating over
+a tree buffer. A cursor initially points at the very last element
+in the buffer. Every time `next()` is called it moves on to the
+previous one.
+*/
+interface BufferCursor {
+    /**
+    The current buffer position (four times the number of nodes
+    remaining).
+    */
+    pos: number;
+    /**
+    The node ID of the next node in the buffer.
+    */
+    id: number;
+    /**
+    The start position of the next node in the buffer.
+    */
+    start: number;
+    /**
+    The end position of the next node.
+    */
+    end: number;
+    /**
+    The size of the next node (the number of nodes inside, counting
+    the node itself, times 4).
+    */
+    size: number;
+    /**
+    Moves `this.pos` down by 4.
+    */
+    next(): void;
+    /**
+    Create a copy of this cursor.
+    */
+    fork(): BufferCursor;
+}
+/**
+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).
+*/
+declare class TreeBuffer {
+    /**
+    The buffer's content.
+    */
+    readonly buffer: Uint16Array;
+    /**
+    The total length of the group of nodes in the buffer.
+    */
+    readonly length: number;
+    /**
+    The node set used in this buffer.
+    */
+    readonly set: NodeSet;
+    /**
+    Create a tree buffer.
+    */
+    constructor(
+    /**
+    The buffer's content.
+    */
+    buffer: Uint16Array,
+    /**
+    The total length of the group of nodes in the buffer.
+    */
+    length: number,
+    /**
+    The node set used in this buffer.
+    */
+    set: NodeSet);
+}
+/**
+The set of properties provided by both [`SyntaxNode`](#common.SyntaxNode)
+and [`TreeCursor`](#common.TreeCursor). Note that, if you need
+an object that is guaranteed to stay stable in the future, you
+need to use the [`node`](#common.SyntaxNodeRef.node) accessor.
+*/
+interface SyntaxNodeRef {
+    /**
+    The start position of the node.
+    */
+    readonly from: number;
+    /**
+    The end position of the node.
+    */
+    readonly to: number;
+    /**
+    The type of the node.
+    */
+    readonly type: NodeType;
+    /**
+    The name of the node (`.type.name`).
+    */
+    readonly name: string;
+    /**
+    Get the [tree](#common.Tree) that represents the current node,
+    if any. Will return null when the node is in a [tree
+    buffer](#common.TreeBuffer).
+    */
+    readonly tree: Tree | null;
+    /**
+    Retrieve a stable [syntax node](#common.SyntaxNode) at this
+    position.
+    */
+    readonly node: SyntaxNode;
+    /**
+    Test whether the node matches a given context—a sequence of
+    direct parent nodes. Empty strings in the context array act as
+    wildcards, other strings must match the ancestor node's name.
+    */
+    matchContext(context: readonly string[]): boolean;
+}
+/**
+A syntax node provides an immutable pointer to a given node in a
+tree. When iterating over large amounts of nodes, you may want to
+use a mutable [cursor](#common.TreeCursor) instead, which is more
+efficient.
+*/
+interface SyntaxNode extends SyntaxNodeRef {
+    /**
+    The node's parent node, if any.
+    */
+    parent: SyntaxNode | null;
+    /**
+    The first child, if the node has children.
+    */
+    firstChild: SyntaxNode | null;
+    /**
+    The node's last child, if available.
+    */
+    lastChild: SyntaxNode | null;
+    /**
+    The first child that ends after `pos`.
+    */
+    childAfter(pos: number): SyntaxNode | null;
+    /**
+    The last child that starts before `pos`.
+    */
+    childBefore(pos: number): SyntaxNode | null;
+    /**
+    Enter the child at the given position. If side is -1 the child
+    may end at that position, when 1 it may start there.
+
+    This will by default enter
+    [overlaid](#common.MountedTree.overlay)
+    [mounted](#common.NodeProp^mounted) trees. You can set
+    `overlays` to false to disable that.
+
+    Similarly, when `buffers` is false this will not enter
+    [buffers](#common.TreeBuffer), only [nodes](#common.Tree) (which
+    is mostly useful when looking for props, which cannot exist on
+    buffer-allocated nodes).
+    */
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): SyntaxNode | null;
+    /**
+    This node's next sibling, if any.
+    */
+    nextSibling: SyntaxNode | null;
+    /**
+    This node's previous sibling.
+    */
+    prevSibling: SyntaxNode | null;
+    /**
+    Read the given node prop from this node.
+    */
+    prop<T>(prop: NodeProp<T>): T | undefined;
+    /**
+    A [tree cursor](#common.TreeCursor) starting at this node.
+    */
+    cursor(mode?: IterMode): TreeCursor;
+    /**
+    Find the node around, before (if `side` is -1), or after (`side`
+    is 1) the given position. Will look in parent nodes if the
+    position is outside this node.
+    */
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    /**
+    Similar to `resolve`, but enter
+    [overlaid](#common.MountedTree.overlay) nodes.
+    */
+    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    /**
+    Move the position to the innermost node before `pos` that looks
+    like it is unfinished (meaning it ends in an error node or has a
+    child ending in an error node right at its end).
+    */
+    enterUnfinishedNodesBefore(pos: number): SyntaxNode;
+    /**
+    Get a [tree](#common.Tree) for this node. Will allocate one if it
+    points into a buffer.
+    */
+    toTree(): Tree;
+    /**
+    Get the first child of the given type (which may be a [node
+    name](#common.NodeType.name) or a [group
+    name](#common.NodeProp^group)). If `before` is non-null, only
+    return children that occur somewhere after a node with that name
+    or group. If `after` is non-null, only return children that
+    occur somewhere before a node with that name or group.
+    */
+    getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode | null;
+    /**
+    Like [`getChild`](#common.SyntaxNode.getChild), but return all
+    matching children, not just the first.
+    */
+    getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
+}
+/**
+A tree cursor object focuses on a given node in a syntax tree, and
+allows you to move to adjacent nodes.
+*/
+declare class TreeCursor implements SyntaxNodeRef {
+    /**
+    The node's type.
+    */
+    type: NodeType;
+    /**
+    Shorthand for `.type.name`.
+    */
+    get name(): string;
+    /**
+    The start source offset of this node.
+    */
+    from: number;
+    /**
+    The end source offset.
+    */
+    to: number;
+    private stack;
+    private bufferNode;
+    private yieldNode;
+    private yieldBuf;
+    /**
+    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(): boolean;
+    /**
+    Move the cursor to this node's last child.
+    */
+    lastChild(): boolean;
+    /**
+    Move the cursor to the first child that ends after `pos`.
+    */
+    childAfter(pos: number): boolean;
+    /**
+    Move to the last child that starts before `pos`.
+    */
+    childBefore(pos: number): boolean;
+    /**
+    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: number, side: -1 | 0 | 1, mode?: IterMode): boolean;
+    /**
+    Move to the node's parent node, if this isn't the top node.
+    */
+    parent(): boolean;
+    /**
+    Move to this node's next sibling, if any.
+    */
+    nextSibling(): boolean;
+    /**
+    Move to this node's previous sibling, if any.
+    */
+    prevSibling(): boolean;
+    private atLastNode;
+    private move;
+    /**
+    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 or `enter` is false, its next sibling or
+    the next sibling of the first parent node that has one.
+    */
+    next(enter?: boolean): boolean;
+    /**
+    Move to the next node in a last-to-first pre-order traversal. A
+    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(enter?: boolean): boolean;
+    /**
+    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`.
+    */
+    moveTo(pos: number, side?: -1 | 0 | 1): this;
+    /**
+    Get a [syntax node](#common.SyntaxNode) at the cursor's current
+    position.
+    */
+    get node(): SyntaxNode;
+    /**
+    Get the [tree](#common.Tree) that represents the current node, if
+    any. Will return null when the node is in a [tree
+    buffer](#common.TreeBuffer).
+    */
+    get tree(): Tree | null;
+    /**
+    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: (node: SyntaxNodeRef) => boolean | void, leave?: (node: SyntaxNodeRef) => void): void;
+    /**
+    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: readonly string[]): boolean;
+}
+
+/**
+Data structure used to accumulate a block's content during [leaf
+block parsing](#BlockParser.leaf).
+*/
+declare class LeafBlock {
+    /**
+    The start position of the block.
+    */
+    readonly start: number;
+    /**
+    The block's text content.
+    */
+    content: string;
+    /**
+    The block parsers active for this block.
+    */
+    parsers: LeafBlockParser[];
+}
+/**
+Data structure used during block-level per-line parsing.
+*/
+declare class Line {
+    /**
+    The line's full text.
+    */
+    text: string;
+    /**
+    The base indent provided by the composite contexts (that have
+    been handled so far).
+    */
+    baseIndent: number;
+    /**
+    The string position corresponding to the base indent.
+    */
+    basePos: number;
+    /**
+    Any markers (i.e. block quote markers) parsed for the contexts.
+    A block parser that moves across lines, covering such marks, may
+    need to include these in its node structure.
+    */
+    markers: Element$1[];
+    /**
+    The position of the next non-whitespace character beyond any
+    list, blockquote, or other composite block markers.
+    */
+    pos: number;
+    /**
+    The column of the next non-whitespace character.
+    */
+    indent: number;
+    /**
+    The character code of the character after `pos`.
+    */
+    next: number;
+    /**
+    Skip whitespace after the given position, return the position of
+    the next non-space character or the end of the line if there's
+    only space after `from`.
+    */
+    skipSpace(from: number): number;
+    /**
+    Move the line's base position forward to the given position.
+    This should only be called by composite [block
+    parsers](#BlockParser.parse) or [markup skipping
+    functions](#NodeSpec.composite).
+    */
+    moveBase(to: number): void;
+    /**
+    Move the line's base position forward to the given _column_.
+    */
+    moveBaseColumn(indent: number): void;
+    /**
+    Store a composite-block-level marker. Should be called from
+    [markup skipping functions](#NodeSpec.composite) when they
+    consume any non-whitespace characters.
+    */
+    addMarker(elt: Element$1): void;
+    /**
+    Find the column position at `to`, optionally starting at a given
+    position and column.
+    */
+    countIndent(to: number, from?: number, indent?: number): number;
+    /**
+    Find the position corresponding to the given column.
+    */
+    findColumn(goal: number): number;
+}
+type BlockResult = boolean | null;
+/**
+Block-level parsing functions get access to this context object.
+*/
+declare class BlockContext implements PartialParse {
+    /**
+    The parser configuration used.
+    */
     readonly parser: MarkdownParser;
     private line;
     private atEnd;
@@ -7087,7 +8205,9 @@ general types of block parsers:
 - Composite block parsers, which handle things like lists and
   blockquotes. These define a [`parse`](#BlockParser.parse) method
   that [starts](#BlockContext.startComposite) a composite block
-  and returns null when it recognizes its syntax.
+  and returns null when it recognizes its syntax. The node type
+  used by such a block must define a
+  [`composite`](#NodeSpec.composite) function as well.
 
 - Eager leaf block parsers, used for things like code or HTML
   blocks. These can unambiguously recognize their content from its
@@ -7116,7 +8236,7 @@ interface BlockParser {
     The eager parse function, which can look at the block's first
     line and return `false` to do nothing, `true` if it has parsed
     (and [moved past](#BlockContext.nextLine) a block), or `null` if
-    it has started a composite block.
+    it has [started](#BlockContext.startComposite) a composite block.
     */
     parse?(cx: BlockContext, line: Line): BlockResult;
     /**
@@ -7341,6 +8461,17 @@ declare class InlineContext {
     */
     takeContent(startIndex: number): Element$1[];
     /**
+    Return the delimiter at the given index. Mostly useful to get
+    additional info out of a delimiter index returned by
+    [`findOpeningDelimiter`](#InlineContext.findOpeningDelimiter).
+    Returns null if there is no delimiter at this index.
+    */
+    getDelimiterAt(index: number): {
+        from: number;
+        to: number;
+        type: DelimiterType;
+    } | null;
+    /**
     Skip space after the given (document) position, returning either
     the position of the next non-space character or the end of the
     section.
@@ -7351,6 +8482,14 @@ declare class InlineContext {
     */
     elt(type: string, from: number, to: number, children?: readonly Element$1[]): Element$1;
     elt(tree: Tree, at: number): Element$1;
+    /**
+    The opening delimiter type used by the standard link parser.
+    */
+    static linkStart: DelimiterType;
+    /**
+    Opening delimiter type used for standard images.
+    */
+    static imageStart: DelimiterType;
 }
 
 /**
@@ -7715,12 +8854,12 @@ type NestedLang = {
     attrs?: (attrs: {
         [attr: string]: string;
     }) => boolean;
-    parser: Parser;
+    parser: Parser$1;
 };
 type NestedAttr = {
     name: string;
     tagName?: string;
-    parser: Parser;
+    parser: Parser$1;
 };
 /**
 A language provider based on the [Lezer HTML
@@ -8054,4 +9193,4 @@ declare function vue(): Promise<typeof _codemirror_lang_vue>;
 declare function wast(): Promise<typeof _codemirror_lang_wast>;
 declare function xml(): Promise<typeof _codemirror_lang_xml>;
 
-export { Annotation, AnnotationType, ChangeDesc, ChangeSet, type ChangeSpec, type Command, Compartment, type Completion, CompletionContext, type CompletionResult, type CompletionSource, Decoration, type DecorationSet, EditorSelection, EditorState, type EditorStateConfig, EditorView, type Extension, Facet, GutterMarker, HighlightStyle, type KeyBinding, LRParser, Language, LanguageSupport, Line$1 as Line, MapMode, MatchDecorator, NodeProp, NodeSet, NodeType, type Panel, Parser, Prec, Range, RangeSet, RangeSetBuilder, SelectionRange, StateEffect, StateEffectType, StateField, StreamLanguage, type StreamParser, StringStream, StyleModule, type SyntaxNode, Tag, type TagStyle, Text, type TextIterator, type Tooltip, type TooltipView, Transaction, type TransactionSpec, Tree, TreeCursor, ViewPlugin, ViewUpdate, WidgetType, acceptCompletion, angular, autocompletion, bidiIsolates, bracketMatching, clojure, closeBrackets, closeBracketsKeymap, closeCompletion, codeFolding, coffeescript, completeAnyWord, completionStatus, cpp, css, cssStreamParser, currentCompletions, cursorGroupLeft, cursorGroupRight, cursorMatchingBracket, cursorSyntaxLeft, cursorSyntaxRight, dart, drawSelection, ensureSyntaxTree, foldGutter, foldKeymap, forceParsing, go, gss, gutter, gutters, highlightSelectionMatches, highlightSpecialChars, highlightTree, history, historyKeymap, index_d$1 as html, ifNotIn, indentLess, indentMore, indentOnInput, indentUnit, indentationMarkers, insertNewlineAndIndent, java, index_d as javascript, keymap, kotlin, less, lineNumberMarkers, lineNumbers, markdown, moveCompletionSelection, php, placeholder, python, redo, redoSelection, repositionTooltips, sass, scala, scrollPastEnd, selectGroupLeft, selectGroupRight, selectMatchingBracket, selectNextOccurrence, selectSyntaxLeft, selectSyntaxRight, selectedCompletion, selectedCompletionIndex, shell, showPanel, showTooltip, standardKeymap, startCompletion, svelte, syntaxHighlighting, syntaxParserRunning, syntaxTree, tags, toggleComment, tooltips, undo, undoSelection, vue, wast, xml };
+export { Annotation, AnnotationType, ChangeDesc, ChangeSet, type ChangeSpec, type Command, Compartment, type Completion, CompletionContext, type CompletionResult, type CompletionSource, Decoration, type DecorationSet, EditorSelection, EditorState, type EditorStateConfig, EditorView, type Extension, Facet, GutterMarker, HighlightStyle, type KeyBinding, LRParser, Language, LanguageSupport, Line$1 as Line, MapMode, MatchDecorator, NodeProp$1 as NodeProp, NodeSet$1 as NodeSet, NodeType$1 as NodeType, type Panel, Parser$1 as Parser, Prec, Range, RangeSet, RangeSetBuilder, SelectionRange, StateEffect, StateEffectType, StateField, StreamLanguage, type StreamParser, StringStream, StyleModule, type SyntaxNode$1 as SyntaxNode, Tag, type TagStyle, Text, type TextIterator, type Tooltip, type TooltipView, Transaction, type TransactionSpec, Tree$1 as Tree, TreeCursor$1 as TreeCursor, ViewPlugin, ViewUpdate, WidgetType, acceptCompletion, angular, autocompletion, bidiIsolates, bracketMatching, clojure, closeBrackets, closeBracketsKeymap, closeCompletion, codeFolding, coffeescript, completeAnyWord, completionStatus, cpp, css, cssStreamParser, currentCompletions, cursorGroupLeft, cursorGroupRight, cursorMatchingBracket, cursorSyntaxLeft, cursorSyntaxRight, dart, drawSelection, ensureSyntaxTree, foldGutter, foldKeymap, forceParsing, go, gss, gutter, gutters, highlightSelectionMatches, highlightSpecialChars, highlightTree, history, historyKeymap, index_d$1 as html, ifNotIn, indentLess, indentMore, indentOnInput, indentUnit, indentationMarkers, insertNewlineAndIndent, java, index_d as javascript, keymap, kotlin, less, lineNumberMarkers, lineNumbers, markdown, moveCompletionSelection, php, placeholder, python, redo, redoSelection, repositionTooltips, sass, scala, scrollPastEnd, selectGroupLeft, selectGroupRight, selectMatchingBracket, selectNextOccurrence, selectSyntaxLeft, selectSyntaxRight, selectedCompletion, selectedCompletionIndex, shell, showPanel, showTooltip, standardKeymap, startCompletion, svelte, syntaxHighlighting, syntaxParserRunning, syntaxTree, tags, toggleComment, tooltips, undo, undoSelection, vue, wast, xml };