@bikky/replication 1.0.2 → 1.0.4

package/Expressions/Compiler/Parser/Interfaces.js

@@ -0,0 +1,112 @@
+import { ErrorStack } from "../../../Constants/Errors.js";
+import { GrammarRegistry } from "../GrammarRegistry.js";
+export var GrammarInterfaces;
+(function (GrammarInterfaces) {
+    var ExpressionSyntaxError = GrammarRegistry.ExpressionSyntaxError;
+    function isFunctionOutputType(type) {
+        return type.kind === "function";
+    }
+    GrammarInterfaces.isFunctionOutputType = isFunctionOutputType;
+    function isAssignableCompile(version, to, from, node, stack) {
+        let errors = new ErrorStack({ Version: version, SourceFile: node.file.sourceLocation });
+        if (!to || !from) {
+            if (!to) {
+                errors.syntaxError(`GI_AIAS_1B`, `Type is not assignable to null.`, node);
+            }
+            if (!from) {
+                errors.syntaxError(`GI_AIAS_2B`, `Null is not assignable to type.`, node);
+            }
+        }
+        else {
+            //Make sure each from is assignable to at least one to.
+            for (let fromEntry of from) {
+                let paramErrors = new ErrorStack({ Version: version, SourceFile: node.file.sourceLocation });
+                let success = false;
+                for (let toEntry of to) {
+                    success = true;
+                    if (isFunctionOutputType(toEntry) && isFunctionOutputType(fromEntry)) {
+                        if (fromEntry.parameters.length !== toEntry.parameters.length) {
+                            paramErrors.syntaxError(`GI_AIAS_01`, `Function is not assignable to function, provided ${fromEntry.parameters.length}` +
+                                ` but expected ${toEntry.parameters.length}.`, node);
+                            success = false;
+                        }
+                        else {
+                            for (let i = 0; i < toEntry.parameters.length; i++) {
+                                let subErrors = new ErrorStack({ Version: version, SourceFile: node.file.sourceLocation });
+                                if (!isAssignableCompile(version, toEntry.parameters[i].type, fromEntry.parameters[i].type, node, subErrors)) {
+                                    paramErrors.appendAndIndent(subErrors);
+                                    paramErrors.syntaxError(`GI_AIAS_02`, `Function is not assignable to function, parameter ${i} (${toEntry.parameters[i].assignmentName}) doesn't match.`, node);
+                                    success = false;
+                                }
+                            }
+                        }
+                        let subErrors = new ErrorStack({ Version: version, SourceFile: node.file.sourceLocation });
+                        if (!isAssignableCompile(version, toEntry.returnType, fromEntry.returnType, node, subErrors)) {
+                            paramErrors.appendAndIndent(subErrors);
+                            paramErrors.syntaxError(`GI_AIAS_03`, `Function is not assignable to function, return type doesn't match.`, node);
+                            success = false;
+                        }
+                    }
+                    else if (!isFunctionOutputType(toEntry) && !isFunctionOutputType(fromEntry)) {
+                        if (!toEntry.isAssignableCompile(version, fromEntry)) {
+                            paramErrors.syntaxError(`GI_AIAS_04`, `${fromEntry.debugName} is not assignable to ${toEntry.debugName}.`, node);
+                            success = false;
+                        }
+                    }
+                    else {
+                        paramErrors.syntaxError(`GI_AIAS_05`, `Function is not assignable to non-function, types don't match.`, node);
+                        success = false;
+                    }
+                    if (success) {
+                        break;
+                    }
+                }
+                if (!success) {
+                    errors.appendWithoutIndent(paramErrors);
+                }
+            }
+        }
+        stack.appendWithoutIndent(errors);
+        return errors.hasErrors();
+    }
+    GrammarInterfaces.isAssignableCompile = isAssignableCompile;
+    function collapseTypeLive(scope, node, value, types) {
+        if (!types)
+            return null;
+        let stack = new ErrorStack({ Version: scope.version, SourceFile: node.file.sourceLocation });
+        for (let type of types) {
+            if (type.kind === "value") {
+                //TODO: Handle collections
+                if (!type.isAssignable(scope.version, !!scope.data, value, stack)) {
+                    continue;
+                }
+                return type;
+            }
+            else if (type.kind === "function") {
+                if (typeof value !== "function") {
+                    continue;
+                }
+                if (value.type != type) {
+                    continue;
+                }
+                return type;
+            }
+        }
+        throw new ExpressionSyntaxError(`Value is not assignable to any of the expected types.\n` + stack.toString(`EXP_GI_CTL_01`), node);
+    }
+    GrammarInterfaces.collapseTypeLive = collapseTypeLive;
+    function dedupeTypes(types) {
+        const seen = new Set(types);
+        return [...seen];
+    }
+    GrammarInterfaces.dedupeTypes = dedupeTypes;
+    let SpecialType;
+    (function (SpecialType) {
+        /**
+         * Allow extra types to be input by the parent. Used as a placeholder for blocks so that the expression
+         * lines from the parent are used in the evaluation of this grammar rule.
+         **/
+        SpecialType[SpecialType["INPUT_TYPES"] = 1000] = "INPUT_TYPES";
+    })(SpecialType = GrammarInterfaces.SpecialType || (GrammarInterfaces.SpecialType = {}));
+})(GrammarInterfaces || (GrammarInterfaces = {}));
+//# sourceMappingURL=Interfaces.js.map

package/Expressions/Compiler/Parser/Interfaces.js.map

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

package/Expressions/Compiler/Parser/MatchGrammar.d.ts

@@ -0,0 +1,15 @@
+import { MatchSuccess, NextMatchDetails } from "./TypesAndPrint.js";
+import { NodeType } from "./Enums.js";
+import { GrammarInterfaces } from "./Interfaces.js";
+import EAST_Complex_Node = GrammarInterfaces.EAST_Complex_Node;
+/**
+ * Given the current location and a list of possible rules for what could come next, iterate through each rule and evaluate
+ * it.
+ * We do track which rules we've already started evaluating on this node, because in the case of expressions referencing each
+ * other in the first node, we might infinite loop on the evaluation if we don't bail. If we do bail we need to not remember
+ * that we bailed due to an infinite loop, because a valid binary expression could still be a valid expression (even though
+ * it was skipped when the expression was evaluated).
+ * Example of an infinite loop:
+ *    Binary Expression -> Expression -> Binary Expression -> Expression -> ...
+ */
+export declare function MatchGrammar(details: NextMatchDetails, grammarType: NodeType, historicalMatches: NodeType[]): MatchSuccess<EAST_Complex_Node>;

package/Expressions/Compiler/Parser/MatchGrammar.js

@@ -0,0 +1,128 @@
+import { PrintNodeName } from "./TypesAndPrint.js";
+import { GrammarRegistry } from "../GrammarRegistry.js";
+import { MatchRepeatingRule } from "./MatchRepeatingRule.js";
+import { MatchRule } from "./MatchRule.js";
+import { CheckRuleDone, IsRuleSkippable } from "./Checks.js";
+import { NodeType } from "./Enums.js";
+/**
+ * Given the current location and a list of possible rules for what could come next, iterate through each rule and evaluate
+ * it.
+ * We do track which rules we've already started evaluating on this node, because in the case of expressions referencing each
+ * other in the first node, we might infinite loop on the evaluation if we don't bail. If we do bail we need to not remember
+ * that we bailed due to an infinite loop, because a valid binary expression could still be a valid expression (even though
+ * it was skipped when the expression was evaluated).
+ * Example of an infinite loop:
+ *    Binary Expression -> Expression -> Binary Expression -> Expression -> ...
+ */
+export function MatchGrammar(details, grammarType, historicalMatches) {
+    let grammar = GrammarRegistry.getRule(details.parser.versionIndex, grammarType);
+    let tokenIndexAtStartOfNode = details.parser.currentNodeIndex;
+    let previousRuleMatched = true;
+    let start = details.parser.token.position;
+    let column = details.parser.token.column;
+    let line = details.parser.token.line;
+    let cached = details.parser.partialEvaluationResults.get2D(grammarType, tokenIndexAtStartOfNode);
+    if (typeof cached !== "undefined") {
+        if (cached === null) {
+            console.debug(`Cache for rule ${NodeType[grammarType]} at ${tokenIndexAtStartOfNode}`
+                + ` is recorded as having failed, so returning failure and skipping resolution.`);
+        }
+        else {
+            console.debug(`Retrieving cached node for ${PrintNodeName(cached)}`);
+        }
+        return {
+            result: cached,
+            cachable: true
+        };
+    }
+    // We've hit a loop - we've already tried to evaluate this grammar type for this node.
+    // We should only need to do this for the first rule in a grammar, because it's fine for
+    // rules to be recursive after the first entry (e.g. having multiple parenthesised expressions
+    // starting with multiple '('s ).
+    if (historicalMatches.includes(grammar.ID)) {
+        // Don't cache nodes that failed due to recursion, because we can't guarantee that
+        // that they will fail again next time.
+        return {
+            result: null,
+            cachable: false
+        };
+    }
+    let cachable = true;
+    let node = null;
+    let childDetails = { ...details, debugTabs: details.debugTabs + "\t" };
+    let ruleMatchSuccess = false;
+    //Must match one rule cluster.
+    MatchOneRuleCluster: for (let ruleClusterIndex = 0; ruleClusterIndex < grammar.rules.length; ruleClusterIndex++) {
+        node = {
+            type: grammarType,
+            execute: grammar.execute,
+            values: {},
+            startTokenIndex: tokenIndexAtStartOfNode,
+            debugName: PrintNodeName({ type: grammarType })
+        };
+        //Must match each rule in the cluster.
+        MatchEachRule: for (let grammarRuleIndex = 0; grammarRuleIndex < grammar.rules[ruleClusterIndex].length; grammarRuleIndex++) {
+            if (details.parser.done) {
+                if (CheckRuleDone(grammar, grammar.rules[ruleClusterIndex], grammarRuleIndex)) {
+                    ruleMatchSuccess = true;
+                    break MatchOneRuleCluster;
+                }
+                else {
+                    details.parser.resetToken(tokenIndexAtStartOfNode);
+                    continue MatchOneRuleCluster;
+                }
+            }
+            let rule = grammar.rules[ruleClusterIndex][grammarRuleIndex];
+            let ruleSkippable = IsRuleSkippable(rule, previousRuleMatched);
+            let ruleRepeat = !!rule.repeat;
+            let history = details.parser.currentNodeIndex == tokenIndexAtStartOfNode ? [...historicalMatches, grammar.ID] : [];
+            let success = ruleRepeat ? MatchRepeatingRule(childDetails, rule, node, history) : MatchRule(childDetails, rule, node, history);
+            // Should this propagate cacheability or not?
+            // Sometimes! - If we've correctly parsed the first token when we've gotten to this point then we can
+            // ignore the cache.
+            // And it's only recursion on the first token that is a danger for causing infinite loops, so it's the
+            // only failure we guard against with the history check. All other failures are going to be the same
+            // regardless of which node starts evaluating them.
+            if (details.parser.currentNodeIndex == tokenIndexAtStartOfNode && !success.cachable) {
+                cachable = false;
+            }
+            if (!success.result && !ruleSkippable) {
+                continue MatchOneRuleCluster;
+            }
+        }
+    }
+    if (!ruleMatchSuccess) {
+        return {
+            result: null,
+            cachable
+        };
+    }
+    if (!node) {
+        if (cachable) {
+            details.parser.partialEvaluationResults.set2D(grammarType, tokenIndexAtStartOfNode, null);
+        }
+        details.parser.resetToken(tokenIndexAtStartOfNode);
+        return {
+            result: null,
+            cachable: true
+        };
+    }
+    let lastToken = details.parser.token ? details.parser.token : details.parser.tokens[details.parser.tokens.length - 1];
+    let finishedNode = {
+        ...node,
+        file: details.parser.file,
+        position: start,
+        version: details.parser.version,
+        column: column,
+        line: line,
+        length: lastToken.position + lastToken.length - start
+    };
+    if (cachable) {
+        details.parser.partialEvaluationResults.set2D(grammarType, tokenIndexAtStartOfNode, finishedNode);
+    }
+    return {
+        result: finishedNode,
+        cachable: true
+    };
+}
+//# sourceMappingURL=MatchGrammar.js.map

package/Expressions/Compiler/Parser/MatchGrammar.js.map

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

package/Expressions/Compiler/Parser/MatchRepeatingRule.d.ts

@@ -0,0 +1,4 @@
+import { MatchSuccess, NextMatchDetails, PartialEASTNode } from "./TypesAndPrint.js";
+import { NodeType } from "./Enums.js";
+import { GrammarInterfaces } from "./Interfaces.js";
+export declare function MatchRepeatingRule(details: NextMatchDetails, rule: GrammarInterfaces.Rule, progress: PartialEASTNode, historicalMatches: NodeType[]): MatchSuccess<PartialEASTNode>;

package/Expressions/Compiler/Parser/MatchRepeatingRule.js

@@ -0,0 +1,51 @@
+import { PrintNodeName } from "./TypesAndPrint.js";
+import { MatchRule } from "./MatchRule.js";
+import { TokenDataMatchesRule } from "./Checks.js";
+export function MatchRepeatingRule(details, rule, progress, historicalMatches) {
+    let ruleCurrentRepeatNumber = 0;
+    let cachable = true;
+    do {
+        //Consume repeat token if present!
+        if (rule.repeatSeparator && ruleCurrentRepeatNumber > 0) {
+            if (rule.repeatSeparator.optional == "previous") {
+                throw new Error(`Repeat separator's optionality can't be based on previous rule.`);
+            }
+            if (details.parser.token.type == rule.repeatSeparator.type
+                && TokenDataMatchesRule(details.parser.version, rule.repeatSeparator, details.parser.token)) {
+                console.debug(`${details.debugTabs}Skipping ${PrintNodeName(details.parser.token)} ${details.parser.token.data}`);
+                details.parser.consumeToken();
+            }
+            else {
+                break;
+            }
+        }
+        // Finished repeats - so return success.
+        if (details.parser.done) {
+            break;
+        }
+        //For each type that may be next, there is an early exit if repeating but no more tokens.
+        let valid = MatchRule(details, rule, progress, historicalMatches);
+        if (details.parser.currentNodeIndex === progress.startTokenIndex) {
+            cachable &&= valid.cachable;
+        }
+        if (!valid.result) {
+            //Didn't repeat enough, so die in a fire!
+            if (ruleCurrentRepeatNumber < rule.repeat[0]) {
+                console.debug(`${details.debugTabs}Repeated ${ruleCurrentRepeatNumber} times, which is less than ${rule.repeat[0]}!`);
+                return { result: null, cachable };
+            }
+            //We hit the minimum needed repeats, so we can stop with a valid node here.
+            break;
+        }
+        ruleCurrentRepeatNumber++;
+        //Repeat too much, so force continue.
+        if (ruleCurrentRepeatNumber >= rule.repeat[1]) {
+            break;
+        }
+    } while (true);
+    return {
+        result: progress,
+        cachable
+    };
+}
+//# sourceMappingURL=MatchRepeatingRule.js.map

package/Expressions/Compiler/Parser/MatchRepeatingRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatchRepeatingRule.js","sourceRoot":"","sources":["MatchRepeatingRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmD,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACpG,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAInD,MAAM,UAAU,kBAAkB,CAAC,OAAyB,EAAE,IAA4B,EAAE,QAAyB,EAAE,iBAA6B;IACnJ,IAAI,uBAAuB,GAAG,CAAC,CAAC;IAChC,IAAI,QAAQ,GAAG,IAAI,CAAC;IAEpB,GAAG,CAAC;QACH,kCAAkC;QAClC,IAAI,IAAI,CAAC,eAAe,IAAI,uBAAuB,GAAG,CAAC,EAAE,CAAC;YACzD,IAAI,IAAI,CAAC,eAAe,CAAC,QAAQ,IAAI,UAAU,EAAE,CAAC;gBACjD,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;YACpF,CAAC;YACD,IACC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI;mBACnD,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAC1F,CAAC;gBACF,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,SAAS,YAAY,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;gBAClH,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC/B,CAAC;iBACI,CAAC;gBACL,MAAM;YACP,CAAC;QACF,CAAC;QAED,wCAAwC;QACxC,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACzB,MAAM;QACP,CAAC;QAED,yFAAyF;QACzF,IAAI,KAAK,GAAG,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,iBAAiB,CAAC,CAAC;QAClE,IAAI,OAAO,CAAC,MAAM,CAAC,gBAAgB,KAAK,QAAQ,CAAC,eAAe,EAAE,CAAC;YAClE,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACnB,yCAAyC;YACzC,IAAI,uBAAuB,GAAG,IAAI,CAAC,MAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC/C,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,SAAS,YAAY,uBAAuB,8BAA8B,IAAI,CAAC,MAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBACvH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;YACnC,CAAC;YACD,2EAA2E;YAC3E,MAAM;QACP,CAAC;QAED,uBAAuB,EAAE,CAAC;QAE1B,qCAAqC;QACrC,IAAI,uBAAuB,IAAI,IAAI,CAAC,MAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAChD,MAAM;QACP,CAAC;IACF,CAAC,QAAQ,IAAI,EAAE;IAEf,OAAO;QACN,MAAM,EAAE,QAAQ;QAChB,QAAQ;KACR,CAAA;AACF,CAAC"}

package/Expressions/Compiler/Parser/MatchRule.d.ts

@@ -0,0 +1,4 @@
+import { MatchSuccess, NextMatchDetails, PartialEASTNode } from "./TypesAndPrint.js";
+import { GrammarInterfaces } from "./Interfaces.js";
+import { NodeType } from "./Enums.js";
+export declare function MatchRule(details: NextMatchDetails, rule: GrammarInterfaces.Rule, progress: PartialEASTNode, historicalMatches: NodeType[]): MatchSuccess<PartialEASTNode>;

package/Expressions/Compiler/Parser/MatchRule.js

@@ -0,0 +1,57 @@
+import { PrintNodeName, PrintTokenText } from "./TypesAndPrint.js";
+import { AddToPartialEASTNode, ComputeChildInputs, ComputeValidTypes } from "./Updates.js";
+import { TokenDataMatchesRule } from "./Checks.js";
+import { MatchGrammar } from "./MatchGrammar.js";
+import { NodeType, TokenType } from "./Enums.js";
+export function MatchRule(details, rule, progress, historicalMatches) {
+    let validTypes = ComputeValidTypes(rule, details.extraTypes);
+    let childInputs = ComputeChildInputs(rule, details.extraTypes);
+    let cachable = true;
+    if ("value" in rule || "values" in rule) {
+        if (!TokenDataMatchesRule(details.parser.version, rule, details.parser.token)) {
+            console.debug(`${details.debugTabs}  - Token data ${PrintTokenText(details.parser.token)} is undesirable, skipping type.`);
+            // Value mismatch, assuming this tokenType can only ever match one value it's safe to break.
+            return {
+                result: null,
+                cachable
+            };
+        }
+    }
+    for (let type of validTypes) {
+        //Check if type is the current valid type.
+        if (type == details.parser.token.type) {
+            console.debug(`${details.debugTabs}  - Matched a ${TokenType[type]} ${PrintTokenText(details.parser.token)}`);
+            AddToPartialEASTNode(details, rule, progress, details.parser.token);
+            return {
+                result: progress,
+                cachable
+            };
+        }
+        //Or if we're currently looking at a compound node type, we'll see if we can create it!
+        else if (type in NodeType) {
+            console.debug(`${details.debugTabs} - Trying to make a ${NodeType[type]}`);
+            //Try make a node.
+            //Run through all of the rules of a possible compound rule.
+            //If the rules match, then make a new node.
+            let subMatch = MatchGrammar({ ...details, extraTypes: childInputs }, type, historicalMatches);
+            if (!subMatch.cachable && details.parser.currentNodeIndex == progress.startTokenIndex) {
+                cachable = false;
+            }
+            //Node succeeded, continue.
+            if (subMatch.result) {
+                console.debug(`${details.debugTabs}Made a ${NodeType[type]}`);
+                AddToPartialEASTNode(details, rule, progress, subMatch.result);
+                return {
+                    result: progress,
+                    cachable
+                };
+            }
+        }
+    }
+    console.debug(`${details.debugTabs}Failed to create a ${PrintNodeName(progress)}, '${details.parser.token.data}' != '${rule.debug_name ?? rule.value ?? rule.values}'`);
+    return {
+        result: null,
+        cachable
+    };
+}
+//# sourceMappingURL=MatchRule.js.map

package/Expressions/Compiler/Parser/MatchRule.js.map

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

package/Expressions/Compiler/Parser/Parser.d.ts

@@ -0,0 +1,26 @@
+import { Map2D } from "@bikky/smart-collections";
+import { FileNode } from "../Grammar/General.js";
+import { GrammarInterfaces } from "./Interfaces.js";
+import Token = GrammarInterfaces.Token;
+export declare class ExpressionParser {
+    tokens: Token[];
+    version: string;
+    versionIndex: number;
+    currentNodeIndex: number;
+    done: boolean;
+    token: Token;
+    file: Partial<FileNode>;
+    sourceLocation: string;
+    partialEvaluationResults: Map2D<number, GrammarInterfaces.EAST_Complex_Node | null>;
+    constructor(version: string, code: string, sourceLocation: string, start: {
+        line: number;
+        column: number;
+    });
+    consumeToken(): void;
+    resetToken(index: number): void;
+    run(): FileNode | null;
+}
+export declare function CreateASTFromString(version: string, lines: string, sourceLocation: string, start: {
+    line: number;
+    column: number;
+}): FileNode | null;

package/Expressions/Compiler/Parser/Parser.js

@@ -0,0 +1,67 @@
+import { TokenizeExpression } from "./Tokenizer.js";
+import { GetVersionIndex } from "../../../Constants/Versions.js";
+import { MatchGrammar } from "./MatchGrammar.js";
+import { Map2D } from "@bikky/smart-collections";
+import { NodeType, TokenType } from "./Enums.js";
+let debug = false;
+export class ExpressionParser {
+    constructor(version, code, sourceLocation, start) {
+        // Keeps track of successful and failed partial evaluations to speed up compilation.
+        this.partialEvaluationResults = new Map2D();
+        this.tokens = TokenizeExpression(code, version);
+        this.versionIndex = GetVersionIndex(version);
+        this.version = version;
+        this.sourceLocation = sourceLocation;
+        this.currentNodeIndex = 0;
+        this.done = false;
+        this.token = this.tokens[0];
+        if (this.token.type == TokenType.WHITESPACE)
+            this.consumeToken();
+        this.file = {
+            text: code,
+            line: start.line,
+            column: start.column,
+            sourceLocation: sourceLocation
+        };
+    }
+    consumeToken() {
+        this.currentNodeIndex++;
+        while (this.tokens[this.currentNodeIndex]?.type == TokenType.WHITESPACE) {
+            this.currentNodeIndex++;
+        }
+        this.token = this.tokens[this.currentNodeIndex];
+        if (this.token) {
+            debug &&
+                console.log(`[New token is ${this.currentNodeIndex}: ${TokenType[this.token.type]} '${this.token.data.slice(0, Math.min(this.token.data.length, 20))}']`);
+        }
+        this.done = this.currentNodeIndex >= this.tokens.length;
+    }
+    //We reset if we fail to generate a node.
+    resetToken(index) {
+        this.currentNodeIndex = index;
+        this.token = this.tokens[this.currentNodeIndex];
+        console.debug(`[Reset token to ${this.currentNodeIndex}: ${TokenType[this.token.type]} '${this.token.data.slice(0, Math.min(this.token.data.length, 20))}']`);
+        this.done = this.currentNodeIndex >= this.tokens.length;
+    }
+    run() {
+        if (this.token.type == TokenType.WHITESPACE)
+            this.consumeToken();
+        //Start with a file :]
+        let node = MatchGrammar({
+            parser: this,
+            extraTypes: [],
+            debugTabs: ""
+        }, NodeType.FILE, []).result;
+        if (node == null)
+            return null;
+        let prop;
+        for (prop in node) {
+            this.file[prop] = node[prop];
+        }
+        return this.file;
+    }
+}
+export function CreateASTFromString(version, lines, sourceLocation, start) {
+    return new ExpressionParser(version, lines, sourceLocation, start).run();
+}
+//# sourceMappingURL=Parser.js.map

package/Expressions/Compiler/Parser/Parser.js.map

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

package/Expressions/Compiler/Parser/Tokenizer.d.ts

@@ -0,0 +1,12 @@
+import { GrammarInterfaces } from "./Interfaces.js";
+import TokenCategoryRule = GrammarInterfaces.TokenCategoryRule;
+import Token = GrammarInterfaces.Token;
+export declare function getEASTTokenValues(fileVersion: string, category: TokenCategoryRule): Set<string>;
+/**
+ *
+ * @param expression The whole string
+ * @param version The version of the expression language this was compiled against
+ * @param offset The offset from the start of the file that this expression occurred within.
+ * @constructor
+ */
+export declare function TokenizeExpression(expression: string, version: string, offset?: number): Token[];