circuitscript 0.1.15 → 0.1.16

package/dist/esm/layout.js

@@ -1,21 +1,20 @@
-import graphlib, { Graph } from '@dagrejs/graphlib';
+import graphlib from '@dagrejs/graphlib';
 const { alg } = graphlib;
-import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
-import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
+import { SymbolCustom, SymbolDrawing, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
+import { defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
-import { Logger } from './logger.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
 import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
 import { Direction } from './objects/types.js';
 import { milsToMM, UnitDimension } from './helpers.js';
-import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { numeric } from './objects/ParamDefinition.js';
+import { generateLayoutPinDefinition, getWireName, RenderItemType } from './graph.js';
 export class LayoutEngine {
     logger;
     layoutWarnings = [];
     showBaseFrame = false;
-    constructor(options = { showBaseFrame: false }) {
-        this.logger = new Logger();
+    constructor(logger, options = { showBaseFrame: false }) {
+        this.logger = logger;
         const { showBaseFrame = false } = options ?? {};
         this.showBaseFrame = showBaseFrame;
     }
@@ -29,30 +28,8 @@ export class LayoutEngine {
         const padding = ''.padStart(value * 4, ' ');
         return "[" + value + "]" + padding;
     }
-    runLayout(sequence, nets) {
-        const logNodesAndEdges = true;
+    runLayout(graph, containerFrames, nets) {
         const renderNets = this.collectRenderNets(nets);
-        this.print('===== creating graph and populating with nodes =====');
-        const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
-        this.print('===== done populating graph =====');
-        this.print('');
-        if (logNodesAndEdges) {
-            this.print('===== graph edges =====');
-            const allEdges = graph.edges();
-            allEdges.forEach(edge => {
-                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
-                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
-            });
-            this.print('===== end edges =====');
-            this.print();
-            this.print('===== graph nodes =====');
-            const nodes = graph.nodes();
-            nodes.forEach(node => {
-                this.print(`name:${node}, value:${graph.node(node)}`);
-            });
-            this.print('===== end nodes =====');
-            this.print('');
-        }
         const subgraphInfo = this.sizeSubGraphs(graph);
         const dumpSubgraphInfo = true;
         if (dumpSubgraphInfo) {
@@ -643,158 +620,6 @@ export class LayoutEngine {
             }
         }
     }
-    generateLayoutGraph(sequence, nets) {
-        let previousNode = null;
-        let previousPin = null;
-        const graph = new Graph({
-            directed: true,
-            compound: true,
-        });
-        this.print('sequence length:', sequence.length);
-        const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
-        const frameStack = [baseFrame];
-        const containerFrames = [baseFrame];
-        sequence.forEach((sequenceStep, index) => {
-            const action = sequenceStep[0];
-            let tmpComponent;
-            switch (action) {
-                case SequenceAction.To:
-                case SequenceAction.At: {
-                    this.print(...sequenceStep);
-                    const [, component, pin] = sequenceStep;
-                    const tmpInstanceName = component.instanceName;
-                    if (!graph.hasNode(tmpInstanceName)) {
-                        this.print('create instance', tmpInstanceName);
-                        const { displayProp = null } = component;
-                        let tmpSymbol;
-                        if (displayProp instanceof SymbolDrawing) {
-                            tmpSymbol = new SymbolPlaceholder(displayProp);
-                            tmpSymbol.drawing.logger = this.logger;
-                        }
-                        else {
-                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
-                            if (component.typeProp === ComponentTypes.module) {
-                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                            else {
-                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                        }
-                        applyComponentParamsToSymbol(component, tmpSymbol);
-                        tmpSymbol.refreshDrawing();
-                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
-                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
-                        tmpComponent.symbol = tmpSymbol;
-                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
-                        const currentFrame = frameStack[frameStack.length - 1];
-                        currentFrame && currentFrame.innerItems.push(tmpComponent);
-                    }
-                    if (action === SequenceAction.To && previousNode && previousPin) {
-                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
-                    }
-                    previousNode = tmpInstanceName;
-                    previousPin = pin;
-                    break;
-                }
-                case SequenceAction.Wire: {
-                    const [, wireId, wireSegments] = sequenceStep;
-                    let useNet;
-                    if (previousNode !== null) {
-                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
-                        if (prevNodeType === RenderItemType.Component) {
-                            const matchingItem = nets.find(([comp, pin]) => {
-                                return comp.instanceName === previousNode
-                                    && pin === previousPin;
-                            });
-                            if (matchingItem !== undefined) {
-                                useNet = matchingItem[2];
-                            }
-                        }
-                        else if (prevNodeType === RenderItemType.Wire) {
-                            useNet = prevNodeItem.net;
-                        }
-                    }
-                    const wire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments);
-                    wire.id = wireId;
-                    wire.netName = useNet.toString();
-                    const wireName = getWireName(wire.id);
-                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
-                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
-                    previousNode = wireName;
-                    previousPin = 1;
-                    const wireSegmentsInfo = wireSegments.map(item => {
-                        const tmp = {
-                            direction: item.direction,
-                            value: item.value,
-                        };
-                        if (item.valueXY) {
-                            tmp.valueXY = item.valueXY;
-                        }
-                        if (item.until) {
-                            tmp.until = [item.until[0].toString(), item.until[1]];
-                        }
-                        return tmp;
-                    });
-                    this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
-                    break;
-                }
-                case SequenceAction.WireJump: {
-                    this.print(...sequenceStep);
-                    const wireId = sequenceStep[1];
-                    const wireName = getWireName(wireId);
-                    let wirePin = 1;
-                    if (sequenceStep.length === 3) {
-                        wirePin = sequenceStep[2];
-                    }
-                    previousNode = wireName;
-                    previousPin = wirePin;
-                    break;
-                }
-                case SequenceAction.Frame: {
-                    const [, frameObject, frameAction] = sequenceStep;
-                    if (frameAction === FrameAction.Enter) {
-                        const prevFrame = frameStack[frameStack.length - 1];
-                        const newFrame = new RenderFrame(frameObject);
-                        if (frameObject.parameters.has(FrameParamKeys.Direction)) {
-                            newFrame.direction =
-                                frameObject.parameters.get(FrameParamKeys.Direction);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Padding)) {
-                            newFrame.padding = milsToMM(frameObject.parameters.get(FrameParamKeys.Padding));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Border)) {
-                            newFrame.borderWidth =
-                                frameObject.parameters.get(FrameParamKeys.Border);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Width)) {
-                            newFrame.width = milsToMM(frameObject.parameters.get(FrameParamKeys.Width));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Height)) {
-                            newFrame.height = milsToMM(frameObject.parameters.get(FrameParamKeys.Height));
-                        }
-                        containerFrames.push(newFrame);
-                        frameStack.push(newFrame);
-                        prevFrame && prevFrame.innerItems.push(newFrame);
-                    }
-                    else if (frameAction === FrameAction.Exit) {
-                        frameStack.pop();
-                    }
-                    break;
-                }
-            }
-        });
-        return {
-            graph,
-            containerFrames,
-        };
-    }
-    setGraphEdge(graph, node1, node2, edgeValue) {
-        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
-            this.print(`Warning: edge already exists ${node1} ${node2}`);
-        }
-        graph.setEdge(node1, node2, edgeValue);
-        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
-    }
     sizeSubGraphs(graph) {
         const subGraphs = alg.components(graph);
         const subGraphsStarts = [];
@@ -1092,52 +917,6 @@ function getNeighbours(graph, nodeIds) {
         return accum;
     }, []);
 }
-function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
-    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
-}
-function getWireName(wireId) {
-    return 'wire:' + wireId;
-}
-function generateLayoutPinDefinition(component) {
-    const pins = component.pins;
-    const symbolPinDefinitions = [];
-    const existingPinIds = Array.from(pins.keys());
-    const arrangeProps = component.arrangeProps ?? [];
-    const addedPins = [];
-    for (const [key, items] of arrangeProps) {
-        let useItems;
-        if (!Array.isArray(items)) {
-            useItems = [items];
-        }
-        else {
-            useItems = [...items];
-        }
-        useItems.forEach(pinId => {
-            if (pinId instanceof NumericValue) {
-                const pinIdValue = pinId.toNumber();
-                if (existingPinIds.indexOf(pinIdValue) !== -1) {
-                    const pin = pins.get(pinIdValue);
-                    symbolPinDefinitions.push({
-                        side: key,
-                        pinId: pinIdValue,
-                        text: pin.name,
-                        position: pin.position,
-                        pinType: pin.pinType,
-                    });
-                    addedPins.push(pinIdValue);
-                }
-            }
-        });
-    }
-    const unplacedPins = existingPinIds.filter(pinId => {
-        return addedPins.indexOf(pinId) === -1;
-    });
-    if (unplacedPins.length > 0) {
-        component._unplacedPins = unplacedPins;
-        console.warn("Warning: There are unplaced pins: " + unplacedPins);
-    }
-    return symbolPinDefinitions;
-}
 export function applyComponentParamsToSymbol(component, symbol) {
     const { widthProp = null, heightProp = null } = component;
     const newMap = new Map(component.parameters);
@@ -1523,8 +1302,3 @@ export function ExtractDrawingRects(drawing) {
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }
-var RenderItemType;
-(function (RenderItemType) {
-    RenderItemType["Wire"] = "wire";
-    RenderItemType["Component"] = "component";
-})(RenderItemType || (RenderItemType = {}));

package/dist/esm/objects/types.js

@@ -1,4 +1,21 @@
+import { ReferenceTypes } from '../globals.js';
 import { RuntimeExecutionError } from '../utils.js';
+export class CFunctionEntry {
+    name;
+    execute;
+    uniqueId;
+    source;
+    constructor(name, execute, source, uniqueId) {
+        this.name = name;
+        this.execute = execute;
+        this.uniqueId = uniqueId;
+        this.source = source;
+    }
+    toString() {
+        return `[Function: ${this.name}]`;
+    }
+}
+;
 export class AnyReference {
     found = false;
     name;
@@ -6,21 +23,27 @@ export class AnyReference {
     type;
     value;
     parentValue;
+    referenceName = 'AnyReference';
     constructor(refType) {
-        if (refType.value instanceof AnyReference) {
+        if (refType.value instanceof AnyReference
+            && refType.value.type !== ReferenceTypes.function) {
             throw new RuntimeExecutionError("Nested reference types!");
         }
         this.found = refType.found;
         this.name = refType.name;
         this.trailers = refType.trailers;
-        this.type = refType.type;
+        this.type = refType.type ?? ReferenceTypes.unknown;
         this.value = refType.value;
         this.parentValue = refType.parentValue;
     }
+    toString() {
+        return `[${this.referenceName} name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
+    }
 }
-export class UndeclaredReference {
+export class UndeclaredReference extends AnyReference {
     reference;
     constructor(reference) {
+        super(reference);
         this.reference = reference;
     }
     throwMessage() {
@@ -39,9 +62,7 @@ export class UndeclaredReference {
     }
 }
 export class DeclaredReference extends AnyReference {
-    toString() {
-        return `[DeclaredReference name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
-    }
+    referenceName = 'DeclaredReference';
     toDisplayString() {
         let returnValue = undefined;
         if (this.parentValue) {

package/dist/esm/visitor.js

@@ -2,7 +2,7 @@ import { ClassComponent } from './objects/ClassComponent.js';
 import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
@@ -376,7 +376,7 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxNestedProperties) {
             const nestedKeyValues = this.visitResult(ctxNestedProperties);
             nestedKeyValues.forEach((value, key) => {
-                parameters.push(['keyword', key, value]);
+                parameters.push(['keyword', key, unwrapValue(value)]);
             });
         }
         else {
@@ -534,36 +534,36 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitData_expr_with_assignment = (ctx) => {
-        let component = null;
-        let componentCtx = null;
+        let dataResult = null;
+        let componentCtx;
         const ctxDataExpr = ctx.data_expr();
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
-            component = this.visitResult(ctxDataExpr);
-            component = unwrapValue(component);
+            dataResult = this.visitResult(ctxDataExpr);
             componentCtx = ctxDataExpr;
-            if (component === null || component === undefined) {
-                this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
-            }
         }
         else if (ctxAssignmentExpr) {
-            component = this.visitResult(ctxAssignmentExpr);
+            dataResult = this.visitResult(ctxAssignmentExpr);
             componentCtx = ctxAssignmentExpr;
         }
-        if (component instanceof ClassComponent
-            && component.copyProp) {
-            component = this.getExecutor().copyComponent(component);
-        }
-        if (component instanceof UndeclaredReference) {
-            const { reference: { trailers = [], parentValue = null } } = component;
+        if (dataResult instanceof AnyReference) {
+            const { trailers = [], parentValue = null } = dataResult;
             if (parentValue instanceof ClassComponent
                 && trailers.length > 0
                 && trailers[0] === ModuleContainsKeyword) {
-                component = parentValue;
-                this.placeModuleContains(component);
+                dataResult = parentValue;
+                this.placeModuleContains(dataResult);
             }
         }
-        if (component && component instanceof ClassComponent) {
+        dataResult = unwrapValue(dataResult);
+        if (dataResult === null || dataResult === undefined) {
+            this.throwWithContext(componentCtx, "Could not find component: " + componentCtx.getText());
+        }
+        if (dataResult instanceof ClassComponent
+            && dataResult.copyProp) {
+            dataResult = this.getExecutor().copyComponent(dataResult);
+        }
+        if (dataResult && dataResult instanceof ClassComponent) {
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
                 const modifierText = modifier.ID(0).getText();
@@ -580,23 +580,23 @@ export class ParserVisitor extends BaseVisitor {
                 if (modifierText === ParamKeys.flip) {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
-                        component.setParam(ParamKeys.flipX, 1);
+                        dataResult.setParam(ParamKeys.flipX, 1);
                         shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
-                        component.setParam(ParamKeys.flipY, 1);
+                        dataResult.setParam(ParamKeys.flipY, 1);
                         shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === ParamKeys.angle) {
-                    component.setParam(ParamKeys.angle, result);
+                    dataResult.setParam(ParamKeys.angle, result);
                     shouldIgnoreWireOrientation = true;
                 }
                 else if (modifierText === 'anchor') {
-                    component.setParam('anchor', result);
+                    dataResult.setParam('anchor', result);
                 }
                 if (shouldIgnoreWireOrientation) {
-                    component.useWireOrientationAngle = false;
+                    dataResult.useWireOrientationAngle = false;
                 }
             });
         }
@@ -606,15 +606,15 @@ export class ParserVisitor extends BaseVisitor {
             pinValue = this.visitResult(ctxPinSelectExpr);
         }
         else {
-            if (component instanceof ClassComponent) {
-                pinValue = component.getDefaultPin();
+            if (dataResult instanceof ClassComponent) {
+                pinValue = dataResult.getDefaultPin();
             }
             else {
-                const undeclaredRef = component;
+                const undeclaredRef = dataResult;
                 this.throwWithContext(componentCtx, 'Invalid component: ' + undeclaredRef.reference.name);
             }
         }
-        this.setResult(ctx, [component, pinValue]);
+        this.setResult(ctx, [dataResult, pinValue]);
     };
     expandModuleContains(component, netNamespace) {
         this.getExecutor().log('expanding module `contains`');
@@ -794,8 +794,8 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitAdditionExpr = (ctx) => {
-        const value1 = this.resolveDataExpr(ctx.data_expr(0));
-        const value2 = this.resolveDataExpr(ctx.data_expr(1));
+        const value1 = unwrapValue(this.resolveDataExpr(ctx.data_expr(0)));
+        const value2 = unwrapValue(this.resolveDataExpr(ctx.data_expr(1)));
         if (ctx.Addition() && (typeof value1 === 'string' || typeof value2 === 'string')) {
             let tmpValue1 = value1;
             if (value1 instanceof NumericValue) {
@@ -824,6 +824,8 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
+        const uniqueFunctionID = '__._' + ctx.start.line + '_'
+            + ctx.start.column + '_' + functionName + '_' + ctx.getText();
         let funcDefinedParameters = [];
         const ctxFunctionArgsExpr = ctx.function_args_expr();
         if (ctxFunctionArgsExpr) {
@@ -845,7 +847,7 @@ export class ParserVisitor extends BaseVisitor {
             nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
             return [lastExecution, returnValue];
         };
-        this.getExecutor().createFunction(functionName, __runFunc);
+        this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
     };
     visitPin_select_expr2 = (ctx) => {
         const ctxStringValue = ctx.STRING_VALUE();

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-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 { Array_exprContext, ArrayExprContext, ArrayIndexExprContext, 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, Trailer_expr2Context, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -46,6 +46,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
     visitOperator_assignment_expr: (ctx: Operator_assignment_exprContext) => void;
     private getReference;
+    visitTrailer_expr2: (ctx: Trailer_expr2Context) => void;
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
@@ -59,6 +60,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitFlow_expressions: (ctx: Flow_expressionsContext) => void;
     visitArray_expr: (ctx: Array_exprContext) => void;
     visitArrayExpr: (ctx: ArrayExprContext) => void;
+    visitArrayIndexExpr: (ctx: ArrayIndexExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
     visitResult(ctx: ParserRuleContext): any;

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

@@ -109,30 +109,31 @@ export declare class CircuitScriptParser extends antlr.Parser {
     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 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 literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -184,6 +185,7 @@ export declare class CircuitScriptParser extends antlr.Parser {
     function_args_expr(): Function_args_exprContext;
     atom_expr(): Atom_exprContext;
     trailer_expr(): Trailer_exprContext;
+    trailer_expr2(): Trailer_expr2Context;
     function_call_expr(): Function_call_exprContext;
     net_namespace_expr(): Net_namespace_exprContext;
     function_return_expr(): Function_return_exprContext;
@@ -507,6 +509,12 @@ export declare class ArrayExprContext extends Data_exprContext {
     array_expr(): Array_exprContext;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
+export declare class ArrayIndexExprContext extends Data_exprContext {
+    constructor(ctx: Data_exprContext);
+    data_expr(): Data_exprContext[];
+    data_expr(i: number): Data_exprContext | null;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
 export declare class FunctionCallExprContext extends Data_exprContext {
     constructor(ctx: Data_exprContext);
     function_call_expr(): Function_call_exprContext;
@@ -634,8 +642,9 @@ export declare class Function_args_exprContext extends antlr.ParserRuleContext {
 }
 export declare class Atom_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    ID(): antlr.TerminalNode[];
-    ID(i: number): antlr.TerminalNode | null;
+    ID(): antlr.TerminalNode;
+    trailer_expr2(): Trailer_expr2Context[];
+    trailer_expr2(i: number): Trailer_expr2Context | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -644,7 +653,14 @@ export declare class Trailer_exprContext extends antlr.ParserRuleContext {
     OPEN_PAREN(): antlr.TerminalNode | null;
     CLOSE_PAREN(): antlr.TerminalNode | null;
     parameters(): ParametersContext | null;
+    trailer_expr2(): Trailer_expr2Context | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Trailer_expr2Context extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     ID(): antlr.TerminalNode | null;
+    data_expr(): Data_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }

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

@@ -31,6 +31,7 @@ import { ParametersContext } from "./CircuitScriptParser.js";
 import { Property_set_exprContext } from "./CircuitScriptParser.js";
 import { Double_dot_property_set_exprContext } from "./CircuitScriptParser.js";
 import { ArrayExprContext } from "./CircuitScriptParser.js";
+import { ArrayIndexExprContext } from "./CircuitScriptParser.js";
 import { FunctionCallExprContext } from "./CircuitScriptParser.js";
 import { AdditionExprContext } from "./CircuitScriptParser.js";
 import { MultiplyExprContext } from "./CircuitScriptParser.js";
@@ -48,6 +49,7 @@ 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 { Trailer_expr2Context } from "./CircuitScriptParser.js";
 import { Function_call_exprContext } from "./CircuitScriptParser.js";
 import { Net_namespace_exprContext } from "./CircuitScriptParser.js";
 import { Function_return_exprContext } from "./CircuitScriptParser.js";
@@ -108,6 +110,7 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitProperty_set_expr?: (ctx: Property_set_exprContext) => Result;
     visitDouble_dot_property_set_expr?: (ctx: Double_dot_property_set_exprContext) => Result;
     visitArrayExpr?: (ctx: ArrayExprContext) => Result;
+    visitArrayIndexExpr?: (ctx: ArrayIndexExprContext) => Result;
     visitFunctionCallExpr?: (ctx: FunctionCallExprContext) => Result;
     visitAdditionExpr?: (ctx: AdditionExprContext) => Result;
     visitMultiplyExpr?: (ctx: MultiplyExprContext) => Result;
@@ -125,6 +128,7 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitFunction_args_expr?: (ctx: Function_args_exprContext) => Result;
     visitAtom_expr?: (ctx: Atom_exprContext) => Result;
     visitTrailer_expr?: (ctx: Trailer_exprContext) => Result;
+    visitTrailer_expr2?: (ctx: Trailer_expr2Context) => 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;