circuitscript 0.0.24 → 0.0.25

package/dist/types/antlr/CircuitScriptVisitor.d.ts

@@ -1,71 +1,77 @@
-import { ParseTreeVisitor } from 'antlr4';
-import { ScriptContext } from "./CircuitScriptParser";
-import { ExpressionContext } from "./CircuitScriptParser";
-import { Path_blocksContext } from "./CircuitScriptParser";
-import { Path_block_innerContext } from "./CircuitScriptParser";
-import { Property_set_expr2Context } from "./CircuitScriptParser";
-import { Assignment_expr2Context } from "./CircuitScriptParser";
-import { Data_expr_with_assignmentContext } from "./CircuitScriptParser";
-import { Add_component_exprContext } from "./CircuitScriptParser";
-import { Component_select_exprContext } from "./CircuitScriptParser";
-import { Pin_select_exprContext } from "./CircuitScriptParser";
-import { Pin_select_expr2Context } from "./CircuitScriptParser";
-import { At_component_exprContext } from "./CircuitScriptParser";
-import { To_component_exprContext } from "./CircuitScriptParser";
-import { At_to_multiple_exprContext } from "./CircuitScriptParser";
-import { At_to_multiple_line_exprContext } from "./CircuitScriptParser";
-import { At_to_multiple_line_expr_to_pinContext } from "./CircuitScriptParser";
-import { At_blockContext } from "./CircuitScriptParser";
-import { At_block_expressionsContext } from "./CircuitScriptParser";
-import { At_block_pin_exprContext } from "./CircuitScriptParser";
-import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser";
-import { At_block_pin_expression_complexContext } from "./CircuitScriptParser";
-import { Break_keywordContext } from "./CircuitScriptParser";
-import { Assignment_exprContext } from "./CircuitScriptParser";
-import { Keyword_assignment_exprContext } from "./CircuitScriptParser";
-import { ParametersContext } from "./CircuitScriptParser";
-import { Property_set_exprContext } from "./CircuitScriptParser";
-import { Double_dot_property_set_exprContext } from "./CircuitScriptParser";
-import { AdditionExprContext } from "./CircuitScriptParser";
-import { MultiplyExprContext } from "./CircuitScriptParser";
-import { DataExprContext } from "./CircuitScriptParser";
-import { UnaryOperatorExprContext } from "./CircuitScriptParser";
-import { ValueAtomExprContext } from "./CircuitScriptParser";
-import { BinaryOperatorExprContext } from "./CircuitScriptParser";
-import { RoundedBracketsExprContext } from "./CircuitScriptParser";
-import { Binary_operatorContext } from "./CircuitScriptParser";
-import { Unary_operatorContext } from "./CircuitScriptParser";
-import { Value_exprContext } from "./CircuitScriptParser";
-import { Function_def_exprContext } from "./CircuitScriptParser";
-import { Function_exprContext } from "./CircuitScriptParser";
-import { Function_args_exprContext } from "./CircuitScriptParser";
-import { Atom_exprContext } from "./CircuitScriptParser";
-import { Trailer_exprContext } from "./CircuitScriptParser";
-import { Net_namespace_exprContext } from "./CircuitScriptParser";
-import { Function_return_exprContext } from "./CircuitScriptParser";
-import { Create_component_exprContext } from "./CircuitScriptParser";
-import { Create_graphic_exprContext } from "./CircuitScriptParser";
-import { Sub_exprContext } from "./CircuitScriptParser";
-import { Property_exprContext } from "./CircuitScriptParser";
-import { Property_key_exprContext } from "./CircuitScriptParser";
-import { Nested_propertiesContext } from "./CircuitScriptParser";
-import { Single_line_propertyContext } from "./CircuitScriptParser";
-import { Blank_exprContext } from "./CircuitScriptParser";
-import { Wire_exprContext } from "./CircuitScriptParser";
-import { Point_exprContext } from "./CircuitScriptParser";
-import { Import_exprContext } from "./CircuitScriptParser";
-import { Frame_exprContext } from "./CircuitScriptParser";
-export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Result> {
+import { AbstractParseTreeVisitor } from "antlr4ng";
+import { ScriptContext } from "./CircuitScriptParser.js";
+import { ExpressionContext } from "./CircuitScriptParser.js";
+import { Path_blocksContext } from "./CircuitScriptParser.js";
+import { Path_block_innerContext } from "./CircuitScriptParser.js";
+import { Property_set_expr2Context } from "./CircuitScriptParser.js";
+import { Assignment_expr2Context } from "./CircuitScriptParser.js";
+import { Pin_select_exprContext } from "./CircuitScriptParser.js";
+import { Component_modifier_exprContext } from "./CircuitScriptParser.js";
+import { Data_expr_with_assignmentContext } from "./CircuitScriptParser.js";
+import { Add_component_exprContext } from "./CircuitScriptParser.js";
+import { Component_select_exprContext } from "./CircuitScriptParser.js";
+import { Pin_select_expr2Context } from "./CircuitScriptParser.js";
+import { At_component_exprContext } from "./CircuitScriptParser.js";
+import { To_component_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_line_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_line_expr_to_pinContext } from "./CircuitScriptParser.js";
+import { At_blockContext } from "./CircuitScriptParser.js";
+import { At_block_expressionsContext } from "./CircuitScriptParser.js";
+import { At_block_pin_exprContext } from "./CircuitScriptParser.js";
+import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser.js";
+import { At_block_pin_expression_complexContext } from "./CircuitScriptParser.js";
+import { Break_keywordContext } from "./CircuitScriptParser.js";
+import { Assignment_exprContext } from "./CircuitScriptParser.js";
+import { Keyword_assignment_exprContext } from "./CircuitScriptParser.js";
+import { ParametersContext } from "./CircuitScriptParser.js";
+import { Property_set_exprContext } from "./CircuitScriptParser.js";
+import { Double_dot_property_set_exprContext } from "./CircuitScriptParser.js";
+import { FunctionCallExprContext } from "./CircuitScriptParser.js";
+import { AdditionExprContext } from "./CircuitScriptParser.js";
+import { MultiplyExprContext } from "./CircuitScriptParser.js";
+import { DataExprContext } from "./CircuitScriptParser.js";
+import { UnaryOperatorExprContext } from "./CircuitScriptParser.js";
+import { ValueAtomExprContext } from "./CircuitScriptParser.js";
+import { BinaryOperatorExprContext } from "./CircuitScriptParser.js";
+import { RoundedBracketsExprContext } from "./CircuitScriptParser.js";
+import { Binary_operatorContext } from "./CircuitScriptParser.js";
+import { Unary_operatorContext } from "./CircuitScriptParser.js";
+import { Value_exprContext } from "./CircuitScriptParser.js";
+import { Function_def_exprContext } from "./CircuitScriptParser.js";
+import { Function_exprContext } from "./CircuitScriptParser.js";
+import { Function_args_exprContext } from "./CircuitScriptParser.js";
+import { Atom_exprContext } from "./CircuitScriptParser.js";
+import { Trailer_exprContext } from "./CircuitScriptParser.js";
+import { Function_call_exprContext } from "./CircuitScriptParser.js";
+import { Net_namespace_exprContext } from "./CircuitScriptParser.js";
+import { Function_return_exprContext } from "./CircuitScriptParser.js";
+import { Create_component_exprContext } from "./CircuitScriptParser.js";
+import { Create_graphic_exprContext } from "./CircuitScriptParser.js";
+import { Sub_exprContext } from "./CircuitScriptParser.js";
+import { Property_exprContext } from "./CircuitScriptParser.js";
+import { Property_key_exprContext } from "./CircuitScriptParser.js";
+import { Nested_propertiesContext } from "./CircuitScriptParser.js";
+import { Single_line_propertyContext } from "./CircuitScriptParser.js";
+import { Blank_exprContext } from "./CircuitScriptParser.js";
+import { Wire_expr_direction_valueContext } from "./CircuitScriptParser.js";
+import { Wire_expr_direction_onlyContext } from "./CircuitScriptParser.js";
+import { Wire_exprContext } from "./CircuitScriptParser.js";
+import { Point_exprContext } from "./CircuitScriptParser.js";
+import { Import_exprContext } from "./CircuitScriptParser.js";
+import { Frame_exprContext } from "./CircuitScriptParser.js";
+export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<Result> {
     visitScript?: (ctx: ScriptContext) => Result;
     visitExpression?: (ctx: ExpressionContext) => Result;
     visitPath_blocks?: (ctx: Path_blocksContext) => Result;
     visitPath_block_inner?: (ctx: Path_block_innerContext) => Result;
     visitProperty_set_expr2?: (ctx: Property_set_expr2Context) => Result;
     visitAssignment_expr2?: (ctx: Assignment_expr2Context) => Result;
+    visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
+    visitComponent_modifier_expr?: (ctx: Component_modifier_exprContext) => Result;
     visitData_expr_with_assignment?: (ctx: Data_expr_with_assignmentContext) => Result;
     visitAdd_component_expr?: (ctx: Add_component_exprContext) => Result;
     visitComponent_select_expr?: (ctx: Component_select_exprContext) => Result;
-    visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
     visitPin_select_expr2?: (ctx: Pin_select_expr2Context) => Result;
     visitAt_component_expr?: (ctx: At_component_exprContext) => Result;
     visitTo_component_expr?: (ctx: To_component_exprContext) => Result;
@@ -83,6 +89,7 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitParameters?: (ctx: ParametersContext) => Result;
     visitProperty_set_expr?: (ctx: Property_set_exprContext) => Result;
     visitDouble_dot_property_set_expr?: (ctx: Double_dot_property_set_exprContext) => Result;
+    visitFunctionCallExpr?: (ctx: FunctionCallExprContext) => Result;
     visitAdditionExpr?: (ctx: AdditionExprContext) => Result;
     visitMultiplyExpr?: (ctx: MultiplyExprContext) => Result;
     visitDataExpr?: (ctx: DataExprContext) => Result;
@@ -98,6 +105,7 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitFunction_args_expr?: (ctx: Function_args_exprContext) => Result;
     visitAtom_expr?: (ctx: Atom_exprContext) => Result;
     visitTrailer_expr?: (ctx: Trailer_exprContext) => Result;
+    visitFunction_call_expr?: (ctx: Function_call_exprContext) => Result;
     visitNet_namespace_expr?: (ctx: Net_namespace_exprContext) => Result;
     visitFunction_return_expr?: (ctx: Function_return_exprContext) => Result;
     visitCreate_component_expr?: (ctx: Create_component_exprContext) => Result;
@@ -108,6 +116,8 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitNested_properties?: (ctx: Nested_propertiesContext) => Result;
     visitSingle_line_property?: (ctx: Single_line_propertyContext) => Result;
     visitBlank_expr?: (ctx: Blank_exprContext) => Result;
+    visitWire_expr_direction_value?: (ctx: Wire_expr_direction_valueContext) => Result;
+    visitWire_expr_direction_only?: (ctx: Wire_expr_direction_onlyContext) => Result;
     visitWire_expr?: (ctx: Wire_exprContext) => Result;
     visitPoint_expr?: (ctx: Point_exprContext) => Result;
     visitImport_expr?: (ctx: Import_exprContext) => Result;

package/dist/types/draw_symbols.d.ts

@@ -6,11 +6,17 @@ export declare abstract class SymbolGraphic {
     displayBounds: boolean;
     drawing: SymbolDrawing;
     _angle: number;
+    _flipX: number;
+    _flipY: number;
     width: number;
     height: number;
     labelTexts: Map<string, string>;
     get angle(): number;
     set angle(value: number);
+    get flipX(): number;
+    set flipX(value: number);
+    get flipY(): number;
+    set flipY(value: number);
     refreshDrawing(calculateSize?: boolean): void;
     calculateSize(): void;
     abstract generateDrawing(): void;
@@ -31,6 +37,7 @@ export declare abstract class SymbolGraphic {
     protected drawBody(group: G): void;
     protected drawPins(group: G): void;
     protected drawLabels(group: G): void;
+    roundValues(value: number): number;
     flipTextAnchor(value: HorizontalAlign): HorizontalAlign;
     flipDominantBaseline(value: VerticalAlign): VerticalAlign;
     setLabelValue(labelId: string, labelValue: string): void;
@@ -88,6 +95,8 @@ export declare class SymbolDrawing {
     items: (Feature | GeometryProp)[];
     pins: [number, Feature, number][];
     angle: number;
+    flipX: number;
+    flipY: number;
     mainOrigin: [number, number];
     logger: Logger;
     clear(): void;

package/dist/types/execute.d.ts

@@ -22,11 +22,10 @@ export declare class ExecutionContext {
     silent: boolean;
     logger: Logger;
     __functionCache: {};
-    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger);
-    print(...params: any[]): void;
+    parentContext: ExecutionContext;
+    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, parent: ExecutionContext);
+    log(...params: any[]): void;
     private setupRoot;
-    instanceExists(instanceName: string): boolean;
-    getComponent(instanceName: string): ClassComponent;
     getUniqueInstanceName(className: string): string;
     getUniqueNetName(): string;
     getCurrentPoint(): ComponentPin;
@@ -42,14 +41,11 @@ export declare class ExecutionContext {
     addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {
         addSequence?: boolean;
-        cloneNetComponent?: boolean;
     }): ComponentPin;
     atComponent(component: ClassComponent, pinId: number | null, options?: {
         addSequence?: boolean;
-        cloneNetComponent?: boolean;
     }): ComponentPin;
-    private isNetOnlyComponent;
-    private cloneComponent;
+    cloneComponent(component: ClassComponent): ClassComponent;
     enterBlocks(blockType: BlockTypes): void;
     exitBlocks(): void;
     enterBlock(blockIndex: number): void;
@@ -75,6 +71,7 @@ export declare class ExecutionContext {
 }
 export declare function isNetComponent(component: ClassComponent): boolean;
 export declare function isLabelComponent(component: ClassComponent): boolean;
+export declare function isNetOnlyComponent(component: ClassComponent): boolean;
 export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): PortSideItem[];
 type PortSideItem = {
     pinId: number;

package/dist/types/geometry.d.ts

@@ -30,6 +30,7 @@ export declare class Label extends Flatten.Polygon {
     constructor(id: string, text: string, anchorPoint: [number, number], polygon: Flatten.Polygon, style: LabelStyle, bounds: Box);
     static fromPoint(id: string, x: number, y: number, text: string, style: LabelStyle): Label;
     rotate(angle: number, origin: Flatten.Point): Label;
+    transform(matrix: Flatten.Matrix): Label;
     getLabelPosition(): [number, number];
 }
 export declare class GeometryProp {
@@ -47,7 +48,9 @@ export declare class Geometry {
     static arc(center: [x: number, y: number], radius: number, startAngle: number, endAngle: number, sweepDirection: boolean): Arc;
     static getCoords(item: Feature): [number, number][];
     static rotateDegs(feature: Feature, angleDegrees: number, center: [number, number]): Feature;
+    static flip(feature: Feature, flipX: number, flipY: number): Feature;
     static groupRotate(features: Feature[], angle: number, center: [number, number]): Feature[];
+    static groupFlip(features: Feature[], flipX: number, flipY: number): Feature[];
     static groupBounds(features: Feature[]): {
         start: [number, number];
         end: [number, number];
@@ -60,6 +63,7 @@ export declare class Geometry {
         path: string;
         isClosedPolygon: boolean;
     };
+    static roundPathValues(pathItems: (string | number)[]): string;
     static angle(dx: number, dy: number): number;
     static getQuadrant(dx: number, dy: number): number;
     static mergeWires(wirePoints: {

package/dist/types/helpers.d.ts

@@ -1,9 +1,40 @@
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+import { CommonTokenStream, DefaultErrorStrategy, Parser } from "antlr4ng";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
+import { IParsedToken, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
 export declare enum JSModuleType {
     CommonJs = "cjs",
     ESM = "mjs"
 }
-export declare function renderScript(scriptData: string, outputPath: string, options: any): string;
+export type ScriptOptions = {
+    currentDirectory: string | null;
+    defaultLibsPath: string;
+    dumpNets: boolean;
+    dumpData: boolean;
+    kicadNetlistPath: string | null;
+    showStats: boolean;
+};
+export declare function prepareFile(textData: string): {
+    parser: CircuitScriptParser;
+    lexer: CircuitScriptLexer;
+    lexerTimeTaken: number;
+    tokens: CommonTokenStream;
+};
+export declare function getScriptText(filePath: string): string | null;
+export declare function getSemanticTokens(scriptData: string, options: ScriptOptions): {
+    visitor: SemanticTokensVisitor;
+    parsedTokens: IParsedToken[];
+};
+export declare class ParseErrorStrategy extends DefaultErrorStrategy {
+    reportUnwantedToken(recognizer: Parser): void;
+}
+export declare function validateScript(scriptData: string, options: ScriptOptions): SymbolValidatorVisitor;
+export declare function renderScript(scriptData: string, outputPath: string, options: ScriptOptions): string | null;
 export declare function detectJSModuleType(): JSModuleType;
 export declare function getCurrentPath(): {
     filePath: string;
 };
+export declare function getFontsPath(): string;
+export declare function getDefaultLibsPath(): string;
+export declare function getPackageVersion(): string;

package/dist/types/index.d.ts

@@ -11,3 +11,5 @@ export * from './parser.js';
 export * from './render.js';
 export * from './utils.js';
 export * from './visitor.js';
+export * from './sizing.js';
+export * from './objects/types.js';

package/dist/types/lexer.d.ts

@@ -1,5 +1,5 @@
-import { CharStream, Token } from "antlr4";
-import CircuitScriptLexer from "./antlr/CircuitScriptLexer.js";
+import { CharStream, Token } from "antlr4ng";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
 export declare class MainLexer extends CircuitScriptLexer {
     tokens: any[];
     indents: any[];

package/dist/types/objects/ExecutionScope.d.ts

@@ -1,6 +1,6 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, ComponentPinNet, ComponentPinNetPair, ValueType } from './types.js';
+import { CFunction, ComponentPinNet, ComponentPinNetPair, ParseSymbolType, ValueType } from './types.js';
 import { LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
@@ -10,6 +10,9 @@ export declare class ExecutionScope {
     instances: Map<string, ClassComponent>;
     functions: Map<string, CFunction>;
     variables: Map<string, ValueType | ClassComponent>;
+    symbols: Map<string, {
+        type: ParseSymbolType;
+    }>;
     blockStack: Map<number, any>;
     wires: Wire[];
     frames: Frame[];

package/dist/types/objects/types.d.ts

@@ -47,3 +47,8 @@ export type ReferenceType = {
     type?: string;
     value?: any;
 };
+export declare enum ParseSymbolType {
+    Variable = "variable",
+    Function = "function",
+    Undefined = "undefined"
+}

package/dist/types/parser.d.ts

@@ -1,38 +1,25 @@
-import { ErrorListener, ParseTreeVisitor, ParserRuleContext, TerminalNode } from 'antlr4';
-import CircuitScriptLexer from './antlr/CircuitScriptLexer.js';
-import CircuitScriptParser, { ScriptContext } from './antlr/CircuitScriptParser.js';
-import { MainVisitor } from './visitor.js';
-export declare function parseFileWithVisitor(visitor: MainVisitor, data: string): {
+import { CircuitScriptParser, ScriptContext } from './antlr/CircuitScriptParser.js';
+import { ANTLRErrorListener, ATNConfigSet, ATNSimulator, BitSet, DefaultErrorStrategy, DFA, Parser, RecognitionException, Recognizer, Token } from 'antlr4ng';
+import { BaseVisitor, OnErrorCallback } from './BaseVisitor.js';
+export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string): {
     tree: ScriptContext;
     parser: CircuitScriptParser;
     hasError: boolean;
     hasParseError: boolean;
     parserTimeTaken: number;
     lexerTimeTaken: number;
-    tokens: IParsedToken[];
 };
-export declare class SemanticTokensVisitor extends ParseTreeVisitor<any> {
-    parsedTokens: IParsedToken[];
-    lexer: CircuitScriptLexer;
-    script: string;
-    semanticTokens: Map<string, IParsedToken>;
-    constructor(lexer: CircuitScriptLexer, script: string);
-    visit(ctx: ParserRuleContext): any;
-    handleError(ctx: ParserRuleContext, err: Error): void;
-    checkContext(ctx: ParserRuleContext): void;
-    addSemanticToken(parsedToken: IParsedToken): void;
-    parseToken(node: TerminalNode, modifiers: string[], tokenType?: string | null): IParsedToken;
+export declare class TempErrorStrategy extends DefaultErrorStrategy {
+    recover(recognizer: Parser, e: RecognitionException): void;
+    reportError(recognizer: Parser, e: RecognitionException): void;
 }
-export interface IParsedToken {
-    line: number;
-    column: number;
-    length: number;
-    tokenType: string;
-    tokenModifiers: string[];
-    textValue: string;
-}
-export declare class CircuitscriptParserErrorListener extends ErrorListener {
+export declare class CircuitscriptParserErrorListener implements ANTLRErrorListener {
     syntaxErrorCounter: number;
-    syntaxError(recognizer: any, offendingSymbol: any, line: number, column: number, msg: string, e: any | undefined): void;
-    hasParseErrors(): boolean;
+    onErrorHandler: OnErrorCallback | null;
+    constructor(onErrorHandler?: OnErrorCallback | null);
+    syntaxError<S extends Token, T extends ATNSimulator>(recognizer: Recognizer<T>, offendingSymbol: S | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException | null): void;
+    reportAmbiguity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet): void;
+    reportAttemptingFullContext(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, configs: ATNConfigSet): void;
+    reportContextSensitivity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, configs: ATNConfigSet): void;
+    hasSyntaxErrors(): boolean;
 }

package/dist/types/validate.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export declare function validate(): Promise<void>;

package/dist/types/visitor.d.ts

@@ -1,101 +1,48 @@
-import { ParseTreeVisitor, ParserRuleContext } from 'antlr4';
-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, Frame_exprContext, Function_args_exprContext, Function_def_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 { Add_component_exprContext, AdditionExprContext, At_blockContext, At_block_pin_exprContext, At_block_pin_expression_complexContext, At_block_pin_expression_simpleContext, At_component_exprContext, BinaryOperatorExprContext, Path_blocksContext, Component_select_exprContext, Create_component_exprContext, Create_graphic_exprContext, DataExprContext, Data_expr_with_assignmentContext, Double_dot_property_set_exprContext, Frame_exprContext, Function_def_exprContext, Keyword_assignment_exprContext, MultiplyExprContext, Nested_propertiesContext, Net_namespace_exprContext, Pin_select_expr2Context, Pin_select_exprContext, Point_exprContext, Property_exprContext, Property_key_exprContext, Property_set_exprContext, Single_line_propertyContext, Sub_exprContext, To_component_exprContext, Wire_exprContext, UnaryOperatorExprContext, Wire_expr_direction_onlyContext, Wire_expr_direction_valueContext } from './antlr/CircuitScriptParser.js';
 import { ClassComponent } from './objects/ClassComponent.js';
-import { PinBlankValue } from './objects/ParamDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { CallableParameter, ComplexType, ComponentPin, ComponentPinNet, FunctionDefinedParameter, ReferenceType, ValueType } from './objects/types.js';
-import { Logger } from './logger.js';
+import { ComponentPin, ComponentPinNet } from './objects/types.js';
 import { Net } from './objects/Net.js';
-import { SymbolDrawingCommands } from './draw_symbols.js';
-export declare class MainVisitor extends ParseTreeVisitor<any> {
-    indentLevel: number;
-    startingContext: ExecutionContext;
-    executionStack: ExecutionContext[];
-    silent: boolean;
-    logger: Logger;
-    printStream: string[];
-    printToConsole: boolean;
-    acceptedDirections: string[];
-    pinTypesList: string[];
-    onImportFile: (visitor: MainVisitor, filePath: string) => {
-        hasError: boolean;
-        hasParseError: boolean;
-    };
-    constructor(silent?: boolean);
-    getExecutor(): ExecutionContext;
-    visit(ctx: ParserRuleContext): any;
-    handleError(ctx: ParserRuleContext, err: string | VisitorExecutionException): void;
-    visitScript(ctx: ScriptContext): any;
-    visitParameters(ctx: ParametersContext): CallableParameter[];
-    visitKeyword_assignment_expr(ctx: Keyword_assignment_exprContext): [
-        key: string,
-        value: any
-    ];
-    visitAssignment_expr(ctx: Assignment_exprContext): ComplexType;
-    setInstanceParam(object: ClassComponent, trailers: string[], value: any): void;
-    visitValue_expr(ctx: Value_exprContext): ValueType;
-    visitBlank_expr(ctx: Blank_exprContext): PinBlankValue;
-    visitPin_select_expr(ctx: Pin_select_exprContext): string | number | null;
-    visitAdd_component_expr(ctx: Add_component_exprContext): ComponentPin;
-    visitAt_component_expr(ctx: At_component_exprContext): ComponentPin;
-    visitTo_component_expr(ctx: To_component_exprContext): ComponentPin;
-    visitComponent_select_expr(ctx: Component_select_exprContext): ComponentPin;
-    visitPath_blocks(ctx: Path_blocksContext): ComponentPin;
-    visitBreak_keyword(): number;
-    visitCreate_component_expr(ctx: Create_component_exprContext): ClassComponent;
-    visitCreate_graphic_expr(ctx: Create_graphic_exprContext): SymbolDrawingCommands;
-    visitSub_expr(ctx: Sub_exprContext): [
-        id: string,
-        parameters: CallableParameter[]
-    ];
-    visitProperty_expr(ctx: Property_exprContext): Map<string, any>;
-    visitSingle_line_property(ctx: Single_line_propertyContext): any | any[];
-    visitNested_properties(ctx: Nested_propertiesContext): Map<string, any>;
-    visitProperty_key_expr(ctx: Property_key_exprContext): string | number;
-    visitData_expr_with_assignment(ctx: Data_expr_with_assignmentContext): [
-        component: ComplexType,
-        pin: string | number | null
-    ];
-    visitValueAtomExpr(ctx: ValueAtomExprContext): ComplexType;
-    visitUnaryOperatorExpr(ctx: UnaryOperatorExprContext): ComplexType;
-    visitDataExpr(ctx: DataExprContext): ComplexType;
-    visitBinaryOperatorExpr(ctx: BinaryOperatorExprContext): boolean | number;
-    visitMultiplyExpr(ctx: MultiplyExprContext): number;
-    visitAdditionExpr(ctx: AdditionExprContext): number;
-    visitFunction_args_expr(ctx: Function_args_exprContext): FunctionDefinedParameter[];
-    createNetResolver(executionStack: ExecutionContext[]): (netName: string, netNamespace: string) => {
-        found: boolean;
-        net?: Net;
-    };
-    visitFunction_def_expr(ctx: Function_def_exprContext): void;
-    private setupDefinedParameters;
-    visitFunction_return_expr(ctx: Function_return_exprContext): ComplexType;
-    visitAtom_expr(ctx: Atom_exprContext): ReferenceType;
-    visitPin_select_expr2(ctx: Pin_select_expr2Context): string | number;
-    visitAt_block_pin_expr(ctx: At_block_pin_exprContext): ComponentPin;
-    visitAt_block(ctx: At_blockContext): ComponentPin;
-    visitAt_block_pin_expression_simple(ctx: At_block_pin_expression_simpleContext): void;
-    visitAt_block_pin_expression_complex(ctx: At_block_pin_expression_complexContext): ComponentPin;
-    visitWire_expr(ctx: Wire_exprContext): void;
-    visitPoint_expr(ctx: Point_exprContext): ComponentPin;
-    visitImport_expr(ctx: Import_exprContext): void;
-    visitProperty_set_expr(ctx: Property_set_exprContext): void;
-    visitDouble_dot_property_set_expr(ctx: Double_dot_property_set_exprContext): void;
-    visitRoundedBracketsExpr(ctx: RoundedBracketsExprContext): any;
-    visitFrame_expr(ctx: Frame_exprContext): void;
-    visitNet_namespace_expr(ctx: Net_namespace_exprContext): string;
+import { BaseVisitor } from './BaseVisitor.js';
+import { ParserRuleContext } from 'antlr4ng';
+export declare class ParserVisitor extends BaseVisitor {
+    visitKeyword_assignment_expr: (ctx: Keyword_assignment_exprContext) => void;
+    visitPin_select_expr: (ctx: Pin_select_exprContext) => void;
+    visitAdd_component_expr: (ctx: Add_component_exprContext) => ComponentPin;
+    visitAt_component_expr: (ctx: At_component_exprContext) => ComponentPin;
+    visitTo_component_expr: (ctx: To_component_exprContext) => ComponentPin;
+    visitComponent_select_expr: (ctx: Component_select_exprContext) => void;
+    visitPath_blocks: (ctx: Path_blocksContext) => ComponentPin;
+    visitCreate_component_expr: (ctx: Create_component_exprContext) => void;
+    visitCreate_graphic_expr: (ctx: Create_graphic_exprContext) => void;
+    visitSub_expr: (ctx: Sub_exprContext) => void;
+    visitProperty_expr: (ctx: Property_exprContext) => void;
+    visitSingle_line_property: (ctx: Single_line_propertyContext) => void;
+    visitNested_properties: (ctx: Nested_propertiesContext) => void;
+    visitProperty_key_expr: (ctx: Property_key_exprContext) => void;
+    visitData_expr_with_assignment: (ctx: Data_expr_with_assignmentContext) => void;
+    visitUnaryOperatorExpr: (ctx: UnaryOperatorExprContext) => void;
+    visitDataExpr: (ctx: DataExprContext) => void;
+    visitBinaryOperatorExpr: (ctx: BinaryOperatorExprContext) => void;
+    visitMultiplyExpr: (ctx: MultiplyExprContext) => void;
+    visitAdditionExpr: (ctx: AdditionExprContext) => void;
+    visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
+    visitPin_select_expr2: (ctx: Pin_select_expr2Context) => void;
+    visitAt_block_pin_expr: (ctx: At_block_pin_exprContext) => void;
+    visitAt_block: (ctx: At_blockContext) => void;
+    visitAt_block_pin_expression_simple: (ctx: At_block_pin_expression_simpleContext) => void;
+    visitAt_block_pin_expression_complex: (ctx: At_block_pin_expression_complexContext) => void;
+    visitWire_expr_direction_only: (ctx: Wire_expr_direction_onlyContext) => void;
+    visitWire_expr_direction_value: (ctx: Wire_expr_direction_valueContext) => void;
+    visitWire_expr: (ctx: Wire_exprContext) => void;
+    visitPoint_expr: (ctx: Point_exprContext) => ComponentPin;
+    visitProperty_set_expr: (ctx: Property_set_exprContext) => void;
+    visitDouble_dot_property_set_expr: (ctx: Double_dot_property_set_exprContext) => void;
+    visitFrame_expr: (ctx: Frame_exprContext) => void;
+    visitNet_namespace_expr: (ctx: Net_namespace_exprContext) => void;
     pinTypes: PinTypes[];
-    createImportFileHandler(directory: string, defaultLibsPath: string): ((visitor: MainVisitor, importPath: string) => {
-        hasError: boolean;
-        hasParseError: boolean;
-        pathExists: boolean;
-    });
-    private importLib;
     private parseCreateComponentPins;
     private parseCreateComponentParams;
-    private prepareStringValue;
-    print(...params: any[]): void;
     printNets(): void;
     dumpNets(): ComponentPinNet[];
     dumpUniqueNets(): Net[];
@@ -115,10 +62,8 @@ export declare class MainVisitor extends ParseTreeVisitor<any> {
     annotateComponents(): void;
     private resolveNets;
     private setComponentOrientation;
+    private setComponentFlip;
     private getPropertyExprList;
-    private runExpressions;
-    private setupPrintFunction;
-    private getNetNamespace;
 }
 export type NetListItem = {
     instanceName: string;