circuitscript 0.0.22 → 0.0.25

package/dist/esm/BaseVisitor.mjs

@@ -0,0 +1,488 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { ExpressionContext } from "./antlr/CircuitScriptParser";
+import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor";
+import { ExecutionContext } from "./execute";
+import { Logger } from "./logger";
+import { ClassComponent } from "./objects/ClassComponent";
+import { NumericValue, PercentageValue, PinBlankValue } from "./objects/ParamDefinition";
+import { PinTypes } from "./objects/PinTypes";
+import { UndeclaredReference } from "./objects/types";
+export class BaseVisitor extends CircuitScriptVisitor {
+    indentLevel = 0;
+    startingContext;
+    executionStack;
+    silent = false;
+    logger;
+    currentDirectory;
+    defaultLibsPath;
+    printStream = [];
+    printToConsole = true;
+    acceptedDirections = ['left', 'right', 'up', 'down'];
+    acceptedFlip = ['flipX', 'flipY'];
+    resultData = new Map;
+    paramData = new Map;
+    pinTypesList = [
+        PinTypes.Any,
+        PinTypes.Input,
+        PinTypes.Output,
+        PinTypes.IO,
+        PinTypes.Power,
+    ];
+    onErrorCallbackHandler = null;
+    onImportFile = (visitor, filePath) => {
+        throw "Import file not implemented";
+    };
+    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultLibsPath) {
+        super();
+        this.logger = new Logger();
+        this.onErrorCallbackHandler = onErrorHandler;
+        this.startingContext = new ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger, null);
+        this.setupPrintFunction(this.startingContext);
+        this.executionStack = [this.startingContext];
+        this.startingContext.resolveNet =
+            this.createNetResolver(this.executionStack);
+        this.silent = silent;
+        this.currentDirectory = currentDirectory;
+        this.defaultLibsPath = defaultLibsPath;
+    }
+    getExecutor() {
+        return this.executionStack[this.executionStack.length - 1];
+    }
+    setupPrintFunction(context) {
+        context.createFunction('print', (params) => {
+            const items = params.map(([, , value]) => {
+                return value;
+            });
+            if (this.printToConsole) {
+                console.log('::', ...items);
+            }
+            this.printStream.push(...items);
+            return [this, null];
+        });
+    }
+    createNetResolver(executionStack) {
+        const resolveNet = (netName, netNamespace) => {
+            this.log('find net', netNamespace, netName);
+            const reversed = [...executionStack].reverse();
+            for (let i = 0; i < reversed.length; i++) {
+                const context = reversed[i];
+                const net = context.scope.getNetWithName(netName);
+                if (net !== null && net.namespace === netNamespace) {
+                    return {
+                        found: true,
+                        net,
+                    };
+                }
+            }
+            return {
+                found: false
+            };
+        };
+        return resolveNet;
+    }
+    log(...params) {
+        const indentOutput = ''.padStart(this.indentLevel * 4, '    ');
+        const indentLevelText = this.indentLevel.toString().padStart(3, ' ');
+        const args = ['[' + indentLevelText + ']', indentOutput, ...params];
+        this.logger.add(args.join(' '));
+        if (!this.silent) {
+            console.log.apply(null, args);
+        }
+    }
+    log2(message) {
+        this.getExecutor().log(message);
+    }
+    visitScript = (ctx) => {
+        this.log('===', 'start', '===');
+        const result = this.visitChildren(ctx);
+        this.log('===', 'end', '===');
+        return result;
+    };
+    visitAssignment_expr = (ctx) => {
+        const atomStr = ctx.atom_expr().getText();
+        if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
+            throw "Invalid assignment expression!";
+        }
+        const ctxAtomExpr = ctx.atom_expr();
+        this.visit(ctxAtomExpr);
+        const reference = this.getResult(ctxAtomExpr);
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        if (value instanceof ClassComponent) {
+            const instances = this.getExecutor().scope.instances;
+            const tmpComponent = value;
+            const oldName = tmpComponent.instanceName;
+            tmpComponent.instanceName = reference.name;
+            instances.delete(oldName);
+            instances.set(reference.name, tmpComponent);
+            this.getExecutor().log(`assigned '${reference.name}' to ClassComponent`);
+        }
+        else {
+            const trailers = reference.trailers ?? [];
+            if (trailers.length === 0) {
+                this.getExecutor().scope.variables.set(reference.name, value);
+            }
+            else if (reference.value instanceof ClassComponent) {
+                this.setInstanceParam(reference.value, trailers, value);
+            }
+        }
+        this.setResult(ctx, value);
+    };
+    visitAtom_expr = (ctx) => {
+        const executor = this.getExecutor();
+        const firstId = ctx.ID(0);
+        const atomId = firstId.getText();
+        let currentReference;
+        if (this.pinTypesList.indexOf(atomId) !== -1) {
+            currentReference = {
+                found: true,
+                value: atomId
+            };
+        }
+        else {
+            currentReference = executor.resolveVariable(this.executionStack, atomId);
+        }
+        if (currentReference.found && currentReference.type === 'instance') {
+            const tmpComponent = currentReference.value;
+            for (const [pinId, net] of tmpComponent.pinNets) {
+                executor.scope.setNet(tmpComponent, pinId, net);
+            }
+            if (ctx.ID().length > 1) {
+                currentReference.trailers = [];
+                const idLength = ctx.ID().length;
+                for (let i = 1; i < idLength; i++) {
+                    const tmpCtx = ctx.ID(i);
+                    currentReference.trailers.push(tmpCtx.getText());
+                }
+            }
+        }
+        if (ctx.parent instanceof ExpressionContext && !currentReference.found) {
+            throw "Unknown symbol: " + atomId;
+        }
+        this.setResult(ctx, currentReference);
+    };
+    visitFunctionCallExpr = (ctx) => {
+        const tmpCtx = ctx.function_call_expr();
+        this.visit(tmpCtx);
+        const result = this.getResult(tmpCtx);
+        this.setResult(ctx, result);
+    };
+    visitFunction_call_expr = (ctx) => {
+        const executor = this.getExecutor();
+        const atomId = ctx.ID().getText();
+        let passedNetNamespace = null;
+        const netNameSpaceExpr = ctx.net_namespace_expr();
+        if (netNameSpaceExpr) {
+            this.visit(netNameSpaceExpr);
+            passedNetNamespace = this.getResult(netNameSpaceExpr);
+        }
+        let currentReference = executor.resolveVariable(this.executionStack, atomId);
+        if (ctx.trailer_expr().length > 0) {
+            if (!currentReference.found) {
+                throw "Unknown function name: " + atomId;
+            }
+            currentReference.trailers = [];
+            ctx.trailer_expr().forEach(item => {
+                const itemValue = item.getText();
+                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                    let parameters = [];
+                    const ctxParameters = item.parameters();
+                    if (ctxParameters) {
+                        this.visit(ctxParameters);
+                        parameters = this.getResult(ctxParameters);
+                    }
+                    const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
+                    const [, functionResult] = executor.callFunction(currentReference.name, parameters, this.executionStack, useNetNamespace);
+                    currentReference = {
+                        found: true,
+                        value: functionResult,
+                        type: (functionResult instanceof ClassComponent) ?
+                            'instance' : 'value',
+                    };
+                }
+                else {
+                    currentReference.trailers.push(itemValue);
+                }
+            });
+        }
+        this.setResult(ctx, currentReference.value);
+    };
+    visitValue_expr = (ctx) => {
+        const sign = ctx.Minus() ? -1 : 1;
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        const ctxDecimalValue = ctx.DECIMAL_VALUE();
+        const ctxNumericValue = ctx.NUMERIC_VALUE();
+        const ctxBooleanValue = ctx.BOOLEAN_VALUE();
+        const ctxStringValue = ctx.STRING_VALUE();
+        const ctxPercentageValue = ctx.PERCENTAGE_VALUE();
+        const ctxBlankExpr = ctx.blank_expr();
+        let result = null;
+        if (ctxIntegerValue || ctxDecimalValue || ctxNumericValue) {
+            if (ctxIntegerValue) {
+                result = sign * Number(ctxIntegerValue.getText());
+            }
+            else if (ctxDecimalValue) {
+                result = sign * Number(ctxDecimalValue.getText());
+            }
+            else if (ctxNumericValue) {
+                const textExtra = ctx.Minus() ? '-' : '';
+                result = new NumericValue(textExtra + ctxNumericValue.getText());
+            }
+        }
+        else {
+            if (sign === -1) {
+                throw "Invalid value!";
+            }
+        }
+        if (ctxBooleanValue) {
+            const stringValue = ctxBooleanValue.getText();
+            if (stringValue === 'true') {
+                result = true;
+            }
+            else if (stringValue === 'false') {
+                result = false;
+            }
+        }
+        else if (ctxStringValue) {
+            result = this.prepareStringValue(ctxStringValue.getText());
+        }
+        else if (ctxPercentageValue) {
+            result = new PercentageValue(ctxPercentageValue.getText());
+        }
+        else if (ctxBlankExpr) {
+            this.visit(ctxBlankExpr);
+            result = this.getResult(ctxBlankExpr);
+        }
+        this.setResult(ctx, result);
+    };
+    visitBlank_expr = (ctx) => {
+        this.setResult(ctx, new PinBlankValue(Number(ctx.INTEGER_VALUE().getText())));
+    };
+    visitValueAtomExpr = (ctx) => {
+        let value = null;
+        const ctxValueExpr = ctx.value_expr();
+        const ctxAtomExpr = ctx.atom_expr();
+        if (ctxValueExpr) {
+            this.visit(ctxValueExpr);
+            value = this.getResult(ctxValueExpr);
+        }
+        else if (ctxAtomExpr) {
+            this.visit(ctxAtomExpr);
+            const reference = this.getResult(ctxAtomExpr);
+            if (!reference.found) {
+                value = new UndeclaredReference(reference);
+            }
+            else {
+                value = reference.value;
+            }
+        }
+        this.setResult(ctx, value);
+    };
+    visitFunction_args_expr = (ctx) => {
+        const defaultValuesProvided = ctx.value_expr();
+        const IDs = ctx.ID();
+        const boundary = IDs.length - defaultValuesProvided.length;
+        const result = IDs.map((id, index) => {
+            const idText = id.getText();
+            if (index >= boundary) {
+                const tmpCtx = defaultValuesProvided[index - boundary];
+                this.visit(tmpCtx);
+                const defaultValue = this.getResult(tmpCtx);
+                return [idText, defaultValue];
+            }
+            else {
+                return [idText];
+            }
+        });
+        this.setResult(ctx, result);
+    };
+    visitParameters = (ctx) => {
+        const dataExpressions = ctx.data_expr();
+        const keywordAssignmentExpressions = ctx.keyword_assignment_expr();
+        const returnList = [];
+        dataExpressions.forEach((item, index) => {
+            this.visit(item);
+            const value = this.getResult(item);
+            returnList.push(['position', index, value]);
+        });
+        keywordAssignmentExpressions.forEach((item) => {
+            this.visit(item);
+            const [key, value] = this.getResult(item);
+            returnList.push(['keyword', key, value]);
+        });
+        this.setResult(ctx, returnList);
+    };
+    visitImport_expr = (ctx) => {
+        const ID = ctx.ID().toString();
+        this.log('import', ID);
+        this.handleImportFile(ID, true);
+        this.log('done import', ID);
+    };
+    visitFunction_return_expr = (ctx) => {
+        const executor = this.getExecutor();
+        executor.log('return from function');
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const returnValue = this.getResult(ctxDataExpr);
+        executor.stopFurtherExpressions = true;
+        executor.returnValue = returnValue;
+        this.setResult(ctx, returnValue);
+    };
+    visitBreak_keyword = (ctx) => {
+        this.getExecutor().breakBranch();
+        this.setResult(ctx, -1);
+    };
+    setResult(ctx, value) {
+        this.resultData.set(ctx, value);
+    }
+    getResult(ctx) {
+        return this.resultData.get(ctx);
+    }
+    setParam(ctx, value) {
+        this.paramData.set(ctx, value);
+    }
+    getParam(ctx) {
+        return this.paramData.get(ctx);
+    }
+    hasParam(ctx) {
+        return this.paramData.has(ctx);
+    }
+    handleImportFile(name, throwErrors = true) {
+        let hasError = false;
+        let hasParseError = false;
+        let pathExists = false;
+        const tmpFilePath = join(this.currentDirectory, name + ".cst");
+        this.log('importing path:', tmpFilePath);
+        let fileData = null;
+        try {
+            fileData = readFileSync(tmpFilePath, { encoding: 'utf8' });
+            pathExists = true;
+        }
+        catch (err) {
+            pathExists = false;
+        }
+        if (!pathExists) {
+            try {
+                const tmpFilePath2 = join(this.defaultLibsPath, name + ".cst");
+                fileData = readFileSync(tmpFilePath2, { encoding: 'utf8' });
+                pathExists = true;
+            }
+            catch (err) {
+                pathExists = false;
+            }
+        }
+        try {
+            if (pathExists) {
+                this.log('done reading imported file data');
+                const importResult = this.onImportFile(this, fileData, this.onErrorCallbackHandler);
+                hasError = importResult.hasError;
+                hasParseError = importResult.hasParseError;
+            }
+        }
+        catch (err) {
+            this.log('Failed to import file: ', err.message);
+        }
+        if (throwErrors && (hasError || hasParseError || !pathExists)) {
+            if (!pathExists) {
+                throw `File does not exist: ${name}`;
+            }
+            else {
+                throw `Failed to import: ${name}`;
+            }
+        }
+        return {
+            hasError,
+            hasParseError,
+            pathExists,
+        };
+    }
+    visitRoundedBracketsExpr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const innerResult = this.getResult(ctxDataExpr);
+        this.setResult(ctx, innerResult);
+    };
+    setupDefinedParameters(funcDefinedParameters, passedInParameters, executor) {
+        for (let i = 0; i < funcDefinedParameters.length; i++) {
+            const tmpFuncArg = funcDefinedParameters[i];
+            if (i < passedInParameters.length) {
+                const tmpPassedInArgs = passedInParameters[i];
+                if (tmpPassedInArgs[0] === 'position') {
+                    const variableName = tmpFuncArg[0];
+                    executor.log('set variable in scope, var name: ', variableName);
+                    executor.scope.variables.set(variableName, tmpPassedInArgs[2]);
+                    if (tmpPassedInArgs[2] instanceof ClassComponent) {
+                        const component = tmpPassedInArgs[2];
+                        for (const [pinNumber, net] of component.pinNets) {
+                            executor.scope.setNet(component, pinNumber, net);
+                        }
+                    }
+                }
+            }
+            else if (tmpFuncArg.length === 2) {
+                const variableName = tmpFuncArg[0];
+                const defaultValue = tmpFuncArg[1];
+                executor.log('set variable in scope, var name: ', variableName);
+                executor.scope.variables.set(variableName, defaultValue);
+            }
+            else {
+                throw `Invalid arguments got: ` + passedInParameters;
+            }
+        }
+    }
+    runExpressions(executor, expressions) {
+        let returnValue = null;
+        for (let i = 0; i < expressions.length; i++) {
+            const expr = expressions[i];
+            this.visit(expr);
+            if (executor.stopFurtherExpressions) {
+                returnValue = executor.returnValue;
+                break;
+            }
+        }
+        return returnValue;
+    }
+    getNetNamespace(executorNetNamespace, passedNetNamespace) {
+        let result = executorNetNamespace;
+        if (passedNetNamespace !== null && passedNetNamespace.length > 0) {
+            if (passedNetNamespace === '/' || passedNetNamespace === '_') {
+                result = '';
+            }
+            else if (passedNetNamespace[0] === '+') {
+                if (executorNetNamespace === '/') {
+                    result = passedNetNamespace.slice(1);
+                }
+                else {
+                    result = executorNetNamespace + passedNetNamespace.slice(2);
+                }
+            }
+            else {
+                result = passedNetNamespace;
+            }
+            result = result + '/';
+        }
+        return result;
+    }
+    setInstanceParam(object, trailers, value) {
+        const paramName = trailers[0];
+        object.setParam(paramName, value);
+        this.getExecutor().log(`set instance ${object.instanceName} param ${paramName} to ${value}`);
+    }
+    enterNewChildContext(executionStack, parentContext, executionContextName, options, funcDefinedParameters, passedInParameters) {
+        const { netNamespace = "" } = options;
+        const currentExecutionContext = executionStack[executionStack.length - 1];
+        const executionLevel = currentExecutionContext.executionLevel;
+        const executionContextNamespace = currentExecutionContext.namespace
+            + executionContextName + ".";
+        const newExecutor = new ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.indentLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger, parentContext);
+        this.setupPrintFunction(newExecutor);
+        executionStack.push(newExecutor);
+        this.setupDefinedParameters(funcDefinedParameters, passedInParameters, newExecutor);
+        return newExecutor;
+    }
+    prepareStringValue(value) {
+        return value.slice(1, value.length - 1);
+    }
+}

package/dist/esm/SemanticTokenVisitor.mjs

@@ -0,0 +1,215 @@
+import { Assignment_exprContext } from "./antlr/CircuitScriptParser";
+import { BaseVisitor } from "./BaseVisitor";
+export class SemanticTokensVisitor extends BaseVisitor {
+    parsedTokens = [];
+    lexer;
+    script;
+    semanticTokens = new Map();
+    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultsLibsPath, lexer, script) {
+        super(silent, onErrorHandler, currentDirectory, defaultsLibsPath);
+        this.lexer = lexer;
+        this.script = script;
+    }
+    visitFunction_args_expr = (ctx) => {
+        const IDs = ctx.ID();
+        IDs.map(id => {
+            this.addSemanticToken(id, ['declaration'], 'parameter');
+        });
+    };
+    visitFunction_call_expr = (ctx) => {
+        this.addSemanticToken(ctx.ID(), [], 'function');
+    };
+    visitFunction_def_expr = (ctx) => {
+        const functionName = ctx.ID().getText();
+        this.addSemanticToken(ctx.ID(), ['declaration'], 'function');
+        const ctxFunctionArgsExpr = ctx.function_args_expr();
+        if (ctxFunctionArgsExpr) {
+            this.visit(ctxFunctionArgsExpr);
+        }
+        const executionContextName = functionName + '_validate';
+        const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, [], []);
+        this.runExpressions(newExecutor, ctx.function_expr());
+        this.executionStack.pop();
+    };
+    visitCreate_component_expr = (ctx) => {
+        this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
+        ctx.property_expr().forEach(property_expr => {
+            this.visit(property_expr);
+        });
+    };
+    visitCreate_graphic_expr = (ctx) => {
+        this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
+        ctx.sub_expr().forEach(sub_expr => {
+            this.visit(sub_expr);
+        });
+    };
+    visitProperty_key_expr = (ctx) => {
+        let useValue = null;
+        const ctxId = ctx.ID();
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        const ctxStringValue = ctx.STRING_VALUE();
+        if (ctxId) {
+            useValue = ctxId;
+        }
+        else if (ctxIntegerValue) {
+            useValue = ctxIntegerValue;
+        }
+        else if (ctxStringValue) {
+            useValue = ctxStringValue;
+        }
+        if (useValue) {
+            this.addSemanticToken(useValue, [], 'property');
+        }
+    };
+    visitSub_expr = (ctx) => {
+        let useValue = null;
+        const ctxId = ctx.ID();
+        const ctxPin = ctx.Pin();
+        if (ctxId) {
+            useValue = ctxId;
+        }
+        else if (ctxPin) {
+            useValue = ctxPin;
+        }
+        if (useValue) {
+            this.addSemanticToken(useValue, [], 'property');
+        }
+    };
+    visitValueAtomExpr = (ctx) => {
+        const ctxValueExpr = ctx.value_expr();
+        const ctxAtomExpr = ctx.atom_expr();
+        if (ctxValueExpr) {
+            this.visit(ctxValueExpr);
+        }
+        else if (ctxAtomExpr) {
+            this.visit(ctxAtomExpr);
+        }
+    };
+    visitAssignment_expr = (ctx) => {
+        this.visit(ctx.atom_expr());
+        this.visit(ctx.data_expr());
+    };
+    visitAtom_expr = (ctx) => {
+        if (ctx.parent instanceof Assignment_exprContext && ctx.ID(0)) {
+            this.addSemanticToken(ctx.ID(0), [], 'variable');
+        }
+    };
+    visitImport_expr = (ctx) => {
+        this.addSemanticToken(ctx.ID(), [], 'namespace');
+    };
+    addSemanticToken(node, modifiers, tokenType = null) {
+        const parsedToken = this.parseToken(node, modifiers, tokenType);
+        this.semanticTokens.set(parsedToken.line + "_" + parsedToken.column, parsedToken);
+    }
+    parseToken(node, modifiers, tokenType = null) {
+        const token = node.symbol;
+        let stringValue = "";
+        let textPart = "";
+        if (this.lexer.symbolicNames[token.type] !== null && this.lexer.symbolicNames[token.type] !== undefined) {
+            stringValue = this.lexer.symbolicNames[token.type];
+            if (stringValue !== "NEWLINE") {
+                textPart = this.script.substring(token.start, token.stop + 1);
+            }
+            else {
+                textPart = token.text.length - 1;
+            }
+        }
+        else if (this.lexer.literalNames[token.type] !== null && this.lexer.literalNames[token.type] !== undefined) {
+            stringValue = this.lexer.literalNames[token.type];
+            textPart = this.script.substring(token.start, token.stop + 1);
+        }
+        else {
+            stringValue = token._text;
+        }
+        return {
+            line: token.line,
+            column: token.column,
+            length: token.stop - token.start + 1,
+            tokenType: tokenType !== null ? tokenType : stringValue,
+            tokenModifiers: modifiers,
+            textValue: textPart,
+        };
+    }
+    dumpTokens() {
+        for (const [id, value] of this.semanticTokens) {
+            console.log(id, value);
+        }
+    }
+    getTokens() {
+        return this.semanticTokens;
+    }
+}
+export function prepareTokens(tokens, lexer, script) {
+    const parsedTokens = [];
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = script.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = script.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            if (textPart !== 0 && textPart !== '') {
+                parsedTokens.push({
+                    line: item.line,
+                    column: item.column,
+                    length: item.stop - item.start + 1,
+                    tokenType: resolveTokenType(stringValue),
+                    tokenModifiers: resolveTokenModifiers(stringValue),
+                    textValue: textPart,
+                });
+            }
+        }
+    });
+    return parsedTokens;
+}
+const languageKeywords = [
+    'break', 'branch', 'create', 'component',
+    'graphic', 'wire', 'pin', 'add', 'at', 'to',
+    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'true', 'false', 'nc', 'frame',
+];
+const operatorKeywords = [
+    'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
+];
+function resolveTokenType(tokenType) {
+    if (operatorKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'graphKeyword';
+    }
+    else if (languageKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'keyword';
+    }
+    else {
+        switch (tokenType) {
+            case 'INTEGER_VALUE':
+            case 'NUMERIC_VALUE':
+            case 'DECIMAL_VALUE':
+            case 'PERCENTAGE_VALUE':
+                return 'number';
+            case 'STRING_VALUE':
+                return 'string';
+            case 'ID':
+                return 'variable';
+            case 'Define':
+                return 'keyword';
+            case 'COMMENT':
+                return 'comment';
+        }
+        return null;
+    }
+}
+function resolveTokenModifiers(tokenType) {
+    return [];
+}