circuitscript 0.1.12 → 0.1.14

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -25,8 +25,6 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_block_pin_expr;
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
-    visitBreak_keyword;
-    visitContinue_keyword;
     visitAssignment_expr;
     visitOperator_assignment_expr;
     visitKeyword_assignment_expr;

package/dist/esm/builtinMethods.js

@@ -1,6 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { prepareValue, resolveToNumericValue } from "./utils.js";
+import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -16,8 +16,7 @@ export function linkBuiltInMethods(context, visitor) {
     context.createFunction('print', (params) => {
         const args = getPositionParams(params);
         const items = args.map(item => {
-            const value = prepareValue(item);
-            return toString(value);
+            return toString(unwrapValue(item));
         });
         if (visitor.printToConsole) {
             console.log('::', ...items);
@@ -78,7 +77,7 @@ function toMils(value) {
     return resolveToNumericValue(bigValue);
 }
 function objectLength(obj) {
-    obj = prepareValue(obj);
+    obj = unwrapValue(obj);
     if (Array.isArray(obj)) {
         return numeric(obj.length);
     }
@@ -109,6 +108,9 @@ function arrayGet(arrayObject, index) {
     else {
         useValue = index;
     }
+    if (isNaN(useValue)) {
+        throw new RuntimeExecutionError("Invalid index for arrayGet");
+    }
     return arrayObject[useValue];
 }
 function arraySet(arrayObject, index, setValue) {

package/dist/esm/execute.js

@@ -4,7 +4,7 @@ import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './obj
 import { Net } from './objects/Net.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { PortSide } from './objects/PinDefinition.js';
-import { DeclaredReference, Direction } from './objects/types.js';
+import { AnyReference, DeclaredReference, Direction } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './layout.js';
@@ -28,17 +28,17 @@ export class ExecutionContext {
     parentContext;
     componentAngleFollowsWire = true;
     warnings = [];
-    constructor(name, namespace, netNamespace, executionLevel = 0, indentLevel = 0, silent = false, logger, warnings, parent) {
+    constructor(name, namespace, netNamespace, executionLevel = 0, scopeLevel = 0, silent = false, logger, warnings, parent) {
         this.name = name;
         this.namespace = namespace;
         this.netNamespace = netNamespace;
         this.executionLevel = executionLevel;
         this.logger = logger;
         this.scope = ExecutionScope.create();
-        this.scope.indentLevel = indentLevel;
+        this.scope.scopeLevel = scopeLevel;
         this.setupRoot();
         this.silent = silent;
-        this.log('create new execution context', this.namespace, this.name, this.scope.indentLevel);
+        this.log('create new execution context', this.namespace, this.name, this.scope.scopeLevel);
         this.parentContext = parent;
         this.warnings = warnings;
     }
@@ -50,8 +50,8 @@ export class ExecutionContext {
         });
     }
     log(...params) {
-        const indentOutput = ''.padStart(this.scope.indentLevel * 4, '    ');
-        const indentLevelText = this.scope.indentLevel
+        const indentOutput = ''.padStart(this.scope.scopeLevel * 4, '    ');
+        const indentLevelText = this.scope.scopeLevel
             .toString()
             .padStart(3, ' ');
         const args = ['[' + indentLevelText + ']', indentOutput, ...params];
@@ -403,7 +403,7 @@ export class ExecutionContext {
             this.addPoint(`${Delimiter1}${key}.${this.name}.${this.tmpPointId}`, false);
             this.tmpPointId += 1;
         }
-        this.scope.blockStack.set(this.scope.indentLevel, {
+        this.scope.blockStack.set(this.scope.scopeLevel, {
             start_point: [
                 this.scope.currentComponent,
                 this.scope.currentPin,
@@ -416,8 +416,11 @@ export class ExecutionContext {
         });
         this.log('enter blocks');
     }
-    exitBlocks() {
-        const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
+    exitBlocks(scopeLevel = null) {
+        if (scopeLevel === null) {
+            scopeLevel = this.scope.scopeLevel;
+        }
+        const stackRef = this.scope.blockStack.get(scopeLevel);
         const { type: blockType } = stackRef;
         if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
             const { end_point: finalPoint } = stackRef;
@@ -434,16 +437,18 @@ export class ExecutionContext {
             const { start_point: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
-        this.scope.blockStack.delete(this.scope.indentLevel);
+        this.scope.blockStack.delete(scopeLevel);
         this.log('exit blocks');
     }
-    closeAllBlocks() {
-        if (this.scope.blockStack.has(this.scope.indentLevel)) {
+    closeOpenPathBlocks() {
+        const scope = this.scope;
+        const scopeLevel = scope.scopeLevel;
+        if (scope.blockStack.has(scopeLevel)) {
             this.exitBlocks();
         }
     }
     enterBlock(blockIndex) {
-        const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
+        const stackRef = this.scope.blockStack.get(this.scope.scopeLevel);
         const { type: blockType } = stackRef;
         const blockTypeName = getBlockTypeString(blockType);
         stackRef.inner_blocks.set(blockIndex, {
@@ -459,10 +464,10 @@ export class ExecutionContext {
             this.atComponent(component, pin, { addSequence: true });
         }
         this.log(`enter inner block of type (${blockTypeName}) >>>`);
-        this.scope.indentLevel += 1;
+        this.scope.scopeLevel += 1;
     }
     exitBlock(blockIndex) {
-        const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1);
+        const stackRef = this.scope.blockStack.get(this.scope.scopeLevel - 1);
         const { type: blockType } = stackRef;
         const blockIndexRef = stackRef.inner_blocks.get(blockIndex);
         blockIndexRef.last_net = [
@@ -470,7 +475,7 @@ export class ExecutionContext {
             this.scope.currentPin,
             this.scope.currentWireId
         ];
-        this.scope.indentLevel -= 1;
+        this.scope.scopeLevel -= 1;
         this.log('exit inner block <<<');
         if (blockType === BlockTypes.Branch) {
             const { start_point: [component, pin, wireId] } = stackRef;
@@ -511,8 +516,8 @@ export class ExecutionContext {
     }
     getPointBlockLocation() {
         this.log('get block point');
-        for (let i = 0; i < this.scope.indentLevel; i++) {
-            const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1 - i);
+        for (let i = 0; i < this.scope.scopeLevel; i++) {
+            const stackRef = this.scope.blockStack.get(this.scope.scopeLevel - 1 - i);
             const { start_point } = stackRef;
             const component = start_point[0];
             if (component.instanceName.startsWith(`${Delimiter1}point.`)) {
@@ -562,38 +567,18 @@ export class ExecutionContext {
                 if (isVariable || isComponentInstance) {
                     const scopeList = isVariable ? context.scope.variables
                         : context.scope.instances;
-                    let parentValue = undefined;
-                    let useValue = scopeList.get(idName);
-                    if (trailers.length > 0) {
-                        parentValue = useValue;
-                        const trailersPath = trailers.join(".");
-                        if (!isComponentInstance && (parentValue instanceof ClassComponent)) {
-                            isComponentInstance = true;
-                            isVariable = false;
-                        }
-                        if (isVariable) {
-                            useValue = parentValue[trailersPath];
-                        }
-                        else if (isComponentInstance) {
-                            const tmpComponent = parentValue;
-                            if (tmpComponent.typeProp === ComponentTypes.net) {
-                                const usedNet = this.scope.getNet(tmpComponent, 1);
-                                if (usedNet) {
-                                    const trailerValue = trailers.join(".");
-                                    useValue = usedNet.params.get(trailerValue) ?? null;
-                                }
-                            }
-                            else {
-                                useValue = parentValue.parameters.get(trailersPath);
-                            }
-                        }
+                    const useValue = scopeList.get(idName);
+                    if (!isComponentInstance && (useValue instanceof ClassComponent)) {
+                        isComponentInstance = true;
+                        isVariable = false;
                     }
+                    const tmpReference = this.resolveTrailers(isVariable ? ReferenceTypes.variable : ReferenceTypes.instance, useValue, trailers);
                     return new DeclaredReference({
                         type: isVariable ? ReferenceTypes.variable
                             : ReferenceTypes.instance,
-                        found: (useValue !== undefined),
-                        parentValue,
-                        value: useValue,
+                        found: (tmpReference.value !== undefined),
+                        parentValue: tmpReference.parentValue,
+                        value: tmpReference.value,
                         name: idName,
                         trailers,
                     });
@@ -605,6 +590,37 @@ export class ExecutionContext {
             name: idName,
         });
     }
+    resolveTrailers(type, item, trailers = []) {
+        let parentValue;
+        let useValue = item;
+        if (trailers.length > 0) {
+            parentValue = useValue;
+            const trailersPath = trailers.join(".");
+            if (type === ReferenceTypes.variable) {
+                useValue = parentValue[trailersPath];
+            }
+            else if (type === ReferenceTypes.instance) {
+                const tmpComponent = parentValue;
+                if (tmpComponent.typeProp === ComponentTypes.net) {
+                    const usedNet = this.scope.getNet(tmpComponent, 1);
+                    if (usedNet) {
+                        const trailerValue = trailers.join(".");
+                        useValue = usedNet.params.get(trailerValue) ?? null;
+                    }
+                }
+                else {
+                    useValue = parentValue.parameters.get(trailersPath);
+                }
+            }
+        }
+        return new AnyReference({
+            found: true,
+            type: type,
+            parentValue,
+            trailers,
+            value: useValue,
+        });
+    }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
         if (this.__functionCache[functionName] === undefined) {

package/dist/esm/helpers.js

@@ -184,14 +184,6 @@ export async function renderScript(scriptData, outputPath, options) {
     };
     visitor.log('reading file');
     visitor.log('done reading file');
-    const { tree, parser, parserTimeTaken, lexerTimeTaken } = await parseFileWithVisitor(visitor, scriptData);
-    printWarnings(visitor.getWarnings());
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    if (dumpNets) {
-        const nets = visitor.dumpNets();
-        nets.forEach(item => console.log(item.join(" | ")));
-    }
     const dumpDirectory = environment.getRelativeToModule('/dump/');
     if (dumpData) {
         console.log('Dump data to:', dumpDirectory);
@@ -199,8 +191,19 @@ export async function renderScript(scriptData, outputPath, options) {
             mkdirSync(dumpDirectory);
         }
     }
+    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
+    printWarnings(visitor.getWarnings());
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    if (dumpNets) {
+        const nets = visitor.dumpNets();
+        nets.forEach(item => console.log(item.join(" | ")));
+    }
     dumpData && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
     dumpData && writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    if (throwError) {
+        throw throwError;
+    }
     let svgOutput = "";
     if (errors.length === 0) {
         const { frameComponent } = visitor.applySheetFrameComponent();

package/dist/esm/objects/ExecutionScope.js

@@ -12,7 +12,7 @@ export class ExecutionScope {
     breakStack = [];
     wires = [];
     frames = [];
-    indentLevel = 0;
+    scopeLevel = 0;
     netCounter = 1;
     unnamedCounter = 1;
     currentComponent = null;

package/dist/esm/parser.js

@@ -18,6 +18,7 @@ export async function parseFileWithVisitor(visitor, data) {
     parser.removeErrorListeners();
     parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
+    let throwError;
     try {
         await visitor.visitAsync(tree);
     }
@@ -27,7 +28,7 @@ export async function parseFileWithVisitor(visitor, data) {
                 visitor.onErrorHandler(error.message, null, error);
             }
             else {
-                throw error;
+                throwError = error;
             }
         }
     }
@@ -38,6 +39,7 @@ export async function parseFileWithVisitor(visitor, data) {
         hasError: false,
         parserTimeTaken,
         lexerTimeTaken,
+        throwError
     };
 }
 export class CircuitscriptParserErrorListener {

package/dist/esm/utils.js

@@ -326,7 +326,7 @@ export function printWarnings(warnings) {
         console.log(`Warning: ${message}`);
     });
 }
-export function prepareValue(value) {
+export function unwrapValue(value) {
     if (isReference(value)) {
         return value.value;
     }

package/dist/esm/visitor.js

@@ -4,7 +4,7 @@ import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
-import { prepareValue } from "./utils.js";
+import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
@@ -99,17 +99,17 @@ export class ParserVisitor extends BaseVisitor {
         }
         const scope = this.getScope();
         const executor = this.getExecutor();
-        const indentLevel = scope.indentLevel;
-        if (scope.blockStack.has(indentLevel)) {
-            const blockStackEntry = scope.blockStack.get(indentLevel);
+        const scopeLevel = scope.scopeLevel;
+        if (scope.blockStack.has(scopeLevel)) {
+            const blockStackEntry = scope.blockStack.get(scopeLevel);
             if (blockStackEntry.type !== blockType) {
                 executor.exitBlocks();
             }
         }
-        if (!scope.blockStack.has(indentLevel)) {
+        if (!scope.blockStack.has(scopeLevel)) {
             executor.enterBlocks(blockType);
         }
-        const blockStackEntry = scope.blockStack.get(indentLevel);
+        const blockStackEntry = scope.blockStack.get(scopeLevel);
         const { current_index } = blockStackEntry;
         executor.enterBlock(current_index);
         this.visit(ctx.expressions_block());
@@ -117,12 +117,9 @@ export class ParserVisitor extends BaseVisitor {
         blockStackEntry.current_index++;
     };
     visitGraph_expressions = (ctx) => {
+        this.getExecutor().log('graph expressions', this.getScope().scopeLevel);
         if (ctx.path_block() === null) {
-            const scope = this.getScope();
-            const indentLevel = scope.indentLevel;
-            if (scope.blockStack.has(indentLevel)) {
-                this.getExecutor().exitBlocks();
-            }
+            this.getExecutor().closeOpenPathBlocks();
         }
         const ctxPathBlock = ctx.path_block();
         const ctxNotPathBlock = ctx.graph_linear_expression();
@@ -401,7 +398,7 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitGraphicForExpr = (ctx) => {
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = prepareValue(this.visitResult(ctx.data_expr()));
+        const listItems = unwrapValue(this.visitResult(ctx.data_expr()));
         let keepLooping = true;
         let counter = 0;
         let allCommands = [];
@@ -543,7 +540,7 @@ export class ParserVisitor extends BaseVisitor {
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
             component = this.visitResult(ctxDataExpr);
-            component = prepareValue(component);
+            component = unwrapValue(component);
             componentCtx = ctxDataExpr;
             if (component === null || component === undefined) {
                 this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
@@ -863,9 +860,10 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitAt_block_pin_expr = (ctx) => {
-        const atPin = this.visitResult(ctx.pin_select_expr2());
         const executor = this.getExecutor();
         const [currentComponent, currentPin] = executor.getCurrentPoint();
+        executor.closeOpenPathBlocks();
+        const atPin = this.visitResult(ctx.pin_select_expr2());
         executor.atComponent(currentComponent, atPin, {
             addSequence: true
         });
@@ -886,11 +884,11 @@ export class ParserVisitor extends BaseVisitor {
         executor.log('entering at block');
         this.visit(ctx.at_component_expr());
         const [currentComponent, currentPin] = executor.getCurrentPoint();
-        executor.scope.indentLevel += 1;
+        executor.scope.scopeLevel += 1;
         ctx.at_block_expressions().forEach(expression => {
             this.visit(expression);
         });
-        executor.scope.indentLevel -= 1;
+        executor.scope.scopeLevel -= 1;
         executor.scope.setCurrent(currentComponent, currentPin);
         executor.log('leaving at block');
     };
@@ -1074,7 +1072,7 @@ export class ParserVisitor extends BaseVisitor {
         this.log('in for loop');
         const forVariableNames = ctx.ID().map(item => item.getText());
         let listItems = this.visitResult(ctx.data_expr());
-        listItems = prepareValue(listItems);
+        listItems = unwrapValue(listItems);
         this.getExecutor().addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, Break_keywordContext, Continue_keywordContext, ExpressionContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
+import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -20,7 +20,6 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     printToConsole: boolean;
     acceptedDirections: Direction[];
     protected resultData: Map<ParserRuleContext, any>;
-    protected paramData: Map<ParserRuleContext, any>;
     pinTypesList: string[];
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
@@ -50,14 +49,14 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    private handleFunctionCall;
     visitValue_expr: (ctx: Value_exprContext) => void;
     visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
     visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
     visitParameters: (ctx: ParametersContext) => void;
     visitImport_expr: (ctx: Import_exprContext) => void;
     visitFunction_return_expr: (ctx: Function_return_exprContext) => void;
-    visitBreak_keyword: (ctx: Break_keywordContext) => void;
-    visitContinue_keyword: (ctx: Continue_keywordContext) => void;
+    visitFlow_expressions: (ctx: Flow_expressionsContext) => void;
     visitArray_expr: (ctx: Array_exprContext) => void;
     visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;

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

@@ -94,47 +94,45 @@ export declare class CircuitScriptParser extends antlr.Parser {
     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_break_keyword = 25;
-    static readonly RULE_continue_keyword = 26;
-    static readonly RULE_assignment_expr = 27;
-    static readonly RULE_operator_assignment_expr = 28;
-    static readonly RULE_keyword_assignment_expr = 29;
-    static readonly RULE_parameters = 30;
-    static readonly RULE_property_set_expr = 31;
-    static readonly RULE_double_dot_property_set_expr = 32;
-    static readonly RULE_data_expr = 33;
-    static readonly RULE_binary_operator = 34;
-    static readonly RULE_unary_operator = 35;
-    static readonly RULE_value_expr = 36;
-    static readonly RULE_function_def_expr = 37;
-    static readonly RULE_function_expr = 38;
-    static readonly RULE_function_args_expr = 39;
-    static readonly RULE_atom_expr = 40;
-    static readonly RULE_trailer_expr = 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_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_function_call_expr = 40;
+    static readonly RULE_net_namespace_expr = 41;
+    static readonly RULE_function_return_expr = 42;
+    static readonly RULE_property_block_expr = 43;
+    static readonly RULE_create_component_expr = 44;
+    static readonly RULE_graphic_expressions_block = 45;
+    static readonly RULE_create_graphic_expr = 46;
+    static readonly RULE_create_module_expr = 47;
+    static readonly RULE_nested_properties_inner = 48;
+    static readonly RULE_graphic_expr = 49;
+    static readonly RULE_property_expr = 50;
+    static readonly RULE_property_key_expr = 51;
+    static readonly RULE_property_value_expr = 52;
+    static readonly RULE_wire_atom_expr = 53;
+    static readonly RULE_wire_expr = 54;
+    static readonly RULE_array_expr = 55;
+    static readonly RULE_point_expr = 56;
+    static readonly RULE_import_expr = 57;
+    static readonly RULE_frame_expr = 58;
+    static readonly RULE_if_expr = 59;
+    static readonly RULE_if_inner_expr = 60;
+    static readonly RULE_else_expr = 61;
+    static readonly RULE_while_expr = 62;
+    static readonly RULE_for_expr = 63;
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -170,8 +168,6 @@ export declare class CircuitScriptParser extends antlr.Parser {
     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;
-    break_keyword(): Break_keywordContext;
-    continue_keyword(): Continue_keywordContext;
     assignment_expr(): Assignment_exprContext;
     operator_assignment_expr(): Operator_assignment_exprContext;
     keyword_assignment_expr(): Keyword_assignment_exprContext;
@@ -236,7 +232,6 @@ export declare class ScriptContext extends antlr.ParserRuleContext {
 export declare class ExpressionContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     graph_expressions(): Graph_expressionsContext | null;
-    flow_expressions(): Flow_expressionsContext | null;
     assignment_expr(): Assignment_exprContext | null;
     operator_assignment_expr(): Operator_assignment_exprContext | null;
     property_set_expr(): Property_set_exprContext | null;
@@ -247,6 +242,7 @@ export declare class ExpressionContext extends antlr.ParserRuleContext {
     import_expr(): Import_exprContext | null;
     atom_expr(): Atom_exprContext | null;
     frame_expr(): Frame_exprContext | null;
+    flow_expressions(): Flow_expressionsContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -255,8 +251,8 @@ export declare class Flow_expressionsContext extends antlr.ParserRuleContext {
     if_expr(): If_exprContext | null;
     while_expr(): While_exprContext | null;
     for_expr(): For_exprContext | null;
-    break_keyword(): Break_keywordContext | null;
-    continue_keyword(): Continue_keywordContext | null;
+    Break(): antlr.TerminalNode | null;
+    Continue(): antlr.TerminalNode | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -451,18 +447,6 @@ export declare class At_block_pin_expression_complexContext extends antlr.Parser
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
-export declare class Break_keywordContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    Break(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
-export declare class Continue_keywordContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    Continue(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
 export declare class Assignment_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     data_expr(): Data_exprContext;

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

@@ -24,8 +24,6 @@ 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 { Continue_keywordContext } from "./CircuitScriptParser.js";
 import { Assignment_exprContext } from "./CircuitScriptParser.js";
 import { Operator_assignment_exprContext } from "./CircuitScriptParser.js";
 import { Keyword_assignment_exprContext } from "./CircuitScriptParser.js";
@@ -103,8 +101,6 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     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;
-    visitBreak_keyword?: (ctx: Break_keywordContext) => Result;
-    visitContinue_keyword?: (ctx: Continue_keywordContext) => Result;
     visitAssignment_expr?: (ctx: Assignment_exprContext) => Result;
     visitOperator_assignment_expr?: (ctx: Operator_assignment_exprContext) => Result;
     visitKeyword_assignment_expr?: (ctx: Keyword_assignment_exprContext) => Result;