grammar-well 1.1.2 → 1.1.4

package/build/lexers/token-buffer.js

@@ -1,92 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenBuffer = void 0;
-class TokenBuffer {
-    lexer;
-    history = [];
-    queued = '';
-    $historyIndex = -1;
-    get offset() { return this.active?.offset || 0; }
-    get line() { return this.active?.line || 0; }
-    get column() { return this.active?.column || 0; }
-    get active() { return this.history[this.$historyIndex]; }
-    get state() {
-        return { historyIndex: this.$historyIndex, offset: this.offset };
-    }
-    constructor(lexer) {
-        this.lexer = lexer;
-    }
-    reset(buffer) {
-        this.lexer.feed(buffer);
-        this.history = [];
-        this.$historyIndex = -1;
-    }
-    restore(state) {
-        if (this.history[state.historyIndex].offset != state.offset) {
-            return;
-        }
-        this.$historyIndex = state.historyIndex;
-    }
-    feed(buffer, flush) {
-        this.queued += buffer;
-        if (flush) {
-            this.flush();
-        }
-    }
-    flush() {
-        this.history = this.history.slice(this.$historyIndex);
-        this.$historyIndex = 0;
-        if (this.lexer.flush) {
-            this.lexer.flush();
-        }
-    }
-    previous() {
-        if (this.$historyIndex > 0) {
-            return this.history[--this.$historyIndex];
-        }
-    }
-    next() {
-        if (this.$historyIndex + 1 >= this.history.length) {
-            this.lexerNext();
-        }
-        if (this.$historyIndex + 1 < this.history.length) {
-            return this.history[++this.$historyIndex];
-        }
-    }
-    peek(offset) {
-        offset += this.$historyIndex;
-        while ((offset >= this.history.length) && this.lexerNext()) {
-        }
-        if (offset >= 0 && offset < this.history.length)
-            return this.history[offset];
-    }
-    lexerNext() {
-        let token = this.lexer.next();
-        if (typeof token === 'undefined' && this.queued) {
-            this.lexer.feed(this.queued, this.$historyIndex >= 0 ? this.lexer.state() : undefined);
-            this.queued = '';
-            token = this.lexer.next();
-        }
-        if (token)
-            this.history.push(token);
-        return token;
-    }
-    [Symbol.iterator]() {
-        return new TokenIterator(this);
-    }
-}
-exports.TokenBuffer = TokenBuffer;
-class TokenIterator {
-    buffer;
-    constructor(buffer) {
-        this.buffer = buffer;
-    }
-    next() {
-        const token = this.buffer.next();
-        return { value: token, done: !token };
-    }
-    [Symbol.iterator]() {
-        return this;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenBuffer = void 0;
+class TokenBuffer {
+    lexer;
+    history = [];
+    queued = '';
+    $historyIndex = -1;
+    get offset() { return this.active?.offset || 0; }
+    get line() { return this.active?.line || 0; }
+    get column() { return this.active?.column || 0; }
+    get active() { return this.history[this.$historyIndex]; }
+    get state() {
+        return { historyIndex: this.$historyIndex, offset: this.offset };
+    }
+    constructor(lexer) {
+        this.lexer = lexer;
+    }
+    reset(buffer) {
+        this.lexer.feed(buffer);
+        this.history = [];
+        this.$historyIndex = -1;
+    }
+    restore(state) {
+        if (this.history[state.historyIndex].offset != state.offset) {
+            return;
+        }
+        this.$historyIndex = state.historyIndex;
+    }
+    feed(buffer, flush) {
+        this.queued += buffer;
+        if (flush) {
+            this.flush();
+        }
+    }
+    flush() {
+        this.history = this.history.slice(this.$historyIndex);
+        this.$historyIndex = 0;
+        if (this.lexer.flush) {
+            this.lexer.flush();
+        }
+    }
+    previous() {
+        if (this.$historyIndex > 0) {
+            return this.history[--this.$historyIndex];
+        }
+    }
+    next() {
+        if (this.$historyIndex + 1 >= this.history.length) {
+            this.lexerNext();
+        }
+        if (this.$historyIndex + 1 < this.history.length) {
+            return this.history[++this.$historyIndex];
+        }
+    }
+    peek(offset) {
+        offset += this.$historyIndex;
+        while ((offset >= this.history.length) && this.lexerNext()) {
+        }
+        if (offset >= 0 && offset < this.history.length)
+            return this.history[offset];
+    }
+    lexerNext() {
+        let token = this.lexer.next();
+        if (typeof token === 'undefined' && this.queued) {
+            this.lexer.feed(this.queued, this.$historyIndex >= 0 ? this.lexer.state() : undefined);
+            this.queued = '';
+            token = this.lexer.next();
+        }
+        if (token)
+            this.history.push(token);
+        return token;
+    }
+    [Symbol.iterator]() {
+        return new TokenIterator(this);
+    }
+}
+exports.TokenBuffer = TokenBuffer;
+class TokenIterator {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    next() {
+        const token = this.buffer.next();
+        return { value: token, done: !token };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
 //# sourceMappingURL=token-buffer.js.map

package/build/parser/algorithms/cyk.d.ts

@@ -1,16 +1,16 @@
-import { TokenBuffer } from "../../lexers/token-buffer";
-import { GrammarRule, LanguageDefinition, LexerToken } from "../../typings";
-export declare function CYK(language: LanguageDefinition & {
-    tokens: TokenBuffer;
-}, _options?: {}): {
-    results: any[];
-};
-export interface NonTerminal {
-    rule: GrammarRule;
-    left: NonTerminal | Terminal;
-    right: NonTerminal | Terminal;
-}
-export interface Terminal {
-    rule: GrammarRule;
-    token: LexerToken;
-}
+import { TokenBuffer } from "../../lexers/token-buffer";
+import { GrammarRule, LanguageDefinition, LexerToken } from "../../typings";
+export declare function CYK(language: LanguageDefinition & {
+    tokens: TokenBuffer;
+}, _options?: {}): {
+    results: any[];
+};
+export interface NonTerminal {
+    rule: GrammarRule;
+    left: NonTerminal | Terminal;
+    right: NonTerminal | Terminal;
+}
+export interface Terminal {
+    rule: GrammarRule;
+    token: LexerToken;
+}

package/build/parser/algorithms/cyk.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CYK = void 0;
-const general_1 = require("../../utility/general");
-const parser_1 = require("../parser");
-function CYK(language, _options = {}) {
-    const { grammar, tokens } = language;
-    const terminals = [];
-    const nonTerminals = [];
-    for (const name in grammar.rules) {
-        for (const rule of grammar.rules[name]) {
-            const { symbols } = rule;
-            if (parser_1.ParserUtility.SymbolIsTerminal(symbols[0])) {
-                terminals.push(rule);
-            }
-            else {
-                nonTerminals.push(rule);
-            }
-        }
-    }
-    let currentTokenIndex = -1;
-    const chart = new general_1.Matrix(0, 0, () => new Map());
-    for (const token of tokens) {
-        currentTokenIndex++;
-        chart.resize(currentTokenIndex + 2, currentTokenIndex + 2);
-        for (const rule of terminals) {
-            if (parser_1.ParserUtility.TokenMatchesSymbol(token, rule.symbols[0])) {
-                chart.get(currentTokenIndex, currentTokenIndex).set(rule.name, { rule, token });
-            }
-        }
-        for (let floor = currentTokenIndex; floor >= 0; floor--) {
-            for (let inner = floor; inner <= currentTokenIndex; inner++) {
-                const leftCell = chart.get(floor, inner);
-                const rightCell = chart.get(inner + 1, currentTokenIndex);
-                for (const rule of nonTerminals) {
-                    const { symbols: [leftSymbol, rightSymbol] } = rule;
-                    const left = leftCell.get(leftSymbol);
-                    const right = rightCell.get(rightSymbol);
-                    if (left && right) {
-                        chart.get(floor, currentTokenIndex).set(rule.name, { rule, left, right });
-                    }
-                }
-            }
-        }
-    }
-    const results = Array.from(chart.get(0, currentTokenIndex).values()).map(v => GetValue(v));
-    return { results };
-}
-exports.CYK = CYK;
-function GetValue(ref) {
-    if (!ref)
-        return;
-    if ('token' in ref) {
-        return parser_1.ParserUtility.PostProcess(ref.rule, [ref.token]);
-    }
-    return parser_1.ParserUtility.PostProcess(ref.rule, [GetValue(ref.left), GetValue(ref.right)]);
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CYK = void 0;
+const general_1 = require("../../utility/general");
+const parser_1 = require("../parser");
+function CYK(language, _options = {}) {
+    const { grammar, tokens } = language;
+    const terminals = [];
+    const nonTerminals = [];
+    for (const name in grammar.rules) {
+        for (const rule of grammar.rules[name]) {
+            const { symbols } = rule;
+            if (parser_1.ParserUtility.SymbolIsTerminal(symbols[0])) {
+                terminals.push(rule);
+            }
+            else {
+                nonTerminals.push(rule);
+            }
+        }
+    }
+    let currentTokenIndex = -1;
+    const chart = new general_1.Matrix(0, 0, () => new Map());
+    for (const token of tokens) {
+        currentTokenIndex++;
+        chart.resize(currentTokenIndex + 2, currentTokenIndex + 2);
+        for (const rule of terminals) {
+            if (parser_1.ParserUtility.TokenMatchesSymbol(token, rule.symbols[0])) {
+                chart.get(currentTokenIndex, currentTokenIndex).set(rule.name, { rule, token });
+            }
+        }
+        for (let floor = currentTokenIndex; floor >= 0; floor--) {
+            for (let inner = floor; inner <= currentTokenIndex; inner++) {
+                const leftCell = chart.get(floor, inner);
+                const rightCell = chart.get(inner + 1, currentTokenIndex);
+                for (const rule of nonTerminals) {
+                    const { symbols: [leftSymbol, rightSymbol] } = rule;
+                    const left = leftCell.get(leftSymbol);
+                    const right = rightCell.get(rightSymbol);
+                    if (left && right) {
+                        chart.get(floor, currentTokenIndex).set(rule.name, { rule, left, right });
+                    }
+                }
+            }
+        }
+    }
+    const results = Array.from(chart.get(0, currentTokenIndex).values()).map(v => GetValue(v));
+    return { results };
+}
+exports.CYK = CYK;
+function GetValue(ref) {
+    if (!ref)
+        return;
+    if ('token' in ref) {
+        return parser_1.ParserUtility.PostProcess(ref.rule, [ref.token]);
+    }
+    return parser_1.ParserUtility.PostProcess(ref.rule, [GetValue(ref.left), GetValue(ref.right)]);
+}
 //# sourceMappingURL=cyk.js.map

package/build/parser/algorithms/earley.d.ts

@@ -1,48 +1,48 @@
-import { Dictionary, GrammarRule, LanguageDefinition } from "../../typings";
-import { TokenBuffer } from "../../lexers/token-buffer";
-export interface EarleyParserOptions {
-    keepHistory?: boolean;
-}
-export declare function Earley(language: LanguageDefinition & {
-    tokens: TokenBuffer;
-}, options?: EarleyParserOptions): {
-    results: any[];
-    info: {
-        table: Column[];
-    };
-};
-declare class Column {
-    private rules;
-    index: number;
-    data: any;
-    states: State[];
-    wants: Dictionary<State[]>;
-    scannable: State[];
-    completed: Dictionary<State[]>;
-    constructor(rules: Dictionary<GrammarRule[]>, index: number);
-    process(): void;
-    predict(exp: string): void;
-    expects(): GrammarRule[];
-    private complete;
-}
-declare class State {
-    rule: GrammarRule;
-    dot: number;
-    reference: number;
-    wantedBy: State[];
-    isComplete: boolean;
-    data: any;
-    left: State;
-    right: State | StateToken;
-    constructor(rule: GrammarRule, dot: number, reference: number, wantedBy: State[]);
-    nextState(child: State | StateToken): State;
-    finish(): void;
-    protected build(): any[];
-}
-interface StateToken {
-    data: any;
-    token: any;
-    isToken: boolean;
-    reference: number;
-}
-export {};
+import { Dictionary, GrammarRule, LanguageDefinition } from "../../typings";
+import { TokenBuffer } from "../../lexers/token-buffer";
+export interface EarleyParserOptions {
+    keepHistory?: boolean;
+}
+export declare function Earley(language: LanguageDefinition & {
+    tokens: TokenBuffer;
+}, options?: EarleyParserOptions): {
+    results: any[];
+    info: {
+        table: Column[];
+    };
+};
+declare class Column {
+    private rules;
+    index: number;
+    data: any;
+    states: State[];
+    wants: Dictionary<State[]>;
+    scannable: State[];
+    completed: Dictionary<State[]>;
+    constructor(rules: Dictionary<GrammarRule[]>, index: number);
+    process(): void;
+    predict(exp: string): void;
+    expects(): GrammarRule[];
+    private complete;
+}
+declare class State {
+    rule: GrammarRule;
+    dot: number;
+    reference: number;
+    wantedBy: State[];
+    isComplete: boolean;
+    data: any;
+    left: State;
+    right: State | StateToken;
+    constructor(rule: GrammarRule, dot: number, reference: number, wantedBy: State[]);
+    nextState(child: State | StateToken): State;
+    finish(): void;
+    protected build(): any[];
+}
+interface StateToken {
+    data: any;
+    token: any;
+    isToken: boolean;
+    reference: number;
+}
+export {};