circuitscript 0.1.5 → 0.1.8

package/dist/cjs/utils.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBlockTypeString = exports.generateDebugSequenceAction = exports.sequenceActionString = exports.areasOverlap = exports.isPointWithinArea = exports.resolveToNumericValue = exports.getNumberExponentialText = exports.getNumberExponential = exports.combineMaps = exports.throwWithContext = exports.roundValue = exports.getPortType = exports.getBoundsSize = exports.toNearestGrid = exports.resizeToNearestGrid = exports.printBounds = exports.resizeBounds = exports.SimpleStopwatch = void 0;
+exports.RenderError = exports.RuntimeExecutionError = exports.ParseError = exports.ParseSyntaxError = exports.BaseError = exports.getBlockTypeString = exports.generateDebugSequenceAction = exports.sequenceActionString = exports.areasOverlap = exports.isPointWithinArea = exports.resolveToNumericValue = exports.getNumberExponentialText = exports.getNumberExponential = exports.combineMaps = exports.throwWithTokenRange = exports.throwWithToken = exports.throwWithContext = exports.roundValue = exports.getPortType = exports.getBoundsSize = exports.toNearestGrid = exports.resizeToNearestGrid = exports.printBounds = exports.resizeBounds = exports.SimpleStopwatch = void 0;
 const big_js_1 = require("big.js");
-const ClassComponent_1 = require("./objects/ClassComponent");
-const ParamDefinition_1 = require("./objects/ParamDefinition");
-const ExecutionScope_1 = require("./objects/ExecutionScope");
-const globals_1 = require("./globals");
+const ClassComponent_js_1 = require("./objects/ClassComponent.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
+const globals_js_1 = require("./globals.js");
 class SimpleStopwatch {
     constructor() {
         this.startTime = new Date();
@@ -81,22 +81,21 @@ function roundValue(value) {
     return resolveToNumericValue(new big_js_1.Big(value.toBigNumber().toFixed(7)));
 }
 exports.roundValue = roundValue;
-function throwWithContext(context, message) {
-    const startLine = context.start?.line;
-    const startColumn = context.start?.column;
-    const startString = startLine + ":" + startColumn;
-    const stopLine = context.stop?.line;
-    const stopColumn = context.stop?.column;
-    let stopString = "";
-    if (startLine === stopLine) {
-        stopString = stopColumn?.toString();
+function throwWithContext(context, messageOrError) {
+    if (messageOrError instanceof BaseError) {
+        throw messageOrError;
     }
-    else {
-        stopString = stopLine + ":" + stopString;
-    }
-    throw `Parse exception at [${startString} - ${stopString}] : ${message}`;
+    throwWithTokenRange(messageOrError, context.start, context.stop);
 }
 exports.throwWithContext = throwWithContext;
+function throwWithToken(message, token) {
+    throw new ParseError(message, token);
+}
+exports.throwWithToken = throwWithToken;
+function throwWithTokenRange(message, startToken, endToken) {
+    throw new ParseError(message, startToken, endToken);
+}
+exports.throwWithTokenRange = throwWithTokenRange;
 function combineMaps(map1, map2) {
     const newMap = new Map(map1);
     map2.forEach((value, key) => {
@@ -156,7 +155,7 @@ function getNumberExponentialText(value) {
 exports.getNumberExponentialText = getNumberExponentialText;
 function resolveToNumericValue(value) {
     if (value.toNumber() === 0) {
-        return new ParamDefinition_1.NumericValue(0);
+        return new ParamDefinition_js_1.NumericValue(0);
     }
     const isNeg = value.lt(0);
     const positiveValue = isNeg ? value.neg() : value;
@@ -166,7 +165,7 @@ function resolveToNumericValue(value) {
         const tmpValue1 = positiveValue.div(Math.pow(10, prefixPart * 3));
         useValue = isNeg ? tmpValue1.neg() : tmpValue1;
     }
-    return new ParamDefinition_1.NumericValue(useValue, prefixPart * 3);
+    return new ParamDefinition_js_1.NumericValue(useValue, prefixPart * 3);
 }
 exports.resolveToNumericValue = resolveToNumericValue;
 function isPointWithinArea(point, bounds) {
@@ -190,7 +189,7 @@ exports.areasOverlap = areasOverlap;
 function sequenceActionString(sequenceAction) {
     const tmp = [...sequenceAction];
     const action = tmp[0];
-    if (action === ExecutionScope_1.SequenceAction.Wire) {
+    if (action === ExecutionScope_js_1.SequenceAction.Wire) {
         tmp[2] = tmp[2].map(item2 => {
             const lengthValue = item2.value;
             const useValue = [item2.direction];
@@ -201,12 +200,12 @@ function sequenceActionString(sequenceAction) {
             return useValue.join(",");
         }).join(" ");
     }
-    else if (action === ExecutionScope_1.SequenceAction.Frame) {
+    else if (action === ExecutionScope_js_1.SequenceAction.Frame) {
         tmp[1] = sequenceAction[1].frameId;
     }
-    else if (action !== ExecutionScope_1.SequenceAction.WireJump) {
+    else if (action !== ExecutionScope_js_1.SequenceAction.WireJump) {
         const [, component] = sequenceAction;
-        if (component instanceof ClassComponent_1.ClassComponent) {
+        if (component instanceof ClassComponent_js_1.ClassComponent) {
             tmp[1] = sequenceAction[1].instanceName;
         }
     }
@@ -218,12 +217,12 @@ function generateDebugSequenceAction(sequence) {
     return sequence.map(item => {
         const returnResult = [...item];
         const [action,] = item;
-        if (action === ExecutionScope_1.SequenceAction.Assign) {
+        if (action === ExecutionScope_js_1.SequenceAction.Assign) {
             const [, name, component] = item;
             variableMapping.set(name, component);
         }
         else {
-            if (action === ExecutionScope_1.SequenceAction.At || action === ExecutionScope_1.SequenceAction.To) {
+            if (action === ExecutionScope_js_1.SequenceAction.At || action === ExecutionScope_js_1.SequenceAction.To) {
                 const [, component,] = item;
                 const foundIndex = Array.from(variableMapping.values()).findIndex(item2 => {
                     if (component._copyFrom !== null) {
@@ -244,19 +243,75 @@ exports.generateDebugSequenceAction = generateDebugSequenceAction;
 function getBlockTypeString(type) {
     let returnValue = 'branch';
     switch (type) {
-        case globals_1.BlockTypes.Branch:
+        case globals_js_1.BlockTypes.Branch:
             returnValue = 'branch';
             break;
-        case globals_1.BlockTypes.Join:
+        case globals_js_1.BlockTypes.Join:
             returnValue = 'join';
             break;
-        case globals_1.BlockTypes.Parallel:
+        case globals_js_1.BlockTypes.Parallel:
             returnValue = 'parallel';
             break;
-        case globals_1.BlockTypes.Point:
+        case globals_js_1.BlockTypes.Point:
             returnValue = 'point';
             break;
     }
     return returnValue;
 }
 exports.getBlockTypeString = getBlockTypeString;
+class BaseError extends Error {
+    constructor(message, startToken, endToken, filePath) {
+        super(message);
+        this.name = 'BaseError';
+        this.message = message;
+        this.startToken = startToken;
+        this.endToken = endToken;
+        this.filePath = filePath;
+    }
+    toString() {
+        const parts = [this.name];
+        if (this.startToken) {
+            const { line, column } = this.startToken;
+            if (this.endToken && (this.endToken.line !== this.startToken.line || this.endToken.column !== this.startToken.column)) {
+                const endLine = this.endToken.line;
+                const endColumn = this.endToken.column + (this.endToken.stop - this.endToken.start);
+                parts.push(` at ${line}:${column}-${endLine}:${endColumn}`);
+            }
+            else {
+                parts.push(` at ${line}:${column}`);
+            }
+        }
+        parts.push(`: ${this.message}`);
+        return parts.join('');
+    }
+}
+exports.BaseError = BaseError;
+class ParseSyntaxError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ParseSyntaxError';
+    }
+}
+exports.ParseSyntaxError = ParseSyntaxError;
+class ParseError extends ParseSyntaxError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ParseError';
+    }
+}
+exports.ParseError = ParseError;
+class RuntimeExecutionError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = 'RuntimeExecutionError';
+    }
+}
+exports.RuntimeExecutionError = RuntimeExecutionError;
+class RenderError extends Error {
+    constructor(message, stage) {
+        super(message);
+        this.name = 'RenderError';
+        this.stage = stage;
+    }
+}
+exports.RenderError = RenderError;

package/dist/cjs/validate/SymbolTable.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolTable = void 0;
+const types_js_1 = require("../objects/types.js");
+class SymbolTable {
+    constructor() {
+        this.symbols = new Map();
+        this.executonContextsNamespaces = [];
+    }
+    getSymbols() {
+        return this.symbols;
+    }
+    addFunction(token, fileName, executionContext, id, funcDefinedParameters) {
+        return this.add(fileName, executionContext, id, types_js_1.ParseSymbolType.Function, {
+            funcDefinedParameters
+        }, token);
+    }
+    addVariable(token, fileName, executionContext, id, variableValue) {
+        return this.add(fileName, executionContext, id, types_js_1.ParseSymbolType.Variable, {
+            variableValue
+        }, token);
+    }
+    addUndefined(filePath, executionContext, id, token) {
+        return this.add(filePath, executionContext, id, types_js_1.ParseSymbolType.Undefined, {}, token);
+    }
+    add(fileName, executionContext, id, type, extra, token) {
+        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
+            this.executonContextsNamespaces.push(executionContext.namespace);
+        }
+        const item = {
+            id,
+            type,
+            context: executionContext,
+            fileName,
+            extra,
+            token,
+            instances: [],
+        };
+        if (token !== null) {
+            item.instances.push(token);
+        }
+        this.symbols.set(this.idName(executionContext, id), item);
+        return item;
+    }
+    idName(executionContext, id) {
+        return executionContext.namespace + id;
+    }
+    dumpSymbols() {
+        for (const [key, value] of this.symbols) {
+            console.log(value.type.padEnd(10, " "), key);
+        }
+    }
+    exists(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.has(name);
+    }
+    existsAny(executionContext, id) {
+        if (this.exists(executionContext, id)) {
+            return true;
+        }
+        else {
+            return this.searchParentContext(executionContext, id) !== null;
+        }
+    }
+    get(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.get(name);
+    }
+    getParentContexts(executionContext, contextsNamespace) {
+        if (executionContext.parentContext !== null) {
+            contextsNamespace.push(executionContext.parentContext.namespace);
+            this.getParentContexts(executionContext.parentContext, contextsNamespace);
+        }
+        return contextsNamespace;
+    }
+    searchParentContext(executionContext, id) {
+        const contextNames = this.getParentContexts(executionContext, []);
+        for (const [key,] of this.symbols) {
+            if (key.endsWith(`.${id}`)) {
+                const { context } = this.symbols.get(key);
+                if (contextNames.indexOf(context.namespace) !== -1) {
+                    return context;
+                }
+            }
+        }
+        return null;
+    }
+    clearUndefined() {
+        for (const [key, value] of this.symbols) {
+            if (value.type === types_js_1.ParseSymbolType.Undefined) {
+                this.symbols.delete(key);
+            }
+        }
+    }
+}
+exports.SymbolTable = SymbolTable;

package/dist/cjs/validate/SymbolValidatorResolveVisitor.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolValidatorResolveVisitor = void 0;
+const SymbolValidatorVisitor_js_1 = require("./SymbolValidatorVisitor.js");
+class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor_js_1.SymbolValidatorVisitor {
+    addSymbolVariable(token, name, value) {
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+        }
+    }
+}
+exports.SymbolValidatorResolveVisitor = SymbolValidatorResolveVisitor;

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolValidatorVisitor = void 0;
+const builtinMethods_js_1 = require("../builtinMethods.js");
+const types_js_1 = require("../objects/types.js");
+const SymbolTable_js_1 = require("./SymbolTable.js");
+const BaseVisitor_js_1 = require("../BaseVisitor.js");
+const globals_js_1 = require("../globals.js");
+class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
+    constructor() {
+        super(...arguments);
+        this.symbolTable = new SymbolTable_js_1.SymbolTable();
+        this.filePathStack = [];
+        this.visitImport_expr = (ctx) => {
+            const ID = ctx.ID().toString();
+            const { pathExists } = this.handleImportFile(ID, false, ctx);
+            if (!pathExists) {
+                this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
+            }
+        };
+        this.visitAssignment_expr = (ctx) => {
+            const ctxDataExpr = ctx.data_expr();
+            this.visit(ctxDataExpr);
+            const value = this.getResult(ctxDataExpr);
+            const atomId = ctx.atom_expr().ID(0);
+            const atomText = atomId.getText();
+            const executor = this.getExecutor();
+            if (!this.symbolTable.exists(executor, atomText)) {
+                this.addSymbolVariable(atomId.getSymbol(), atomId.getText(), value);
+            }
+            else {
+                const tmpSymbol = this.symbolTable.get(executor, atomText);
+                this.addSymbolInstance(tmpSymbol, atomId.getSymbol());
+            }
+            return null;
+        };
+        this.visitAtom_expr = (ctx) => {
+            const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
+            this.setResult(ctx, tmpSymbol);
+        };
+        this.visitFunction_call_expr = (ctx) => {
+            this.handleAtomSymbol(ctx.ID());
+            if (ctx.trailer_expr().length > 0) {
+                ctx.trailer_expr().forEach(item => {
+                    if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                        const params = item.parameters();
+                        if (params) {
+                            this.visit(params);
+                        }
+                    }
+                });
+            }
+        };
+        this.visitValueAtomExpr = (ctx) => {
+            let value = null;
+            const ctxValueExpr = ctx.value_expr();
+            const cxtAtomExpr = ctx.atom_expr();
+            if (ctxValueExpr) {
+                this.visit(ctxValueExpr);
+                value = this.getResult(ctxValueExpr);
+            }
+            else if (cxtAtomExpr) {
+                this.visit(cxtAtomExpr);
+                value = this.getResult(cxtAtomExpr);
+            }
+            this.setResult(ctx, value);
+        };
+        this.visitUnaryOperatorExpr = (ctx) => {
+            this.visit(ctx.data_expr());
+        };
+        this.visitMultiplyExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitAdditionExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitBinaryOperatorExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitDataExpr = (ctx) => {
+            return;
+        };
+        this.visitFunction_def_expr = (ctx) => {
+            const functionName = ctx.ID().getText();
+            let funcDefinedParameters = [];
+            const ctxFunctionArgsExpr = ctx.function_args_expr();
+            if (ctxFunctionArgsExpr) {
+                this.visit(ctxFunctionArgsExpr);
+                funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
+            }
+            this.addSymbolFunction(ctx.ID().getSymbol(), functionName, funcDefinedParameters);
+            const executionContextName = functionName + globals_js_1.SymbolValidatorContext;
+            const passedInParamsNull = funcDefinedParameters.map((param, index) => {
+                return ['position', index, null];
+            });
+            const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
+            funcDefinedParameters.forEach(param => {
+                this.addSymbolVariable(param[1], param[0], null, newExecutor);
+            });
+            this.runExpressions(newExecutor, ctx.function_expr());
+            this.executionStack.pop();
+        };
+    }
+    enterFile(filePath) {
+        this.filePathStack.push(filePath);
+    }
+    exitFile() {
+        this.filePathStack.pop();
+    }
+    getCurrentFile() {
+        return this.filePathStack[this.filePathStack.length - 1];
+    }
+    addSymbolVariable(token, name, value, executor = null) {
+        const useExecutor = executor === null ? this.getExecutor() : executor;
+        this.symbolTable.addVariable(token, this.getCurrentFile(), useExecutor, name, value);
+        this.log2('add symbol variable: ' + name);
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+            this.log2('add symbol function: ' + functionName);
+        }
+    }
+    handleAtomSymbol(atom) {
+        const atomId = atom.getText();
+        const executor = this.getExecutor();
+        let tmpSymbol;
+        if (this.symbolTable.exists(executor, atomId)) {
+            tmpSymbol = this.symbolTable.get(executor, atomId);
+        }
+        else {
+            if (builtinMethods_js_1.buildInMethodNamesList.indexOf(atomId) !== -1) {
+                tmpSymbol = this.symbolTable.addFunction(null, "<builtIn>", this.getRootExecutor(), atomId, {});
+            }
+            else {
+                const foundContext = this.symbolTable.searchParentContext(executor, atomId);
+                if (foundContext === null) {
+                    tmpSymbol = this.symbolTable.addUndefined(this.getCurrentFile(), executor, atomId, atom.getSymbol());
+                    this.log2('symbol not found: ' + atomId);
+                }
+                else {
+                    tmpSymbol = this.symbolTable.get(foundContext, atomId);
+                }
+            }
+        }
+        if (tmpSymbol.type !== types_js_1.ParseSymbolType.Undefined) {
+            this.addSymbolInstance(tmpSymbol, atom.getSymbol());
+        }
+        return tmpSymbol;
+    }
+    addSymbolInstance(symbol, token) {
+        symbol = symbol;
+        if (symbol.instances.indexOf(token) == -1) {
+            symbol.instances.push(token);
+        }
+    }
+    setSymbols(symbolTable) {
+        this.symbolTable = symbolTable;
+    }
+    getSymbols() {
+        return this.symbolTable;
+    }
+    dumpSymbols() {
+        this.symbolTable.dumpSymbols();
+    }
+}
+exports.SymbolValidatorVisitor = SymbolValidatorVisitor;

package/dist/cjs/validate.js

@@ -1,81 +1,108 @@
 #! /usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
 const commander_1 = require("commander");
-const figlet_1 = __importDefault(require("figlet"));
-const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
-const sizing_js_1 = require("./sizing.js");
 const helpers_js_1 = require("./helpers.js");
+const environment_js_1 = require("./environment.js");
+const types_js_1 = require("./objects/types.js");
 async function validate() {
-    const { filePath } = (0, helpers_js_1.getCurrentPath)();
-    const toolSrcPath = filePath;
-    const toolDirectory = path_1.default.dirname(toolSrcPath) + '/../../';
-    const fontsPath = toolDirectory + '/fonts';
-    const defaultLibsPath = toolDirectory + '/libs';
-    const packageJson = JSON.parse((0, fs_1.readFileSync)(toolDirectory + 'package.json').toString());
-    ;
-    const { version } = packageJson;
+    const env = new environment_js_1.NodeScriptEnvironment();
+    environment_js_1.NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
     commander_1.program
-        .description('generate graphical output from circuitscript files')
+        .description('generate validation output circuitscript files')
         .version(version)
+        .argument('[input path]', 'Input path')
+        .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
-        .option('-f, --input-file <path>', 'Input file')
-        .option('-o, --output <path>', 'Output path')
         .option('-c, --current-directory <path>', 'Set current directory')
-        .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
         .option('-w, --watch', 'Watch for file changes')
         .option('-n, --dump-nets', 'Dump out net information')
         .option('-d, --dump-data', 'Dump data during parsing')
-        .option('-s, --stats', 'Show stats during generation');
-    commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
-        font: 'Small Slant'
-    }));
+        .option('-s, --stats', 'Show stats during generation')
+        .option('-x, --skip-output', 'Skip output generation');
     if (process.argv.length < 3) {
         commander_1.program.help();
     }
     commander_1.program.parse();
     const options = commander_1.program.opts();
+    const args = commander_1.program.args;
     const watchFileChanges = options.watch;
-    const outputPath = options.output ?? null;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
-    const kicadNetlist = options.kicadNetlist;
-    let currentDirectory = options.currentDirectory ?? null;
+    if (options.currentDirectory) {
+        env.setModuleDirectory(options.currentDirectory);
+    }
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
-    await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
-    let inputFilePath = null;
+    await env.prepareSVGEnvironment();
+    let inputFilePath = "";
+    if (args.length > 2) {
+        console.log("Error: Extra arguments passed");
+        return;
+    }
     let scriptData;
-    if (options.input) {
+    if (args.length > 0 && args[0]) {
+        inputFilePath = args[0];
+        if ((0, fs_1.existsSync)(inputFilePath)) {
+            scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
+        }
+        else {
+            console.error("Error: File could not be found");
+            return;
+        }
+    }
+    else if (options.input) {
         scriptData = options.input;
     }
     else {
-        inputFilePath = options.inputFile;
-        const tmpScriptData = (0, helpers_js_1.getScriptText)(inputFilePath);
-        if (tmpScriptData === null) {
-            throw "File does not exists";
-        }
-        scriptData = tmpScriptData;
-        if (currentDirectory === null) {
-            currentDirectory = path_1.default.dirname(inputFilePath);
-        }
+        console.error("Error: No input provided");
+        return;
     }
     const scriptOptions = {
-        currentDirectory,
-        defaultLibsPath,
         dumpNets,
         dumpData,
-        kicadNetlistPath: kicadNetlist,
         showStats: options.stats,
+        environment: env,
     };
-    const visitor = (0, helpers_js_1.validateScript)(scriptData, scriptOptions);
-    const semanticTokensVisitor = (0, helpers_js_1.getSemanticTokens)(scriptData, scriptOptions);
+    const visitor = await (0, helpers_js_1.validateScript)(inputFilePath, scriptData, scriptOptions);
+    const symbols = visitor.getSymbols().getSymbols();
+    const undefinedSymbols = [];
+    symbols.forEach((value, key) => {
+        if (value.type !== types_js_1.ParseSymbolType.Undefined) {
+            value = value;
+            const token = value.token;
+            console.log(key, value.fileName, token !== null ? (token.line + ":" + token.column) : "");
+            value.instances.forEach(instance => {
+                console.log("    " + instance.line + ":" + instance.column + " " + instance.start);
+            });
+        }
+        else {
+            undefinedSymbols.push(value);
+        }
+    });
+    const { parsedTokens } = await (0, helpers_js_1.getSemanticTokens)(scriptData, scriptOptions);
+    parsedTokens.forEach(item => {
+        const { line, column, tokenType, tokenModifiers, textValue } = item;
+        console.log(`${line}:${column} - ${textValue} - ${tokenType} | ${tokenModifiers.join(',')}`);
+    });
+    console.log('--- undefined ---');
+    undefinedSymbols.forEach(symbol => {
+        const { token } = symbol;
+        const info = {
+            start: {
+                line: (token?.line || 1),
+                character: token?.column || 0
+            },
+            end: {
+                line: (token?.line || 1),
+                character: (token?.column || 0) + ((token?.stop || 0) - (token?.start || 0) + 1)
+            }
+        };
+        console.log(token.text, info);
+    });
 }
-exports.validate = validate;
+exports.default = validate;
 validate();