lezer - npm Package Compare versions

Comparing version 0.12.1 to 0.13.0

CHANGELOG.md

@@ -0,1 +1,25 @@
+## 0.13.0 (2020-12-04)
+
+### Breaking changes
+
+`Parser.group` is now called `Parser.nodeSet`.
+
+Nested parsers now work differently. They don't have to be Lezer parsers, but have to produce object conforoming to the `PartialParse` interface. The interface with which non-trivial nested parsers are specified also changed—see the `NestedParser` type.
+
+Parser objects no longer have a `topType` property (scan their node set for types with `isTop` set instead).
+
+`Parser` objects no longer have `withProps`, `withNested`, and `withTokenizer` methods (use `configure` instead).
+
+Both `Parser.parse` and `Parser.startParse` now take an optional start position as second parameter and an optional parse context as third. `startParse` returns an instance of the `PartialParse` interface instead of the old `ParseContext` class (whose name is now used for something else). Parse _options_ are no longer passed to these methods, but configured in advance through `Parser.configure`.
+
+During incremental parsing, instead of passing a tree as the `cache` option, reusable subtrees (see `TreeFragment` from lezer-tree) are now retrieved from the `fragments` property of the parse context object, if provided.
+
+`Parser.parse` and `Parser.startParse` no longer take an options parameter. Instead, `bufferLength` and `strict` can be configured with `Parser.configure` now, and the start position and context are passed as optional arguments.
+
+The `InputStream` type has been replaced by `Input` from the lezer-tree package (which has the same interface but a more appropriate name).
+
+### New features
+
+The `Parser` class now has a `configure` method that is used to create a parser instance with a more specific configuration.
+
 ## 0.12.1 (2020-11-19)
@@ -2,0 +26,0 @@

dist/constants.d.ts

@@ -45,10 +45,4 @@ export declare const enum Action {
 }
-export declare const enum NodeFlag {
-    Top = 1,
-    Skipped = 2,
-    Error = 4,
-    Repeated = 8
-}
 export declare const enum File {
-    Version = 12
+    Version = 13
 }

dist/index.d.ts

@@ -1,4 +0,4 @@
-export { Parser, ParseOptions, ParseContext, NestedGrammar, NestedGrammarSpec } from "./parse";
-export { InputStream, Token, ExternalTokenizer } from "./token";
+export { Parser, ParserConfig, NestedParser, NestedParserSpec } from "./parse";
+export { Token, ExternalTokenizer } from "./token";
 export { Stack } from "./stack";
-export { Tree, TreeCursor, SyntaxNode, NodeGroup, NodeType, NodeProp } from "lezer-tree";
+export { Tree, Input, TreeCursor, SyntaxNode, NodeSet, NodeType, NodeProp } from "lezer-tree";

dist/parse.d.ts

@@ -0,13 +1,23 @@
+import { Tree, TreeBuffer, TreeFragment, NodeSet, NodeType, NodePropSource, Input, PartialParse, ParseContext } from "lezer-tree";
 import { Stack } from "./stack";
-import { InputStream, Token, Tokenizer, ExternalTokenizer } from "./token";
-import { Tree, TreeBuffer, NodeGroup, NodePropSource } from "lezer-tree";
-export declare type NestedGrammar = null | Parser | ((input: InputStream, stack: Stack) => NestedGrammarSpec);
-export interface NestedGrammarSpec {
-    parser?: Parser;
-    top?: string;
-    dialect?: string;
-    stay?: boolean;
-    parseNode?: (input: InputStream, start: number) => Tree;
-    wrapType?: number;
-    filterEnd?: (endToken: string) => boolean;
+import { Token, Tokenizer, ExternalTokenizer } from "./token";
+export declare type NestedParserSpec = {
+    startParse?: (input: Input, startPos: number, context: ParseContext) => PartialParse;
+    wrapType?: NodeType | number;
+    filterEnd?(endToken: string): boolean;
+};
+export declare type NestedParser = NestedParserSpec | ((input: Input, stack: Stack) => NestedParserSpec | null);
+declare class FragmentCursor {
+    readonly fragments: readonly TreeFragment[];
+    i: number;
+    fragment: TreeFragment | null;
+    safeFrom: number;
+    safeTo: number;
+    trees: Tree[];
+    start: number[];
+    index: number[];
+    nextStart: number;
+    constructor(fragments: readonly TreeFragment[]);
+    nextFragment(): void;
+    nodeAt(pos: number): Tree | TreeBuffer | null;
 }
@@ -24,34 +34,24 @@ declare class CachedToken extends Token {
     constructor(parser: Parser);
-    getActions(stack: Stack, input: InputStream): number[];
-    updateCachedToken(token: CachedToken, tokenizer: Tokenizer, stack: Stack, input: InputStream): void;
+    getActions(stack: Stack, input: Input): number[];
+    updateCachedToken(token: CachedToken, tokenizer: Tokenizer, stack: Stack, input: Input): void;
     putAction(action: number, token: number, end: number, index: number): number;
     addActions(stack: Stack, token: number, end: number, index: number): number;
 }
-export interface ParseOptions {
-    cache?: Tree;
-    strict?: boolean;
-    bufferLength?: number;
-    top?: string;
-    dialect?: string;
-}
-export declare class StackContext {
-    readonly parser: Parser;
-    readonly maxBufferLength: number;
-    readonly input: InputStream;
-    readonly topTerm: number;
-    readonly dialect: Dialect;
-    readonly parent: Stack | null;
-    wrapType: number;
+export declare class Parse implements PartialParse {
+    parser: Parser;
+    input: Input;
+    startPos: number;
+    context: ParseContext;
+    stacks: Stack[];
+    pos: number;
+    recovering: number;
+    fragments: FragmentCursor | null;
+    nextStackID: number;
+    nested: PartialParse | null;
+    nestEnd: number;
+    nestWrap: NodeType | null;
     reused: (Tree | TreeBuffer)[];
     tokens: TokenCache;
-    constructor(parser: Parser, maxBufferLength: number, input: InputStream, topTerm: number, dialect: Dialect, parent?: Stack | null, wrapType?: number);
-}
-export declare class ParseContext {
-    private stacks;
-    pos: number;
-    private recovering;
-    private tokenCount;
-    private cache;
-    private strict;
-    private nextStackID;
+    topTerm: number;
+    constructor(parser: Parser, input: Input, startPos: number, context: ParseContext);
     advance(): Tree;
@@ -62,3 +62,5 @@ private advanceStack;
     forceFinish(): Tree;
-    get badness(): number;
+    stackToTree(stack: Stack, pos?: number): Tree;
+    private checkNest;
+    private startNested;
     private scanForNestEnd;
@@ -75,4 +77,18 @@ private finishNested;
 }
+export interface ParserConfig {
+    props?: readonly NodePropSource[];
+    top?: string;
+    dialect?: string;
+    nested?: {
+        [name: string]: NestedParser;
+    };
+    tokenizers?: {
+        from: ExternalTokenizer;
+        to: ExternalTokenizer;
+    }[];
+    strict?: boolean;
+    bufferLength?: number;
+}
 export declare class Parser {
-    readonly group: NodeGroup;
+    readonly nodeSet: NodeSet;
     readonly topRules: {
@@ -83,14 +99,8 @@ [name: string]: [number, number];
     private cachedDialect;
-    parse(input: InputStream | string, options?: ParseOptions): Tree;
-    startParse(input: InputStream | string, options?: ParseOptions): ParseContext;
-    withNested(spec: {
-        [name: string]: NestedGrammar | null;
-    }): Parser;
-    withProps(...props: NodePropSource[]): Parser;
-    withTokenizer(from: ExternalTokenizer, to: ExternalTokenizer): Parser;
-    private copy;
+    parse(input: Input | string, startPos?: number, context?: ParseContext): Tree;
+    startParse(input: Input | string, startPos?: number, context?: ParseContext): PartialParse;
+    configure(config: ParserConfig): Parser;
     getName(term: number): string;
     get hasNested(): boolean;
-    get topType(): any;
 }
 export {};

dist/stack.d.ts

@@ -1,4 +0,5 @@
-import { StackContext } from "./parse";
+import { Parse } from "./parse";
+import { BufferCursor } from "lezer-tree";
 export declare class Stack {
-    readonly cx: StackContext;
+    readonly cx: Parse;
     pos: number;
@@ -18,1 +19,16 @@ canShift(term: number): boolean;
 }
+export declare class StackBufferCursor implements BufferCursor {
+    stack: Stack;
+    pos: number;
+    index: number;
+    buffer: number[];
+    constructor(stack: Stack, pos: number, index: number);
+    static create(stack: Stack): StackBufferCursor;
+    maybeNext(): void;
+    get id(): number;
+    get start(): number;
+    get end(): number;
+    get size(): number;
+    next(): void;
+    fork(): StackBufferCursor;
+}

dist/token.d.ts

@@ -0,1 +1,2 @@
+import { Input } from "lezer-tree";
 import { Stack } from "./stack";
@@ -8,18 +9,4 @@ export declare class Token {
 }
-export interface InputStream {
-    length: number;
-    get(pos: number): number;
-    read(from: number, to: number): string;
-    clip(at: number): InputStream;
-}
-export declare class StringStream implements InputStream {
-    readonly string: string;
-    readonly length: number;
-    constructor(string: string, length?: number);
-    get(pos: number): number;
-    read(from: number, to: number): string;
-    clip(at: number): StringStream;
-}
 export interface Tokenizer {
-    token(input: InputStream, token: Token, stack: Stack): void;
+    token(input: Input, token: Token, stack: Stack): void;
     contextual: boolean;
@@ -35,4 +22,4 @@ fallback: boolean;
 export declare class ExternalTokenizer {
-    constructor(token: (input: InputStream, token: Token, stack: Stack) => void, options?: ExternalOptions);
+    constructor(token: (input: Input, token: Token, stack: Stack) => void, options?: ExternalOptions);
 }
 export {};

package.json

 {
   "name": "lezer",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Incremental parser",
@@ -5,0 +5,0 @@ "main": "dist/index.cjs",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

350352

decreased by-10.48%

Lines of code

3071

decreased by-4.6%

No dependency changes