grammar-well 2.1.0 → 2.3.0

package/src/generator/stringify/common.ts

@@ -1,8 +1,11 @@
-import { ASTGrammarSymbolLiteral, ASTGrammarSymbolNonTerminal, ASTGrammarSymbolRegex, ASTGrammarSymbolToken, GeneratorGrammarSymbol } from "../../typings/index.js";
-import { GeneratorState } from "../state.js";
+import type { ASTGrammarSymbolLiteral, ASTGrammarSymbolNonTerminal, ASTGrammarSymbolRegex, ASTGrammarSymbolToken, GeneratorGrammarSymbol } from "../../typings/index.ts";
+import { GeneratorState } from "../state.ts";
 
 export class CommonGenerator {
-    constructor(public state: GeneratorState) { }
+    public state: GeneratorState;
+    constructor(state: GeneratorState) {
+        this.state = state;
+    }
 
     static NewLine(indent: number) {
         return '\n' + ' '.repeat(indent * 4);

package/src/generator/stringify/exports/javascript.ts

@@ -1,4 +1,4 @@
-import { JavaScriptGenerator } from "../javascript.js";
+import { JavaScriptGenerator } from "../javascript.ts";
 
 export function CJSOutput(generator: JavaScriptGenerator) {
     const exportName = generator.name();

package/src/generator/stringify/exports/json.ts

@@ -1,4 +1,4 @@
-import { JavaScriptGenerator } from "../javascript.js";
+import { JavaScriptGenerator } from "../javascript.ts";
 
 export function JSONFormatter(generator: JavaScriptGenerator) {
     return JSON.stringify({ state: generator.state.export(), output: generator.options });

package/src/generator/stringify/exports/registry.ts

@@ -1,8 +1,8 @@
 
-import { JavaScriptGenerator } from "../javascript.js";
-import { CJSOutput, ESMOutput } from "./javascript.js";
-import { JSONFormatter } from "./json.js";
-import { TypescriptFormat } from "./typescript.js";
+import { JavaScriptGenerator } from "../javascript.ts";
+import { CJSOutput, ESMOutput } from "./javascript.ts";
+import { JSONFormatter } from "./json.ts";
+import { TypescriptFormat } from "./typescript.ts";
 
 
 export const ExportsRegistry = {

package/src/generator/stringify/exports/typescript.ts

@@ -1,4 +1,4 @@
-import { JavaScriptGenerator } from "../javascript.js";
+import { JavaScriptGenerator } from "../javascript.ts";
 
 export function TypescriptFormat(generator: JavaScriptGenerator) {
     const exportName = generator.name();

package/src/generator/stringify/grammar/v2.ts

@@ -1,4 +1,4 @@
-import { ASTConfig, ASTDirectives, ASTGrammar, ASTGrammarProduction, ASTGrammarSymbol, ASTImport, ASTLexer, ASTLexerState, ASTLexerStateImportRule, ASTLexerStateMatchRule, ASTLexerStateNonMatchRule, GeneratorGrammarSymbol } from "../../../typings/index.js";
+import type { ASTConfig, ASTDirectives, ASTGrammar, ASTGrammarProduction, ASTGrammarSymbol, ASTImport, ASTLexer, ASTLexerState, ASTLexerStateImportRule, ASTLexerStateMatchRule, ASTLexerStateNonMatchRule, GeneratorGrammarSymbol } from "../../../typings/index.ts";
 
 export class V2GrammarString {
     source: string = '';

package/src/generator/stringify/javascript.ts

@@ -1,9 +1,9 @@
-import { Dictionary, GeneratorOutputOptions, GeneratorGrammarProductionRule } from "../../typings/index.js";
-import { BasicGrammarTable } from "../artifacts/basic.js";
-import { LexerArtifact } from "../artifacts/lexer.js";
-import { LRParseTableBuilder } from "../artifacts/lr.js";
-import { GeneratorState } from "../state.js";
-import { CommonGenerator } from "./common.js";
+import type { Dictionary, GeneratorOutputOptions, GeneratorGrammarProductionRule } from "../../typings/index.ts";
+import { BasicGrammarTable } from "../artifacts/basic.ts";
+import { LexerArtifact } from "../artifacts/lexer.ts";
+import { LRParseTableBuilder } from "../artifacts/lr.ts";
+import { GeneratorState } from "../state.ts";
+import { CommonGenerator } from "./common.ts";
 
 const PostProcessors = {
     "join": "({data}) => data.join('')",
@@ -13,8 +13,12 @@ const PostProcessors = {
 };
 
 export class JavaScriptGenerator {
-
-    constructor(public state: GeneratorState, public options: GeneratorOutputOptions) { }
+    public state: GeneratorState;
+    public options: GeneratorOutputOptions;
+    constructor(state: GeneratorState, options: GeneratorOutputOptions) {
+        this.state = state;
+        this.options = options;
+    }
 
     name() {
         return this.options.name || 'GWLanguage';

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from './generator/generator.js';
-export * from './generator/import-resolvers/auto.js';
-export { StatefulLexer } from './lexers/stateful-lexer.js';
-export * from './parser/parse.js';
-export * from './utility/parsing.js';
-export * from './typings/index.js';
-export * from './utility/index.js';
+export * from './generator/generator.ts';
+export * from './generator/import-resolvers/auto.ts';
+export { StatefulLexer } from './lexers/stateful-lexer.ts';
+export * from './parser/parse.ts';
+export * from './utility/parsing.ts';
+export * from './typings/index.ts';
+export * from './utility/index.ts';

package/src/lexers/character-lexer.ts

@@ -1,4 +1,4 @@
-import { RuntimeLexer } from "../typings/index.js";
+import type  { RuntimeLexer } from "../typings/index.ts";
 
 export class CharacterLexer implements RuntimeLexer {
     private buffer: string | any[] = '';

package/src/lexers/stateful-lexer.ts

@@ -1,4 +1,4 @@
-import { RuntimeLexerStateMatchRule, ASTLexerStateNonMatchRule, RuntimeLexer, RuntimeLexerConfig, StatefulLexerStateDefinition } from "../typings/index.js";
+import type { RuntimeLexerStateMatchRule, ASTLexerStateNonMatchRule, RuntimeLexer, RuntimeLexerConfig, StatefulLexerStateDefinition } from "../typings/index.ts";
 
 export class StatefulLexer implements RuntimeLexer {
     private start: string;

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, RuntimeLexerToken, 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,12 @@ export function Earley(language: RuntimeParserClass & { tokens: TokenBuffer }, o
             results.push(data);
         }
     }
-    const clone = results.length > 1;
-    for (let i = 0; i < results.length; i++) {
-        results[i] = PostProcess(results[i], clone);
+
+    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 } };
 }
@@ -76,28 +81,35 @@ function PostProcess(ast: PreAST | RuntimeLexerToken, clone?: boolean) {
 }
 
 class Column {
-    data: any;
-    states: State[] = [];
-    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
+    public data: any;
+    public states: State[] = [];
+    public wants: Dictionary<State[]> = Object.create(null);
+    public scannable: State[] = [];
+    public completed: Dictionary<State[]> = Object.create(null);
+    public index: number;
+    private rules: Dictionary<RuntimeGrammarProductionRule[]>;
+    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() {
         let w = 0;
         let state: State;
 
-        // eslint-disable-next-line no-cond-assign
-        while (state = this.states[w++]) { // nb. we push() during iteration
+        while (state = this.states[w++]) {
             if (state.isComplete) {
                 state.finish();
                 const { wantedBy } = state;
-                for (let i = wantedBy.length; i--;) { // this line is hot
+                for (let i = wantedBy.length; i--;) {
                     this.complete(wantedBy[i], state);
                 }
 
@@ -136,7 +148,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]));
         }
     }
 
@@ -156,22 +168,31 @@ class Column {
     }
 }
 
-class State {
-    isComplete: boolean;
-    data: any = [];
-    left: State;
-    right: State | StateToken;
+abstract class State {
+    public isComplete: boolean;
+    public data: any = [];
+    public left: State;
+    public 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) {
@@ -182,13 +203,10 @@ class State {
     }
 
 
-    finish() {
-        this.data = [this.rule, this.data, { reference: this.reference, dot: this.dot }];
-    }
+    abstract finish(): void;
 
     protected build() {
         const children = [];
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let node: State = this;
         do {
             children[node.dot - 1] = node.right.data;
@@ -198,6 +216,18 @@ 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,
@@ -205,4 +235,5 @@ interface StateToken {
     reference: number
 }
 
-type PreAST = [RuntimeGrammarProductionRule, (RuntimeLexerToken | PreAST)[], { reference: number, dot: 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}`;
     }
-}
+}