@lezer/common 0.15.10 → 0.16.0

package/dist/tree.d.ts

@@ -62,6 +62,12 @@ export declare class NodeSet {
     constructor(types: readonly NodeType[]);
     extend(...props: NodePropSource[]): NodeSet;
 }
+export declare enum IterMode {
+    ExcludeBuffers = 1,
+    IncludeAnonymous = 2,
+    IgnoreMounts = 4,
+    IgnoreOverlays = 8
+}
 export declare class Tree {
     readonly type: NodeType;
     readonly children: readonly (Tree | TreeBuffer)[];
@@ -69,16 +75,17 @@ export declare class Tree {
     readonly length: number;
     constructor(type: NodeType, children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number, props?: readonly [NodeProp<any> | number, any][]);
     static empty: Tree;
-    cursor(pos?: number, side?: -1 | 0 | 1): TreeCursor;
-    fullCursor(): TreeCursor;
+    cursor(mode?: IterMode): TreeCursor;
+    cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode): TreeCursor;
     get topNode(): SyntaxNode;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     iterate(spec: {
-        enter(type: NodeType, from: number, to: number, get: () => SyntaxNode): false | void;
-        leave?(type: NodeType, from: number, to: number, get: () => SyntaxNode): void;
+        enter(node: SyntaxNodeRef): boolean | void;
+        leave?(node: SyntaxNodeRef): void;
         from?: number;
         to?: number;
+        mode?: IterMode;
     }): void;
     prop<T>(prop: NodeProp<T>): T | undefined;
     get propValues(): readonly [NodeProp<any> | number, any][];
@@ -113,27 +120,31 @@ export declare class TreeBuffer {
     readonly set: NodeSet;
     constructor(buffer: Uint16Array, length: number, set: NodeSet);
 }
-export interface SyntaxNode {
-    type: NodeType;
-    name: string;
-    from: number;
-    to: number;
+export interface SyntaxNodeRef {
+    readonly from: number;
+    readonly to: number;
+    readonly type: NodeType;
+    readonly name: string;
+    readonly tree: Tree | null;
+    readonly node: SyntaxNode;
+}
+export interface SyntaxNode extends SyntaxNodeRef {
     parent: SyntaxNode | null;
     firstChild: SyntaxNode | null;
     lastChild: SyntaxNode | null;
     childAfter(pos: number): SyntaxNode | null;
     childBefore(pos: number): SyntaxNode | null;
-    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): SyntaxNode | null;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): SyntaxNode | null;
     nextSibling: SyntaxNode | null;
     prevSibling: SyntaxNode | null;
-    cursor: TreeCursor;
+    cursor(mode?: IterMode): TreeCursor;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
-    tree: Tree | null;
     toTree(): Tree;
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode | null;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
+    matchContext(context: readonly string[]): boolean;
 }
 declare const enum Side {
     Before = -2,
@@ -143,31 +154,26 @@ declare const enum Side {
     After = 2,
     DontCare = 4
 }
-export declare const enum Mode {
-    Full = 1,
-    NoEnterBuffer = 2
-}
 export declare class TreeNode implements SyntaxNode {
-    readonly node: Tree;
-    readonly _from: number;
+    readonly _tree: Tree;
+    readonly from: number;
     readonly index: number;
     readonly _parent: TreeNode | null;
-    constructor(node: Tree, _from: number, index: number, _parent: TreeNode | null);
+    constructor(_tree: Tree, from: number, index: number, _parent: TreeNode | null);
     get type(): NodeType;
     get name(): string;
-    get from(): number;
     get to(): number;
-    nextChild(i: number, dir: 1 | -1, pos: number, side: Side, mode?: Mode): TreeNode | BufferNode | null;
+    nextChild(i: number, dir: 1 | -1, pos: number, side: Side, mode?: IterMode): TreeNode | BufferNode | null;
     get firstChild(): TreeNode | BufferNode;
     get lastChild(): TreeNode | BufferNode;
     childAfter(pos: number): TreeNode | BufferNode;
     childBefore(pos: number): TreeNode | BufferNode;
-    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): TreeNode | BufferNode;
+    enter(pos: number, side: -1 | 0 | 1, mode?: number): TreeNode | BufferNode;
     nextSignificantParent(): TreeNode;
     get parent(): TreeNode;
     get nextSibling(): TreeNode | BufferNode;
     get prevSibling(): TreeNode | BufferNode;
-    get cursor(): TreeCursor;
+    cursor(mode?: IterMode): TreeCursor;
     get tree(): Tree;
     toTree(): Tree;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
@@ -175,6 +181,8 @@ export declare class TreeNode implements SyntaxNode {
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
+    get node(): this;
+    matchContext(context: readonly string[]): boolean;
 }
 declare class BufferContext {
     readonly parent: TreeNode;
@@ -197,12 +205,12 @@ declare class BufferNode implements SyntaxNode {
     get lastChild(): BufferNode;
     childAfter(pos: number): BufferNode;
     childBefore(pos: number): BufferNode;
-    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): BufferNode;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): BufferNode;
     get parent(): TreeNode | BufferNode;
     externalSibling(dir: 1 | -1): TreeNode | BufferNode;
     get nextSibling(): SyntaxNode | null;
     get prevSibling(): SyntaxNode | null;
-    get cursor(): TreeCursor;
+    cursor(mode?: IterMode): TreeCursor;
     get tree(): any;
     toTree(): Tree;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
@@ -210,15 +218,15 @@ declare class BufferNode implements SyntaxNode {
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode;
     getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[];
+    get node(): this;
+    matchContext(context: readonly string[]): boolean;
 }
-export declare class TreeCursor {
+export declare class TreeCursor implements SyntaxNodeRef {
     type: NodeType;
     get name(): string;
     from: number;
     to: number;
-    private buffer;
     private stack;
-    private index;
     private bufferNode;
     private yieldNode;
     private yieldBuf;
@@ -227,7 +235,7 @@ export declare class TreeCursor {
     lastChild(): boolean;
     childAfter(pos: number): boolean;
     childBefore(pos: number): boolean;
-    enter(pos: number, side: -1 | 0 | 1, overlays?: boolean, buffers?: boolean): boolean;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): boolean;
     parent(): boolean;
     nextSibling(): boolean;
     prevSibling(): boolean;
@@ -238,5 +246,16 @@ export declare class TreeCursor {
     moveTo(pos: number, side?: -1 | 0 | 1): this;
     get node(): SyntaxNode;
     get tree(): Tree | null;
+    iterate(enter: (node: SyntaxNodeRef) => boolean | void, leave?: (node: SyntaxNodeRef) => void): void;
+    matchContext(context: readonly string[]): boolean;
+}
+export declare class NodeWeakMap<T> {
+    private map;
+    private setBuffer;
+    private getBuffer;
+    set(node: SyntaxNode, value: T): void;
+    get(node: SyntaxNode): T | undefined;
+    cursorSet(cursor: TreeCursor, value: T): void;
+    cursorGet(cursor: TreeCursor): T | undefined;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lezer/common",
-  "version": "0.15.10",
+  "version": "0.16.0",
   "description": "Syntax tree data structure and parser interfaces for the lezer parser",
   "main": "dist/index.cjs",
   "type": "module",

package/dist/composite.d.ts

@@ -1,42 +0,0 @@
-import { Tree, SyntaxNode } from "./tree";
-import { Parser, PartialParse, TreeFragment, Input } from "./parse";
-export declare class SubtreeRange {
-    constructor(from: number, to: number, parser: Parser, cont?: any);
-}
-export declare class CompositeParser extends Parser {
-    private subtreeRanges;
-    private subtreeCache;
-    constructor(main: Parser, subtreeRanges: {
-        [nodeID: number]: (node: SyntaxNode, input: Input) => (readonly SubtreeRange[] | null);
-    });
-    startParseInner(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
-        from: number;
-        to: number;
-    }[]): CompositeParse;
-}
-declare class CompositeParse implements PartialParse {
-    readonly input: Input;
-    readonly fragments: readonly TreeFragment[];
-    readonly ranges: readonly {
-        from: number;
-        to: number;
-    }[];
-    readonly parser: CompositeParser;
-    main: PartialParse;
-    mainResult: Tree | null;
-    mainSub: Tree[];
-    inner: PartialParse[];
-    subtrees: Tree[];
-    stoppedAt: number | null;
-    constructor(input: Input, fragments: readonly TreeFragment[], ranges: readonly {
-        from: number;
-        to: number;
-    }[], parser: CompositeParser);
-    advance(): Tree | null;
-    private startSub;
-    private startInner;
-    private reuseInner;
-    stopAt(pos: number): void;
-    get parsedPos(): number;
-}
-export {};

package/dist/frame.d.ts

@@ -1,25 +0,0 @@
-import { Parser, ParseSpec, FullParseSpec, PartialParse } from "./parse";
-import { Tree, NodeType } from "./tree";
-export declare class FramingParser extends Parser {
-    constructor(config: {
-        frame: Parser;
-        fill: Parser;
-        frameNodes: readonly NodeType[];
-    });
-    startParse(spec: ParseSpec): FramingParse;
-}
-declare class FramingParse implements PartialParse {
-    readonly parser: FramingParser;
-    readonly spec: FullParseSpec;
-    outerTree: Tree | null;
-    outer: PartialParse;
-    inner: PartialParse | null;
-    stoppedAt: null | number;
-    constructor(parser: FramingParser, spec: FullParseSpec);
-    get parsedPos(): number;
-    advance(): Tree;
-    stopAt(pos: number): void;
-    private startInner;
-    private finishParse;
-}
-export {};

package/dist/scaffold.d.ts

@@ -1,25 +0,0 @@
-import { Parser, ParseSpec, FullParseSpec, PartialParse } from "./parse";
-import { Tree, NodeType } from "./tree";
-export declare class ScaffoldParser extends Parser {
-    constructor(config: {
-        scaffold: Parser;
-        fill: Parser;
-        scaffoldNodes: readonly NodeType[];
-    });
-    startParse(spec: ParseSpec): ScaffoldParse;
-}
-declare class ScaffoldParse implements PartialParse {
-    readonly parser: ScaffoldParser;
-    readonly spec: FullParseSpec;
-    outerTree: Tree | null;
-    outer: PartialParse;
-    inner: PartialParse | null;
-    stoppedAt: null | number;
-    constructor(parser: ScaffoldParser, spec: FullParseSpec);
-    get parsedPos(): number;
-    advance(): Tree;
-    stopAt(pos: number): void;
-    private startInner;
-    private finishParse;
-}
-export {};