grammar-well 1.1.0

package/build/parser/algorithms/earley.js

@@ -0,0 +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;
+    }
+}
+//# sourceMappingURL=earley.js.map

package/build/parser/algorithms/earley.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"earley.js","sourceRoot":"","sources":["../../../src/parser/algorithms/earley.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +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;
+};

package/build/parser/algorithms/lr.js

@@ -0,0 +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;
+//# sourceMappingURL=lr.js.map

package/build/parser/algorithms/lr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lr.js","sourceRoot":"","sources":["../../../src/parser/algorithms/lr.ts"],"names":[],"mappings":";;;AAEA,yCAAgE;AAChE,sCAA0C;AAE1C,SAAgB,EAAE,CAAC,QAAuF,EAAE,QAAQ,GAAG,EAAE;IACrH,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;IAChD,MAAM,UAAU,GAAG,SAAS,IAAI,IAAI,wBAAmB,CAAC,OAAO,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,IAAI,YAAO,EAAE,CAAC;IAC5B,MAAM,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChB,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACf,IAAI,KAAK,CAAC;IAGV,OAAO,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,EAAE;QAC1B,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE;YACvD,IAAI,sBAAa,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE;gBACjD,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAClB,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBACtC,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;gBAC5B,MAAM;aACT;SACJ;QAED,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE;YACjC,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC;YACxC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACnB,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,sBAAa,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YAChG,MAAM,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnD,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;SAErC;KACJ;IAED,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,CAAA;AACpE,CAAC;AA/BD,gBA+BC"}

package/build/parser/parser.d.ts

@@ -0,0 +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 {};

package/build/parser/parser.js

@@ -0,0 +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;
+//# sourceMappingURL=parser.js.map

package/build/parser/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../src/parser/parser.ts"],"names":[],"mappings":"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"}

package/build/typings.d.ts

@@ -0,0 +1,198 @@
+import { TokenBuffer } from "./lexers/token-buffer";
+import { ParserUtility } from "./parser/parser";
+export interface Dictionary<T> {
+    [key: string]: T;
+}
+export interface CompileOptions {
+    version?: string;
+    noscript?: boolean;
+    basedir?: string;
+    resolver?: ImportResolverConstructor;
+    resolverInstance?: ImportResolver;
+    exportName?: string;
+    format?: OutputFormat;
+}
+export type OutputFormat = '_default' | 'object' | 'json' | 'js' | 'javascript' | 'module' | 'esmodule' | 'ts' | 'typescript';
+export interface GrammarBuilderContext {
+    alreadyCompiled: Set<string>;
+    resolver: ImportResolver;
+    uuids: Dictionary<number>;
+}
+export interface ImportResolver {
+    path(path: string): string;
+    body(path: string): Promise<string>;
+}
+export interface ImportResolverConstructor {
+    new (basePath: string): ImportResolver;
+}
+export type PostProcessor = (payload: PostProcessorPayload) => any;
+interface PostProcessorPayload {
+    data: any[];
+    rule: GrammarRule;
+    meta: any;
+}
+export type JavascriptDirective = {
+    body: GrammarTypeJS;
+} | {
+    head: GrammarTypeJS;
+};
+export interface ImportDirective {
+    import: string;
+    path?: boolean;
+}
+export interface ConfigDirective {
+    config: Dictionary<any>;
+}
+export interface GrammarDirective {
+    grammar: {
+        config?: Dictionary<any>;
+        rules: GrammarBuilderRule[];
+    };
+}
+export interface LexerDirective {
+    lexer: {
+        start?: string;
+        states: LexerStateDefinition[];
+    };
+}
+export interface GrammarBuilderRule {
+    name: string;
+    expressions: GrammarBuilderExpression[];
+    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
+}
+export interface GrammarBuilderExpression {
+    symbols: GrammarBuilderSymbol[];
+    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
+}
+export type GrammarBuilderSymbol = GrammarTypeRule | GrammarTypeRegex | GrammarTypeToken | GrammarTypeLiteral | GrammarBuilderSymbolRepeat | GrammarBuilderSymbolSubexpression;
+export interface GrammarBuilderSymbolSubexpression {
+    subexpression: GrammarBuilderExpression[];
+}
+export interface GrammarBuilderSymbolRepeat {
+    expression: GrammarBuilderSymbol;
+    repeat: "+" | "*" | "?";
+}
+export interface GrammarTypeRule {
+    rule: string;
+}
+export interface GrammarTypeRegex {
+    regex: string;
+    flags?: string;
+}
+export interface GrammarTypeToken {
+    token: string;
+}
+export interface GrammarTypeLiteral {
+    literal: string;
+    insensitive?: boolean;
+}
+export type GrammarTypeBuiltIn = {
+    builtin: string;
+};
+export type GrammarTypeTemplate = {
+    template: string;
+};
+export type GrammarTypeJS = {
+    js: string;
+};
+export type ParserAlgorithm = ((language: LanguageDefinition & {
+    tokens: TokenBuffer;
+    utility: ParserUtility;
+}, options?: any) => {
+    results: any[];
+    info?: any;
+});
+export type LanguageDirective = (JavascriptDirective | ImportDirective | ConfigDirective | GrammarDirective | LexerDirective);
+type GrammarRuleSymbolFunction = (data: LexerToken) => boolean;
+export interface GrammarRule {
+    name: string;
+    symbols: GrammarRuleSymbol[];
+    postprocess?: PostProcessor;
+}
+export type GrammarRuleSymbol = string | RegExp | GrammarTypeLiteral | GrammarTypeToken | GrammarRuleSymbolFunction;
+export interface GeneratorGrammarRule {
+    name: string;
+    symbols: GeneratorGrammarSymbol[];
+    postprocess?: GrammarTypeTemplate | GrammarTypeBuiltIn | GrammarTypeJS;
+}
+export type GeneratorGrammarSymbol = {
+    alias?: string;
+} & (GrammarTypeRule | GrammarTypeRegex | GrammarTypeLiteral | GrammarTypeToken | GrammarTypeJS);
+export interface LanguageDefinition {
+    lexer?: Lexer | LexerConfig;
+    grammar: {
+        start: string;
+        rules: Dictionary<GrammarRule[]>;
+    };
+}
+export interface TQRestorePoint {
+    historyIndex: number;
+    offset: number;
+}
+export interface Lexer {
+    next(): LexerToken | undefined;
+    feed(chunk?: string, state?: ReturnType<Lexer['state']>): void;
+    state(): any;
+    flush?(): void;
+}
+export interface LexerToken {
+    type?: string | undefined;
+    tag?: Set<string>;
+    value: string;
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface LexerStatus {
+    index: number;
+    line: number;
+    column: number;
+    state: string;
+}
+export interface LexerStateDefinition {
+    name: string;
+    unmatched?: string;
+    default?: string;
+    rules: (LexerStateImportRule | LexerStateMatchRule)[];
+}
+export interface LexerStateImportRule {
+    import: string[];
+}
+export interface LexerStateMatchRule {
+    when: string | RegExp;
+    type?: string;
+    tag?: string[];
+    pop?: number | 'all';
+    inset?: number;
+    goto?: string;
+    set?: string;
+}
+export interface ResolvedStateDefinition {
+    name: string;
+    unmatched?: string;
+    rules: LexerStateMatchRule[];
+}
+export interface CompiledStateDefinition {
+    regexp: RegExp;
+    unmatched?: LexerStateMatchRule;
+    rules: LexerStateMatchRule[];
+}
+export interface LexerConfig {
+    start?: string;
+    states: Dictionary<LexerStateDefinition>;
+}
+export interface GeneratorState {
+    version: string;
+    config: Dictionary<string>;
+    head: string[];
+    body: string[];
+    lexer?: LexerConfig;
+    grammar: {
+        start: string;
+        rules: Dictionary<GeneratorGrammarRule[]>;
+        uuids: {
+            [key: string]: number;
+        };
+    };
+}
+export {};

package/build/typings.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=typings.js.map

package/build/typings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typings.js","sourceRoot":"","sources":["../src/typings.ts"],"names":[],"mappings":""}

package/build/utility/general.d.ts

@@ -0,0 +1,46 @@
+import { Dictionary, GrammarRuleSymbol } from "../typings";
+export declare class Collection<T> {
+    categorized: Dictionary<Dictionary<number>>;
+    private uncategorized;
+    private items;
+    constructor(ref?: T[]);
+    encode(ref: T): number;
+    decode(id: number | string): T;
+    resolve(_: T): {
+        category: keyof Collection<T>['categorized'];
+        key: string;
+    } | void;
+    private addCategorized;
+    private addUncategorized;
+}
+export declare class SymbolCollection extends Collection<GrammarRuleSymbol> {
+    categorized: {
+        nonTerminal: {};
+        literalI: {};
+        literalS: {};
+        token: {};
+        regex: {};
+        function: {};
+    };
+    resolve(symbol: GrammarRuleSymbol): {
+        category: string;
+        key: string;
+    };
+}
+export declare class Matrix<T> {
+    private initial?;
+    private $x;
+    private $y;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    matrix: GetCallbackOrValue<T>[][];
+    constructor(x: number, y: number, initial?: T | ((...args: any) => T));
+    get(x: number, y: number): T;
+    set(x: number, y: number, value: any): any;
+    resize(x: number, y: number): void;
+    static Array<T>(length: any, initial?: T | ((...args: any) => T)): GetCallbackOrValue<T>[];
+}
+type GetCallbackOrValue<T> = T extends (...args: any) => any ? ReturnType<T> : T;
+export {};