grammar-well 2.0.7 → 2.2.0

package/src/lexers/token-buffer.ts

@@ -1,4 +1,4 @@
-import { RuntimeLexer, RuntimeLexerToken, TQRestorePoint } from '../typings/index.js';
+import type { RuntimeLexer, RuntimeLexerToken, TQRestorePoint } from '../typings/index.ts';
 
 export class TokenBuffer {
     private history: RuntimeLexerToken[] = [];
@@ -6,6 +6,9 @@ export class TokenBuffer {
 
     private $historyIndex = -1;
 
+    public lexer: RuntimeLexer;
+    private tokenProcessor?: (token: RuntimeLexerToken) => RuntimeLexerToken;
+
     get offset() { return this.active?.offset || 0 }
     get line() { return this.active?.line || 0 }
     get column() { return this.active?.column || 0; }
@@ -15,7 +18,13 @@ export class TokenBuffer {
         return { historyIndex: this.$historyIndex, offset: this.offset };
     }
 
-    constructor(public lexer: RuntimeLexer, private tokenProcessor?: (token: RuntimeLexerToken) => RuntimeLexerToken) { }
+    constructor(
+        lexer: RuntimeLexer,
+        tokenProcessor?: (token: RuntimeLexerToken) => RuntimeLexerToken
+    ) {
+        this.lexer = lexer;
+        this.tokenProcessor = tokenProcessor;
+    }
 
     reset(buffer: string) {
         this.lexer.feed(buffer);
@@ -92,7 +101,11 @@ export class TokenBuffer {
 }
 
 class TokenIterator {
-    constructor(private buffer: TokenBuffer) { }
+    private buffer: TokenBuffer;
+
+    constructor(buffer: TokenBuffer) {
+        this.buffer = buffer;
+    }
 
     next() {
         const token = this.buffer.next()

package/src/parser/algorithms/cyk.ts

@@ -1,7 +1,7 @@
-import { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass, RuntimeLexerToken } from "../../typings/index.js";
-import { TokenBuffer } from "../../lexers/token-buffer.js";
-import { Matrix } from "../../utility/general.js";
-import { ParserUtility } from "../../utility/parsing.js";
+import type { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass, RuntimeLexerToken } from "../../typings/index.ts";
+import { TokenBuffer } from "../../lexers/token-buffer.ts";
+import { Matrix } from "../../utility/general.ts";
+import { ParserUtility } from "../../utility/parsing.ts";
 
 export function CYK(language: RuntimeParserClass & { tokens: TokenBuffer }, _options = {}) {
     const { grammar } = language.artifacts;

package/src/parser/algorithms/earley.ts

@@ -1,16 +1,18 @@
-import { Dictionary, RuntimeGrammarProductionRule, RuntimeParserClass } from "../../typings/index.js";
-import { TokenBuffer } from "../../lexers/token-buffer.js";
-import { TextFormatter } from "../../utility/text-format.js";
-import { ParserUtility } from "../../utility/parsing.js";
+import type { Dictionary, RuntimeGrammarProductionRule, RuntimeLexerToken, RuntimeParserClass } from "../../typings/index.ts";
+import { TokenBuffer } from "../../lexers/token-buffer.ts";
+import { TextFormatter } from "../../utility/text-format.ts";
+import { ParserUtility } from "../../utility/parsing.ts";
 
 export interface EarleyParserOptions {
     keepHistory?: boolean;
+    postProcessing?: 'eager' | 'lazy';
 }
 
 export function Earley(language: RuntimeParserClass & { tokens: TokenBuffer }, options: EarleyParserOptions = {}) {
     const { tokens } = language;
     const { rules, start } = language.artifacts.grammar;
-    const column = new Column(rules, 0);
+    const StateClass = options.postProcessing === 'eager' ? EagerState : LazyState;
+    const column = new Column(rules, 0, StateClass);
     const table: Column[] = [column];
     column.wants[start] = [];
     column.predict(start);
@@ -27,7 +29,7 @@ export function Earley(language: RuntimeParserClass & { tokens: TokenBuffer }, o
 
         current++;
 
-        const nextColumn = new Column(rules, current);
+        const nextColumn = new Column(rules, current, StateClass);
         table.push(nextColumn);
 
         const literal = token.value;
@@ -58,9 +60,25 @@ export function Earley(language: RuntimeParserClass & { tokens: TokenBuffer }, o
             results.push(data);
         }
     }
+
+    if (StateClass == LazyState) {
+        const clone = results.length > 1;
+        for (let i = 0; i < results.length; i++) {
+            results[i] = PostProcess(results[i], clone);
+        }
+    }
     return { results, info: { table } };
 }
 
+function PostProcess(ast: PreAST | RuntimeLexerToken, clone?: boolean) {
+    if (!Array.isArray(ast))
+        return clone ? { ...ast } : ast;
+    const data = [];
+    for (let i = 0; i < ast[1].length; i++) {
+        data[i] = PostProcess(ast[1][i], clone);
+    }
+    return ParserUtility.PostProcess(ast[0], data, ast[2]);
+}
 
 class Column {
     data: any;
@@ -68,11 +86,19 @@ class Column {
     wants: Dictionary<State[]> = Object.create(null);// states indexed by the non-terminal they expect
     scannable: State[] = [];// list of states that expect a token
     completed: Dictionary<State[]> = Object.create(null);  // states that are nullable
+    private rules: Dictionary<RuntimeGrammarProductionRule[]>;
+    public index: number;
+    private StateClass: Concrete<typeof State>;
 
     constructor(
-        private rules: Dictionary<RuntimeGrammarProductionRule[]>,
-        public index: number
-    ) { }
+        rules: Dictionary<RuntimeGrammarProductionRule[]>,
+        index: number,
+        StateClass: Concrete<typeof State>
+    ) {
+        this.rules = rules;
+        this.index = index;
+        this.StateClass = StateClass;
+    }
 
 
     process() {
@@ -123,7 +149,7 @@ class Column {
             return;
 
         for (const rule of this.rules[exp]) {
-            this.states.push(new State(rule, 0, this.index, this.wants[exp]));
+            this.states.push(new this.StateClass(rule, 0, this.index, this.wants[exp]));
         }
     }
 
@@ -143,22 +169,30 @@ class Column {
     }
 }
 
-class State {
+abstract class State {
     isComplete: boolean;
     data: any = [];
     left: State;
     right: State | StateToken;
+    public rule: RuntimeGrammarProductionRule;
+    public dot: number;
+    public reference: number;
+    public wantedBy: State[];
     constructor(
-        public rule: RuntimeGrammarProductionRule,
-        public dot: number,
-        public reference: number,
-        public wantedBy: State[]
+        rule: RuntimeGrammarProductionRule,
+        dot: number,
+        reference: number,
+        wantedBy: State[]
     ) {
+        this.rule = rule;
+        this.dot = dot;
+        this.reference = reference;
+        this.wantedBy = wantedBy;
         this.isComplete = this.dot === rule.symbols.length;
     }
 
     nextState(child: State | StateToken) {
-        const state = new State(this.rule, this.dot + 1, this.reference, this.wantedBy);
+        const state = new (this.constructor as any)(this.rule, this.dot + 1, this.reference, this.wantedBy);
         state.left = this;
         state.right = child;
         if (state.isComplete) {
@@ -169,9 +203,7 @@ class State {
     }
 
 
-    finish() {
-        this.data = ParserUtility.PostProcess(this.rule, this.data, { reference: this.reference, dot: this.dot });
-    }
+    abstract finish(): void;
 
     protected build() {
         const children = [];
@@ -185,9 +217,25 @@ class State {
     }
 }
 
+class EagerState extends State {
+    finish() {
+        this.data = ParserUtility.PostProcess(this.rule, this.data, { reference: this.reference, dot: this.dot });
+    }
+}
+
+class LazyState extends State {
+    finish() {
+        this.data = [this.rule, this.data, { reference: this.reference, dot: this.dot }];
+    }
+}
+
 interface StateToken {
     data: any,
     token: any,
     isToken: boolean,
     reference: number
-}
+}
+
+type PreAST = [RuntimeGrammarProductionRule, (RuntimeLexerToken | PreAST)[], { reference: number, dot: number }];
+type Concrete<T extends abstract new (...args: any) => any> =
+    new (...args: ConstructorParameters<T>) => InstanceType<T>;

package/src/parser/algorithms/lrk/algorithm.ts

@@ -1,37 +1,52 @@
-import { RuntimeParserClass } from "../../../typings/index.js";
-import { TokenBuffer } from "../../../lexers/token-buffer.js";
-import { ParserUtility } from "../../../utility/parsing.js";
-import { CanonicalCollection } from "./canonical-collection.js";
-import { LRStack } from "./stack.js";
+import type { RuntimeParserClass } from "../../../typings/index.ts";
+import { TokenBuffer } from "../../../lexers/token-buffer.ts";
+import { ParserUtility } from "../../../utility/parsing.ts";
+import { CanonicalCollection } from "./canonical-collection.ts";
+import { Stack } from "./stack.ts";
+import type { State } from "./typings.ts";
 
 export function LRK(language: RuntimeParserClass & { tokens: TokenBuffer }, options = {}) {
     const { grammar } = language.artifacts;
     const { tokens } = language;
-    const { states, rules: rules } = new CanonicalCollection(grammar);
-    const stack = new LRStack();
-    const s = states.get('0.0');
-    stack.append(s.rule.name);
-    stack.shift(s);
+    const { start } = new CanonicalCollection(grammar);
+    const stateStack = new Stack<State>();
+    const inputStack = new Stack<any>();
+    stateStack.push(start);
+
     let token;
 
-    while (token = tokens.next()) {
-        for (const [symbol, state] of stack.current.state.actions) {
-            if (ParserUtility.SymbolMatchesToken(symbol, token)) {
-                stack.append(symbol);
-                stack.shift(states.get(state));
-                stack.current.value = token;
-                break;
-            }
+    tokenloop: while (token = tokens.next()) {
+        const match = stateStack.current.actions.find(a => ParserUtility.SymbolMatchesToken(a.symbol, token));
+
+        if (match) {
+            inputStack.push(token);
+            stateStack.push(match.state);
+        } else {
+            throw new Error("Syntax Error: Unexpected Token");
         }
-        while (stack.current.state?.isFinal) {
-            const rule = rules.fetch(stack.current.state.reduce);
-            stack.reduce(rule);
-            stack.current.value = ParserUtility.PostProcess(rule, stack.current.children.map(v => v.value));
-            const s = stack.previous.state.goto.get(rule.name);
-            stack.shift(states.get(s));
 
+        while (stateStack.current.reduce) {
+            const rule = stateStack.current.reduce;
+            const value = inputStack.pop(rule.symbols.length);
+            stateStack.pop(rule.symbols.length);
+            inputStack.push(ParserUtility.PostProcess(rule, value));
+            const nextState = stateStack.current.goto[rule.name];
+
+            if (!nextState)
+                break tokenloop;
+
+            stateStack.push(nextState);
         }
     }
 
-    return { results: [stack.current.value] }
+    if (stateStack.size > 1) {
+        throw new Error("Syntax Error: Unexpected End of Input");
+    }
+    const peek = tokens.next();
+    if (peek) {
+        console.log(peek)
+        throw new Error("Syntax Error: Expected End of Input");
+    }
+
+    return { results: [inputStack.current[0]] }
 }

package/src/parser/algorithms/lrk/canonical-collection.ts

@@ -1,79 +1,108 @@
-import { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass } from "../../../typings/index.js";
-import { ParserUtility } from "../../../utility/parsing.js";
-import { BiMap } from "./bimap.js";
-import { ClosureBuilder } from "./closure.js";
-import { State } from "./state.js";
+import type { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass } from "../../../typings/index.ts";
+import { ParserUtility } from "../../../utility/parsing.ts";
+import { TextFormatter } from "../../../utility/text-format.ts";
+import { BiMap } from "./bimap.ts";
+import type { LRItem, State } from "./typings.ts";
 
 export class CanonicalCollection {
-    states: Map<string, State> = new Map();
-    rules: BiMap<RuntimeGrammarProductionRule> = new BiMap();
-    terminals: BiMap<RuntimeGrammarRuleSymbol> = new BiMap();
+    public start: State;
+    public rules: BiMap<RuntimeGrammarProductionRule> = new BiMap();
+    public grammar: RuntimeParserClass['artifacts']['grammar'];
+    private cache: { [key: string]: State } = {};
 
-    private closure: ClosureBuilder;
     constructor(
-        public grammar:  RuntimeParserClass['artifacts']['grammar']
+        grammar: RuntimeParserClass['artifacts']['grammar']
     ) {
+        this.grammar = grammar;
         const augmented = {
             name: Symbol() as unknown as string,
             symbols: [this.grammar.start]
         }
-        this.grammar['rules'][augmented.name] = [augmented];
-        this.closure = new ClosureBuilder(this.grammar);
+        this.grammar.rules[augmented.name] = [augmented];
         this.rules.id(augmented);
-        this.addState(this.grammar['rules'][augmented.name][0], 0);
-        this.linkStates('0.0');
+        this.start = this.generateState([{ rule: augmented, dot: 0 }]);
     }
 
-    private addState(rule: RuntimeGrammarProductionRule, dot: number) {
-        const id = this.getStateId(rule, dot);
-        if (this.states.has(id))
-            return;
+    private generateState(kernel: LRItem[]): State {
+        const id = this.canonicalStateId(kernel);
+        if (this.cache[id])
+            return this.cache[id];
 
-        const state: State = {
-            items: [],
-            isFinal: false,
-            actions: new Map(),
-            goto: new Map(),
-            reduce: null,
-            rule: rule
+        this.cache[id] = { id };
+        if (kernel.length == 1 && kernel[0].rule.symbols.length == kernel[0].dot) {
+            this.cache[id].reduce = kernel[0].rule;
+            return this.cache[id];
         }
 
-        state.items.push({ rule, dot });
-        if (rule.symbols.length == dot)
-            state.isFinal = true;
+        const items = [...kernel];
+        const visited = new Set<string>();
+        const refs: { [key: string]: RuntimeGrammarRuleSymbol } = {}
+        const actions: { [key: string]: LRItem[] } = {};
+        const goto: { [key: string]: LRItem[] } = {};
+        for (let i = 0; i < items.length; i++) {
+            const { rule, dot } = items[i];
+            const id = this.canonicalLRItemId(items[i]);
+            if (dot == rule.symbols.length)
+                throw new Error('Reduce Conflict on state: ' + id + `\n${items.map(v => TextFormatter.GrammarRule(v.rule, v.dot)).join('\n')}`);
 
-        this.states.set(id, state);
+            if (visited.has(id))
+                continue;
+            visited.add(id);
+            const symbol = rule.symbols[dot];
+            const name = this.canonicalSymbolId(symbol);
+            refs[name] = symbol;
 
-        state.items.push(...this.closure.get(rule.symbols[dot] as string))
-
-        if (!state.isFinal)
-            for (const { rule, dot } of state.items) {
-                this.addState(rule, dot + 1);
+            if (symbol && !ParserUtility.SymbolIsTerminal(symbol)) {
+                const prods = this.grammar.rules[symbol] || [];
+                for (const rule of prods) {
+                    items.push({ rule, dot: 0 });
+                }
+                goto[name] = goto[name] || [];
+                goto[name].push({ rule, dot: dot + 1 });
+            } else {
+                actions[name] = actions[name] || [];
+                actions[name].push({ rule, dot: dot + 1 });
             }
-    }
+        }
+        this.cache[id].actions = [];
+        this.cache[id].goto = {};
 
-    private linkStates(id: string, completed: Set<string> = new Set()) {
-        completed.add(id);
-        const state = this.states.get(id);
-        if (!state.isFinal) {
-            for (const { rule, dot } of state.items) {
-                const symbol = rule.symbols[dot];
-                const itemStateId = this.getStateId(rule, dot + 1);
-                if (ParserUtility.SymbolIsTerminal(symbol) && typeof symbol != 'symbol') {
-                    state.actions.set(symbol, itemStateId);
-                } else {
-                    state.goto.set(symbol, itemStateId);
-                }
+        for (const key in actions) {
+            this.cache[id].actions.push({ symbol: refs[key], state: this.generateState(actions[key]) })
+        }
 
-                if (!completed.has(itemStateId))
-                    this.linkStates(itemStateId, completed);
-            }
-        } else {
-            state.reduce = this.rules.id(state.rule);
+        for (const key in goto) {
+            this.cache[id].goto[refs[key] as string] = this.generateState(goto[key]);
         }
+
+        return this.cache[id];
+    }
+
+    private canonicalStateId(items: LRItem[]): string {
+        return items
+            .map(item => this.canonicalLRItemId(item))
+            .sort()
+            .join('|');
+    }
+
+    private canonicalLRItemId(item: LRItem) {
+        return `${this.rules.id(item.rule)}:${item.dot}`;
     }
 
-    private getStateId(rule: RuntimeGrammarProductionRule, dot: number) {
-        return this.rules.id(rule) + '.' + dot;
+    private canonicalSymbolId(symbol: RuntimeGrammarRuleSymbol) {
+        if (typeof symbol === 'symbol')
+            return `SY:START`;
+        if (typeof symbol === 'string')
+            return `NT:${symbol}`;
+        if (typeof symbol == 'function')
+            return `FN:${symbol.toString()}`;
+        if (!symbol)
+            return
+        if (symbol instanceof RegExp)
+            return `RG:${symbol.source}`;
+        if ("token" in symbol)
+            return `TK:${symbol.token}`;
+        if ("literal" in symbol)
+            return `LT:${symbol.literal}`;
     }
-}
+}

package/src/parser/algorithms/lrk/stack.ts

@@ -1,53 +1,28 @@
-import { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol } from "../../../typings/index.js";
-import { State } from "./state.js";
+export class Stack<T> {
 
-export class LRStack {
+    private stack: T[] = [];
 
-    stack: LRStackItem[] = [];
-
-    get current() {
-        return this.stack[this.stack.length - 1];
+    get size() {
+        return this.stack.length;
     }
 
     get previous() {
         return this.stack[this.stack.length - 2];
     }
 
-
-    shift(state: State) {
-        this.current.state = state;
+    get current() {
+        return this.stack[this.stack.length - 1];
     }
 
-    reduce(rule: RuntimeGrammarProductionRule) {
-        const n = LRStack.NewItem();
-        const l = rule.symbols.length;
-        n.children = this.stack.splice(l * -1, l);
-        n.children.forEach(v => delete v.state);
-        n.rule = rule;
-        n.symbol = rule.name;
-        this.stack.push(n);
+    set current(item: T) {
+        this.stack[this.stack.length - 1] = item;
     }
 
-    append(symbol: RuntimeGrammarRuleSymbol) {
-        this.stack.push(LRStack.NewItem())
-        this.current.symbol = symbol;
+    push(...items: T[]) {
+        return this.stack.push(...items);
     }
 
-    static NewItem(): LRStackItem {
-        return {
-            children: [],
-            state: null,
-            symbol: null,
-            rule: null,
-            value: null
-        }
+    pop(n: number = 1): T[] {
+        return this.stack.splice(n * -1, n);
     }
-}
-
-interface LRStackItem {
-    children: LRStackItem[];
-    state: State;
-    symbol: RuntimeGrammarRuleSymbol;
-    rule: RuntimeGrammarProductionRule;
-    value: any;
 }

package/src/parser/algorithms/lrk/typings.ts

@@ -0,0 +1,13 @@
+import type { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol } from "../../../typings/index.ts";
+
+export interface LRItem {
+    rule: RuntimeGrammarProductionRule;
+    dot: number;
+}
+
+export interface State {
+    id: string;
+    actions?: { symbol: RuntimeGrammarRuleSymbol, state: State }[];
+    goto?: { [key: string]: State };
+    reduce?: RuntimeGrammarProductionRule;
+}

package/src/parser/parse.ts

@@ -1,11 +1,11 @@
-import { ParserAlgorithm, RuntimeParserClass } from "../typings/index.js";
-import { CharacterLexer } from "../lexers/character-lexer.js";
-import { StatefulLexer } from "../lexers/stateful-lexer.js";
-import { TokenBuffer } from "../lexers/token-buffer.js";
-import { CYK } from "./algorithms/cyk.js";
-import { Earley } from "./algorithms/earley.js";
-import { LRK } from "./algorithms/lrk/algorithm.js";
-import { ParserUtility } from "../utility/parsing.js";
+import type { ParserAlgorithm, RuntimeParserClass } from "../typings/index.ts";
+import { CharacterLexer } from "../lexers/character-lexer.ts";
+import { StatefulLexer } from "../lexers/stateful-lexer.ts";
+import { TokenBuffer } from "../lexers/token-buffer.ts";
+import { CYK } from "./algorithms/cyk.ts";
+import { Earley } from "./algorithms/earley.ts";
+import { LRK } from "./algorithms/lrk/algorithm.ts";
+import { ParserUtility } from "../utility/parsing.ts";
 
 const ParserRegistry: { [key: string]: ParserAlgorithm } = {
     earley: Earley,

package/src/typings/ast.ts

@@ -1,4 +1,4 @@
-import { Dictionary } from "./common.js";
+import type { Dictionary } from "./common.ts";
 
 export type AST = ASTDirectives[];
 

package/src/typings/generator.ts

@@ -1,7 +1,7 @@
-import { GeneratorState } from "../generator/state.js";
-import { ASTGrammarSymbolLiteral, ASTGrammarSymbolNonTerminal, ASTGrammarSymbolRegex, ASTGrammarSymbolToken, ASTJavaScriptBuiltin, ASTJavaScriptLiteral, ASTJavaScriptTemplate, ASTLexerStateImportRule, ASTLexerStateMatchRule, ASTLexerStateNonMatchRule } from "./ast.js";
-import { Dictionary } from "./common.js";
-import { ImportResolver, ImportResolverConstructor } from "./index.js";
+import { GeneratorState } from "../generator/state.ts";
+import type { ASTGrammarSymbolLiteral, ASTGrammarSymbolNonTerminal, ASTGrammarSymbolRegex, ASTGrammarSymbolToken, ASTJavaScriptBuiltin, ASTJavaScriptLiteral, ASTJavaScriptTemplate, ASTLexerStateImportRule, ASTLexerStateMatchRule, ASTLexerStateNonMatchRule } from "./ast.ts";
+import type { Dictionary } from "./common.ts";
+import type { ImportResolver, ImportResolverConstructor } from "./index.ts";
 
 
 export type GenerateOptions = GeneratorOptions & { output?: GeneratorOutputOptions };

package/src/typings/index.ts

@@ -1,11 +1,11 @@
-import { TokenBuffer } from "../lexers/token-buffer.js";
-import { ParserUtility } from "../utility/parsing.js";
-import { ASTLexerStateNonMatchRule } from "./ast.js";
-import { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass, RuntimeLexerStateMatchRule } from "./runtime.js";
-export * from './ast.js';
-export * from './common.js';
-export * from './generator.js';
-export * from './runtime.js';
+import type { TokenBuffer } from "../lexers/token-buffer.ts";
+import type { ParserUtility } from "../utility/parsing.ts";
+import type { ASTLexerStateNonMatchRule } from "./ast.ts";
+import type { RuntimeGrammarProductionRule, RuntimeGrammarRuleSymbol, RuntimeParserClass, RuntimeLexerStateMatchRule } from "./runtime.ts";
+export * from './ast.ts';
+export * from './common.ts';
+export * from './generator.ts';
+export * from './runtime.ts';
 
 export interface ImportResolver {
     path(path: string): string;

package/src/typings/runtime.ts

@@ -1,6 +1,6 @@
-import { LRState } from "./index.js";
-import { ASTGrammarSymbolLiteral, ASTGrammarSymbolToken, ASTLexerStateNonMatchRule } from "./ast.js";
-import { Dictionary } from "./common.js";
+import type { LRState } from "./index.ts";
+import type { ASTGrammarSymbolLiteral, ASTGrammarSymbolToken, ASTLexerStateNonMatchRule } from "./ast.ts";
+import type { Dictionary } from "./common.ts";
 
 export interface RuntimeParserClass {
     artifacts: {

package/src/utility/format.ts

@@ -1,7 +1,7 @@
-import V1Grammar from '../generator/grammars/v1.js';
-import V2Grammar from '../generator/grammars/v2.js';
-import { V2GrammarString } from "../generator/stringify/grammar/v2.js";
-import { Parse } from '../parser/parse.js';
+import V1Grammar from '../generator/grammars/v1.ts';
+import V2Grammar from '../generator/grammars/v2.ts';
+import { V2GrammarString } from "../generator/stringify/grammar/v2.ts";
+import { Parse } from '../parser/parse.ts';
 
 export function Format(source: string, sourceVersion: '1' | '2' = '2') {
     const grammar = sourceVersion.toString() == '1' ? V1Grammar : V2Grammar;

package/src/utility/general.ts

@@ -1,4 +1,4 @@
-import { Dictionary, GeneratorGrammarSymbol } from "../typings/index.js";
+import type { Dictionary, GeneratorGrammarSymbol } from "../typings/index.ts";
 
 export class Collection<T> {
     categorized: Dictionary<Dictionary<number>> = {};
@@ -85,10 +85,11 @@ export class Matrix<T> {
     set x(x: number) { x != this.$x && this.resize(x, this.y); }
     get y() { return this.$y }
     set y(y: number) { y != this.$y && this.resize(this.x, y); }
-
+    private initial?: T | ((...args: any) => T);
     matrix: GetCallbackOrValue<T>[][] = [];
 
-    constructor(x: number, y: number, private initial?: T | ((...args: any) => T)) {
+    constructor(x: number, y: number, initial?: T | ((...args: any) => T)) {
+        this.initial = initial;
         this.resize(x, y);
     }