@lezer/common 0.15.12 → 1.0.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,32 @@ 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;
+    matchContext(context: readonly string[]): boolean;
+}
+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 +155,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;
+    get parent(): TreeNode | null;
+    get nextSibling(): SyntaxNode | null;
+    get prevSibling(): SyntaxNode | null;
+    cursor(mode?: IterMode): TreeCursor;
     get tree(): Tree;
     toTree(): Tree;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
@@ -175,6 +182,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 +206,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;
-    get parent(): TreeNode | BufferNode;
+    enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): BufferNode;
+    get parent(): SyntaxNode | null;
     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 +219,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 +236,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 +247,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.12",
+  "version": "1.0.0",
   "description": "Syntax tree data structure and parser interfaces for the lezer parser",
   "main": "dist/index.cjs",
   "type": "module",