circuitscript 0.1.15 → 0.1.17

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;

package/dist/types/draw_symbols.d.ts

@@ -4,6 +4,7 @@ import { Logger } from "./logger.js";
 import { PinTypes } from "./objects/PinTypes.js";
 import { ParserRuleContext } from "antlr4ng";
 import { NumericValue } from "./objects/ParamDefinition.js";
+import { PinId } from "./objects/PinDefinition.js";
 export declare abstract class SymbolGraphic {
     drawPortsName: boolean;
     displayBounds: boolean;
@@ -37,7 +38,7 @@ export declare abstract class SymbolGraphic {
     drawPlaceRemove(group: G, extra?: {
         place?: boolean;
     }): void;
-    pinPosition(id: number): {
+    pinPosition(id: PinId): {
         x: NumericValue;
         y: NumericValue;
         angle: NumericValue;
@@ -131,7 +132,7 @@ export declare class SymbolCustomModule extends SymbolCustom {
 }
 export declare class SymbolDrawing {
     items: (Feature | GeometryProp)[];
-    pins: [NumericValue, Feature, angle: NumericValue, lineColor: string][];
+    pins: PinRenderInfo[];
     angle: number;
     flipX: number;
     flipY: number;
@@ -141,8 +142,7 @@ export declare class SymbolDrawing {
     clear(): void;
     log(...params: any[]): void;
     addLine(startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue): SymbolDrawing;
-    addPin(pinId: NumericValue, startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue, lineColor: string): SymbolDrawing;
-    addPinMM(pinId: NumericValue, startXMM: NumericValue, startYMM: NumericValue, endXMM: NumericValue, endYMM: NumericValue, lineColor: string): SymbolDrawing;
+    addPinMM(pinId: PinId, startXMM: NumericValue, startYMM: NumericValue, endXMM: NumericValue, endYMM: NumericValue, lineColor: string): SymbolDrawing;
     addVLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
     addHLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
     addRect(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
@@ -177,7 +177,7 @@ export declare class SymbolDrawing {
         start: SimplePoint;
         end: SimplePoint;
     };
-    getPinPosition(pinId: number): {
+    getPinPosition(pinId: PinId): {
         start: [x: NumericValue, y: NumericValue];
         end: [x: NumericValue, y: NumericValue];
         angle: NumericValue;
@@ -191,7 +191,7 @@ export type GraphicExprCommand = [
 ];
 export declare class SymbolDrawingCommands extends SymbolDrawing {
     id: string;
-    private commands;
+    protected commands: GraphicExprCommand[];
     paramIds: string[];
     callback: (variables: Map<string, any>) => GraphicExprCommand[];
     constructor(callback: (variables: Map<string, any>) => GraphicExprCommand[]);
@@ -216,9 +216,15 @@ type SymbolPinLayout = {
 };
 export type SymbolPinDefintion = {
     side: string;
-    pinId: number;
+    pinId: PinId;
     text: string;
     position: number;
     pinType: PinTypes;
 };
+export type PinRenderInfo = [
+    PinId,
+    Feature,
+    angle: NumericValue,
+    lineColor: string
+];
 export {};

package/dist/types/execute.d.ts

@@ -4,8 +4,8 @@ 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 { AnyReference, CFunction, CFunctionResult, CallableParameter, ComponentPin, DeclaredReference } from './objects/types.js';
+import { PinDefinition, PinId } from './objects/PinDefinition.js';
+import { AnyReference, CFunction, CFunctionEntry, CFunctionResult, CallableParameter, ComponentPin } from './objects/types.js';
 import { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -21,12 +21,12 @@ export declare class ExecutionContext {
         found: boolean;
         net?: Net;
     });
-    resolveComponentPinNet: (component: ClassComponent, pin: number) => Net | null;
+    resolveComponentPinNet: (component: ClassComponent, pin: PinId) => Net | null;
     stopFurtherExpressions: boolean;
     returnValue: null;
     silent: boolean;
     logger: Logger;
-    __functionCache: {};
+    __functionCache: Map<string, CFunction>;
     parentContext: ExecutionContext;
     componentAngleFollowsWire: boolean;
     warnings: ExecutionWarning[];
@@ -40,7 +40,7 @@ export declare class ExecutionContext {
     private linkComponentPinNet;
     private mergeNets;
     createComponent(instanceName: string, pins: PinDefinition[], params: ParamDefinition[], props: {
-        arrange?: Map<string, number[]>;
+        arrange?: Map<string, PinId[]>;
         display?: SymbolDrawingCommands;
         type?: string;
         width?: number;
@@ -52,11 +52,11 @@ export declare class ExecutionContext {
     private removeArrangePropDuplicates;
     private getArrangePropPins;
     printPoint(extra?: string): void;
-    addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
+    addComponentExisting(component: ClassComponent, pin: PinId): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {
         addSequence?: boolean;
     }): ComponentPin;
-    atComponent(component: ClassComponent, pinId: number | null, options?: {
+    atComponent(component: ClassComponent, pinId: PinId | null, options?: {
         addSequence?: boolean;
     }): ComponentPin;
     copyComponent(component: ClassComponent): ClassComponent;
@@ -71,10 +71,10 @@ export declare class ExecutionContext {
     addBreakContext(ctx: ParserRuleContext): void;
     popBreakContext(): ParserRuleContext;
     getBreakContext(): ParserRuleContext;
-    createFunction(functionName: string, __runFunc: CFunction): void;
+    createFunction(functionName: string, __runFunc: CFunction, source?: ParserRuleContext, uniqueId?: string): void;
     hasFunction(functionName: string): boolean;
-    getFunction(functionName: string): CFunction;
-    resolveVariable(executionStack: ExecutionContext[], idName: string, trailers?: string[]): DeclaredReference;
+    getFunction(functionName: string): CFunctionEntry;
+    resolveVariable(executionStack: ExecutionContext[], idName: string, trailers?: string[]): AnyReference;
     resolveTrailers(type: ReferenceTypes, item: any, trailers?: string[]): AnyReference;
     callFunction(functionName: string, functionParams: CallableParameter[], executionStack: ExecutionContext[], netNamespace: string): CFunctionResult;
     mergeScope(childScope: ExecutionScope, namespace: string): void;
@@ -86,12 +86,12 @@ export declare class ExecutionContext {
     enterFrame(frameType: FrameType): number;
     exitFrame(frameId: number): void;
 }
-export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): {
+export declare function getPortSide(pins: Map<PinId, PinDefinition>, arrangeProps: null | Map<string, number[]>): {
     pins: PortSideItem[];
     maxPositions: Map<string, number>;
 };
 type PortSideItem = {
-    pinId: number;
+    pinId: PinId;
     side: string;
     order: number;
     position: number;

package/dist/types/globals.d.ts

@@ -9,6 +9,7 @@ export declare const NoNetText = "NO_NET";
 export declare enum ParamKeys {
     priority = "priority",
     net_name = "net_name",
+    net_type = "net_type",
     flip = "flip",
     flipX = "flipX",
     flipY = "flipY",
@@ -80,7 +81,8 @@ export declare enum ReferenceTypes {
     value = "value",
     variable = "variable",
     instance = "instance",
-    pinType = "pinType"
+    pinType = "pinType",
+    unknown = "unknown"
 }
 export declare enum BlockTypes {
     Branch = 1,
@@ -109,3 +111,4 @@ export declare const RenderFlags: {
     ShowLabelOrigin: boolean;
 };
 export declare const SymbolValidatorContext = "_sym";
+export declare const TrailerArrayIndex = "index";

package/dist/types/graph.d.ts

@@ -0,0 +1,29 @@
+import { Graph } from "@dagrejs/graphlib";
+import { SymbolPinDefintion } from "./draw_symbols.js";
+import { RenderFrame } from "./layout.js";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { SequenceItem } from "./objects/ExecutionScope.js";
+import { Net } from "./objects/Net.js";
+import { Logger } from "./logger.js";
+import { ComponentPinNetPair } from "./objects/types.js";
+import { PinId } from "./objects/PinDefinition.js";
+export declare class NetGraph {
+    logger: Logger;
+    constructor(logger: Logger);
+    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: PinId, net: Net][]): {
+        graph: Graph;
+        containerFrames: RenderFrame[];
+    };
+    private setGraphEdge;
+    protected print(...params: any[]): void;
+    generateNetGraph(nets: ComponentPinNetPair[]): void;
+    findNodePaths(graph: Graph, startNode: string, endNode: string, seenNodes?: string[]): string[][];
+    private getNetNodeName;
+    private getComponentName;
+}
+export declare function getWireName(wireId: number): string;
+export declare function generateLayoutPinDefinition(component: ClassComponent): SymbolPinDefintion[];
+export declare enum RenderItemType {
+    Wire = "wire",
+    Component = "component"
+}

package/dist/types/layout.d.ts

@@ -1,7 +1,6 @@
 import { Graph } from '@dagrejs/graphlib';
 import { SymbolGraphic, SymbolText, SymbolDrawingCommands, SimplePoint } from "./draw_symbols.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
-import { SequenceItem } from "./objects/ExecutionScope.js";
 import { WireAutoDirection } from './globals.js';
 import { WireSegment } from './objects/Wire.js';
 import { Net } from './objects/Net.js';
@@ -9,18 +8,19 @@ import { Logger } from './logger.js';
 import { Frame, FramePlotDirection } from './objects/Frame.js';
 import { BoundBox } from './utils.js';
 import { ComponentPinNetPair } from './objects/types.js';
+import { PinId } from './objects/PinDefinition.js';
 import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
     layoutWarnings: string[];
     showBaseFrame: boolean;
-    constructor(options?: {
+    constructor(logger: Logger, options?: {
         showBaseFrame: boolean;
     });
     protected print(...params: any[]): void;
     protected printLevel(level: number, ...params: any[]): void;
     protected padLevel(value: number): string;
-    runLayout(sequence: SequenceItem[], nets: ComponentPinNetPair[]): SheetFrame[];
+    runLayout(graph: Graph, containerFrames: RenderFrame[], nets: ComponentPinNetPair[]): SheetFrame[];
     private collectRenderNets;
     private flattenFrameItems;
     private findJunctions;
@@ -31,17 +31,12 @@ export declare class LayoutEngine {
     dumpFrame(frame: RenderFrame, level?: number): void;
     private prepareFrames;
     private checkAddFrameTitle;
-    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
-        graph: Graph;
-        containerFrames: RenderFrame[];
-    };
-    private setGraphEdge;
     private sizeSubGraphs;
     private walkAndPlaceGraph;
     private placeSubgraphV2;
     mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
     translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
-    placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: number, depth?: number): void;
+    placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: PinId, depth?: number): void;
     placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
     printWarnings(): void;
 }

package/dist/types/objects/ClassComponent.d.ts

@@ -9,8 +9,8 @@ export declare class ClassComponent {
     instanceName: string;
     numPins: number;
     parameters: Map<string, number | string | NumericValue>;
-    pins: Map<number, PinDefinition>;
-    pinNets: Map<number, Net>;
+    pins: Map<PinId, PinDefinition>;
+    pinNets: Map<PinId, Net>;
     pinWires: Map<number, WireSegment[]>;
     pinsMaxPositions: Map<string, number>;
     _cachedPins: string;
@@ -18,8 +18,8 @@ export declare class ClassComponent {
     _copyID?: number;
     _copyFrom?: ClassComponent;
     _pointLinkComponent?: ClassComponent;
-    _unplacedPins: number[];
-    arrangeProps: Map<string, NumericValue[]> | null;
+    _unplacedPins: PinId[];
+    arrangeProps: Map<string, PinId[]> | null;
     displayProp: SymbolDrawingCommands | null;
     widthProp: number | null;
     heightProp: number | null;
@@ -33,10 +33,10 @@ export declare class ClassComponent {
     assignedRefDes: string | null;
     constructor(instanceName: string, numPins: number);
     setupPins(): void;
-    getDefaultPin(): number;
-    hasPin(pinId: number | string): boolean;
-    getPin(pinId: number | string): PinId;
-    getNextPinAfter(pinIndex: number): number;
+    getDefaultPin(): PinId;
+    hasPin(pinId: PinId): boolean;
+    getPin(pinId: PinId): PinId;
+    getNextPinAfter(pinIndex: PinId): PinId;
     setParam(key: string, value: number | string | NumericValue): void;
     hasParam(key: string): boolean;
     private refreshParamCache;

package/dist/types/objects/ExecutionScope.d.ts

@@ -1,18 +1,19 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ParseSymbolType, ValueType } from './types.js';
+import { CFunctionEntry, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ParseSymbolType, ValueType } from './types.js';
 import { BlockTypes, LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
 import { BaseVisitor } from 'src/BaseVisitor.js';
+import { PinId } from './PinDefinition.js';
 type OnPropertyHandler = (path: PropertyTreeKey[], value: any, valueContext: ParserRuleContext) => void;
 export type PropertyTreeKey = [ctx: ParserRuleContext, value: any] | ['index', number];
 export declare class ExecutionScope {
     scopeId: number;
     private nets;
     instances: Map<string, ClassComponent>;
-    functions: Map<string, CFunction>;
+    functions: Map<string, CFunctionEntry>;
     variables: Map<string, ValueType | ClassComponent>;
     symbols: Map<string, {
         type: ParseSymbolType;
@@ -33,16 +34,16 @@ export declare class ExecutionScope {
     componentRoot: ClassComponent | null;
     copyIDs: Map<string, number>;
     sequence: SequenceItem[];
-    constructor(scopeId: number);
+    private constructor();
     static scopeId: number;
     static create(): ExecutionScope;
     private findNet;
     getNetWithName(name: string): Net;
     getNetWithNamespacePath(namespace: string, name: string): Net | null;
-    hasNet(component: ClassComponent, pin: number): boolean;
-    getNet(component: ClassComponent, pin: number): Net | null;
-    setNet(component: ClassComponent, pin: number, net: Net): void;
-    removeNet(component: ClassComponent, pin: number): void;
+    hasNet(component: ClassComponent, pin: PinId): boolean;
+    getNet(component: ClassComponent, pin: PinId): Net | null;
+    setNet(component: ClassComponent, pin: PinId, net: Net): void;
+    removeNet(component: ClassComponent, pin: PinId): void;
     getNets(): ComponentPinNetPair[];
     dumpNets(): ComponentPinNet[];
     printNets(): void;

package/dist/types/objects/Net.d.ts

@@ -3,9 +3,9 @@ export declare class Net {
     baseName: string;
     namespace: string;
     priority: number;
-    type: any;
+    type: string;
     params: Map<string, any>;
-    constructor(namespace: string, name: string, priority?: number, type?: any);
+    constructor(namespace: string, name: string, priority?: number, type?: string);
     toString(): string;
     static isSame(netA: Net, netB: Net): boolean;
 }

package/dist/types/objects/PinDefinition.d.ts

@@ -1,5 +1,18 @@
+import { NumericValue } from './ParamDefinition.js';
 import { PinTypes } from './PinTypes.js';
-export type PinId = number | string;
+export declare class PinId {
+    private value;
+    private type;
+    constructor(value: number | string);
+    getValue(): number | string;
+    getType(): PinIdType;
+    isNumeric(): boolean;
+    isString(): boolean;
+    toString(): string;
+    equals(other: PinId | number | string): boolean;
+    static from(value: number | string | NumericValue): PinId;
+    static isPinIdType(value: number | string): boolean;
+}
 export declare class PinDefinition {
     id: PinId;
     idType: PinIdType;
@@ -8,7 +21,7 @@ export declare class PinDefinition {
     altNames: string[];
     side: string;
     position: number;
-    constructor(id: PinId, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
+    constructor(id: PinId | number | string, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
 }
 export declare enum PinIdType {
     Int = "int",
@@ -20,3 +33,5 @@ export declare enum PortSide {
     SOUTH = "SOUTH",
     NORTH = "NORTH"
 }
+export declare function isPinId(item: any): boolean;
+export declare function getPinDefinition(map: Map<PinId, PinDefinition>, id: PinId): PinDefinition;

package/dist/types/objects/types.d.ts

@@ -1,10 +1,19 @@
-import { Token } from 'antlr4ng';
+import { ParserRuleContext, Token } from 'antlr4ng';
 import { ExecutionContext } from '../execute.js';
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
 import { NumericValue, PercentageValue } from './ParamDefinition.js';
 import { ReferenceTypes } from '../globals.js';
+import { PinId } from './PinDefinition.js';
 export type CFunction = (args: CallableParameter[], options?: CFunctionOptions) => CFunctionResult;
+export declare class CFunctionEntry {
+    name: string;
+    execute: CFunction;
+    uniqueId?: string;
+    source?: ParserRuleContext;
+    constructor(name: string, execute: CFunction, source?: ParserRuleContext, uniqueId?: string);
+    toString(): string;
+}
 export type CFunctionOptions = {
     netNamespace?: string;
 };
@@ -19,7 +28,7 @@ export type ComponentPinNet = [
 ];
 export type ComponentPinNetPair = [
     component: ClassComponent,
-    pin: number,
+    pin: PinId,
     net: Net
 ];
 export type ComponentPinWireId = [
@@ -50,20 +59,22 @@ export type FunctionDefinedParameter = [
 export declare class AnyReference {
     found: boolean;
     name?: string;
-    trailers: string[];
-    type?: ReferenceTypes;
+    trailers: (string | ['index', number])[];
+    type: ReferenceTypes;
     value?: any;
     parentValue?: any;
+    referenceName: string;
     constructor(refType: {
         found: boolean;
         name?: string;
-        trailers?: string[];
+        trailers?: (string | ['index', number])[];
         type?: ReferenceTypes;
         value?: any;
         parentValue?: any;
     });
+    toString(): string;
 }
-export declare class UndeclaredReference {
+export declare class UndeclaredReference extends AnyReference {
     reference: AnyReference;
     constructor(reference: AnyReference);
     throwMessage(): string;
@@ -71,7 +82,7 @@ export declare class UndeclaredReference {
     nameString(): string;
 }
 export declare class DeclaredReference extends AnyReference {
-    toString(): string;
+    referenceName: string;
     toDisplayString(): string;
 }
 export declare enum ParseSymbolType {
@@ -85,3 +96,16 @@ export declare enum Direction {
     Down = "down",
     Up = "up"
 }
+export declare enum TypeProps {
+    Net = "net",
+    Port = "port",
+    Graphic = "graphic",
+    Resistor = "res",
+    Capacitor = "cap",
+    Inductor = "ind",
+    Diode = "diode"
+}
+export declare enum NetTypes {
+    Any = "any",
+    Source = "source"
+}

package/libs/std.cst

@@ -1,6 +1,6 @@
 # Circuitscript default lib
 
-def net(net_name):
+def net(net_name, net_type = "any"):
     return create component:
         pins: 1
         copy: true
@@ -13,9 +13,10 @@ def net(net_name):
         params:
             net_name: net_name
             priority: 10
+            net_type: net_type
 
 def supply(net_name):
-    net_obj = net(net_name)
+    net_obj = net(net_name, "source")
     return net_obj
 
 def label(value, anchor="left"):

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.15",
+    "version": "0.1.17",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {
@@ -88,6 +88,7 @@
         "express": "^4.18.2",
         "figlet": "^1.7.0",
         "lodash": "^4.17.21",
+        "ml-matrix": "^6.12.1",
         "pdfkit": "^0.15.1",
         "svg-to-pdfkit": "^0.1.8",
         "svgdom": "^0.1.22",