circuitscript 0.1.11 → 0.1.13

package/dist/esm/render.js

@@ -1,7 +1,7 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.js";
 import { applyFontsToSVG } from './sizing.js';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, MilsToMM, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { combineMaps, getBoundsSize } from './utils.js';
 import { getPaperSize, milsToMM } from './helpers.js';
@@ -169,28 +169,70 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 .translate(wire.x.add(5).toNumber(), wire.y.add(5).toNumber());
         });
     }
+    const mergedWireHighlightGroup = canvas.group();
     const mergedWireGroup = canvas.group();
     mergedWires.forEach(tmpItem => {
-        const { segments, intersectPoints } = tmpItem;
+        const { segments, intersectPoints, net = null } = tmpItem;
+        let useJunctionColor = ColorScheme.JunctionColor;
+        let useColor = ColorScheme.WireColor;
+        let useLineWidth = defaultWireLineWidth;
+        let displayHighlight = false;
+        let displayHighlightColor = null;
+        if (net !== null) {
+            useColor = net.color ?? ColorScheme.WireColor;
+            useJunctionColor = net.color ?? ColorScheme.JunctionColor;
+            useLineWidth = net.lineWidth ?? defaultWireLineWidth;
+            if (net.highlight !== null) {
+                displayHighlight = true;
+                displayHighlightColor = net.highlight ?? null;
+            }
+        }
+        const pathItems = [];
+        const highlightExtraSize = 5 * MilsToMM;
         segments.forEach(segment => {
             const pt1 = segment[0];
             const pt2 = segment[1];
-            mergedWireGroup.line([pt1, pt2])
+            pathItems.push(...[
+                'M', pt1[0], pt1[1],
+                'L', pt2[0], pt2[1]
+            ]);
+        });
+        if (displayHighlight) {
+            mergedWireHighlightGroup.path(pathItems)
                 .stroke({
-                width: defaultWireLineWidth,
-                color: ColorScheme.WireColor,
+                width: useLineWidth + highlightExtraSize,
+                color: displayHighlightColor,
+                opacity: 0.3,
                 linecap: 'square'
             })
                 .fill('none');
-        });
+        }
+        mergedWireGroup.path(pathItems)
+            .stroke({
+            width: useLineWidth,
+            color: useColor,
+            linecap: 'square'
+        })
+            .fill('none');
         const halfJunctionSize = junctionSize.half();
+        const highlightJunctionSize = numeric(junctionSize.toNumber() + highlightExtraSize);
+        const tmpHighlightExtraSize = highlightJunctionSize.half();
         intersectPoints.forEach(point => {
             const [x, y,] = point;
             const translateX = numeric(x).sub(halfJunctionSize);
             const translateY = numeric(y).sub(halfJunctionSize);
+            if (displayHighlight && displayHighlightColor !== null) {
+                const tmpTranslateX = numeric(x).sub(tmpHighlightExtraSize);
+                const tmpTranslateY = numeric(y).sub(tmpHighlightExtraSize);
+                mergedWireHighlightGroup.circle(highlightJunctionSize.toNumber())
+                    .translate(tmpTranslateX.toNumber(), tmpTranslateY.toNumber())
+                    .fill(displayHighlightColor)
+                    .opacity(0.3)
+                    .stroke('none');
+            }
             mergedWireGroup.circle(junctionSize.toNumber())
                 .translate(translateX.toNumber(), translateY.toNumber())
-                .fill(ColorScheme.JunctionColor)
+                .fill(useJunctionColor)
                 .stroke('none');
         });
     });

package/dist/esm/utils.js

@@ -4,6 +4,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { SequenceAction } from './objects/ExecutionScope.js';
 import { BlockTypes } from './globals.js';
+import { DeclaredReference, AnyReference } from './objects/types.js';
 export class SimpleStopwatch {
     startTime;
     constructor() {
@@ -325,3 +326,15 @@ export function printWarnings(warnings) {
         console.log(`Warning: ${message}`);
     });
 }
+export function unwrapValue(value) {
+    if (isReference(value)) {
+        return value.value;
+    }
+    else {
+        return value;
+    }
+}
+export function isReference(value) {
+    return (value instanceof AnyReference ||
+        value instanceof DeclaredReference);
+}

package/dist/esm/visitor.js

@@ -4,6 +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 { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
@@ -82,39 +83,55 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, componentPin);
     };
-    visitPath_blocks = (ctx) => {
-        const blocks = ctx.path_block_inner();
-        let blockIndex = 0;
+    visitPath_block = (ctx) => {
         let blockType = BlockTypes.Branch;
-        let prevBlockType = null;
-        blocks.forEach((block, index) => {
-            if (block.Branch()) {
-                blockType = BlockTypes.Branch;
-            }
-            else if (block.Join()) {
-                blockType = BlockTypes.Join;
-            }
-            else if (block.Parallel()) {
-                blockType = BlockTypes.Parallel;
-            }
-            else if (block.Point()) {
-                blockType = BlockTypes.Point;
+        if (ctx.Branch()) {
+            blockType = BlockTypes.Branch;
+        }
+        else if (ctx.Join()) {
+            blockType = BlockTypes.Join;
+        }
+        else if (ctx.Parallel()) {
+            blockType = BlockTypes.Parallel;
+        }
+        else if (ctx.Point()) {
+            blockType = BlockTypes.Point;
+        }
+        const scope = this.getScope();
+        const executor = this.getExecutor();
+        const indentLevel = scope.indentLevel;
+        if (scope.blockStack.has(indentLevel)) {
+            const blockStackEntry = scope.blockStack.get(indentLevel);
+            if (blockStackEntry.type !== blockType) {
+                executor.exitBlocks();
             }
-            if (prevBlockType !== blockType) {
-                if (index > 0) {
-                    this.getExecutor().exitBlocks();
-                }
-                this.getExecutor().enterBlocks(blockType);
-                blockIndex = 0;
+        }
+        if (!scope.blockStack.has(indentLevel)) {
+            executor.enterBlocks(blockType);
+        }
+        const blockStackEntry = scope.blockStack.get(indentLevel);
+        const { current_index } = blockStackEntry;
+        executor.enterBlock(current_index);
+        this.visit(ctx.expressions_block());
+        executor.exitBlock(current_index);
+        blockStackEntry.current_index++;
+    };
+    visitGraph_expressions = (ctx) => {
+        if (ctx.path_block() === null) {
+            const scope = this.getScope();
+            const indentLevel = scope.indentLevel;
+            if (scope.blockStack.has(indentLevel)) {
+                this.getExecutor().exitBlocks();
             }
-            this.getExecutor().enterBlock(blockIndex);
-            this.visit(block);
-            this.getExecutor().exitBlock(blockIndex);
-            blockIndex += 1;
-            prevBlockType = blockType;
-        });
-        this.getExecutor().exitBlocks();
-        return this.getExecutor().getCurrentPoint();
+        }
+        const ctxPathBlock = ctx.path_block();
+        const ctxNotPathBlock = ctx.graph_linear_expression();
+        if (ctxPathBlock) {
+            this.visit(ctxPathBlock);
+        }
+        if (ctxNotPathBlock) {
+            this.visit(ctxNotPathBlock);
+        }
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
@@ -293,7 +310,7 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxId !== null) {
             const varName = ctxId.getText();
             paramIds.push(varName);
-            this.getScope().variables.set(varName, {});
+            this.getScope().setVariable(varName, {});
         }
         const executor = this.getExecutor();
         const stack = [...this.executionStack];
@@ -303,7 +320,7 @@ export class ParserVisitor extends BaseVisitor {
                 variables.forEach((value, key) => {
                     obj[key] = value;
                 });
-                executor.scope.variables.set(paramIds[0], obj);
+                executor.scope.setVariable(paramIds[0], obj);
             }
             const currentStack = this.executionStack.splice(0);
             this.executionStack.push(...stack);
@@ -384,7 +401,7 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitGraphicForExpr = (ctx) => {
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = this.visitResult(ctx.data_expr());
+        const listItems = unwrapValue(this.visitResult(ctx.data_expr()));
         let keepLooping = true;
         let counter = 0;
         let allCommands = [];
@@ -395,7 +412,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getScope().variables.set(forVariableNames[index], value);
+                    this.getScope().setVariable(forVariableNames[index], value);
                 });
                 const commands = this.visitResult(ctx.graphic_expressions_block());
                 allCommands = allCommands.concat(commands);
@@ -526,6 +543,7 @@ export class ParserVisitor extends BaseVisitor {
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
             component = this.visitResult(ctxDataExpr);
+            component = unwrapValue(component);
             componentCtx = ctxDataExpr;
             if (component === null || component === undefined) {
                 this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
@@ -867,15 +885,13 @@ export class ParserVisitor extends BaseVisitor {
         const executor = this.getExecutor();
         executor.log('entering at block');
         this.visit(ctx.at_component_expr());
-        const currentComponent = executor.scope.currentComponent;
-        const currentPin = executor.scope.currentPin;
+        const [currentComponent, currentPin] = executor.getCurrentPoint();
         executor.scope.indentLevel += 1;
         ctx.at_block_expressions().forEach(expression => {
             this.visit(expression);
         });
         executor.scope.indentLevel -= 1;
-        executor.scope.currentComponent = currentComponent;
-        executor.scope.currentPin = currentPin;
+        executor.scope.setCurrent(currentComponent, currentPin);
         executor.log('leaving at block');
     };
     visitAt_block_pin_expression_simple = (ctx) => {
@@ -1057,7 +1073,8 @@ export class ParserVisitor extends BaseVisitor {
     visitFor_expr = (ctx) => {
         this.log('in for loop');
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = this.visitResult(ctx.data_expr());
+        let listItems = this.visitResult(ctx.data_expr());
+        listItems = unwrapValue(listItems);
         this.getExecutor().addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;
@@ -1068,7 +1085,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getScope().variables.set(forVariableNames[index], value);
+                    this.getScope().setVariable(forVariableNames[index], value);
                 });
                 this.visit(ctx.expressions_block());
                 keepLooping = true;

package/dist/types/BaseVisitor.d.ts

@@ -1,16 +1,16 @@
-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";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
-import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, ReferenceType } from "./objects/types.js";
+import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, AnyReference } from "./objects/types.js";
 import { ParserRuleContext } from 'antlr4ng';
 import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
-export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | ReferenceType | any> {
+export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyReference | any> {
     indentLevel: number;
     startingContext: ExecutionContext;
     executionStack: ExecutionContext[];
@@ -20,7 +20,6 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     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 | Refe
     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

@@ -71,29 +71,29 @@ export declare class CircuitScriptParser extends antlr.Parser {
     static readonly DEDENT = 67;
     static readonly RULE_script = 0;
     static readonly RULE_expression = 1;
-    static readonly RULE_expressions_block = 2;
-    static readonly RULE_path_blocks = 3;
-    static readonly RULE_path_block_inner = 4;
-    static readonly RULE_property_set_expr2 = 5;
-    static readonly RULE_assignment_expr2 = 6;
-    static readonly RULE_pin_select_expr = 7;
-    static readonly RULE_component_modifier_expr = 8;
-    static readonly RULE_data_expr_with_assignment = 9;
-    static readonly RULE_add_component_expr = 10;
-    static readonly RULE_component_select_expr = 11;
-    static readonly RULE_pin_select_expr2 = 12;
-    static readonly RULE_at_component_expr = 13;
-    static readonly RULE_to_component_expr = 14;
-    static readonly RULE_at_to_multiple_expr = 15;
-    static readonly RULE_at_to_multiple_line_expr = 16;
-    static readonly RULE_at_to_multiple_line_expr_to_pin = 17;
-    static readonly RULE_at_block = 18;
-    static readonly RULE_at_block_expressions = 19;
-    static readonly RULE_at_block_pin_expr = 20;
-    static readonly RULE_at_block_pin_expression_simple = 21;
-    static readonly RULE_at_block_pin_expression_complex = 22;
-    static readonly RULE_break_keyword = 23;
-    static readonly RULE_continue_keyword = 24;
+    static readonly RULE_flow_expressions = 2;
+    static readonly RULE_graph_expressions = 3;
+    static readonly RULE_graph_linear_expression = 4;
+    static readonly RULE_expressions_block = 5;
+    static readonly RULE_path_block = 6;
+    static readonly RULE_property_set_expr2 = 7;
+    static readonly RULE_assignment_expr2 = 8;
+    static readonly RULE_pin_select_expr = 9;
+    static readonly RULE_component_modifier_expr = 10;
+    static readonly RULE_data_expr_with_assignment = 11;
+    static readonly RULE_add_component_expr = 12;
+    static readonly RULE_component_select_expr = 13;
+    static readonly RULE_pin_select_expr2 = 14;
+    static readonly RULE_at_component_expr = 15;
+    static readonly RULE_to_component_expr = 16;
+    static readonly RULE_at_to_multiple_expr = 17;
+    static readonly RULE_at_to_multiple_line_expr = 18;
+    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;
@@ -145,9 +145,11 @@ export declare class CircuitScriptParser extends antlr.Parser {
     constructor(input: antlr.TokenStream);
     script(): ScriptContext;
     expression(): ExpressionContext;
+    flow_expressions(): Flow_expressionsContext;
+    graph_expressions(): Graph_expressionsContext;
+    graph_linear_expression(): Graph_linear_expressionContext;
     expressions_block(): Expressions_blockContext;
-    path_blocks(): Path_blocksContext;
-    path_block_inner(): Path_block_innerContext;
+    path_block(): Path_blockContext;
     property_set_expr2(): Property_set_expr2Context;
     assignment_expr2(): Assignment_expr2Context;
     pin_select_expr(): Pin_select_exprContext;
@@ -166,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;
@@ -231,28 +231,46 @@ export declare class ScriptContext extends antlr.ParserRuleContext {
 }
 export declare class ExpressionContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    add_component_expr(): Add_component_exprContext | null;
-    to_component_expr(): To_component_exprContext | null;
-    at_component_expr(): At_component_exprContext | null;
+    graph_expressions(): Graph_expressionsContext | null;
     assignment_expr(): Assignment_exprContext | null;
     operator_assignment_expr(): Operator_assignment_exprContext | null;
     property_set_expr(): Property_set_exprContext | null;
     property_set_expr2(): Property_set_expr2Context | null;
     double_dot_property_set_expr(): Double_dot_property_set_exprContext | null;
-    break_keyword(): Break_keywordContext | null;
-    continue_keyword(): Continue_keywordContext | null;
     function_def_expr(): Function_def_exprContext | null;
     function_call_expr(): Function_call_exprContext | null;
-    wire_expr(): Wire_exprContext | null;
     import_expr(): Import_exprContext | null;
-    frame_expr(): Frame_exprContext | null;
     atom_expr(): Atom_exprContext | null;
-    at_block(): At_blockContext | null;
-    path_blocks(): Path_blocksContext | null;
-    point_expr(): Point_exprContext | null;
+    frame_expr(): Frame_exprContext | null;
+    flow_expressions(): Flow_expressionsContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Flow_expressionsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     if_expr(): If_exprContext | null;
     while_expr(): While_exprContext | null;
     for_expr(): For_exprContext | null;
+    Break(): antlr.TerminalNode | null;
+    Continue(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Graph_expressionsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    graph_linear_expression(): Graph_linear_expressionContext | null;
+    path_block(): Path_blockContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Graph_linear_expressionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    add_component_expr(): Add_component_exprContext | null;
+    to_component_expr(): To_component_exprContext | null;
+    at_component_expr(): At_component_exprContext | null;
+    at_block(): At_blockContext | null;
+    wire_expr(): Wire_exprContext | null;
+    point_expr(): Point_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -267,14 +285,7 @@ export declare class Expressions_blockContext extends antlr.ParserRuleContext {
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
-export declare class Path_blocksContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    path_block_inner(): Path_block_innerContext[];
-    path_block_inner(i: number): Path_block_innerContext | null;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
-export declare class Path_block_innerContext extends antlr.ParserRuleContext {
+export declare class Path_blockContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     expressions_block(): Expressions_blockContext;
     Branch(): antlr.TerminalNode | null;
@@ -436,22 +447,11 @@ 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);
-    atom_expr(): Atom_exprContext;
     data_expr(): Data_exprContext;
+    atom_expr(): Atom_exprContext | null;
+    function_call_expr(): Function_call_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }

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

@@ -1,9 +1,11 @@
 import { AbstractParseTreeVisitor } from "antlr4ng";
 import { ScriptContext } from "./CircuitScriptParser.js";
 import { ExpressionContext } from "./CircuitScriptParser.js";
+import { Flow_expressionsContext } from "./CircuitScriptParser.js";
+import { Graph_expressionsContext } from "./CircuitScriptParser.js";
+import { Graph_linear_expressionContext } from "./CircuitScriptParser.js";
 import { Expressions_blockContext } from "./CircuitScriptParser.js";
-import { Path_blocksContext } from "./CircuitScriptParser.js";
-import { Path_block_innerContext } from "./CircuitScriptParser.js";
+import { Path_blockContext } from "./CircuitScriptParser.js";
 import { Property_set_expr2Context } from "./CircuitScriptParser.js";
 import { Assignment_expr2Context } from "./CircuitScriptParser.js";
 import { Pin_select_exprContext } from "./CircuitScriptParser.js";
@@ -22,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";
@@ -78,9 +78,11 @@ import { For_exprContext } from "./CircuitScriptParser.js";
 export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<Result> {
     visitScript?: (ctx: ScriptContext) => Result;
     visitExpression?: (ctx: ExpressionContext) => Result;
+    visitFlow_expressions?: (ctx: Flow_expressionsContext) => Result;
+    visitGraph_expressions?: (ctx: Graph_expressionsContext) => Result;
+    visitGraph_linear_expression?: (ctx: Graph_linear_expressionContext) => Result;
     visitExpressions_block?: (ctx: Expressions_blockContext) => Result;
-    visitPath_blocks?: (ctx: Path_blocksContext) => Result;
-    visitPath_block_inner?: (ctx: Path_block_innerContext) => Result;
+    visitPath_block?: (ctx: Path_blockContext) => Result;
     visitProperty_set_expr2?: (ctx: Property_set_expr2Context) => Result;
     visitAssignment_expr2?: (ctx: Assignment_expr2Context) => Result;
     visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
@@ -99,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;

package/dist/types/execute.d.ts

@@ -1,11 +1,11 @@
-import { BlockTypes, FrameType } from './globals.js';
+import { BlockTypes, FrameType, ReferenceTypes } from './globals.js';
 import { ExecutionWarning } from "./utils.js";
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
 import { NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
 import { PinDefinition } from './objects/PinDefinition.js';
-import { CFunction, CFunctionResult, CallableParameter, ComponentPin, DeclaredReference } from './objects/types.js';
+import { AnyReference, CFunction, CFunctionResult, CallableParameter, ComponentPin, DeclaredReference } from './objects/types.js';
 import { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -62,6 +62,7 @@ export declare class ExecutionContext {
     copyComponent(component: ClassComponent): ClassComponent;
     enterBlocks(blockType: BlockTypes): void;
     exitBlocks(): void;
+    closeAllBlocks(): void;
     enterBlock(blockIndex: number): void;
     exitBlock(blockIndex: number): void;
     atPointBlock(): void;
@@ -74,6 +75,7 @@ export declare class ExecutionContext {
     hasFunction(functionName: string): boolean;
     getFunction(functionName: string): CFunction;
     resolveVariable(executionStack: ExecutionContext[], idName: string, trailers?: string[]): DeclaredReference;
+    resolveTrailers(type: ReferenceTypes, item: any, trailers?: string[]): AnyReference;
     callFunction(functionName: string, functionParams: CallableParameter[], executionStack: ExecutionContext[], netNamespace: string): CFunctionResult;
     mergeScope(childScope: ExecutionScope, namespace: string): void;
     addWire(segments: [string, (number | UnitDimension)?][]): void;

package/dist/types/globals.d.ts

@@ -88,6 +88,11 @@ export declare enum BlockTypes {
     Parallel = 3,
     Point = 4
 }
+export declare enum NetGraphicsParams {
+    Color = "color",
+    Highight = "highlight",
+    LineWidth = "lineWidth"
+}
 export declare enum FrameType {
     Frame = 1,
     Sheet = 2

package/dist/types/layout.d.ts

@@ -8,6 +8,7 @@ import { Net } from './objects/Net.js';
 import { Logger } from './logger.js';
 import { Frame, FramePlotDirection } from './objects/Frame.js';
 import { BoundBox } from './utils.js';
+import { ComponentPinNetPair } from './objects/types.js';
 import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
@@ -19,7 +20,8 @@ export declare class LayoutEngine {
     protected print(...params: any[]): void;
     protected printLevel(level: number, ...params: any[]): void;
     protected padLevel(value: number): string;
-    runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): SheetFrame[];
+    runLayout(sequence: SequenceItem[], nets: ComponentPinNetPair[]): SheetFrame[];
+    private collectRenderNets;
     private flattenFrameItems;
     private findJunctions;
     private placeFrames;
@@ -52,6 +54,14 @@ export declare class RenderObject {
     isFloating: boolean;
     floatingRelativeTo: [selfPin: number, nodeId: string, pin: number][];
 }
+export type RenderNet = {
+    netName: string;
+    net: Net;
+    color?: string;
+    lineWidth?: number;
+    highlight?: string;
+    highlightOpacity?: number;
+};
 export declare class RenderWire extends RenderObject {
     id: number;
     segments: WireSegment[];
@@ -60,7 +70,8 @@ export declare class RenderWire extends RenderObject {
         y: number;
     }[];
     netName: string;
-    constructor(x: NumericValue, y: NumericValue, segments: WireSegment[]);
+    net: Net;
+    constructor(net: Net, x: NumericValue, y: NumericValue, segments: WireSegment[]);
     refreshPoints(): void;
     getAutoPoints(value: [x: NumericValue, y: NumericValue], direction: WireAutoDirection): [dx: number, dy: number][];
     getWireEnd(): {
@@ -76,6 +87,7 @@ export type MergedWire = {
     netName: string;
     segments: [x: number, y: number][][];
     intersectPoints: [x: number, y: number, count: number][];
+    net: RenderNet;
 };
 export declare class RenderComponent extends RenderObject {
     component: ClassComponent;
@@ -122,7 +134,8 @@ export declare enum RenderFrameType {
 export declare class RenderJunction {
     x: NumericValue;
     y: NumericValue;
-    constructor(x: NumericValue, y: NumericValue);
+    net: RenderNet;
+    constructor(x: NumericValue, y: NumericValue, net: RenderNet);
 }
 export type SheetFrame = {
     frame: RenderFrame;