grammar-well 1.1.2 → 1.1.4

package/build/parser/algorithms/earley.js

@@ -1,158 +1,158 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Earley = void 0;
-const text_format_1 = require("../../utility/text-format");
-const parser_1 = require("../parser");
-function Earley(language, options = {}) {
-    const { tokens } = language;
-    const { rules, start } = language.grammar;
-    const column = new Column(rules, 0);
-    const table = [column];
-    column.wants[start] = [];
-    column.predict(start);
-    column.process();
-    let current = 0;
-    for (const token of tokens) {
-        const previousColumn = table[current];
-        if (!(options.keepHistory)) {
-            delete table[current - 1];
-        }
-        current++;
-        const nextColumn = new Column(rules, current);
-        table.push(nextColumn);
-        const literal = token.value;
-        const data = token;
-        nextColumn.data = literal;
-        const { scannable } = previousColumn;
-        for (let w = scannable.length; w--;) {
-            const state = scannable[w];
-            const symbol = state.rule.symbols[state.dot];
-            if (parser_1.ParserUtility.TokenMatchesSymbol(token, symbol)) {
-                const next = state.nextState({ data, token, isToken: true, reference: current - 1 });
-                nextColumn.states.push(next);
-            }
-        }
-        nextColumn.process();
-        if (nextColumn.states.length === 0) {
-            throw text_format_1.TextFormatter.UnexpectedToken(tokens, previousColumn.expects());
-        }
-    }
-    const results = [];
-    const { states } = table[table.length - 1];
-    for (const { rule: { name, symbols }, dot, reference, data } of states) {
-        if (name === start && dot === symbols.length && reference == 0) {
-            results.push(data);
-        }
-    }
-    return { results, info: { table } };
-}
-exports.Earley = Earley;
-class Column {
-    rules;
-    index;
-    data;
-    states = [];
-    wants = Object.create(null);
-    scannable = [];
-    completed = Object.create(null);
-    constructor(rules, index) {
-        this.rules = rules;
-        this.index = index;
-    }
-    process() {
-        let w = 0;
-        let state;
-        while (state = this.states[w++]) {
-            if (state.isComplete) {
-                state.finish();
-                const { wantedBy } = state;
-                for (let i = wantedBy.length; i--;) {
-                    this.complete(wantedBy[i], state);
-                }
-                if (state.reference === this.index) {
-                    const { name } = state.rule;
-                    this.completed[name] = this.completed[name] || [];
-                    this.completed[name].push(state);
-                }
-            }
-            else {
-                const exp = state.rule.symbols[state.dot];
-                if (typeof exp !== 'string') {
-                    this.scannable.push(state);
-                    continue;
-                }
-                if (this.wants[exp]) {
-                    this.wants[exp].push(state);
-                    if (this.completed[exp]) {
-                        for (const right of this.completed[exp]) {
-                            this.complete(state, right);
-                        }
-                    }
-                }
-                else {
-                    this.wants[exp] = [state];
-                    this.predict(exp);
-                }
-            }
-        }
-    }
-    predict(exp) {
-        if (!this.rules[exp])
-            return;
-        for (const rule of this.rules[exp]) {
-            this.states.push(new State(rule, 0, this.index, this.wants[exp]));
-        }
-    }
-    expects() {
-        return this.states
-            .filter((state) => {
-            const nextSymbol = state.rule.symbols[state.dot];
-            return nextSymbol && typeof nextSymbol !== "string";
-        })
-            .map(v => ({ ...v.rule, index: v.dot }));
-    }
-    complete(left, right) {
-        const copy = left.nextState(right);
-        this.states.push(copy);
-    }
-}
-class State {
-    rule;
-    dot;
-    reference;
-    wantedBy;
-    isComplete;
-    data = [];
-    left;
-    right;
-    constructor(rule, dot, reference, wantedBy) {
-        this.rule = rule;
-        this.dot = dot;
-        this.reference = reference;
-        this.wantedBy = wantedBy;
-        this.isComplete = this.dot === rule.symbols.length;
-    }
-    nextState(child) {
-        const state = new State(this.rule, this.dot + 1, this.reference, this.wantedBy);
-        state.left = this;
-        state.right = child;
-        if (state.isComplete) {
-            state.data = state.build();
-            state.right = undefined;
-        }
-        return state;
-    }
-    finish() {
-        this.data = parser_1.ParserUtility.PostProcess(this.rule, this.data, { reference: this.reference, dot: this.dot });
-    }
-    build() {
-        const children = [];
-        let node = this;
-        do {
-            children[node.dot - 1] = node.right.data;
-            node = node.left;
-        } while (node.left);
-        return children;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Earley = void 0;
+const text_format_1 = require("../../utility/text-format");
+const parser_1 = require("../parser");
+function Earley(language, options = {}) {
+    const { tokens } = language;
+    const { rules, start } = language.grammar;
+    const column = new Column(rules, 0);
+    const table = [column];
+    column.wants[start] = [];
+    column.predict(start);
+    column.process();
+    let current = 0;
+    for (const token of tokens) {
+        const previousColumn = table[current];
+        if (!(options.keepHistory)) {
+            delete table[current - 1];
+        }
+        current++;
+        const nextColumn = new Column(rules, current);
+        table.push(nextColumn);
+        const literal = token.value;
+        const data = token;
+        nextColumn.data = literal;
+        const { scannable } = previousColumn;
+        for (let w = scannable.length; w--;) {
+            const state = scannable[w];
+            const symbol = state.rule.symbols[state.dot];
+            if (parser_1.ParserUtility.TokenMatchesSymbol(token, symbol)) {
+                const next = state.nextState({ data, token, isToken: true, reference: current - 1 });
+                nextColumn.states.push(next);
+            }
+        }
+        nextColumn.process();
+        if (nextColumn.states.length === 0) {
+            throw text_format_1.TextFormatter.UnexpectedToken(tokens, previousColumn.expects());
+        }
+    }
+    const results = [];
+    const { states } = table[table.length - 1];
+    for (const { rule: { name, symbols }, dot, reference, data } of states) {
+        if (name === start && dot === symbols.length && reference == 0) {
+            results.push(data);
+        }
+    }
+    return { results, info: { table } };
+}
+exports.Earley = Earley;
+class Column {
+    rules;
+    index;
+    data;
+    states = [];
+    wants = Object.create(null);
+    scannable = [];
+    completed = Object.create(null);
+    constructor(rules, index) {
+        this.rules = rules;
+        this.index = index;
+    }
+    process() {
+        let w = 0;
+        let state;
+        while (state = this.states[w++]) {
+            if (state.isComplete) {
+                state.finish();
+                const { wantedBy } = state;
+                for (let i = wantedBy.length; i--;) {
+                    this.complete(wantedBy[i], state);
+                }
+                if (state.reference === this.index) {
+                    const { name } = state.rule;
+                    this.completed[name] = this.completed[name] || [];
+                    this.completed[name].push(state);
+                }
+            }
+            else {
+                const exp = state.rule.symbols[state.dot];
+                if (typeof exp !== 'string') {
+                    this.scannable.push(state);
+                    continue;
+                }
+                if (this.wants[exp]) {
+                    this.wants[exp].push(state);
+                    if (this.completed[exp]) {
+                        for (const right of this.completed[exp]) {
+                            this.complete(state, right);
+                        }
+                    }
+                }
+                else {
+                    this.wants[exp] = [state];
+                    this.predict(exp);
+                }
+            }
+        }
+    }
+    predict(exp) {
+        if (!this.rules[exp])
+            return;
+        for (const rule of this.rules[exp]) {
+            this.states.push(new State(rule, 0, this.index, this.wants[exp]));
+        }
+    }
+    expects() {
+        return this.states
+            .filter((state) => {
+            const nextSymbol = state.rule.symbols[state.dot];
+            return nextSymbol && typeof nextSymbol !== "string";
+        })
+            .map(v => ({ ...v.rule, index: v.dot }));
+    }
+    complete(left, right) {
+        const copy = left.nextState(right);
+        this.states.push(copy);
+    }
+}
+class State {
+    rule;
+    dot;
+    reference;
+    wantedBy;
+    isComplete;
+    data = [];
+    left;
+    right;
+    constructor(rule, dot, reference, wantedBy) {
+        this.rule = rule;
+        this.dot = dot;
+        this.reference = reference;
+        this.wantedBy = wantedBy;
+        this.isComplete = this.dot === rule.symbols.length;
+    }
+    nextState(child) {
+        const state = new State(this.rule, this.dot + 1, this.reference, this.wantedBy);
+        state.left = this;
+        state.right = child;
+        if (state.isComplete) {
+            state.data = state.build();
+            state.right = undefined;
+        }
+        return state;
+    }
+    finish() {
+        this.data = parser_1.ParserUtility.PostProcess(this.rule, this.data, { reference: this.reference, dot: this.dot });
+    }
+    build() {
+        const children = [];
+        let node = this;
+        do {
+            children[node.dot - 1] = node.right.data;
+            node = node.left;
+        } while (node.left);
+        return children;
+    }
+}
 //# sourceMappingURL=earley.js.map

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

@@ -1,10 +1,10 @@
-import { TokenBuffer } from "../../lexers/token-buffer";
-import { LanguageDefinition } from "../../typings";
-import { CanonicalCollection } from "../../utility/lr";
-export declare function LR(language: LanguageDefinition & {
-    tokens: TokenBuffer;
-    canonical?: CanonicalCollection;
-}, _options?: {}): {
-    results: any[];
-    canonical: CanonicalCollection;
-};
+import { TokenBuffer } from "../../lexers/token-buffer";
+import { LanguageDefinition } from "../../typings";
+import { CanonicalCollection } from "../../utility/lr";
+export declare function LR(language: LanguageDefinition & {
+    tokens: TokenBuffer;
+    canonical?: CanonicalCollection;
+}, _options?: {}): {
+    results: any[];
+    canonical: CanonicalCollection;
+};

package/build/parser/algorithms/lr.js

@@ -1,34 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LR = void 0;
-const lr_1 = require("../../utility/lr");
-const parser_1 = require("../parser");
-function LR(language, _options = {}) {
-    const { grammar, tokens, canonical } = language;
-    const collection = canonical || new lr_1.CanonicalCollection(grammar);
-    const stack = new lr_1.LRStack();
-    const s = collection.states['0.0'];
-    stack.add(null);
-    stack.shift(s);
-    let token;
-    while (token = tokens.next()) {
-        for (const [symbol, state] of stack.current.state.actions) {
-            if (parser_1.ParserUtility.TokenMatchesSymbol(token, symbol)) {
-                stack.add(symbol);
-                stack.shift(collection.states[state]);
-                stack.current.value = token;
-                break;
-            }
-        }
-        while (stack.current.state?.isFinal) {
-            const rule = stack.current.state.reduce;
-            stack.reduce(rule);
-            stack.current.value = parser_1.ParserUtility.PostProcess(rule, stack.current.children.map(v => v.value));
-            const s = stack.previous.state.goto.get(rule.name);
-            stack.shift(collection.states[s]);
-        }
-    }
-    return { results: [stack.current.value], canonical: collection };
-}
-exports.LR = LR;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LR = void 0;
+const lr_1 = require("../../utility/lr");
+const parser_1 = require("../parser");
+function LR(language, _options = {}) {
+    const { grammar, tokens, canonical } = language;
+    const collection = canonical || new lr_1.CanonicalCollection(grammar);
+    const stack = new lr_1.LRStack();
+    const s = collection.states['0.0'];
+    stack.add(null);
+    stack.shift(s);
+    let token;
+    while (token = tokens.next()) {
+        for (const [symbol, state] of stack.current.state.actions) {
+            if (parser_1.ParserUtility.TokenMatchesSymbol(token, symbol)) {
+                stack.add(symbol);
+                stack.shift(collection.states[state]);
+                stack.current.value = token;
+                break;
+            }
+        }
+        while (stack.current.state?.isFinal) {
+            const rule = stack.current.state.reduce;
+            stack.reduce(rule);
+            stack.current.value = parser_1.ParserUtility.PostProcess(rule, stack.current.children.map(v => v.value));
+            const s = stack.previous.state.goto.get(rule.name);
+            stack.shift(collection.states[s]);
+        }
+    }
+    return { results: [stack.current.value], canonical: collection };
+}
+exports.LR = LR;
 //# sourceMappingURL=lr.js.map

package/build/parser/parser.d.ts

@@ -1,26 +1,26 @@
-import { GrammarRule, GrammarRuleSymbol, LanguageDefinition, LexerToken, ParserAlgorithm } from "../typings";
-declare const ParserRegistry: {
-    [key: string]: ParserAlgorithm;
-};
-export declare function Parse(language: LanguageDefinition, input: string, options?: ParserOptions): {
-    results: any[];
-};
-export declare class Parser {
-    private language;
-    private options;
-    constructor(language: LanguageDefinition, options?: ParserOptions);
-    run(input: string): {
-        results: any[];
-    };
-    private getTokenQueue;
-}
-export declare class ParserUtility {
-    static TokenMatchesSymbol(token: LexerToken, symbol: GrammarRuleSymbol): boolean;
-    static SymbolIsTerminal<T extends GrammarRuleSymbol>(symbol: T): boolean;
-    static PostProcess(rule: GrammarRule, data: any, meta?: any): any;
-}
-interface ParserOptions {
-    algorithm: (keyof typeof ParserRegistry) | ParserAlgorithm;
-    parserOptions?: any;
-}
-export {};
+import { GrammarRule, GrammarRuleSymbol, LanguageDefinition, LexerToken, ParserAlgorithm } from "../typings";
+declare const ParserRegistry: {
+    [key: string]: ParserAlgorithm;
+};
+export declare function Parse(language: LanguageDefinition, input: string, options?: ParserOptions): {
+    results: any[];
+};
+export declare class Parser {
+    private language;
+    private options;
+    constructor(language: LanguageDefinition, options?: ParserOptions);
+    run(input: string): {
+        results: any[];
+    };
+    private getTokenQueue;
+}
+export declare class ParserUtility {
+    static TokenMatchesSymbol(token: LexerToken, symbol: GrammarRuleSymbol): boolean;
+    static SymbolIsTerminal<T extends GrammarRuleSymbol>(symbol: T): boolean;
+    static PostProcess(rule: GrammarRule, data: any, meta?: any): any;
+}
+interface ParserOptions {
+    algorithm: (keyof typeof ParserRegistry) | ParserAlgorithm;
+    parserOptions?: any;
+}
+export {};

package/build/parser/parser.js

@@ -1,74 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserUtility = exports.Parser = exports.Parse = void 0;
-const character_lexer_1 = require("../lexers/character-lexer");
-const stateful_lexer_1 = require("../lexers/stateful-lexer");
-const token_buffer_1 = require("../lexers/token-buffer");
-const cyk_1 = require("./algorithms/cyk");
-const earley_1 = require("./algorithms/earley");
-const lr_1 = require("./algorithms/lr");
-const ParserRegistry = {
-    earley: earley_1.Earley,
-    cyk: cyk_1.CYK,
-    lr: lr_1.LR
-};
-function Parse(language, input, options) {
-    const i = new Parser(language, options);
-    return i.run(input);
-}
-exports.Parse = Parse;
-class Parser {
-    language;
-    options;
-    constructor(language, options = { algorithm: 'earley', parserOptions: {} }) {
-        this.language = language;
-        this.options = options;
-    }
-    run(input) {
-        const tokenQueue = this.getTokenQueue();
-        tokenQueue.feed(input);
-        if (typeof this.options.algorithm == 'function')
-            return this.options.algorithm({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
-        return ParserRegistry[this.options.algorithm]({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
-    }
-    getTokenQueue() {
-        const { lexer } = this.language;
-        if (!lexer) {
-            return new token_buffer_1.TokenBuffer(new character_lexer_1.CharacterLexer());
-        }
-        else if ("feed" in lexer && typeof lexer.feed == 'function') {
-            return new token_buffer_1.TokenBuffer(lexer);
-        }
-        else if ('states' in lexer) {
-            return new token_buffer_1.TokenBuffer(new stateful_lexer_1.StatefulLexer(lexer));
-        }
-    }
-}
-exports.Parser = Parser;
-class ParserUtility {
-    static TokenMatchesSymbol(token, symbol) {
-        if (typeof symbol === 'string')
-            throw 'Attempted to match token against non-terminal';
-        if (typeof symbol == 'function')
-            return symbol(token);
-        if (!symbol)
-            return;
-        if ("test" in symbol)
-            return symbol.test(token.value);
-        if ("token" in symbol)
-            return symbol.token === token.type || token.tag?.has(symbol.token);
-        if ("literal" in symbol)
-            return symbol.literal === token.value;
-    }
-    static SymbolIsTerminal(symbol) {
-        return typeof symbol != 'string';
-    }
-    static PostProcess(rule, data, meta) {
-        if (rule.postprocess) {
-            return rule.postprocess({ rule, data, meta });
-        }
-        return data;
-    }
-}
-exports.ParserUtility = ParserUtility;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserUtility = exports.Parser = exports.Parse = void 0;
+const character_lexer_1 = require("../lexers/character-lexer");
+const stateful_lexer_1 = require("../lexers/stateful-lexer");
+const token_buffer_1 = require("../lexers/token-buffer");
+const cyk_1 = require("./algorithms/cyk");
+const earley_1 = require("./algorithms/earley");
+const lr_1 = require("./algorithms/lr");
+const ParserRegistry = {
+    earley: earley_1.Earley,
+    cyk: cyk_1.CYK,
+    lr: lr_1.LR
+};
+function Parse(language, input, options) {
+    const i = new Parser(language, options);
+    return i.run(input);
+}
+exports.Parse = Parse;
+class Parser {
+    language;
+    options;
+    constructor(language, options = { algorithm: 'earley', parserOptions: {} }) {
+        this.language = language;
+        this.options = options;
+    }
+    run(input) {
+        const tokenQueue = this.getTokenQueue();
+        tokenQueue.feed(input);
+        if (typeof this.options.algorithm == 'function')
+            return this.options.algorithm({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
+        return ParserRegistry[this.options.algorithm]({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
+    }
+    getTokenQueue() {
+        const { lexer } = this.language;
+        if (!lexer) {
+            return new token_buffer_1.TokenBuffer(new character_lexer_1.CharacterLexer());
+        }
+        else if ("feed" in lexer && typeof lexer.feed == 'function') {
+            return new token_buffer_1.TokenBuffer(lexer);
+        }
+        else if ('states' in lexer) {
+            return new token_buffer_1.TokenBuffer(new stateful_lexer_1.StatefulLexer(lexer));
+        }
+    }
+}
+exports.Parser = Parser;
+class ParserUtility {
+    static TokenMatchesSymbol(token, symbol) {
+        if (typeof symbol === 'string')
+            throw 'Attempted to match token against non-terminal';
+        if (typeof symbol == 'function')
+            return symbol(token);
+        if (!symbol)
+            return;
+        if ("test" in symbol)
+            return symbol.test(token.value);
+        if ("token" in symbol)
+            return symbol.token === token.type || token.tag?.has(symbol.token);
+        if ("literal" in symbol)
+            return symbol.literal === token.value;
+    }
+    static SymbolIsTerminal(symbol) {
+        return typeof symbol != 'string';
+    }
+    static PostProcess(rule, data, meta) {
+        if (rule.postprocess) {
+            return rule.postprocess({ rule, data, meta });
+        }
+        return data;
+    }
+}
+exports.ParserUtility = ParserUtility;
 //# sourceMappingURL=parser.js.map