@lezer/common 0.15.11 → 0.15.12

package/dist/index.cjs

@@ -1399,7 +1399,7 @@ class MixedParse {
                     if (match)
                         for (let r of match.mount.overlay) {
                             let from = r.from + match.pos, to = r.to + match.pos;
-                            if (from >= cursor.from && to <= cursor.to)
+                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))
                                 overlay.ranges.push({ from, to });
                         }
                 }

package/dist/index.js

@@ -1395,7 +1395,7 @@ class MixedParse {
                     if (match)
                         for (let r of match.mount.overlay) {
                             let from = r.from + match.pos, to = r.to + match.pos;
-                            if (from >= cursor.from && to <= cursor.to)
+                            if (from >= cursor.from && to <= cursor.to && !overlay.ranges.some(r => r.from < to && r.to > from))
                                 overlay.ranges.push({ from, to });
                         }
                 }

package/dist/tree.d.ts

@@ -72,8 +72,8 @@ export declare class Tree {
     cursor(pos?: number, side?: -1 | 0 | 1): TreeCursor;
     fullCursor(): TreeCursor;
     get topNode(): SyntaxNode;
-    resolve(pos: number, side?: -1 | 0 | 1): any;
-    resolveInner(pos: number, side?: -1 | 0 | 1): any;
+    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;
@@ -170,8 +170,8 @@ export declare class TreeNode implements SyntaxNode {
     get cursor(): TreeCursor;
     get tree(): Tree;
     toTree(): Tree;
-    resolve(pos: number, side?: -1 | 0 | 1): any;
-    resolveInner(pos: number, side?: -1 | 0 | 1): any;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): 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[];
@@ -205,8 +205,8 @@ declare class BufferNode implements SyntaxNode {
     get cursor(): TreeCursor;
     get tree(): any;
     toTree(): Tree;
-    resolve(pos: number, side?: -1 | 0 | 1): any;
-    resolveInner(pos: number, side?: -1 | 0 | 1): any;
+    resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): 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[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lezer/common",
-  "version": "0.15.11",
+  "version": "0.15.12",
   "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 {};