circuitscript 0.0.24 → 0.0.26

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

@@ -1,71 +1,81 @@
-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 { LogicalOperatorExprContext } 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 { Graphic_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";
+import { If_exprContext } from "./CircuitScriptParser.js";
+import { If_inner_exprContext } from "./CircuitScriptParser.js";
+import { Else_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,8 +93,10 @@ 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;
+    visitLogicalOperatorExpr?: (ctx: LogicalOperatorExprContext) => Result;
     visitDataExpr?: (ctx: DataExprContext) => Result;
     visitUnaryOperatorExpr?: (ctx: UnaryOperatorExprContext) => Result;
     visitValueAtomExpr?: (ctx: ValueAtomExprContext) => Result;
@@ -98,18 +110,24 @@ 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;
     visitCreate_graphic_expr?: (ctx: Create_graphic_exprContext) => Result;
-    visitSub_expr?: (ctx: Sub_exprContext) => Result;
+    visitGraphic_expr?: (ctx: Graphic_exprContext) => Result;
     visitProperty_expr?: (ctx: Property_exprContext) => Result;
     visitProperty_key_expr?: (ctx: Property_key_exprContext) => Result;
     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;
     visitFrame_expr?: (ctx: Frame_exprContext) => Result;
+    visitIf_expr?: (ctx: If_exprContext) => Result;
+    visitIf_inner_expr?: (ctx: If_inner_exprContext) => Result;
+    visitElse_expr?: (ctx: Else_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;
@@ -127,7 +136,7 @@ export declare class SymbolDrawing {
         angle: number;
     };
 }
-export type SubExpressionCommand = [
+export type GraphicExprCommand = [
     commandName: string,
     positionParams: any[],
     keywordParams: Map<string, any>
@@ -135,8 +144,8 @@ export type SubExpressionCommand = [
 export declare class SymbolDrawingCommands extends SymbolDrawing {
     id: string;
     private commands;
-    constructor(commands: SubExpressionCommand[]);
-    getCommands(): SubExpressionCommand[];
+    constructor(commands: GraphicExprCommand[]);
+    getCommands(): GraphicExprCommand[];
     clone(): SymbolDrawingCommands;
 }
 type SimplePoint = [x: number, y: number];

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;
@@ -37,19 +36,17 @@ export declare class ExecutionContext {
         display?: string;
         type?: string;
         width?: number;
+        copy: boolean;
     }): ClassComponent;
     printPoint(extra?: string): void;
     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;
+    copyComponent(component: ClassComponent): ClassComponent;
     enterBlocks(blockType: BlockTypes): void;
     exitBlocks(): void;
     enterBlock(blockIndex: number): void;
@@ -73,8 +70,6 @@ export declare class ExecutionContext {
     enterFrame(): number;
     exitFrame(frameId: number): void;
 }
-export declare function isNetComponent(component: ClassComponent): boolean;
-export declare function isLabelComponent(component: ClassComponent): boolean;
 export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): PortSideItem[];
 type PortSideItem = {
     pinId: number;

package/dist/types/export.d.ts

@@ -1,2 +1,28 @@
 import { NetListItem } from "./visitor.js";
-export declare function generateKiCADNetList(netlist: NetListItem[]): string;
+export declare function generateKiCADNetList(netlist: NetListItem[]): {
+    tree: SExp;
+    missingFootprints: {
+        refdes: string;
+        instanceName: string;
+    }[];
+};
+export declare function printTree(tree: (IdObject | string)[] | string, level?: number): string;
+export declare class IdObject {
+    keyName: string;
+    constructor(keyName: string);
+}
+export declare function _id(key: string): IdObject;
+export declare class SExpObject {
+    object: SExp;
+    constructor(object: SExp);
+    getKey(object?: SExp | null): IdObject;
+    getValue(object?: SExp | null): any;
+    getJSON(object?: SExp | null): {
+        [key: string]: any;
+    };
+    getWithId(id: string, object?: SExp | null): SExp | null;
+    print(): void;
+}
+export type SExpString = [id: IdObject, string];
+export type SExpNested = [id: IdObject, SExp];
+export type SExp = [id: IdObject, ...(SExpString | SExpNested)[]];

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/globals.d.ts

@@ -8,8 +8,6 @@ export declare enum GlobalNames {
 }
 export declare const NoNetText = "NO_NET";
 export declare enum ParamKeys {
-    __is_net = "__is_net",
-    __is_label = "__is_label",
     priority = "priority",
     net_name = "net_name"
 }
@@ -40,7 +38,8 @@ export declare enum ReferenceTypes {
     function = "function",
     value = "value",
     variable = "variable",
-    instance = "instance"
+    instance = "instance",
+    pinType = "pinType"
 }
 export declare enum BlockTypes {
     Branch = 1,

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/ClassComponent.d.ts

@@ -18,6 +18,7 @@ export declare class ClassComponent {
     displayProp: string | SymbolDrawingCommands | null;
     widthProp: number | null;
     typeProp: string | null;
+    copyProp: boolean;
     styles: {
         [key: string]: number | string;
     };

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>;