circuitscript 0.1.0 → 0.1.3

package/dist/types/BaseVisitor.d.ts

@@ -17,7 +17,6 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     printStream: string[];
     printToConsole: boolean;
     acceptedDirections: Direction[];
-    acceptedFlip: string[];
     protected resultData: Map<ParserRuleContext, any>;
     protected paramData: Map<ParserRuleContext, any>;
     pinTypesList: string[];
@@ -54,6 +53,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
+    protected visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): {
         hasError: boolean;
         hasParseError: boolean;

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

@@ -339,6 +339,7 @@ export declare class Component_select_exprContext extends antlr.ParserRuleContex
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     data_expr_with_assignment(): Data_expr_with_assignmentContext | null;
     pin_select_expr(): Pin_select_exprContext | null;
+    Point(): antlr.TerminalNode | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -352,15 +353,13 @@ export declare class Pin_select_expr2Context extends antlr.ParserRuleContext {
 export declare class At_component_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     At(): antlr.TerminalNode;
-    component_select_expr(): Component_select_exprContext | null;
-    Point(): antlr.TerminalNode | null;
+    component_select_expr(): Component_select_exprContext;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
 export declare class To_component_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     To(): antlr.TerminalNode;
-    Point(): antlr.TerminalNode | null;
     component_select_expr(): Component_select_exprContext[];
     component_select_expr(i: number): Component_select_exprContext | null;
     get ruleIndex(): number;

package/dist/types/draw_symbols.d.ts

@@ -3,6 +3,7 @@ import { Feature, GeometryProp, HorizontalAlign, LabelStyle, Textbox, VerticalAl
 import { Logger } from "./logger.js";
 import { PinTypes } from "./objects/PinTypes.js";
 import { ParserRuleContext } from "antlr4ng";
+import { NumericValue } from "./objects/ParamDefinition.js";
 export declare abstract class SymbolGraphic {
     drawPortsName: boolean;
     displayBounds: boolean;
@@ -10,8 +11,8 @@ export declare abstract class SymbolGraphic {
     _angle: number;
     _flipX: number;
     _flipY: number;
-    width: number;
-    height: number;
+    width: NumericValue;
+    height: NumericValue;
     labelTexts: Map<string, string>;
     constructor();
     get angle(): number;
@@ -21,7 +22,12 @@ export declare abstract class SymbolGraphic {
     get flipY(): number;
     set flipY(value: number);
     refreshDrawing(calculateSize?: boolean): void;
-    calculateSize(): void;
+    calculateSize(): {
+        bodyWidth: NumericValue;
+        bodyHeight: NumericValue;
+        width: NumericValue;
+        height: NumericValue;
+    };
     abstract generateDrawing(): void;
     size(): {
         width: number;
@@ -32,9 +38,9 @@ export declare abstract class SymbolGraphic {
         place?: boolean;
     }): void;
     pinPosition(id: number): {
-        x: number;
-        y: number;
-        angle: number;
+        x: NumericValue;
+        y: NumericValue;
+        angle: NumericValue;
     };
     protected drawBounds(group: G): void;
     protected drawBody(group: G): void;
@@ -43,13 +49,9 @@ export declare abstract class SymbolGraphic {
     flipTextAnchor(value: HorizontalAlign): HorizontalAlign;
     flipDominantBaseline(value: VerticalAlign): VerticalAlign;
 }
-export declare function SymbolFactory(name: string): SymbolGraphic;
-export declare class SymbolPointHidden extends SymbolGraphic {
-    generateDrawing(): void;
-}
 export declare class SymbolText extends SymbolGraphic {
     text: string;
-    fontSize: number;
+    fontSize: NumericValue;
     fontWeight: string;
     constructor(text: string);
     generateDrawing(): void;
@@ -67,6 +69,7 @@ export declare enum PlaceHolderCommands {
     arc = "arc",
     circle = "circle",
     rect = "rect",
+    crect = "crect",
     triangle = "triangle",
     pin = "pin",
     hpin = "hpin",
@@ -86,62 +89,85 @@ export declare enum PlaceHolderCommands {
 }
 export declare class SymbolCustom extends SymbolGraphic {
     pinDefinition: SymbolPinDefintion[];
-    bodyWidth: number;
-    pinLength: number;
-    width: number;
-    height: number;
-    pinSpacing: number;
-    pinTextPadding: number;
+    bodyWidth: NumericValue;
+    bodyHeight: NumericValue;
+    pinLength: NumericValue;
+    width: NumericValue;
+    height: NumericValue;
+    pinSpacing: NumericValue;
+    pinTextPadding: NumericValue;
     pins: SymbolPinLayout[];
     _cacheLeftPins: SymbolPinDefintion[];
     _cacheRightPins: SymbolPinDefintion[];
-    constructor(pinDefinition: SymbolPinDefintion[]);
+    _cacheTopPins: SymbolPinDefintion[];
+    _cacheBottomPins: SymbolPinDefintion[];
+    pinMaxPositions: {
+        [key: string]: number;
+    };
+    constructor(pinDefinition: SymbolPinDefintion[], pinMaxPositions: {
+        [key: string]: number;
+    });
     generateDrawing(): void;
-    generateDrawingPins(drawing: SymbolDrawing, bodyWidthMM: number, bodyHeightMM: number, leftPins: SymbolPinDefintion[], rightPins: SymbolPinDefintion[], defaultLineColor: string): void;
-    calculateSize(): void;
+    private getPins;
+    generateDrawingPins(drawing: SymbolDrawing, bodyWidthMM: NumericValue, bodyHeightMM: NumericValue, pins: {
+        left: SymbolPinDefintion[];
+        right: SymbolPinDefintion[];
+        top: SymbolPinDefintion[];
+        bottom: SymbolPinDefintion[];
+    }, defaultLineColor: string): void;
+    calculateSize(): {
+        bodyWidth: NumericValue;
+        bodyHeight: NumericValue;
+        width: NumericValue;
+        height: NumericValue;
+    };
 }
 export declare class SymbolCustomModule extends SymbolCustom {
-    pinLength: number;
-    portWidth: number;
-    portHeight: number;
-    generateDrawingPins(drawing: SymbolDrawing, bodyWidthMM: number, bodyHeightMM: number, leftPins: SymbolPinDefintion[], rightPins: SymbolPinDefintion[], defaultLineColor: string): void;
+    pinLength: NumericValue;
+    portWidth: NumericValue;
+    portHeight: NumericValue;
+    generateDrawingPins(drawing: SymbolDrawing, bodyWidthMM: NumericValue, bodyHeightMM: NumericValue, pins: {
+        left: SymbolPinDefintion[];
+        right: SymbolPinDefintion[];
+        top: SymbolPinDefintion[];
+        bottom: SymbolPinDefintion[];
+    }, defaultLineColor: string): void;
 }
 export declare class SymbolDrawing {
     items: (Feature | GeometryProp)[];
-    pins: [number, Feature, number, lineColor: string][];
+    pins: [NumericValue, Feature, angle: NumericValue, lineColor: string][];
     angle: number;
     flipX: number;
     flipY: number;
-    mainOrigin: [number, number];
+    mainOrigin: [x: NumericValue, y: NumericValue];
     logger: Logger;
     variables: Map<string, any>;
     clear(): void;
     log(...params: any[]): void;
-    addLine(startX: number, startY: number, endX: number, endY: number): SymbolDrawing;
-    addPin(pinId: number, startX: number, startY: number, endX: number, endY: number, lineColor: string): SymbolDrawing;
-    addPinMM(pinId: number, startXMM: number, startYMM: number, endXMM: number, endYMM: number, lineColor: string): SymbolDrawing;
-    addVLine(startX: number, startY: number, value: number): SymbolDrawing;
-    addHLine(startX: number, startY: number, value: number): SymbolDrawing;
-    addRect(centerX: number, centerY: number, width: number, height: number): SymbolDrawing;
-    addRectMM(centerX: number, centerY: number, width: number, height: number): SymbolDrawing;
-    addTriangle(startX: number, startY: number, endX: number, endY: number, width: number): SymbolDrawing;
-    addRect2(x: number, y: number, x2: number, y2: number): SymbolDrawing;
-    addLabel(x: number, y: number, textValue: string, style: LabelStyle): SymbolDrawing;
-    addLabelMils(x: number, y: number, textValue: string, style: LabelStyle): SymbolDrawing;
-    addTextbox(x: number, y: number, textValue: string, style: LabelStyle): SymbolDrawing;
-    addModulePort(x: number, y: number, width: number, height: number, portType?: PinTypes, scaleX?: number): SymbolDrawing;
+    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;
+    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;
+    addRectMM(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
+    addTriangle(startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue, width: NumericValue): SymbolDrawing;
+    addLabel(x: NumericValue, y: NumericValue, textValue: string, style: LabelStyle): SymbolDrawing;
+    addLabelMils(x: NumericValue, y: NumericValue, textValue: string, style: LabelStyle): SymbolDrawing;
+    addTextbox(x: NumericValue, y: NumericValue, textValue: string, style: LabelStyle): SymbolDrawing;
+    addModulePort(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue, portType?: PinTypes, scaleX?: number, angle?: number): SymbolDrawing;
     addPath(...pathParts: any): SymbolDrawing;
-    addSetLineWidth(value: number): SymbolDrawing;
+    addSetLineWidth(value: NumericValue): SymbolDrawing;
     addSetLineColor(value: string): SymbolDrawing;
     addSetTextColor(value: string): SymbolDrawing;
     addSetFillColor(value: string): SymbolDrawing;
-    addArc(x: number, y: number, radius: number, startAngle: number, endAngle: number): SymbolDrawing;
+    addArc(x: NumericValue, y: NumericValue, radius: NumericValue, startAngle: NumericValue, endAngle: NumericValue): SymbolDrawing;
     addSetUnits(value: string): SymbolDrawing;
     getPaths(): {
         path: string;
         fillColor: string;
         lineColor: string;
-        lineWidth: number;
+        lineWidth: NumericValue;
     }[];
     getPinsPath(): {
         path: string;
@@ -156,9 +182,9 @@ export declare class SymbolDrawing {
         end: SimplePoint;
     };
     getPinPosition(pinId: number): {
-        start: [number, number];
-        end: [number, number];
-        angle: number;
+        start: [x: NumericValue, y: NumericValue];
+        end: [x: NumericValue, y: NumericValue];
+        angle: NumericValue;
     };
 }
 export type GraphicExprCommand = [
@@ -176,6 +202,7 @@ export declare class SymbolDrawingCommands extends SymbolDrawing {
     runCommands(): void;
     getCommands(): GraphicExprCommand[];
     clone(): SymbolDrawingCommands;
+    eq(other: SymbolDrawingCommands): boolean;
 }
 type SimplePoint = [x: number, y: number];
 type SymbolPinLayout = {

package/dist/types/execute.d.ts

@@ -2,12 +2,13 @@ import { BlockTypes, FrameType } from './globals.js';
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
-import { ParamDefinition } from './objects/ParamDefinition.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 { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
 import { ParserRuleContext } from 'antlr4ng';
+import { SymbolDrawingCommands } from './draw_symbols.js';
 export declare class ExecutionContext {
     name: string;
     namespace: string;
@@ -29,20 +30,21 @@ export declare class ExecutionContext {
     constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, parent: ExecutionContext);
     log(...params: any[]): void;
     private setupRoot;
-    getUniqueInstanceName(className: string): string;
-    getUniqueNetName(): string;
+    getUniqueInstanceName(): string;
+    private getUniqueNetName;
     getCurrentPoint(): ComponentPin;
     private linkComponentPinNet;
     private mergeNets;
     createComponent(instanceName: string, pins: PinDefinition[], params: ParamDefinition[], props: {
         arrange?: Map<string, number[]>;
-        display?: string;
+        display?: SymbolDrawingCommands;
         type?: string;
         width?: number;
+        height?: number;
         copy: boolean;
-        angle?: number;
+        angle?: NumericValue;
         followWireOrientation: boolean;
-    }): ClassComponent;
+    }, isModule?: boolean): ClassComponent;
     printPoint(extra?: string): void;
     addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {
@@ -70,15 +72,18 @@ export declare class ExecutionContext {
     mergeScope(childScope: ExecutionScope, namespace: string): void;
     addWire(segments: [string, (number | UnitDimension)?][]): void;
     addPoint(pointId: string, userDefined?: boolean): ComponentPin;
+    private getPointSymbol;
     setProperty(nameWithProp: string, value: any): void;
-    setCurrentComponentStyle(styles: {
-        [key: string]: number | string;
-    }): void;
     applyComponentAngleFromWire(component: ClassComponent, pin: number, opposite?: boolean): void;
     enterFrame(frameType: FrameType): number;
     exitFrame(frameId: number): void;
 }
-export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): PortSideItem[];
+export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): {
+    pins: PortSideItem[];
+    maxPositions: {
+        [key: string]: number;
+    };
+};
 type PortSideItem = {
     pinId: number;
     side: string;

package/dist/types/geometry.d.ts

@@ -1,5 +1,6 @@
 import Flatten from '@flatten-js/core';
 import { Box } from '@svgdotjs/svg.js';
+import { NumericValue } from './objects/ParamDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 export type Segment = Flatten.Segment;
 export type Polygon = Flatten.Polygon;
@@ -9,9 +10,9 @@ export type Arc = Flatten.Arc;
 export type Feature = Segment | Polygon | Textbox | Arc | Multiline;
 export type LabelStyle = {
     font?: string;
-    fontSize?: number;
+    fontSize?: NumericValue;
     fontWeight?: string;
-    angle?: number;
+    angle?: NumericValue;
     anchor?: HorizontalAlign.Left | HorizontalAlign.Middle | HorizontalAlign.Right;
     vanchor?: VerticalAlign.Top | VerticalAlign.Middle | VerticalAlign.Bottom;
     textColor?: string;
@@ -20,7 +21,7 @@ export type LabelStyle = {
 export declare class Textbox extends Flatten.Polygon {
     id: string;
     text: string;
-    anchorPoint: [number, number];
+    anchorPoint: [NumericValue, NumericValue];
     boundingBox: {
         width: number;
         height: number;
@@ -31,12 +32,12 @@ export declare class Textbox extends Flatten.Polygon {
     textMeasurementBounds: Box;
     label: boolean;
     get box(): Flatten.Box;
-    constructor(id: string, text: string, anchorPoint: [number, number], polygon: Flatten.Polygon, style: LabelStyle, bounds: Box, label: boolean);
-    static fromPoint(id: string, x: number, y: number, text: string, style: LabelStyle, label: boolean): Textbox;
+    constructor(id: string, text: string, anchorPoint: [NumericValue, NumericValue], polygon: Flatten.Polygon, style: LabelStyle, bounds: Box, label: boolean);
+    static fromPoint(id: string, x: NumericValue, y: NumericValue, text: string, style: LabelStyle, label: boolean): Textbox;
     rotate(angle: number, origin: Flatten.Point): Textbox;
     transform(matrix: Flatten.Matrix): Textbox;
     private transformAnchorPoint;
-    getLabelPosition(): [number, number];
+    getLabelPosition(): [x: NumericValue, y: NumericValue];
 }
 export declare class GeometryProp {
     name: string;
@@ -44,18 +45,18 @@ export declare class GeometryProp {
     constructor(name: any, value: any);
 }
 export declare class Geometry {
-    static point(x: number, y: number): Flatten.Point;
-    static line(x1: number, y1: number, x2: number, y2: number): Flatten.Line;
-    static label(id: string, x: number, y: number, text: string, style: LabelStyle): Textbox;
-    static textbox(id: string | null, x: number, y: number, text: string, style: LabelStyle): Textbox;
-    static segment(start: [number, number], end: [number, number]): Segment;
-    static polygon(coords: [number, number][]): Polygon;
-    static multiline(coords: [number, number][]): Multiline;
-    static arc(center: [x: number, y: number], radius: number, startAngle: number, endAngle: number, sweepDirection: boolean): Arc;
-    static getCoords(item: Feature): [number, number][];
-    static rotateDegs(feature: Feature, angleDegrees: number, center: [number, number]): Feature;
+    static point(x: NumericValue, y: NumericValue): Flatten.Point;
+    static line(x1: NumericValue, y1: NumericValue, x2: NumericValue, y2: NumericValue): Flatten.Line;
+    static label(id: string, x: NumericValue, y: NumericValue, text: string, style: LabelStyle): Textbox;
+    static textbox(id: string | null, x: NumericValue, y: NumericValue, text: string, style: LabelStyle): Textbox;
+    static segment(start: [NumericValue, NumericValue], end: [NumericValue, NumericValue]): Segment;
+    static polygon(coords: [NumericValue, NumericValue][]): Polygon;
+    static multiline(coords: [NumericValue, NumericValue][]): Multiline;
+    static arc(center: [x: NumericValue, y: NumericValue], radius: NumericValue, startAngle: NumericValue, endAngle: NumericValue, sweepDirection: boolean): Arc;
+    static getCoords(item: Feature): [x: NumericValue, y: NumericValue][];
+    static rotateDegs(feature: Feature, angleDegrees: number, center: [x: NumericValue, y: NumericValue]): Feature;
     static flip(feature: Feature, flipX: number, flipY: number): Feature;
-    static groupRotate(features: Feature[], angle: number, center: [number, number]): Feature[];
+    static groupRotate(features: Feature[], angle: number, center: [x: NumericValue, y: NumericValue]): Feature[];
     static groupFlip(features: Feature[], flipX: number, flipY: number): Feature[];
     static groupBounds(features: Feature[]): {
         start: [number, number];
@@ -72,8 +73,8 @@ export declare class Geometry {
     static angle(dx: number, dy: number): number;
     static getQuadrant(dx: number, dy: number): number;
     static mergeWires(wirePoints: {
-        x: number;
-        y: number;
+        x: NumericValue;
+        y: NumericValue;
     }[][]): {
         intersectPoints: WirePointCount[];
         segments: [x: number, y: number][][];
@@ -90,4 +91,15 @@ export declare enum VerticalAlign {
     Middle = "middle",
     Bottom = "bottom"
 }
+export declare enum HorizontalAlignProp {
+    Start = "start",
+    Middle = "middle",
+    End = "end"
+}
+export declare enum VerticalAlignProp {
+    Hanging = "hanging",
+    Middle = "middle",
+    Central = "central",
+    TextTop = "text-top"
+}
 export {};

package/dist/types/globals.d.ts

@@ -1,15 +1,15 @@
 export declare enum GlobalNames {
     __root = "__root",
-    gnd = "gnd",
-    DefaultResistor = "res",
-    DefaultCapacitor = "cap",
-    DefaultInductor = "ind",
     symbol = "symbol"
 }
 export declare const NoNetText = "NO_NET";
 export declare enum ParamKeys {
     priority = "priority",
-    net_name = "net_name"
+    net_name = "net_name",
+    flip = "flip",
+    flipX = "flipX",
+    flipY = "flipY",
+    angle = "angle"
 }
 export declare enum LayoutDirection {
     RIGHT = "RIGHT",
@@ -17,7 +17,9 @@ export declare enum LayoutDirection {
 }
 export declare enum SymbolPinSide {
     Left = "left",
-    Right = "right"
+    Right = "right",
+    Top = "top",
+    Bottom = "bottom"
 }
 export declare enum LengthUnit {
     mm = "mm",
@@ -52,7 +54,7 @@ export declare const displayUnits = LengthUnit.mils;
 export declare const defaultFont = "Arial";
 export declare const defaultFontBold = "Arial";
 export declare const defaultFontSize = 10;
-export declare const junctionSize: number;
+export declare const junctionSize: import("./objects/ParamDefinition").NumericValue;
 export declare const PortArrowSize: number;
 export declare const PortPaddingHorizontal: number;
 export declare const PortPaddingVertical: number;
@@ -64,11 +66,10 @@ export declare const ColorScheme: {
     PinNameColor: string;
 };
 export declare enum ComponentTypes {
-    gnd = "gnd",
     net = "net",
-    label = "label",
-    point = "point",
-    frame = "frame"
+    graphic = "graphic",
+    port = "port",
+    module = "module"
 }
 export declare enum ReferenceTypes {
     function = "function",
@@ -92,4 +93,7 @@ export declare const GlobalDocumentName = "document";
 export declare const RenderFlags: {
     ShowElementFrames: boolean;
     ShowOrigin: boolean;
+    ShowGridOrigin: boolean;
+    ShowLabelBoxBounds: boolean;
+    ShowLabelOrigin: boolean;
 };

package/dist/types/helpers.d.ts

@@ -4,6 +4,7 @@ import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
 import { IParsedToken, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
 import { LengthUnit } from "./globals.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
 export declare enum JSModuleType {
     CommonJs = "cjs",
     ESM = "mjs"
@@ -47,7 +48,7 @@ export declare class UnitDimension {
     static mils(value: number): UnitDimension;
     static px(value: number): UnitDimension;
 }
-export declare function milsToMM(value: number): number;
+export declare function milsToMM(value: NumericValue | number): NumericValue;
 export declare function pxToMM(value: number): number;
 export declare const PaperGridReferences: {
     [key: string]: [rows: number, columns: number];

package/dist/types/layout.d.ts

@@ -8,9 +8,9 @@ import { Net } from './objects/Net.js';
 import { Logger } from './logger.js';
 import { Frame, FramePlotDirection } from './objects/Frame.js';
 import { BoundBox } from './utils.js';
+import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
-    placeSubgraphVersion: number;
     layoutWarnings: string[];
     showBaseFrame: boolean;
     constructor(options?: {
@@ -21,50 +21,34 @@ export declare class LayoutEngine {
     protected padLevel(value: number): string;
     runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): SheetFrame[];
     private flattenFrameItems;
-    findJunctions(wireGroups: Map<string, RenderWire[]>): {
-        junctions: RenderJunction[];
-        mergedWires: MergedWire[];
-    };
-    placeFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frameObjects: RenderFrame[]): {
-        elementFrames: RenderFrame[];
-        textObjects: RenderText[];
-    };
+    private findJunctions;
+    private placeFrames;
     collectElementFrames(frame: RenderFrame, level?: number): RenderFrame[];
     applyFrameOffset(frame: RenderFrame, level?: number): void;
-    placeAndSizeFrame(frame: RenderFrame, level?: number): void;
+    private placeAndSizeFrame;
     dumpFrame(frame: RenderFrame, level?: number): void;
-    prepareFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frame: RenderFrame, level?: number): {
-        elementFrames: RenderFrame[];
-        textObjects: RenderText[];
-    };
+    private prepareFrames;
+    private checkAddFrameTitle;
     generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
         graph: Graph;
         containerFrames: RenderFrame[];
     };
-    setGraphEdge(graph: Graph, node1: string, node2: string, edgeValue: EdgeValue): void;
-    sizeSubGraphs(graph: Graph): SubGraphInfo[];
-    walkAndPlaceGraph(graph: Graph, firstNodeId: string, subgraphNodes: string[]): void;
+    private setGraphEdge;
+    private sizeSubGraphs;
+    private walkAndPlaceGraph;
     placeSubgraphV2(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
-    placeSubgraph(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
-    placeNodeAtPosition(fromX: number, fromY: number, item: RenderItem, pin: number, depth?: number): void;
+    placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: number, depth?: number): void;
     placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
     printWarnings(): void;
 }
-type EdgeValue = [
-    instance1: string,
-    instancePin1: number,
-    instance2: string,
-    instancePin2: number,
-    priority: number
-];
 type RenderItem = RenderComponent | RenderWire | RenderText;
 export declare function applyComponentParamsToSymbol(component: ClassComponent, symbol: SymbolGraphic): void;
 export declare function getBounds(components: (RenderComponent | RenderText)[], wires: RenderWire[], junctions: RenderJunction[], frames: RenderFrame[]): BoundBox;
 export declare class RenderObject {
-    x: number;
-    y: number;
+    x: NumericValue;
+    y: NumericValue;
     isFloating: boolean;
     floatingRelativeTo: [selfPin: number, nodeId: string, pin: number][];
 }
@@ -76,16 +60,16 @@ export declare class RenderWire extends RenderObject {
         y: number;
     }[];
     netName: string;
-    constructor(x: number, y: number, segments: WireSegment[]);
+    constructor(x: NumericValue, y: NumericValue, segments: WireSegment[]);
     refreshPoints(): void;
-    getAutoPoints(value: [x: number, y: number], direction: WireAutoDirection): [dx: number, dy: number][];
+    getAutoPoints(value: [x: NumericValue, y: NumericValue], direction: WireAutoDirection): [dx: number, dy: number][];
     getWireEnd(): {
         x: number;
         y: number;
     };
     isEndAutoLength(): boolean;
     getEndAuto(): [instance: ClassComponent, pin: number];
-    setEndAuto(untilX: number, untilY: number): void;
+    setEndAuto(untilX: NumericValue, untilY: NumericValue): void;
     toString(): string;
 }
 export type MergedWire = {
@@ -105,10 +89,10 @@ export declare class RenderComponent extends RenderObject {
 }
 export declare class RenderText extends RenderObject {
     symbol: SymbolText;
-    _fontSize: number;
+    _fontSize: NumericValue;
     _fontWeight: string;
-    get fontSize(): number;
-    set fontSize(value: number);
+    get fontSize(): NumericValue;
+    set fontSize(value: NumericValue);
     get fontWeight(): string;
     set fontWeight(value: string);
     constructor(text: string);
@@ -119,15 +103,14 @@ export declare class RenderFrame extends RenderObject {
     innerItems: (RenderComponent | RenderFrame | RenderText)[];
     translateX: number;
     translateY: number;
-    padding: number;
-    gap: number;
+    padding: NumericValue;
+    gap: NumericValue;
+    borderWidth: NumericValue;
     direction: FramePlotDirection;
-    borderWidth: number;
-    width: number | null;
-    height: number | null;
-    size: string | null;
+    width: NumericValue | null;
+    height: NumericValue | null;
     subgraphId: string;
-    type: RenderFrameType;
+    renderType: RenderFrameType;
     containsTitle: boolean;
     constructor(frame: Frame, type?: RenderFrameType);
     toString(): string;
@@ -137,9 +120,9 @@ export declare enum RenderFrameType {
     Elements = 2
 }
 export declare class RenderJunction {
-    x: number;
-    y: number;
-    constructor(x: number, y: number);
+    x: NumericValue;
+    y: NumericValue;
+    constructor(x: NumericValue, y: NumericValue);
 }
 export type SheetFrame = {
     frame: RenderFrame;
@@ -151,17 +134,15 @@ export type SheetFrame = {
     mergedWires: MergedWire[];
 };
 export declare function CalculatePinPositions(component: ClassComponent): Map<number, {
-    x: number;
-    y: number;
-    angle: number;
+    x: NumericValue;
+    y: NumericValue;
+    angle: NumericValue;
 }>;
 export declare function ExtractDrawingRects(drawing: SymbolDrawingCommands): {
-    width: number;
-    height: number;
+    x: NumericValue;
+    y: NumericValue;
+    width: NumericValue;
+    height: NumericValue;
+    className: string | undefined;
 }[];
-type SubGraphInfo = {
-    firstNodeId: string;
-    components: string[];
-    bounds: BoundBox;
-};
 export { BoundBox };