circuitscript 0.1.19 → 0.1.22

package/dist/esm/visitor.js

@@ -10,7 +10,9 @@ import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
 import { UnitDimension } from './helpers.js';
 import { FrameParamKeys } from './objects/Frame.js';
+import { ComponentAnnotater } from './ComponentAnnotater.js';
 export class ParserVisitor extends BaseVisitor {
+    componentCreationIndex = 0;
     visitKeyword_assignment_expr = (ctx) => {
         const id = ctx.ID().getText();
         const value = this.visitResult(ctx.data_expr());
@@ -35,28 +37,53 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, pinId);
     };
+    trackNewComponentCreated = (callback) => {
+        const preCreatedIndex = this.componentCreationIndex;
+        callback();
+        const postCreatedIndex = this.componentCreationIndex;
+        let creationFlag = false;
+        if (postCreatedIndex > preCreatedIndex) {
+            creationFlag = true;
+        }
+        return creationFlag;
+    };
     visitAdd_component_expr = (ctx) => {
-        const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
-        this.getExecutor().addComponentExisting(component, pinValue);
+        let refComponent;
+        const creationFlag = this.trackNewComponentCreated(() => {
+            const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
+            this.getExecutor().addComponentExisting(component, pinValue);
+            refComponent = component;
+        });
+        this.linkComponentToCtx(ctx, refComponent, creationFlag);
     };
     visitAt_component_expr = (ctx) => {
-        const [component, pin] = this.visitResult(ctx.component_select_expr());
-        this.getExecutor().atComponent(component, pin, {
-            addSequence: true
+        let refComponent;
+        const creationFlag = this.trackNewComponentCreated(() => {
+            const [component, pin] = this.visitResult(ctx.component_select_expr());
+            this.getExecutor().atComponent(component, pin, {
+                addSequence: true
+            });
+            refComponent = component;
         });
+        this.linkComponentToCtx(ctx, refComponent, creationFlag);
         return this.getExecutor().getCurrentPoint();
     };
     visitTo_component_expr = (ctx) => {
         ctx.component_select_expr().forEach(item => {
-            const [component, pin] = this.visitResult(item);
-            try {
-                this.getExecutor().toComponent(component, pin, {
-                    addSequence: true
-                });
-            }
-            catch (err) {
-                throw new RuntimeExecutionError(err.message, ctx);
-            }
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pin] = this.visitResult(item);
+                try {
+                    this.getExecutor().toComponent(component, pin, {
+                        addSequence: true
+                    });
+                    refComponent = component;
+                }
+                catch (err) {
+                    throw new RuntimeExecutionError(err.message, ctx);
+                }
+            });
+            this.linkComponentToCtx(item, refComponent, creationFlag);
         });
         return this.getExecutor().getCurrentPoint();
     };
@@ -327,6 +354,7 @@ export class ParserVisitor extends BaseVisitor {
         try {
             const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
             this.setResult(ctx, createdComponent);
+            createdComponent._creationIndex = this.componentCreationIndex++;
         }
         catch (error) {
             this.throwWithContext(ctx, error.message);
@@ -867,7 +895,28 @@ export class ParserVisitor extends BaseVisitor {
         const resolveNet = this.createNetResolver(this.executionStack);
         const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
         const __runFunc = (passedInParameters, options) => {
-            const executionContextName = `${functionName}-${functionCounter['counter']}`;
+            const executor = this.getExecutor();
+            const parentBreakContext = executor.getParentBreakContext();
+            executor.addBreakContext(ctx);
+            let useIndex = -1;
+            if (parentBreakContext === null) {
+                useIndex = options.functionCallIndex;
+            }
+            else {
+                const parentEntry = executor.indexedStack.get(parentBreakContext);
+                const { funcCallIndex } = parentEntry;
+                if (!funcCallIndex.has(ctx)) {
+                    funcCallIndex.set(ctx, 0);
+                    useIndex = 0;
+                }
+                else {
+                    useIndex = funcCallIndex.get(ctx) + 1;
+                    funcCallIndex.set(ctx, useIndex);
+                }
+            }
+            executor.setBreakContextIndex(useIndex);
+            const functionCounterIndex = functionCounter['counter'];
+            const executionContextName = `${functionName}-${functionCounterIndex}`;
             const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
             functionCounter['counter'] += 1;
             newExecutor.resolveNet = resolveNet;
@@ -875,7 +924,23 @@ export class ParserVisitor extends BaseVisitor {
             const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
             const lastExecution = executionStack.pop();
             const nextLastExecution = executionStack[executionStack.length - 1];
-            nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+            const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+            const scope = this.getScope();
+            const indexedStack = [];
+            if (scope.breakStack.length > 0) {
+                const executor = this.getExecutor();
+                scope.breakStack.forEach(stackCtx => {
+                    const entry = executor.indexedStack.get(stackCtx);
+                    const { index } = entry;
+                    indexedStack.push([stackCtx, index]);
+                });
+                mergedComponents.forEach(component => {
+                    component.ctxReferences.forEach(ref => {
+                        ref.indexedStack = [...indexedStack, ...ref.indexedStack];
+                    });
+                });
+            }
+            executor.popBreakContext();
             return [lastExecution, returnValue];
         };
         this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
@@ -919,10 +984,18 @@ export class ParserVisitor extends BaseVisitor {
         executor.log('end at block pin expressions');
         executor.atComponent(currentComponent, currentPin);
     };
+    visitAt_block_header = (ctx) => {
+        const ctxAtComponent = ctx.at_component_expr();
+        this.visit(ctxAtComponent);
+        const [currentComponent,] = this.getExecutor().getCurrentPoint();
+        this.componentCtxLinks.delete(ctxAtComponent);
+        this.componentCtxLinks.set(ctx, currentComponent);
+    };
     visitAt_block = (ctx) => {
         const executor = this.getExecutor();
         executor.log('entering at block');
-        this.visit(ctx.at_component_expr());
+        const ctxAtBlockComponent = ctx.at_block_header();
+        this.visit(ctxAtBlockComponent);
         const [currentComponent, currentPin] = executor.getCurrentPoint();
         executor.scope.scopeLevel += 1;
         ctx.at_block_expressions().forEach(expression => {
@@ -1082,10 +1155,14 @@ export class ParserVisitor extends BaseVisitor {
         const dataExpr = ctx.data_expr();
         let keepLooping = true;
         this.log('enter while loop');
-        this.getExecutor().addBreakContext(ctx);
+        const executor = this.getExecutor();
+        executor.addBreakContext(ctx);
+        let counter = 0;
         while (keepLooping) {
             const result = this.visitResult(dataExpr);
             if (result) {
+                executor.setBreakContextIndex(counter);
+                executor.resetBreakContextFunctionCalls();
                 this.visit(ctx.expressions_block());
                 keepLooping = true;
                 const currentResult = this.getResult(ctx) ?? {};
@@ -1100,6 +1177,7 @@ export class ParserVisitor extends BaseVisitor {
                         continueSignal: false
                     });
                 }
+                counter++;
             }
             else {
                 keepLooping = false;
@@ -1113,7 +1191,8 @@ export class ParserVisitor extends BaseVisitor {
         const forVariableNames = ctx.ID().map(item => item.getText());
         let listItems = this.visitResult(ctx.data_expr());
         listItems = unwrapValue(listItems);
-        this.getExecutor().addBreakContext(ctx);
+        const executor = this.getExecutor();
+        executor.addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;
         while (keepLooping) {
@@ -1125,6 +1204,8 @@ export class ParserVisitor extends BaseVisitor {
                 useValueArray.forEach((value, index) => {
                     this.getScope().setVariable(forVariableNames[index], value);
                 });
+                executor.setBreakContextIndex(counter);
+                executor.resetBreakContextFunctionCalls();
                 this.visit(ctx.expressions_block());
                 keepLooping = true;
                 const currentResult = this.getResult(ctx) ?? {};
@@ -1146,7 +1227,19 @@ export class ParserVisitor extends BaseVisitor {
                 keepLooping = false;
             }
         }
-        this.getExecutor().popBreakContext();
+        executor.popBreakContext();
+    };
+    visitAnnotation_comment_expr = (ctx) => {
+        const refdesID = ctx.ID().getText();
+        const currentComponent = this.getScope().currentComponent;
+        if (currentComponent !== null) {
+            if (refdesID.indexOf('_') === -1) {
+                currentComponent.setParam('refdes', refdesID);
+            }
+            else {
+                currentComponent.placeHolderRefDes = refdesID;
+            }
+        }
     };
     resolveDataExpr(data_expr) {
         const value = this.visitResult(data_expr);
@@ -1349,8 +1442,8 @@ export class ParserVisitor extends BaseVisitor {
                 continue;
             }
             if (instance.assignedRefDes === null) {
-                if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes');
+                if (instance.hasParam('refdes')) {
+                    const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
@@ -1362,10 +1455,7 @@ export class ParserVisitor extends BaseVisitor {
             }
         }
         toAnnotate.forEach(instance => {
-            const useTypeProp = instance.typeProp ?? 'conn';
-            instance.typeProp === null
-                && this.log('Instance has no type:', instance.instanceName, ' assuming connector');
-            const newRefDes = annotater.getAnnotation(useTypeProp);
+            const newRefDes = annotater.getAnnotation(instance);
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
@@ -1449,7 +1539,7 @@ export class ParserVisitor extends BaseVisitor {
         return this.warnings;
     }
 }
-const ComponentRefDesPrefixes = {
+export const ComponentRefDesPrefixes = {
     res: 'R',
     cap: 'C',
     ind: 'L',
@@ -1460,48 +1550,6 @@ const ComponentRefDesPrefixes = {
     ic: 'U',
     '?': '?',
 };
-class ComponentAnnotater {
-    counter = {};
-    existingRefDes = [];
-    constructor() {
-        for (const key in ComponentRefDesPrefixes) {
-            this.counter[key] = 1;
-        }
-    }
-    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) {
-                ComponentRefDesPrefixes[type] = type;
-                this.counter[type] = 1;
-            }
-        }
-        if (ComponentRefDesPrefixes[type] === undefined) {
-            return null;
-        }
-        let attempts = 100;
-        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) {
-        this.existingRefDes.push(name);
-    }
-}
 export class VisitorExecutionException {
     errorMessage;
     context;

package/dist/types/BaseVisitor.d.ts

@@ -21,6 +21,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     printToConsole: boolean;
     acceptedDirections: Direction[];
     protected resultData: Map<ParserRuleContext, any>;
+    protected componentCtxLinks: Map<ParserRuleContext, ClassComponent>;
     pinTypesList: string[];
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
@@ -64,6 +65,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitArrayIndexExpr: (ctx: ArrayIndexExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
+    protected linkComponentToCtx(ctx: ParserRuleContext, instance: ClassComponent, creationFlag?: boolean): void;
+    getComponentCtxLinks(): Map<ParserRuleContext, ClassComponent>;
     visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): Promise<ImportFile>;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;

package/dist/types/ComponentAnnotater.d.ts

@@ -0,0 +1,16 @@
+import { ParserRuleContext } from 'antlr4ng';
+import { ClassComponent } from './objects/ClassComponent.js';
+export declare class ComponentAnnotater {
+    counter: {
+        [key: string]: number;
+    };
+    indexedContextPrefix: Map<ParserRuleContext, string>;
+    existingRefDes: string[];
+    constructor();
+    getAnnotation(instance: ClassComponent): string | null;
+    getNextRefdesCounter(prefix: string, startingIndex: number): {
+        index: number;
+        proposedName: string;
+    };
+    trackRefDes(name: string): void;
+}

package/dist/types/RefdesAnnotationVisitor.d.ts

@@ -0,0 +1,35 @@
+import { ParserRuleContext, CommonTokenStream } from 'antlr4ng';
+import { Add_component_exprContext, At_block_headerContext, At_blockContext, At_component_exprContext, Component_select_exprContext, Frame_exprContext, Function_def_exprContext, Function_return_exprContext, ScriptContext, To_component_exprContext } from './antlr/CircuitScriptParser.js';
+import { BaseVisitor } from './BaseVisitor.js';
+import { ClassComponent } from './objects/ClassComponent.js';
+export declare class RefdesAnnotationVisitor extends BaseVisitor {
+    private sourceText;
+    private tokenStream;
+    private modifications;
+    resultText: string;
+    debug: boolean;
+    componentCtxLinks: Map<ParserRuleContext, ClassComponent>;
+    constructor(silent: boolean, sourceText: string, tokenStream: CommonTokenStream, componentCtxLinks: Map<ParserRuleContext, ClassComponent>);
+    private getOriginalText;
+    visitScript: (ctx: ScriptContext) => Promise<void>;
+    visitAdd_component_expr: (ctx: Add_component_exprContext) => void;
+    visitAt_component_expr: (ctx: At_component_exprContext) => void;
+    visitComponent_select_expr: (ctx: Component_select_exprContext) => void;
+    visitAt_block_header: (ctx: At_block_headerContext) => void;
+    visitAt_block: (ctx: At_blockContext) => void;
+    visitTo_component_expr: (ctx: To_component_exprContext) => void;
+    visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
+    visitFunction_return_expr: (ctx: Function_return_exprContext) => void;
+    visitFrame_expr: (ctx: Frame_exprContext) => void;
+    visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    visitParameters: (ctx: ParametersContext) => void;
+    addedRefdesAnnotations: string[];
+    private generateRefdesAnnotationComment;
+    private addRefdesAnnotationComment;
+    getOutput(): string;
+    private generateModifiedText;
+    private buildContextTokenRanges;
+    private findContextForToken;
+    private markTokensAsProcessed;
+    private log;
+}

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

@@ -51,20 +51,21 @@ export declare class CircuitScriptLexer extends antlr.Lexer {
     static readonly DivideAssign = 49;
     static readonly MultiplyAssign = 50;
     static readonly ModulusAssign = 51;
-    static readonly OPEN_PAREN = 52;
-    static readonly CLOSE_PAREN = 53;
-    static readonly NOT_CONNECTED = 54;
-    static readonly BOOLEAN_VALUE = 55;
-    static readonly ID = 56;
-    static readonly INTEGER_VALUE = 57;
-    static readonly DECIMAL_VALUE = 58;
-    static readonly NUMERIC_VALUE = 59;
-    static readonly STRING_VALUE = 60;
-    static readonly PERCENTAGE_VALUE = 61;
-    static readonly ALPHA_NUMERIC = 62;
-    static readonly WS = 63;
-    static readonly NEWLINE = 64;
-    static readonly COMMENT = 65;
+    static readonly ANNOTATION_START = 52;
+    static readonly OPEN_PAREN = 53;
+    static readonly CLOSE_PAREN = 54;
+    static readonly NOT_CONNECTED = 55;
+    static readonly BOOLEAN_VALUE = 56;
+    static readonly ID = 57;
+    static readonly INTEGER_VALUE = 58;
+    static readonly DECIMAL_VALUE = 59;
+    static readonly NUMERIC_VALUE = 60;
+    static readonly STRING_VALUE = 61;
+    static readonly PERCENTAGE_VALUE = 62;
+    static readonly ALPHA_NUMERIC = 63;
+    static readonly WS = 64;
+    static readonly NEWLINE = 65;
+    static readonly COMMENT = 66;
     static readonly channelNames: string[];
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];

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

@@ -53,22 +53,23 @@ export declare class CircuitScriptParser extends antlr.Parser {
     static readonly DivideAssign = 49;
     static readonly MultiplyAssign = 50;
     static readonly ModulusAssign = 51;
-    static readonly OPEN_PAREN = 52;
-    static readonly CLOSE_PAREN = 53;
-    static readonly NOT_CONNECTED = 54;
-    static readonly BOOLEAN_VALUE = 55;
-    static readonly ID = 56;
-    static readonly INTEGER_VALUE = 57;
-    static readonly DECIMAL_VALUE = 58;
-    static readonly NUMERIC_VALUE = 59;
-    static readonly STRING_VALUE = 60;
-    static readonly PERCENTAGE_VALUE = 61;
-    static readonly ALPHA_NUMERIC = 62;
-    static readonly WS = 63;
-    static readonly NEWLINE = 64;
-    static readonly COMMENT = 65;
-    static readonly INDENT = 66;
-    static readonly DEDENT = 67;
+    static readonly ANNOTATION_START = 52;
+    static readonly OPEN_PAREN = 53;
+    static readonly CLOSE_PAREN = 54;
+    static readonly NOT_CONNECTED = 55;
+    static readonly BOOLEAN_VALUE = 56;
+    static readonly ID = 57;
+    static readonly INTEGER_VALUE = 58;
+    static readonly DECIMAL_VALUE = 59;
+    static readonly NUMERIC_VALUE = 60;
+    static readonly STRING_VALUE = 61;
+    static readonly PERCENTAGE_VALUE = 62;
+    static readonly ALPHA_NUMERIC = 63;
+    static readonly WS = 64;
+    static readonly NEWLINE = 65;
+    static readonly COMMENT = 66;
+    static readonly INDENT = 67;
+    static readonly DEDENT = 68;
     static readonly RULE_script = 0;
     static readonly RULE_expression = 1;
     static readonly RULE_flow_expressions = 2;
@@ -91,49 +92,51 @@ export declare class CircuitScriptParser extends antlr.Parser {
     static readonly RULE_at_to_multiple_line_expr_to_pin = 19;
     static readonly RULE_at_block = 20;
     static readonly RULE_at_block_expressions = 21;
-    static readonly RULE_at_block_pin_expr = 22;
-    static readonly RULE_at_block_pin_expression_simple = 23;
-    static readonly RULE_at_block_pin_expression_complex = 24;
-    static readonly RULE_assignment_expr = 25;
-    static readonly RULE_operator_assignment_expr = 26;
-    static readonly RULE_keyword_assignment_expr = 27;
-    static readonly RULE_parameters = 28;
-    static readonly RULE_property_set_expr = 29;
-    static readonly RULE_double_dot_property_set_expr = 30;
-    static readonly RULE_data_expr = 31;
-    static readonly RULE_binary_operator = 32;
-    static readonly RULE_unary_operator = 33;
-    static readonly RULE_value_expr = 34;
-    static readonly RULE_function_def_expr = 35;
-    static readonly RULE_function_expr = 36;
-    static readonly RULE_function_args_expr = 37;
-    static readonly RULE_atom_expr = 38;
-    static readonly RULE_trailer_expr = 39;
-    static readonly RULE_trailer_expr2 = 40;
-    static readonly RULE_function_call_expr = 41;
-    static readonly RULE_net_namespace_expr = 42;
-    static readonly RULE_function_return_expr = 43;
-    static readonly RULE_property_block_expr = 44;
-    static readonly RULE_create_component_expr = 45;
-    static readonly RULE_graphic_expressions_block = 46;
-    static readonly RULE_create_graphic_expr = 47;
-    static readonly RULE_create_module_expr = 48;
-    static readonly RULE_nested_properties_inner = 49;
-    static readonly RULE_graphic_expr = 50;
-    static readonly RULE_property_expr = 51;
-    static readonly RULE_property_key_expr = 52;
-    static readonly RULE_property_value_expr = 53;
-    static readonly RULE_wire_atom_expr = 54;
-    static readonly RULE_wire_expr = 55;
-    static readonly RULE_array_expr = 56;
-    static readonly RULE_point_expr = 57;
-    static readonly RULE_import_expr = 58;
-    static readonly RULE_frame_expr = 59;
-    static readonly RULE_if_expr = 60;
-    static readonly RULE_if_inner_expr = 61;
-    static readonly RULE_else_expr = 62;
-    static readonly RULE_while_expr = 63;
-    static readonly RULE_for_expr = 64;
+    static readonly RULE_at_block_header = 22;
+    static readonly RULE_at_block_pin_expr = 23;
+    static readonly RULE_at_block_pin_expression_simple = 24;
+    static readonly RULE_at_block_pin_expression_complex = 25;
+    static readonly RULE_assignment_expr = 26;
+    static readonly RULE_operator_assignment_expr = 27;
+    static readonly RULE_keyword_assignment_expr = 28;
+    static readonly RULE_parameters = 29;
+    static readonly RULE_property_set_expr = 30;
+    static readonly RULE_double_dot_property_set_expr = 31;
+    static readonly RULE_data_expr = 32;
+    static readonly RULE_binary_operator = 33;
+    static readonly RULE_unary_operator = 34;
+    static readonly RULE_value_expr = 35;
+    static readonly RULE_function_def_expr = 36;
+    static readonly RULE_function_expr = 37;
+    static readonly RULE_function_args_expr = 38;
+    static readonly RULE_atom_expr = 39;
+    static readonly RULE_trailer_expr = 40;
+    static readonly RULE_trailer_expr2 = 41;
+    static readonly RULE_function_call_expr = 42;
+    static readonly RULE_net_namespace_expr = 43;
+    static readonly RULE_function_return_expr = 44;
+    static readonly RULE_property_block_expr = 45;
+    static readonly RULE_create_component_expr = 46;
+    static readonly RULE_graphic_expressions_block = 47;
+    static readonly RULE_create_graphic_expr = 48;
+    static readonly RULE_create_module_expr = 49;
+    static readonly RULE_nested_properties_inner = 50;
+    static readonly RULE_graphic_expr = 51;
+    static readonly RULE_property_expr = 52;
+    static readonly RULE_property_key_expr = 53;
+    static readonly RULE_property_value_expr = 54;
+    static readonly RULE_wire_atom_expr = 55;
+    static readonly RULE_wire_expr = 56;
+    static readonly RULE_array_expr = 57;
+    static readonly RULE_point_expr = 58;
+    static readonly RULE_import_expr = 59;
+    static readonly RULE_frame_expr = 60;
+    static readonly RULE_if_expr = 61;
+    static readonly RULE_if_inner_expr = 62;
+    static readonly RULE_else_expr = 63;
+    static readonly RULE_while_expr = 64;
+    static readonly RULE_for_expr = 65;
+    static readonly RULE_annotation_comment_expr = 66;
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -166,6 +169,7 @@ export declare class CircuitScriptParser extends antlr.Parser {
     at_to_multiple_line_expr_to_pin(): At_to_multiple_line_expr_to_pinContext;
     at_block(): At_blockContext;
     at_block_expressions(): At_block_expressionsContext;
+    at_block_header(): At_block_headerContext;
     at_block_pin_expr(): At_block_pin_exprContext;
     at_block_pin_expression_simple(): At_block_pin_expression_simpleContext;
     at_block_pin_expression_complex(): At_block_pin_expression_complexContext;
@@ -210,6 +214,7 @@ export declare class CircuitScriptParser extends antlr.Parser {
     else_expr(): Else_exprContext;
     while_expr(): While_exprContext;
     for_expr(): For_exprContext;
+    annotation_comment_expr(): Annotation_comment_exprContext;
     sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean;
     private data_expr_sempred;
     static readonly _serializedATN: number[];
@@ -245,6 +250,7 @@ export declare class ExpressionContext extends antlr.ParserRuleContext {
     atom_expr(): Atom_exprContext | null;
     frame_expr(): Frame_exprContext | null;
     flow_expressions(): Flow_expressionsContext | null;
+    annotation_comment_expr(): Annotation_comment_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -411,7 +417,7 @@ export declare class At_to_multiple_line_expr_to_pinContext extends antlr.Parser
 }
 export declare class At_blockContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    at_component_expr(): At_component_exprContext;
+    at_block_header(): At_block_headerContext;
     NEWLINE(): antlr.TerminalNode[];
     NEWLINE(i: number): antlr.TerminalNode | null;
     INDENT(): antlr.TerminalNode;
@@ -428,6 +434,13 @@ export declare class At_block_expressionsContext extends antlr.ParserRuleContext
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
+export declare class At_block_headerContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    at_component_expr(): At_component_exprContext;
+    annotation_comment_expr(): Annotation_comment_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
 export declare class At_block_pin_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     pin_select_expr2(): Pin_select_expr2Context;
@@ -914,3 +927,10 @@ export declare class For_exprContext extends antlr.ParserRuleContext {
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
+export declare class Annotation_comment_exprContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ANNOTATION_START(): antlr.TerminalNode;
+    ID(): antlr.TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}

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

@@ -21,6 +21,7 @@ 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_headerContext } 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";
@@ -77,6 +78,7 @@ import { If_inner_exprContext } from "./CircuitScriptParser.js";
 import { Else_exprContext } from "./CircuitScriptParser.js";
 import { While_exprContext } from "./CircuitScriptParser.js";
 import { For_exprContext } from "./CircuitScriptParser.js";
+import { Annotation_comment_exprContext } from "./CircuitScriptParser.js";
 export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<Result> {
     visitScript?: (ctx: ScriptContext) => Result;
     visitExpression?: (ctx: ExpressionContext) => Result;
@@ -100,6 +102,7 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitAt_to_multiple_line_expr_to_pin?: (ctx: At_to_multiple_line_expr_to_pinContext) => Result;
     visitAt_block?: (ctx: At_blockContext) => Result;
     visitAt_block_expressions?: (ctx: At_block_expressionsContext) => Result;
+    visitAt_block_header?: (ctx: At_block_headerContext) => Result;
     visitAt_block_pin_expr?: (ctx: At_block_pin_exprContext) => Result;
     visitAt_block_pin_expression_simple?: (ctx: At_block_pin_expression_simpleContext) => Result;
     visitAt_block_pin_expression_complex?: (ctx: At_block_pin_expression_complexContext) => Result;
@@ -156,4 +159,5 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitElse_expr?: (ctx: Else_exprContext) => Result;
     visitWhile_expr?: (ctx: While_exprContext) => Result;
     visitFor_expr?: (ctx: For_exprContext) => Result;
+    visitAnnotation_comment_expr?: (ctx: Annotation_comment_exprContext) => Result;
 }

package/dist/types/environment.d.ts

@@ -9,6 +9,7 @@ export declare class NodeScriptEnvironment {
     protected useModuleDirectoryPath: string | null;
     protected useDefaultLibsPath: string | null;
     protected globalCreateSVGWindow: (() => SVGWindow) | null;
+    private cachedVersion;
     protected supportedFonts: {
         Arial: string;
     };