circuitscript 0.0.21 → 0.0.24

package/{src/visitor.ts → dist/cjs/visitor.js}

@@ -1,1044 +1,702 @@
-import { ParseTreeVisitor, ParserRuleContext } from 'antlr4';
-
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-import {
-    Add_component_exprContext,
-    AdditionExprContext,
-    Assignment_exprContext,
-    At_blockContext,
-    At_block_pin_exprContext,
-    At_block_pin_expression_complexContext,
-    At_block_pin_expression_simpleContext,
-    At_component_exprContext,
-    Atom_exprContext,
-    BinaryOperatorExprContext,
-    Blank_exprContext,
-    Path_blocksContext,
-    Component_select_exprContext,
-    Create_component_exprContext,
-    Create_graphic_exprContext,
-    DataExprContext,
-    Data_expr_with_assignmentContext,
-    Double_dot_property_set_exprContext,
-    ExpressionContext,
-    Frame_exprContext,
-    Function_args_exprContext,
-    Function_def_exprContext,
-    Function_exprContext,
-    Function_return_exprContext,
-    Import_exprContext,
-    Keyword_assignment_exprContext,
-    MultiplyExprContext,
-    Nested_propertiesContext,
-    Net_namespace_exprContext,
-    ParametersContext,
-    Pin_select_expr2Context,
-    Pin_select_exprContext,
-    Point_exprContext,
-    Property_exprContext,
-    Property_key_exprContext,
-    Property_set_exprContext,
-    RoundedBracketsExprContext,
-    ScriptContext,
-    Single_line_propertyContext,
-    Sub_exprContext,
-    To_component_exprContext,
-    Value_exprContext,
-    Wire_exprContext,
-    ValueAtomExprContext,
-    UnaryOperatorExprContext,
-} from './antlr/CircuitScriptParser.js';
-import { ExecutionContext } from './execute.js';
-import { ClassComponent } from './objects/ClassComponent.js';
-import {
-    NumericValue,
-    ParamDefinition,
-    PercentageValue,
-    PinBlankValue,
-} from './objects/ParamDefinition.js';
-import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
-import { PinTypes } from './objects/PinTypes.js';
-import { ExecutionScope } from './objects/ExecutionScope.js';
-import { CFunctionOptions, CallableParameter, ComplexType, ComponentPin, 
-    ComponentPinNet, FunctionDefinedParameter, ReferenceType, UndeclaredReference, ValueType } from './objects/types.js';
-import { Logger } from './logger.js';
-import { BlockTypes, ComponentTypes, NoNetText } from './globals.js';
-import { Net } from './objects/Net.js';
-import { SubExpressionCommand, SymbolDrawingCommands } from './draw_symbols.js';
-import { parseFileWithVisitor } from './parser.js';
-
-export class MainVisitor extends ParseTreeVisitor<any> {
-    // See class CircuitScriptVisitor (generated by antlr4) to find method names
-
-    // Contains the methods here, so that it is function based instead
-    // of just lambdas/callbacks...
-
-    indentLevel = 0;
-    startingContext: ExecutionContext;
-    executionStack: ExecutionContext[];
-
-    // If true, then do not print out anything
-    silent = false;
-
-    logger: Logger;
-
-    printStream: string[] = [];
-    printToConsole = true;
-
-    acceptedDirections = ['left', 'right', 'up', 'down'];
-
-    pinTypesList: string[] = [
-        PinTypes.Any,
-        PinTypes.Input,
-        PinTypes.Output,
-        PinTypes.IO,
-        PinTypes.Power,
-    ];
-
-    onImportFile = (visitor: MainVisitor, filePath:string): {hasError:boolean, hasParseError: boolean} => {
-        throw "Import file not implemented"
-    }
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisitorExecutionException = exports.MainVisitor = void 0;
+const antlr4_1 = require("antlr4");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const execute_js_1 = require("./execute.js");
+const ClassComponent_js_1 = require("./objects/ClassComponent.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const PinDefinition_js_1 = require("./objects/PinDefinition.js");
+const PinTypes_js_1 = require("./objects/PinTypes.js");
+const types_js_1 = require("./objects/types.js");
+const logger_js_1 = require("./logger.js");
+const globals_js_1 = require("./globals.js");
+const draw_symbols_js_1 = require("./draw_symbols.js");
+const parser_js_1 = require("./parser.js");
+class MainVisitor extends antlr4_1.ParseTreeVisitor {
     constructor(silent = false) {
         super();
-        this.logger = new Logger();
-
-        this.startingContext = new ExecutionContext(
-            '__',
-            '__.',
-            '/',
-            0, 0, silent, 
-            this.logger);
-        
+        this.indentLevel = 0;
+        this.silent = false;
+        this.printStream = [];
+        this.printToConsole = true;
+        this.acceptedDirections = ['left', 'right', 'up', 'down'];
+        this.pinTypesList = [
+            PinTypes_js_1.PinTypes.Any,
+            PinTypes_js_1.PinTypes.Input,
+            PinTypes_js_1.PinTypes.Output,
+            PinTypes_js_1.PinTypes.IO,
+            PinTypes_js_1.PinTypes.Power,
+        ];
+        this.onImportFile = (visitor, filePath) => {
+            throw "Import file not implemented";
+        };
+        this.pinTypes = [
+            PinTypes_js_1.PinTypes.Any,
+            PinTypes_js_1.PinTypes.IO,
+            PinTypes_js_1.PinTypes.Input,
+            PinTypes_js_1.PinTypes.Output,
+            PinTypes_js_1.PinTypes.Power,
+        ];
+        this.logger = new logger_js_1.Logger();
+        this.startingContext = new execute_js_1.ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger);
         this.setupPrintFunction(this.startingContext);
-            
         this.executionStack = [this.startingContext];
-        this.startingContext.resolveNet = 
+        this.startingContext.resolveNet =
             this.createNetResolver(this.executionStack);
-
         this.silent = silent;
     }
-
-    getExecutor(): ExecutionContext {
+    getExecutor() {
         return this.executionStack[this.executionStack.length - 1];
     }
-
-    visit(ctx: ParserRuleContext): any {
+    visit(ctx) {
         if (Array.isArray(ctx)) {
             return ctx.map(function (child) {
                 try {
                     return child.accept(this);
-                } catch (err) {
+                }
+                catch (err) {
                     this.handleError(child, err);
                 }
             }, this);
-        } else {
+        }
+        else {
             try {
                 return ctx.accept(this);
-            } catch (err) {
+            }
+            catch (err) {
                 this.handleError(ctx, err);
             }
         }
     }
-
-    handleError(ctx: ParserRuleContext, err: string | VisitorExecutionException): void {
+    handleError(ctx, err) {
         if (!(err instanceof VisitorExecutionException)) {
             throw new VisitorExecutionException(ctx, err);
-        } else {
+        }
+        else {
             throw err;
         }
     }
-
-    visitScript(ctx: ScriptContext): any {
+    visitScript(ctx) {
         this.print('===', 'start', '===');
         const result = this.visitChildren(ctx);
         this.print('===', 'end', '===');
         return result;
     }
-
-    visitParameters(ctx: ParametersContext): CallableParameter[] {
+    visitParameters(ctx) {
         const dataExpressions = ctx.data_expr_list();
         const keywordAssignmentExpressions = ctx.keyword_assignment_expr_list();
-
-        const returnList: CallableParameter[] = [];
-
+        const returnList = [];
         dataExpressions.forEach((item, index) => {
             const value = this.visit(item);
             returnList.push(['position', index, value]);
         });
-
         keywordAssignmentExpressions.forEach((item) => {
             const [key, value] = this.visit(item);
             returnList.push(['keyword', key, value]);
         });
-
         return returnList;
     }
-
-    visitKeyword_assignment_expr(ctx: Keyword_assignment_exprContext):
-        [key: string, value: any] {
+    visitKeyword_assignment_expr(ctx) {
         const id = ctx.ID().getText();
         const value = this.visit(ctx.data_expr());
         return [id, value];
     }
-
-    visitAssignment_expr(ctx: Assignment_exprContext): ComplexType {
+    visitAssignment_expr(ctx) {
         const atomStr = ctx.atom_expr().getText();
-
-        // Do not allow the atom to have any parentheses in the assignment
         if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
             throw "Invalid assignment expression!";
         }
-        
         const reference = this.visit(ctx.atom_expr());
-        const value = this.visit(ctx.data_expr()) as ComplexType;
-
-        if (value instanceof ClassComponent) {
-            // If value is a class component, then update the instance name
+        const value = this.visit(ctx.data_expr());
+        if (value instanceof ClassComponent_js_1.ClassComponent) {
             const instances = this.getExecutor().scope.instances;
-            const tmpComponent: ClassComponent = value;
-
+            const tmpComponent = value;
             const oldName = tmpComponent.instanceName;
-
-            // Rename to new name
             tmpComponent.instanceName = reference.name;
-
             instances.delete(oldName);
             instances.set(reference.name, tmpComponent);
-
-            this.getExecutor().print(
-                `assigned '${reference.name}' to ClassComponent`,
-            );
-        } else {
-            // Otherwise, assign variable name to value
+            this.getExecutor().print(`assigned '${reference.name}' to ClassComponent`);
+        }
+        else {
             const trailers = reference.trailers ?? [];
-
-            if (trailers.length === 0){
-                // No trailers, directly assign the reference name
+            if (trailers.length === 0) {
                 this.getExecutor().scope.variables.set(reference.name, value);
-                
-            } else if (reference.value instanceof ClassComponent) {
+            }
+            else if (reference.value instanceof ClassComponent_js_1.ClassComponent) {
                 this.setInstanceParam(reference.value, trailers, value);
             }
         }
-
         return value;
     }
-
-    setInstanceParam(object: ClassComponent, trailers: string[], value: any): void {
+    setInstanceParam(object, trailers, value) {
         const paramName = trailers[0].slice(1);
         object.setParam(paramName, value);
-
-        this.getExecutor().print(
-            `set instance ${object.instanceName} param ${paramName} to ${value}`);
+        this.getExecutor().print(`set instance ${object.instanceName} param ${paramName} to ${value}`);
     }
-
-    visitValue_expr(ctx: Value_exprContext): ValueType {
+    visitValue_expr(ctx) {
         const sign = ctx.Minus() ? -1 : 1;
-
         if (ctx.INTEGER_VALUE() || ctx.DECIMAL_VALUE() || ctx.NUMERIC_VALUE()) {
             if (ctx.INTEGER_VALUE()) {
                 return sign * Number(ctx.INTEGER_VALUE().getText());
-
-            } else if (ctx.DECIMAL_VALUE()) {
+            }
+            else if (ctx.DECIMAL_VALUE()) {
                 return sign * Number(ctx.DECIMAL_VALUE().getText());
-
-            } else if (ctx.NUMERIC_VALUE()) {
+            }
+            else if (ctx.NUMERIC_VALUE()) {
                 const textExtra = ctx.Minus() ? '-' : '';
-                return new NumericValue(textExtra + ctx.NUMERIC_VALUE().getText());
-
+                return new ParamDefinition_js_1.NumericValue(textExtra + ctx.NUMERIC_VALUE().getText());
             }
-        } else {
+        }
+        else {
             if (sign === -1) {
                 throw "Invalid value!";
             }
         }
-
         if (ctx.BOOLEAN_VALUE()) {
             const stringValue = ctx.BOOLEAN_VALUE().getText();
             if (stringValue === 'true') {
                 return true;
-            } else if (stringValue === 'false') {
+            }
+            else if (stringValue === 'false') {
                 return false;
             }
-
-        } else if (ctx.STRING_VALUE()) {
+        }
+        else if (ctx.STRING_VALUE()) {
             return this.prepareStringValue(ctx.STRING_VALUE().getText());
-
-        } else if (ctx.PERCENTAGE_VALUE()) {
-            return new PercentageValue(ctx.PERCENTAGE_VALUE().getText());
-
-        } else if (ctx.blank_expr()) {
+        }
+        else if (ctx.PERCENTAGE_VALUE()) {
+            return new ParamDefinition_js_1.PercentageValue(ctx.PERCENTAGE_VALUE().getText());
+        }
+        else if (ctx.blank_expr()) {
             return this.visit(ctx.blank_expr());
         }
     }
-
-    visitBlank_expr(ctx: Blank_exprContext): PinBlankValue {
-        // There must be an integer value, otherwise the rule wouldn't match.
-        return new PinBlankValue(Number(ctx.INTEGER_VALUE().getText()));
+    visitBlank_expr(ctx) {
+        return new ParamDefinition_js_1.PinBlankValue(Number(ctx.INTEGER_VALUE().getText()));
     }
-
-    visitPin_select_expr(ctx: Pin_select_exprContext): string | number | null {
+    visitPin_select_expr(ctx) {
         if (ctx.INTEGER_VALUE()) {
             return Number(ctx.INTEGER_VALUE().getText());
-
-        } else if (ctx.STRING_VALUE()) {
+        }
+        else if (ctx.STRING_VALUE()) {
             return this.prepareStringValue(ctx.STRING_VALUE().getText());
         }
-
         return null;
     }
-
-    visitAdd_component_expr(ctx: Add_component_exprContext): ComponentPin {
-        // The component is always the last item
-        const [component, pinValue] = 
-            this.visit(ctx.data_expr_with_assignment());
-
-        if (ctx.ID()){
-            this.setComponentOrientation(
-                component, pinValue, ctx.ID().getText());
-        }
-
+    visitAdd_component_expr(ctx) {
+        const [component, pinValue] = this.visit(ctx.data_expr_with_assignment());
+        if (ctx.ID()) {
+            this.setComponentOrientation(component, pinValue, ctx.ID().getText());
+        }
         return this.getExecutor().addComponentExisting(component, pinValue);
     }
-
-    visitAt_component_expr(ctx: At_component_exprContext): ComponentPin {
+    visitAt_component_expr(ctx) {
         if (ctx.Point()) {
             this.getExecutor().atPointBlock();
-
-        } else {
+        }
+        else {
             const [component, pin] = this.visit(ctx.component_select_expr());
-
             const currentPoint = this.getExecutor().atComponent(component, pin, {
                 addSequence: true,
                 cloneNetComponent: true
             });
-
             if (ctx.ID()) {
-                // If there is ID specified, then it can only be for the 
-                // component orientation.
-                this.setComponentOrientation(currentPoint[0],
-                    currentPoint[1], ctx.ID().getText())
+                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
             }
         }
-
         return this.getExecutor().getCurrentPoint();
     }
-
-    visitTo_component_expr(ctx: To_component_exprContext): ComponentPin {
-        let currentPoint: ComponentPin;
-
+    visitTo_component_expr(ctx) {
+        let currentPoint;
         if (ctx.Point()) {
             this.getExecutor().toPointBlock();
-
-        } else {
+        }
+        else {
             ctx.component_select_expr_list().forEach((item) => {
                 const [component, pin] = this.visit(item);
                 currentPoint = this.getExecutor().toComponent(component, pin, {
                     addSequence: true, cloneNetComponent: true
                 });
             });
-
             if (ctx.ID()) {
-                // If there is ID specified, then it can only be for the 
-                // component orientation.
-                this.setComponentOrientation(currentPoint[0],
-                    currentPoint[1], ctx.ID().getText())
+                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
             }
         }
-
         return this.getExecutor().getCurrentPoint();
     }
-
-    visitComponent_select_expr(ctx: Component_select_exprContext): ComponentPin {
+    visitComponent_select_expr(ctx) {
         if (ctx.data_expr_with_assignment()) {
             return this.visit(ctx.data_expr_with_assignment());
-        } else {
+        }
+        else {
             const component = this.getExecutor().scope.currentComponent;
-            let pinId: number | string | null = null;
-
+            let pinId = null;
             if (ctx.pin_select_expr()) {
                 pinId = this.visit(ctx.pin_select_expr());
             }
             return [component, pinId];
         }
     }
-
-    visitPath_blocks(ctx: Path_blocksContext): ComponentPin {
+    visitPath_blocks(ctx) {
         const blocks = ctx.path_block_inner_list();
-
-        let blockIndex = 0; // Tracks the index of the block with the given type
-        let blockType = BlockTypes.Branch;
+        let blockIndex = 0;
+        let blockType = globals_js_1.BlockTypes.Branch;
         let prevBlockType = null;
-
         blocks.forEach((block, index) => {
             if (block.Branch()) {
-                blockType = BlockTypes.Branch
-            } else if (block.Join()) {
-                blockType = BlockTypes.Join;
-            } else if (block.Parallel()) {
-                blockType = BlockTypes.Parallel;
-            } else if (block.Point()) {
-                blockType = BlockTypes.Point;
+                blockType = globals_js_1.BlockTypes.Branch;
+            }
+            else if (block.Join()) {
+                blockType = globals_js_1.BlockTypes.Join;
+            }
+            else if (block.Parallel()) {
+                blockType = globals_js_1.BlockTypes.Parallel;
+            }
+            else if (block.Point()) {
+                blockType = globals_js_1.BlockTypes.Point;
             }
-
             if (prevBlockType !== blockType) {
-                if (index > 0) { 
-                    // If not the first block, then exit the 
-                    // group of blocks.
+                if (index > 0) {
                     this.getExecutor().exitBlocks();
                 }
-
                 this.getExecutor().enterBlocks(blockType);
-                blockIndex = 0; // Reset counter.
+                blockIndex = 0;
             }
-
             this.getExecutor().enterBlock(blockIndex);
             this.visit(block);
             this.getExecutor().exitBlock(blockIndex);
             blockIndex += 1;
-
             prevBlockType = blockType;
         });
-
         this.getExecutor().exitBlocks();
         return this.getExecutor().getCurrentPoint();
     }
-
-    visitBreak_keyword(): number {
-        // When the break keyword is encountered inside a branch, then leave the branch
-        // without storing the final state. If used, the break should be
-        // the last expression in the branch, any expressions after the break
-        // will be skipped
-
+    visitBreak_keyword() {
         this.getExecutor().breakBranch();
         return -1;
     }
-
-    visitCreate_component_expr(ctx: Create_component_exprContext): ClassComponent {
+    visitCreate_component_expr(ctx) {
         const properties = this.getPropertyExprList(ctx.property_expr_list());
-
-        const pins: PinDefinition[] = this.parseCreateComponentPins(
-            properties.get('pins'),
-        );
-
-        // Use a unique instance name in the context for now
+        const pins = this.parseCreateComponentPins(properties.get('pins'));
         let instanceName = this.getExecutor().getUniqueInstanceName('');
-
         const propParams = properties.get('params');
-        const params: ParamDefinition[] =
-            this.parseCreateComponentParams(propParams);
-
+        const params = this.parseCreateComponentParams(propParams);
         if (params.length > 0) {
-            // Always append the first value
-            // to the generated name.
             const firstParam = params[0];
             const paramValue = firstParam.paramValue;
             let appendValue = paramValue.toString();
-
-            if (paramValue instanceof NumericValue) {
+            if (paramValue instanceof ParamDefinition_js_1.NumericValue) {
                 appendValue = paramValue.value;
             }
-
             instanceName += '_' + appendValue;
         }
-
         const arrange = properties.has('arrange') ?
             properties.get('arrange') : null;
-
         const display = properties.has('display') ?
             properties.get('display') : null;
-
         const type = properties.has('type') ?
             properties.get('type') : null;
-
         const width = properties.has('width') ?
             properties.get('width') : null;
-
         const props = {
             arrange,
             display,
             type,
             width,
-        }
-
-        return this.getExecutor().createComponent(instanceName, 
-            pins, params, props);
+        };
+        return this.getExecutor().createComponent(instanceName, pins, params, props);
     }
-
-    visitCreate_graphic_expr(ctx: Create_graphic_exprContext): 
-        SymbolDrawingCommands {
-        
+    visitCreate_graphic_expr(ctx) {
         const commands = ctx.sub_expr_list().reduce((accum, item) => {
             const [commandName, parameters] = this.visit(item);
-
-            const keywordParams = new Map<string, any>();
-            const positionParams = parameters.reduce(
-                (accum, [argType, name, value]) => {
-                    if (argType === 'position') {
-                        accum.push(value);
-                    } else {
-                        keywordParams.set(name, value);
-                    }
-                    return accum;
-                }, [] as any[]);
-
+            const keywordParams = new Map();
+            const positionParams = parameters.reduce((accum, [argType, name, value]) => {
+                if (argType === 'position') {
+                    accum.push(value);
+                }
+                else {
+                    keywordParams.set(name, value);
+                }
+                return accum;
+            }, []);
             accum.push([commandName, positionParams, keywordParams]);
             return accum;
-        }, [] as SubExpressionCommand[]);
-
-        return new SymbolDrawingCommands(commands);
-    }
-
-    visitSub_expr(ctx: Sub_exprContext):
-        [id: string, parameters: CallableParameter[]] {
-        let commandName: string = null;
+        }, []);
+        return new draw_symbols_js_1.SymbolDrawingCommands(commands);
+    }
+    visitSub_expr(ctx) {
+        let commandName = null;
         if (ctx.ID()) {
             commandName = ctx.ID().getText();
-        } else if (ctx.Pin()) {
+        }
+        else if (ctx.Pin()) {
             commandName = ctx.Pin().getText();
-        } else {
+        }
+        else {
             throw "Invalid command!";
         }
-
-        const parameters: CallableParameter[] = this.visit(ctx.parameters());
+        const parameters = this.visit(ctx.parameters());
         return [commandName, parameters];
     }
-
-    visitProperty_expr(ctx: Property_exprContext): Map<string, any> {
+    visitProperty_expr(ctx) {
         const keyName = this.visit(ctx.property_key_expr());
         const value = this.visit(ctx.property_value_expr());
-
-        const map = new Map<string, any>();
+        const map = new Map();
         map.set(keyName, value);
-
         return map;
     }
-
-    visitSingle_line_property(ctx: Single_line_propertyContext): any | any[] {
+    visitSingle_line_property(ctx) {
         let value;
         if (ctx.data_expr_list().length === 1) {
             value = this.visit(ctx.data_expr(0));
-        } else {
+        }
+        else {
             value = ctx.data_expr_list().map(item => {
                 return this.visit(item);
             });
         }
         return value;
     }
-
-    visitNested_properties(ctx: Nested_propertiesContext): Map<string, any> {
-        const result = new Map<string, any>();
+    visitNested_properties(ctx) {
+        const result = new Map();
         ctx.property_expr_list().forEach((item) => {
-            const property: Map<string, any> = this.visit(item);
-
-            // Get out all items, by default
+            const property = this.visit(item);
             for (const [key, value] of property) {
                 result.set(key, value);
             }
         });
-
         return result;
     }
-
-    visitProperty_key_expr(ctx: Property_key_exprContext): string | number {
+    visitProperty_key_expr(ctx) {
         if (ctx.ID()) {
             return ctx.ID().getText();
-        } else if (ctx.INTEGER_VALUE()) {
+        }
+        else if (ctx.INTEGER_VALUE()) {
             return Number(ctx.INTEGER_VALUE().getText());
-        } else if (ctx.STRING_VALUE()) {
+        }
+        else if (ctx.STRING_VALUE()) {
             return this.prepareStringValue(ctx.STRING_VALUE().getText());
         }
     }
-
-    visitData_expr_with_assignment(ctx: Data_expr_with_assignmentContext):
-        [component: ComplexType, pin: string | number | null] {
-
-        let component: ComplexType;
+    visitData_expr_with_assignment(ctx) {
+        let component;
         if (ctx.data_expr()) {
             component = this.visit(ctx.data_expr());
-
             if (component === null || component === undefined) {
                 throw "Could not find component: " + ctx.data_expr().getText();
             }
-
-        } else if (ctx.assignment_expr()) {
-            component = this.visit(ctx.assignment_expr())
         }
-
-        let pinValue: number | string = null;
+        else if (ctx.assignment_expr()) {
+            component = this.visit(ctx.assignment_expr());
+        }
+        let pinValue = null;
         if (ctx.pin_select_expr()) {
             pinValue = this.visit(ctx.pin_select_expr());
-        } else {
-            pinValue = (component as ClassComponent).getDefaultPin();
         }
-
+        else {
+            pinValue = component.getDefaultPin();
+        }
         return [component, pinValue];
     }
-
-    visitValueAtomExpr(ctx: ValueAtomExprContext): ComplexType {
-        let value: ComplexType;
-
+    visitValueAtomExpr(ctx) {
+        let value;
         if (ctx.value_expr()) {
-            value = this.visit(ctx.value_expr()) as ValueType;
-
-        } else if (ctx.atom_expr()) {
+            value = this.visit(ctx.value_expr());
+        }
+        else if (ctx.atom_expr()) {
             const reference = this.visit(ctx.atom_expr());
-
             if (!reference.found) {
-                value = new UndeclaredReference(reference);
-            } else {
-                // This is the returned component from the function call
+                value = new types_js_1.UndeclaredReference(reference);
+            }
+            else {
                 value = reference.value;
             }
         }
-
         return value;
     }
-
-    visitUnaryOperatorExpr(ctx: UnaryOperatorExprContext): ComplexType {
+    visitUnaryOperatorExpr(ctx) {
         const value = this.visit(ctx.data_expr());
-
         const unaryOp = ctx.unary_operator();
         if (unaryOp) {
             if (unaryOp.Not()) {
                 if (typeof value === "boolean") {
                     value = !value;
-                } else {
+                }
+                else {
                     throw "Failed to do Not operator";
                 }
-            } else if (unaryOp.Minus()) {
+            }
+            else if (unaryOp.Minus()) {
                 if (typeof value === 'number') {
                     return -value;
-                } else {
+                }
+                else {
                     throw "Failed to do Negation operator";
                 }
             }
         }
-
         return value;
     }
-
-    visitDataExpr(ctx: DataExprContext): ComplexType {
-        let value: ComplexType;
-
+    visitDataExpr(ctx) {
+        let value;
         if (ctx.create_component_expr()) {
-            value = this.visit(ctx.create_component_expr()) as ClassComponent;
-
-        } else if (ctx.create_graphic_expr()) {
-            value = this.visit(ctx.create_graphic_expr()) as ClassComponent;
+            value = this.visit(ctx.create_component_expr());
+        }
+        else if (ctx.create_graphic_expr()) {
+            value = this.visit(ctx.create_graphic_expr());
         }
-
         return value;
     }
-
-    visitBinaryOperatorExpr(ctx: BinaryOperatorExprContext): boolean | number {
+    visitBinaryOperatorExpr(ctx) {
         const value1 = this.visit(ctx.data_expr(0));
         const value2 = this.visit(ctx.data_expr(1));
-
         const binaryOperatorType = ctx.binary_operator();
-
         if (binaryOperatorType.Equals()) {
-            return value1 == value2; // Boolean result
-        } else if (binaryOperatorType.NotEquals()) {
+            return value1 == value2;
+        }
+        else if (binaryOperatorType.NotEquals()) {
             return value1 != value2;
         }
     }
-
-    visitMultiplyExpr(ctx: MultiplyExprContext): number {
-        const value1 = this.visit(ctx.data_expr(0)) as number;
-        const value2 = this.visit(ctx.data_expr(1)) as number;
-
+    visitMultiplyExpr(ctx) {
+        const value1 = this.visit(ctx.data_expr(0));
+        const value2 = this.visit(ctx.data_expr(1));
         if (ctx.Multiply()) {
             return value1 * value2;
-        } else if (ctx.Divide()) {
+        }
+        else if (ctx.Divide()) {
             return value1 / value2;
         }
     }
-
-    visitAdditionExpr(ctx: AdditionExprContext): number {
-        const value1 = this.visit(ctx.data_expr(0)) as number;
-        const value2 = this.visit(ctx.data_expr(1)) as number;
-
+    visitAdditionExpr(ctx) {
+        const value1 = this.visit(ctx.data_expr(0));
+        const value2 = this.visit(ctx.data_expr(1));
         if (ctx.Addition()) {
             return value1 + value2;
-        } else if (ctx.Minus()) {
+        }
+        else if (ctx.Minus()) {
             return value1 - value2;
         }
     }
-
-    visitFunction_args_expr(ctx: Function_args_exprContext):
-        FunctionDefinedParameter[] {
-
+    visitFunction_args_expr(ctx) {
         const defaultValuesProvided = ctx.value_expr_list();
-        // The last <defaultValuesProvided> IDs have default values
-        const IDs = ctx.ID_list(); // Do in reverse
-
+        const IDs = ctx.ID_list();
         const boundary = IDs.length - defaultValuesProvided.length;
-
         return IDs.map((id, index) => {
             if (index >= boundary) {
-                const defaultValue =
-                    this.visit(defaultValuesProvided[index - boundary]);
+                const defaultValue = this.visit(defaultValuesProvided[index - boundary]);
                 return [id.getText(), defaultValue];
-            } else {
+            }
+            else {
                 return [id.getText()];
             }
         });
     }
-
-    createNetResolver(executionStack: ExecutionContext[]): 
-        (netName: string, netNamespace: string) => {found: boolean, net?: Net} {
-        const resolveNet = (netName: string, netNamespace: string): 
-            {found: boolean, net?: Net} => {
-            // netNamespace is the current netNamespace where the net name is 
-            // searching from.
-
+    createNetResolver(executionStack) {
+        const resolveNet = (netName, netNamespace) => {
             this.print('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;
     }
-
-    visitFunction_def_expr(ctx: Function_def_exprContext): void {
+    visitFunction_def_expr(ctx) {
         const functionName = ctx.ID().getText();
-
-        // These are the defined arguments for the function
-        let funcDefinedParameters: FunctionDefinedParameter[] = [];
+        let funcDefinedParameters = [];
         if (ctx.function_args_expr()) {
             funcDefinedParameters = this.visit(ctx.function_args_expr());
         }
-
         const executionStack = this.executionStack;
         const functionCounter = { counter: 0 };
-
         const resolveNet = this.createNetResolver(this.executionStack);
-
-        const __runFunc = (passedInParameters:CallableParameter[], 
-            options: CFunctionOptions): [
-            executionContext: ExecutionContext, 
-            result: ComplexType | null] => {
-
-            const {netNamespace = ""} = options;
-            
-            // Create a new execution context, so that the commands are executed only
-            // within this context. Components and nets will be local to this context for now.
-            const currentExecutionContext =
-                executionStack[executionStack.length - 1];
+        const __runFunc = (passedInParameters, options) => {
+            const { netNamespace = "" } = options;
+            const currentExecutionContext = executionStack[executionStack.length - 1];
             const executionLevel = currentExecutionContext.executionLevel;
-
-            const executionContextName =
-                functionName + '_' + functionCounter['counter'];
+            const executionContextName = functionName + '_' + functionCounter['counter'];
             const executionContextNamespace = currentExecutionContext.namespace
                 + executionContextName + ".";
-
             functionCounter['counter'] += 1;
-
-            const newExecutor = new ExecutionContext(
-                executionContextName,
-                executionContextNamespace,
-                netNamespace,
-                executionLevel + 1,
-                this.getExecutor().scope.indentLevel + 1,
-                currentExecutionContext.silent,
-                currentExecutionContext.logger,
-            );
-
+            const newExecutor = new execute_js_1.ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.indentLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger);
             this.setupPrintFunction(newExecutor);
-
             newExecutor.resolveNet = resolveNet;
-
-            // Add the execution context to the end of the execution stack
             executionStack.push(newExecutor);
-
-            // Setup the params in the execution scope if there 
-            // are any function parameters
-
-            this.setupDefinedParameters(
-                functionName,
-                funcDefinedParameters,
-                passedInParameters,
-                newExecutor
-            );
-
-            const returnValue = this.runExpressions(newExecutor,
-                ctx.function_expr_list());
-
-            // Function execution is completed, get the last executor
+            this.setupDefinedParameters(functionName, funcDefinedParameters, passedInParameters, newExecutor);
+            const returnValue = this.runExpressions(newExecutor, ctx.function_expr_list());
             const lastExecution = executionStack.pop();
-
-            // Merge what ever was created in the scope with the outer scope
             const nextLastExecution = executionStack[executionStack.length - 1];
-            nextLastExecution.mergeScope(
-                lastExecution.scope,
-                executionContextName,
-            );
-
-            // Return the last execution context and the final return value of the function
+            nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
             return [lastExecution, returnValue];
         };
-
         this.getExecutor().createFunction(functionName, __runFunc);
     }
-
-    private setupDefinedParameters(
-        functionName: string,
-        funcDefinedParameters: FunctionDefinedParameter[], 
-        passedInParameters: CallableParameter[], 
-        executor: ExecutionContext): void {
-        
-        // Check if the arguments match up
+    setupDefinedParameters(functionName, 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') {
-                    // If value is passed in as function parameter, then
-                    // use it in the scope.
                     const variableName = tmpFuncArg[0];
-                    executor.print(
-                        'set variable in scope, var name: ',
-                        variableName,
-                    );
-                    executor.scope.variables.set(
-                        variableName,
-                        tmpPassedInArgs[2],
-                    );
-
-                    if (tmpPassedInArgs[2] instanceof ClassComponent) {
-                        const component  = tmpPassedInArgs[2];
-
-                        // Add the component nets into the local scope
-                        for(const [pinNumber, net] of component.pinNets){
+                    executor.print('set variable in scope, var name: ', variableName);
+                    executor.scope.variables.set(variableName, tmpPassedInArgs[2]);
+                    if (tmpPassedInArgs[2] instanceof ClassComponent_js_1.ClassComponent) {
+                        const component = tmpPassedInArgs[2];
+                        for (const [pinNumber, net] of component.pinNets) {
                             executor.scope.setNet(component, pinNumber, net);
                         }
                     }
                 }
-            } else if (tmpFuncArg.length === 2) {
-                // Value was not provided to function, but a default 
-                // value is provided.
+            }
+            else if (tmpFuncArg.length === 2) {
                 const variableName = tmpFuncArg[0];
                 const defaultValue = tmpFuncArg[1];
-                executor.print(
-                    'set variable in scope, var name: ',
-                    variableName,
-                );
-                executor.scope.variables.set(
-                    variableName, defaultValue,
-                );
-            } else {
-                throw `Invalid arguments for function '${functionName}', got: ` 
+                executor.print('set variable in scope, var name: ', variableName);
+                executor.scope.variables.set(variableName, defaultValue);
+            }
+            else {
+                throw `Invalid arguments for function '${functionName}', got: `
                     + passedInParameters;
             }
         }
     }
-
-    visitFunction_return_expr(ctx: Function_return_exprContext): ComplexType {
+    visitFunction_return_expr(ctx) {
         const executor = this.getExecutor();
         executor.print('return from function');
-        const returnValue = this.visit(ctx.data_expr()) as ComplexType;
-
+        const returnValue = this.visit(ctx.data_expr());
         executor.stopFurtherExpressions = true;
         executor.returnValue = returnValue;
-
         return returnValue;
     }
-
-    visitAtom_expr(ctx: Atom_exprContext): ReferenceType {
+    visitAtom_expr(ctx) {
         const executor = this.getExecutor();
-
         const atomId = ctx.ID().getText();
-
-        let passedNetNamespace = null; // Assumed empty by default
-
-        if (ctx.net_namespace_expr()){
+        let passedNetNamespace = null;
+        if (ctx.net_namespace_expr()) {
             passedNetNamespace = this.visit(ctx.net_namespace_expr());
         }
-
-        let currentReference: ReferenceType;
-
-        // Check if it is hardcoded values, like the pin types.
+        let currentReference;
         if (this.pinTypesList.indexOf(atomId) !== -1) {
-            // Not sure if just returning the string is enough...
             currentReference = {
                 found: true,
                 value: atomId
-            }
-        } else {
-            currentReference = executor.resolveVariable(
-                this.executionStack, atomId);
+            };
+        }
+        else {
+            currentReference = executor.resolveVariable(this.executionStack, atomId);
         }
-
         if (currentReference.found && currentReference.type === 'instance') {
-            const tmpComponent = currentReference.value as ClassComponent;
-
-            // Copy the nets into the local net
+            const tmpComponent = currentReference.value;
             for (const [pinId, net] of tmpComponent.pinNets) {
                 executor.scope.setNet(tmpComponent, pinId, net);
             }
         }
-
         if (ctx.trailer_expr_list().length > 0) {
-            // Resolve all elements in the trailer expression list
-
             if (!currentReference.found) {
                 throw "Could not find reference! " + atomId;
             }
-
             currentReference.trailers = [];
-
             ctx.trailer_expr_list().forEach(item => {
                 const itemValue = item.getText();
                 if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    let parameters: CallableParameter[] = [];
+                    let parameters = [];
                     if (item.parameters()) {
                         parameters = this.visit(item.parameters());
                     }
-
-                    const useNetNamespace = this.getNetNamespace(
-                        executor.netNamespace,
-                        passedNetNamespace,
-                    )
-
-                    const [, functionResult] =
-                        executor.callFunction(
-                            currentReference.name,
-                            parameters,
-                            this.executionStack,
-                            useNetNamespace);
-
+                    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) ? 
+                        type: (functionResult instanceof ClassComponent_js_1.ClassComponent) ?
                             'instance' : 'value',
-                    }
-
-                } else {
+                    };
+                }
+                else {
                     currentReference.trailers.push(itemValue);
                 }
             });
         }
-
         return currentReference;
     }
-
-    visitPin_select_expr2(ctx: Pin_select_expr2Context): string | number {
+    visitPin_select_expr2(ctx) {
         if (ctx.STRING_VALUE()) {
             return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        } else if (ctx.INTEGER_VALUE()) {
+        }
+        else if (ctx.INTEGER_VALUE()) {
             return Number(ctx.INTEGER_VALUE().getText());
         }
     }
-
-    visitAt_block_pin_expr(ctx: At_block_pin_exprContext): ComponentPin {
-        const atPin: number | string = this.visit(ctx.pin_select_expr2());
-
+    visitAt_block_pin_expr(ctx) {
+        const atPin = this.visit(ctx.pin_select_expr2());
         const executor = this.getExecutor();
-
         const currentComponent = executor.scope.currentComponent;
         const currentPin = executor.scope.currentPin;
-
         executor.atComponent(currentComponent, atPin, {
             addSequence: true
         });
-
         executor.print('at block pin expressions');
-
         if (ctx.at_block_pin_expression_simple()) {
             this.visit(ctx.at_block_pin_expression_simple());
-        } else if (ctx.at_block_pin_expression_complex()) {
+        }
+        else if (ctx.at_block_pin_expression_complex()) {
             this.visit(ctx.at_block_pin_expression_complex());
         }
-
         executor.print('end at block pin expressions');
-
-        // Go back to the original position
         return executor.atComponent(currentComponent, currentPin);
     }
-
-    visitAt_block(ctx: At_blockContext): ComponentPin {
+    visitAt_block(ctx) {
         const executor = this.getExecutor();
         executor.print('entering at block');
-
         this.visit(ctx.at_component_expr());
-
         const currentComponent = executor.scope.currentComponent;
         const currentPin = executor.scope.currentPin;
-
         executor.scope.indentLevel += 1;
-
         ctx.at_block_expressions_list().forEach(expression => {
             this.visit(expression);
         });
-
         executor.scope.indentLevel -= 1;
-
-        // Once all done, then restore
         executor.scope.currentComponent = currentComponent;
         executor.scope.currentPin = currentPin;
-
         executor.print('leaving at block');
-
         return executor.getCurrentPoint();
     }
-
-    visitAt_block_pin_expression_simple(ctx: At_block_pin_expression_simpleContext): void {
+    visitAt_block_pin_expression_simple(ctx) {
         if (ctx.expression()) {
-            // Handle any expressions within
             this.visit(ctx.expression());
-        } else if (ctx.NOT_CONNECTED()) {
-            // Do nothing
+        }
+        else if (ctx.NOT_CONNECTED()) {
             return;
         }
     }
-
-    visitAt_block_pin_expression_complex(ctx: At_block_pin_expression_complexContext): ComponentPin {
+    visitAt_block_pin_expression_complex(ctx) {
         ctx.expression_list().forEach(item => {
             this.visit(item);
-        })
-
+        });
         return this.getExecutor().getCurrentPoint();
     }
-
-    visitWire_expr(ctx: Wire_exprContext): void {
-        const segments: [string, number?][] = [];
-
-        // Ignore 'wire'
+    visitWire_expr(ctx) {
+        const segments = [];
         const parts = ctx.children.slice(1);
-
         for (let i = 0; i < parts.length; i++) {
             const textValue = parts[i].getText();
-
             if (this.acceptedDirections.indexOf(textValue) !== -1) {
-                // If a direction is specified, then the value 
-                // must also be specified, otherwise throw an error
-                const segment: [string, number?] = [textValue];
-
+                const segment = [textValue];
                 let skipNext = false;
                 let invalidValue = true;
-
                 if (i + 1 < parts.length) {
                     const nextValue = parts[i + 1].getText();
                     const nextValueNumber = Number(nextValue);
@@ -1048,316 +706,218 @@ export class MainVisitor extends ParseTreeVisitor<any> {
                         skipNext = true;
                     }
                 }
-
                 if (invalidValue) {
                     throw `Invalid value provided for direction ${textValue} in wire`;
                 }
-
                 segments.push(segment);
-
                 if (skipNext) {
                     i += 1;
                 }
-            } else if (textValue === "auto" || textValue === "auto_") {
-                // Two different auto modes to decide how to form the
-                // connecting wire
+            }
+            else if (textValue === "auto" || textValue === "auto_") {
                 segments.push([textValue]);
             }
         }
-
         this.getExecutor().addWire(segments);
     }
-
-    visitPoint_expr(ctx: Point_exprContext): ComponentPin {
+    visitPoint_expr(ctx) {
         const ID = ctx.ID();
         return this.getExecutor().addPoint(ID.getText());
     }
-
-    visitImport_expr(ctx: Import_exprContext): void {
-        const ID = ctx.ID().toString(); // filename
+    visitImport_expr(ctx) {
+        const ID = ctx.ID().toString();
         this.print('import', ID);
-        const {hasError,hasParseError} = this.onImportFile(this, ID);
-
-        if (hasError || hasParseError){
+        const { hasError, hasParseError } = this.onImportFile(this, ID);
+        if (hasError || hasParseError) {
             this.print('import', ID, 'failed');
             throw `import ${ID} failed`;
-        } 
-
+        }
         this.print('done import', ID);
     }
-
-    visitProperty_set_expr(ctx: Property_set_exprContext): void {
+    visitProperty_set_expr(ctx) {
         const result = this.visit(ctx.data_expr());
-
-        // To check if this works
         const resolvedProperty = this.visit(ctx.atom_expr());
-
-        // TODO: check if this works correctly
         this.getExecutor().setProperty(resolvedProperty, result);
     }
-    
-    visitDouble_dot_property_set_expr(ctx: Double_dot_property_set_exprContext) {
+    visitDouble_dot_property_set_expr(ctx) {
         const result = this.visit(ctx.data_expr());
         const propertyName = ctx.ID().getText();
         this.getExecutor().setProperty('..' + propertyName, result);
     }
-
-    visitRoundedBracketsExpr(ctx: RoundedBracketsExprContext) {
+    visitRoundedBracketsExpr(ctx) {
         return this.visit(ctx.data_expr());
     }
-
-    visitFrame_expr(ctx: Frame_exprContext): void  {
+    visitFrame_expr(ctx) {
         const frameId = this.getExecutor().enterFrame();
         this.runExpressions(this.getExecutor(), ctx.expression_list());
         this.getExecutor().exitFrame(frameId);
     }
-
-    visitNet_namespace_expr(ctx: Net_namespace_exprContext): string {
-        let dataValue: ComplexType = null;
-
+    visitNet_namespace_expr(ctx) {
+        let dataValue = null;
         let netNamespace = null;
         const hasPlus = ctx.Addition();
-
         if (ctx.data_expr()) {
-            dataValue = this.visit(ctx.data_expr()) as ComplexType;
-
-            if (dataValue instanceof UndeclaredReference) {
+            dataValue = this.visit(ctx.data_expr());
+            if (dataValue instanceof types_js_1.UndeclaredReference) {
                 netNamespace = "/" + dataValue.reference.name;
-            } else if (typeof dataValue === "string") {
+            }
+            else if (typeof dataValue === "string") {
                 netNamespace = "/" + dataValue;
-            } else {
+            }
+            else {
                 throw "Failed to resolve net namespace value";
             }
-
-        } else {
-            // If no net namespace specified, then the global namespace
-            // is assumed.
+        }
+        else {
             netNamespace = "/";
         }
-
         return (hasPlus ? "+" : "") + netNamespace;
     }
-
-    pinTypes = [
-        PinTypes.Any,
-        PinTypes.IO,
-        PinTypes.Input,
-        PinTypes.Output,
-        PinTypes.Power,
-    ];
-
-    createImportFileHandler(directory: string, defaultLibsPath: string):
-        ((visitor: MainVisitor, importPath: string) =>
-            { hasError: boolean, hasParseError: boolean, pathExists: boolean }) {
-
-        return (visitor: MainVisitor, importPath: string) => {
-            // Check if different files exist first
-            let importResult: {
-                hasError: boolean,
-                hasParseError: boolean,
-                pathExists: boolean,
-            };
-
+    createImportFileHandler(directory, defaultLibsPath) {
+        return (visitor, importPath) => {
+            let importResult;
             importResult = this.importLib(visitor, directory, importPath);
-
             if (!importResult.pathExists && importPath == 'lib') {
-                // Load default path
                 importResult = this.importLib(visitor, defaultLibsPath, importPath);
             }
-
             return importResult;
-        }
+        };
     }
-
-    private importLib(visitor: MainVisitor, directory: string, filename: string): {hasError: boolean, hasParseError: boolean, pathExists: boolean} {
-        const tmpFilePath = join(directory, filename + ".cst");
+    importLib(visitor, directory, filename) {
+        const tmpFilePath = (0, path_1.join)(directory, filename + ".cst");
         visitor.print('importing path:', tmpFilePath);
         let pathExists = false;
-
-        let fileData: string = null;
-
+        let fileData = null;
         try {
-            fileData = readFileSync(tmpFilePath, { encoding: 'utf8' });
+            fileData = (0, fs_1.readFileSync)(tmpFilePath, { encoding: 'utf8' });
             pathExists = true;
-        } catch (err) {
+        }
+        catch (err) {
             pathExists = false;
         }
-
         try {
-            if (pathExists){
+            if (pathExists) {
                 visitor.print('done reading imported file data');
-
-                const { hasError, hasParseError } =
-                    parseFileWithVisitor(visitor, fileData);
-
-                return { hasError, hasParseError, pathExists }
+                const { hasError, hasParseError } = (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+                return { hasError, hasParseError, pathExists };
             }
-        } catch (err) {
+        }
+        catch (err) {
             visitor.print('Failed to import file: ', err.message);
         }
-
         return {
             hasError: true,
             hasParseError: true,
             pathExists,
-        }
+        };
     }
-
-    private parseCreateComponentPins(
-        pinData: number | Map<string, any>,
-    ): PinDefinition[] {
-        const pins: PinDefinition[] = [];
-
+    parseCreateComponentPins(pinData) {
+        const pins = [];
         if (typeof pinData === 'number') {
             const lastPin = pinData;
             for (let i = 0; i < lastPin; i++) {
                 const pinId = i + 1;
-                pins.push(
-                    new PinDefinition(pinId, PinIdType.Int, pinId.toString()),
-                );
+                pins.push(new PinDefinition_js_1.PinDefinition(pinId, PinDefinition_js_1.PinIdType.Int, pinId.toString()));
             }
-        } else if (pinData instanceof Map) {
+        }
+        else if (pinData instanceof Map) {
             for (const [pinId, pinDef] of pinData) {
-                let pinIdType = PinIdType.Int;
-                let pinType = PinTypes.Any;
-                let pinName: string | null = null;
-                let altPinNames: string[] = [];
-
+                let pinIdType = PinDefinition_js_1.PinIdType.Int;
+                let pinType = PinTypes_js_1.PinTypes.Any;
+                let pinName = null;
+                let altPinNames = [];
                 if (typeof pinId === 'string') {
-                    pinIdType = PinIdType.Str;
+                    pinIdType = PinDefinition_js_1.PinIdType.Str;
                 }
-
                 if (Array.isArray(pinDef)) {
                     const firstValue = pinDef[0];
-
-                    // Check if firstValue matches a pin type
                     if (this.pinTypes.indexOf(firstValue) !== -1) {
-                        // First value matches a pin type
                         pinType = firstValue;
                         pinName = pinDef[1];
-
                         if (pinDef.length > 2) {
                             altPinNames = pinDef.slice(2);
                         }
-                    } else {
+                    }
+                    else {
                         pinName = pinDef[0];
                         if (pinDef.length > 1) {
                             altPinNames = pinDef.slice(1);
                         }
                     }
-                } else {
+                }
+                else {
                     pinName = pinDef;
                 }
-
-                pins.push(
-                    new PinDefinition(
-                        pinId,
-                        pinIdType,
-                        pinName,
-                        pinType,
-                        altPinNames,
-                    ),
-                );
+                pins.push(new PinDefinition_js_1.PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
             }
         }
-
         return pins;
     }
-
-    private parseCreateComponentParams(
-        params: Map<string, any>,
-    ): ParamDefinition[] {
+    parseCreateComponentParams(params) {
         const result = [];
         if (params) {
             for (const [key, value] of params) {
-                result.push(new ParamDefinition(key, value));
+                result.push(new ParamDefinition_js_1.ParamDefinition(key, value));
             }
         }
-
         return result;
     }
-
-    private prepareStringValue(value: string): string {
+    prepareStringValue(value) {
         return value.slice(1, value.length - 1);
     }
-
-    print(...params: any[]): void {
+    print(...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){
+        if (!this.silent) {
             console.log.apply(null, args);
         }
     }
-
-    printNets(): void {
+    printNets() {
         this.getExecutor().scope.printNets();
     }
-
-    dumpNets(): ComponentPinNet[]  {
+    dumpNets() {
         return this.getExecutor().scope.dumpNets();
     }
-
-    dumpUniqueNets(): Net[] {
+    dumpUniqueNets() {
         const nets = this.getExecutor().scope.getNets();
         return nets.reduce((accum, [, , net]) => {
             accum.push(net);
             return accum;
-        }, [] as Net[])
+        }, []);
     }
-
-    dumpVariables(): Map<string, any> {
+    dumpVariables() {
         return this.getExecutor().scope.variables;
     }
-
-    dumpInstances(): Map<string, ClassComponent> {
+    dumpInstances() {
         return this.getExecutor().scope.instances;
     }
-
     dump2() {
         const instances = this.getExecutor().scope.instances;
         const items = [];
-
         for (const [instanceName, instance] of instances) {
             if (instance.assignedRefDes === null) {
                 continue;
             }
-
-            const pinNets = this.resolveNets(
-                this.getExecutor().scope,
-                instance,
-            );
-
+            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
             const componentItem = {
                 name: instanceName,
                 refdes: instance.assignedRefDes,
                 pins: {},
             };
-
             pinNets.forEach((item) => {
                 componentItem.pins[item.pin.id] = item.netName;
             });
-
             items.push(componentItem);
         }
-
         return items;
     }
-
-    getNetList(): NetListItem[] {
-        const netlist: NetListItem[] = [];
-
+    getNetList() {
+        const netlist = [];
         const instances = this.getExecutor().scope.instances;
         for (const [instanceName, instance] of instances) {
-            const pinNets = this.resolveNets(
-                this.getExecutor().scope,
-                instance,
-            );
-
+            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
             const componentItem = {
                 instanceName,
                 instance,
@@ -1367,51 +927,40 @@ export class MainVisitor extends ParseTreeVisitor<any> {
                 componentItem.pins[item.pin.id] = {
                     netName: item.netName,
                     netBaseName: item.netBaseName
-                }
+                };
             });
-
-            netlist.push(componentItem)
+            netlist.push(componentItem);
         }
-
         return netlist;
     }
-
     getGraph() {
         const executor = this.getExecutor();
         const sequence = executor.scope.sequence;
         const nets = executor.scope.getNets();
-
         return {
             sequence,
             nets,
             components: Array.from(executor.scope.instances.values())
         };
     }
-
-    annotateComponents(): void {
+    annotateComponents() {
         this.print('===== annotate components =====');
-
         const annotater = new ComponentAnnotater();
         const instances = this.getExecutor().scope.instances;
-
-        const toAnnotate:ClassComponent[] = [];
-
+        const toAnnotate = [];
         for (const [, instance] of instances) {
             if (instance.assignedRefDes === null) {
-                if (instance.typeProp === ComponentTypes.label ||
-                    instance.typeProp === ComponentTypes.net ||
-                    instance.typeProp === ComponentTypes.point) {
+                if (instance.typeProp === globals_js_1.ComponentTypes.label ||
+                    instance.typeProp === globals_js_1.ComponentTypes.net ||
+                    instance.typeProp === globals_js_1.ComponentTypes.point) {
                     continue;
                 }
-
-                if (instance.typeProp === null){
+                if (instance.typeProp === null) {
                     this.print('Instance has no type:', instance.instanceName, ' assuming connector');
                     instance.typeProp = 'conn';
                 }
-
                 if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes') as string;
-
+                    const refdes = instance.parameters.get('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
@@ -1419,181 +968,106 @@ export class MainVisitor extends ParseTreeVisitor<any> {
                         continue;
                     }
                 }
-
                 toAnnotate.push(instance);
             }
         }
-
         toAnnotate.forEach(instance => {
             const newRefDes = annotater.getAnnotation(instance.typeProp);
-
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.print(newRefDes, '-', instance.instanceName);
-            } else {
+            }
+            else {
                 this.print('Failed to annotate:', instance.instanceName);
             }
         });
-
         this.print('===== annotate done =====');
         this.print('');
     }
-
-    private resolveNets(
-        scope: ExecutionScope,
-        instance: ClassComponent,
-    ): { pin: PinDefinition; netName: string, netBaseName: string }[] {
-        // Returns the list of nets that the component pins are
-        // connected to.
-
+    resolveNets(scope, instance) {
         const result = [];
-
         for (const [pinId, pin] of instance.pins) {
-            let netName = NoNetText;
-            let netBaseName = NoNetText;
-
+            let netName = globals_js_1.NoNetText;
+            let netBaseName = globals_js_1.NoNetText;
             if (scope.hasNet(instance, pinId)) {
                 const netObject = scope.getNet(instance, pinId);
                 netName = netObject.namespace + netObject.name;
                 netBaseName = netObject.baseName;
             }
-
             result.push({
                 pin: pin,
                 netName: netName,
                 netBaseName,
             });
         }
-
         return result;
     }
-
-    private setComponentOrientation(component: ClassComponent, pin: number,
-        orientation: string): void {
-
-        // This can be used to modify the orientation of the component.
+    setComponentOrientation(component, pin, orientation) {
         if (this.acceptedDirections.indexOf(orientation) !== -1) {
-            // a valid direction
             component.setParam('_addDirection', orientation);
             component.setParam('_addPin', pin);
-        } else {
+        }
+        else {
             throw "Invalid modifier for orientation";
         }
     }
-
-    private getPropertyExprList(items: Property_exprContext[]): Map<string, any>{
-        const properties = new Map<string, any>();
-
+    getPropertyExprList(items) {
+        const properties = new Map();
         items.forEach((item) => {
-            const result: Map<string, any> = this.visit(item); // Map should be returned
-
+            const result = this.visit(item);
             for (const [key, value] of result) {
                 properties.set(key, value);
             }
         });
-
         return properties;
     }
-
-    private runExpressions(executor: ExecutionContext,
-        expressions: ExpressionContext[] | Function_exprContext[]): ComplexType {
-
-        let returnValue: ComplexType | null = null;
-
-        // Execute the expressions within the context
+    runExpressions(executor, expressions) {
+        let returnValue = null;
         for (let i = 0; i < expressions.length; i++) {
             const expr = expressions[i];
-
-            // The correct executor MUST be on the top/end of the stack!
             this.visit(expr);
-
-            // If this flag is set, then do not parse anything further!
             if (executor.stopFurtherExpressions) {
                 returnValue = executor.returnValue;
                 break;
             }
         }
-
         return returnValue;
     }
-
-    private checkNetNamespaceIncludes(
-        targetNetName: string, targetNamespaceParts: string[], net: Net): boolean {
-
-        // Returns true if the namespace of <net> is a fit for 
-        // the target namespace supplied
-
-        if (net.name === targetNetName) {
-            // split the net namespace into parts for comparison.
-            // For true to be returned, all parts in net must also be in
-            // targetNamespaceParts.
-            const netNamespaceParts = this.getNamespaceParts(net.namespace);
-            this.print('check namespace', targetNetName,
-                targetNamespaceParts, netNamespaceParts);
-
-            let matches = 0;
-            for (let i = 0; i < netNamespaceParts.length; i++) {
-                if (netNamespaceParts[i] === targetNamespaceParts[i]) {
-                    matches++;
-                }
-            }
-
-            if (matches === netNamespaceParts.length) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private getNamespaceParts(namespace: string): string[] {
-        return namespace.split(".").slice(0, -2);
-    }
-
-    private setupPrintFunction(context: ExecutionContext): void {
+    setupPrintFunction(context) {
         context.createFunction('print', (params) => {
-            // Only accept position params
             const items = params.map(([, , value]) => {
-                return value
+                return value;
             });
-
             if (this.printToConsole) {
                 console.log('::', ...items);
             }
             this.printStream.push(...items);
-
             return [this, null];
         });
     }
-
-    private getNetNamespace(executorNetNamespace: string,
-        passedNetNamespace: string | null): string {
-
+    getNetNamespace(executorNetNamespace, passedNetNamespace) {
         let result = executorNetNamespace;
-
         if (passedNetNamespace !== null && passedNetNamespace.length > 0) {
-            // Either user specified '/' or '/_' to indicate the global
-            // net namespace
             if (passedNetNamespace === '/' || passedNetNamespace === '_') {
                 result = '';
-            } else if (passedNetNamespace[0] === '+') {
+            }
+            else if (passedNetNamespace[0] === '+') {
                 if (executorNetNamespace === '/') {
-                    result = passedNetNamespace.slice(1)
-                } else {
+                    result = passedNetNamespace.slice(1);
+                }
+                else {
                     result = executorNetNamespace + passedNetNamespace.slice(2);
                 }
-            } else {
+            }
+            else {
                 result = passedNetNamespace;
             }
-
             result = result + '/';
         }
-
         return result;
     }
 }
-
-
+exports.MainVisitor = MainVisitor;
 const ComponentRefDesPrefixes = {
     'res': 'R',
     'cap': 'C',
@@ -1603,89 +1077,59 @@ const ComponentRefDesPrefixes = {
     'transistor': 'Q',
     'relay': 'K',
     'ic': 'U',
-
     '?': '?',
-}
-
+};
 class ComponentAnnotater {
-
-    counter = {};
-
-    existingRefDes: string[] = [];
-
-    constructor(){
-        for(const key in ComponentRefDesPrefixes){
+    constructor() {
+        this.counter = {};
+        this.existingRefDes = [];
+        for (const key in ComponentRefDesPrefixes) {
             this.counter[key] = 1;
         }
-
         this.counter['?'] = 1;
     }
-
-    getAnnotation(type: string): string | null {
-
-        // If type is unknown, then allow it to define a new range
+    getAnnotation(type) {
         if (this.counter[type] === undefined && type.length <= 2) {
             for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
                 if (value === type) {
                     throw "Refdes prefix is already in use!";
                 }
             }
-
             if (ComponentRefDesPrefixes[type] === undefined) {
-                // Define new type and start counting
                 ComponentRefDesPrefixes[type] = type;
                 this.counter[type] = 1;
             }
         }
-
         let attempts = 100;
-        let proposedName: string;
-
+        let proposedName;
         while (attempts >= 0) {
             proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
             this.counter[type]++;
-
             if (this.existingRefDes.indexOf(proposedName) === -1) {
                 break;
             }
             attempts--;
         }
-
         if (attempts === 0) {
             throw "Annotation failed!";
         }
-
         return proposedName;
     }
-
-    trackRefDes(name: string): void {
+    trackRefDes(name) {
         this.existingRefDes.push(name);
     }
 }
-
-export type NetListItem = {
-    instanceName: string,
-    instance: ClassComponent,
-    pins: { [key: string | number]: string },
-}
-
-export class VisitorExecutionException {
-    
-    errorMessage: string;
-    context: ParserRuleContext;
-    
-    constructor(context: ParserRuleContext, errorMessage: string){
+class VisitorExecutionException {
+    constructor(context, errorMessage) {
         this.errorMessage = errorMessage;
         this.context = context;
     }
-
-    print(scriptData: string): void {
+    print(scriptData) {
         const startPoint = this.context.start.start;
         const endPoint = this.context.stop.stop + 1;
-
-        console.log('Error at line ' + 
-            this.context.start.line + "," + this.context.start.column + ": " 
+        console.log('Error at line ' +
+            this.context.start.line + "," + this.context.start.column + ": "
             + scriptData.slice(startPoint, endPoint) + " - " + this.errorMessage);
-
     }
-}
+}
+exports.VisitorExecutionException = VisitorExecutionException;