circuitscript 0.1.4 → 0.1.7

package/dist/esm/{builtinMethods.mjs → builtinMethods.js}

@@ -1,6 +1,16 @@
 import Big from "big.js";
-import { numeric, NumericValue } from "./objects/ParamDefinition";
-import { resolveToNumericValue } from "./utils";
+import { numeric, NumericValue } from "./objects/ParamDefinition.js";
+import { resolveToNumericValue } from "./utils.js";
+const builtInMethods = [
+    ['enumerate', enumerate],
+    ['toMils', toMils],
+    ['range', range],
+    ['len', objectLength],
+    ['arrayPush', arrayPush],
+    ['arrayGet', arrayGet],
+    ['print', null],
+];
+export const buildInMethodNamesList = builtInMethods.map(item => item[0]);
 export function linkBuiltInMethods(context, visitor) {
     context.createFunction('print', (params) => {
         const args = getPositionParams(params);
@@ -12,18 +22,14 @@ export function linkBuiltInMethods(context, visitor) {
         visitor.printStream.push(printedValue);
         return [visitor, printedValue];
     });
-    const builtIns = [
-        ['enumerate', enumerate],
-        ['toMils', toMils],
-        ['range', range],
-        ['len', objectLength],
-    ];
-    builtIns.forEach(([functionName, functionImpl]) => {
-        context.createFunction(functionName, params => {
-            const args = getPositionParams(params);
-            const functionReturn = functionImpl(...args);
-            return [visitor, functionReturn];
-        });
+    builtInMethods.forEach(([functionName, functionImpl]) => {
+        if (functionImpl !== null) {
+            context.createFunction(functionName, params => {
+                const args = getPositionParams(params);
+                const functionReturn = functionImpl(...args);
+                return [visitor, functionReturn];
+            });
+        }
     });
 }
 function range(...args) {
@@ -80,6 +86,26 @@ function objectLength(obj) {
         }
     }
 }
+function arrayPush(arrayObject, valueToPush) {
+    if (!Array.isArray(arrayObject)) {
+        throw "Invalid array object to push";
+    }
+    arrayObject.push(valueToPush);
+    return arrayObject;
+}
+function arrayGet(arrayObject, index) {
+    if (!Array.isArray(arrayObject)) {
+        throw "Invalid array object to get";
+    }
+    let useValue;
+    if (index instanceof NumericValue) {
+        useValue = index.toNumber();
+    }
+    else {
+        useValue = index;
+    }
+    return arrayObject[useValue];
+}
 function getPositionParams(params) {
     return params.map(([, , value]) => value);
 }

package/dist/esm/{draw_symbols.mjs → draw_symbols.js}

@@ -1,10 +1,10 @@
-import { milsToMM } from "./helpers.mjs";
-import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, RenderFlags, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.mjs";
-import { Geometry, GeometryProp, HorizontalAlign, HorizontalAlignProp, Textbox, VerticalAlign, VerticalAlignProp } from "./geometry.mjs";
-import { PinTypes } from "./objects/PinTypes.mjs";
-import { roundValue, throwWithContext } from "./utils.mjs";
-import { DeclaredReference, UndeclaredReference } from "./objects/types.mjs";
-import { numeric, NumericValue } from "./objects/ParamDefinition.mjs";
+import { milsToMM } from "./helpers.js";
+import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, RenderFlags, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.js";
+import { Geometry, GeometryProp, HorizontalAlign, HorizontalAlignProp, Textbox, VerticalAlign, VerticalAlignProp } from "./geometry.js";
+import { PinTypes } from "./objects/PinTypes.js";
+import { roundValue, throwWithContext } from "./utils.js";
+import { DeclaredReference, UndeclaredReference } from "./objects/types.js";
+import { numeric, NumericValue } from "./objects/ParamDefinition.js";
 export class SymbolGraphic {
     drawPortsName = true;
     displayBounds = false;
@@ -789,7 +789,10 @@ export class SymbolCustom extends SymbolGraphic {
     calculateSize() {
         const tmpPinSpacing = this.pinSpacing.toNumber();
         const tmpPinLength = this.pinLength.toNumber();
-        const { [SymbolPinSide.Top]: maxTopPins, [SymbolPinSide.Bottom]: maxBottomPins, [SymbolPinSide.Left]: maxLeftPins, [SymbolPinSide.Right]: maxRightPins } = this.pinMaxPositions;
+        const maxTopPins = this.pinMaxPositions.get(SymbolPinSide.Top);
+        const maxBottomPins = this.pinMaxPositions.get(SymbolPinSide.Bottom);
+        const maxLeftPins = this.pinMaxPositions.get(SymbolPinSide.Left);
+        const maxRightPins = this.pinMaxPositions.get(SymbolPinSide.Right);
         const bodyWidthFromPins = numeric((1 + Math.max(maxTopPins, maxBottomPins)) * tmpPinSpacing);
         const bodyWidth = Math.max(bodyWidthFromPins.toNumber(), this.bodyWidth.toNumber());
         let tmpBodyHeight = 0;

package/dist/esm/environment.js

@@ -0,0 +1,110 @@
+import { registerWindow, SVG } from "@svgdotjs/svg.js";
+import fs from 'fs';
+import path from "path";
+import { TOOL_VERSION } from "./globals.js";
+import { RuntimeExecutionError } from "./utils.js";
+export class NodeScriptEnvironment {
+    static _instance = null;
+    static setInstance(instance) {
+        NodeScriptEnvironment._instance = instance;
+    }
+    static getInstance() {
+        return NodeScriptEnvironment._instance;
+    }
+    useModuleDirectoryPath = null;
+    useDefaultLibsPath = null;
+    globalCreateSVGWindow = null;
+    supportedFonts = {
+        'Arial': 'Arial.ttf',
+    };
+    setModuleDirectory(path) {
+        this.useModuleDirectoryPath = path;
+    }
+    setDefaultLibsPath(path) {
+        this.useDefaultLibsPath = path;
+    }
+    getPackageVersion() {
+        return TOOL_VERSION;
+    }
+    getModuleDirectory() {
+        if (this.useModuleDirectoryPath !== null) {
+            return this.useModuleDirectoryPath;
+        }
+        if (typeof __dirname !== 'undefined') {
+            return __dirname;
+        }
+        const stackLine = new Error().stack?.split('\n')[1];
+        if (stackLine) {
+            const fileMatch = stackLine.match(/\((.+)\:[\d]+\:[\d]+\)/);
+            if (fileMatch) {
+                const filePath = fileMatch[1].replace('file://', '');
+                return path.dirname(filePath);
+            }
+        }
+        throw new RuntimeExecutionError("Failed to get current module directory");
+    }
+    getRelativeToModule(filePath) {
+        return path.join(this.getModuleDirectory(), filePath);
+    }
+    getRelativeToDefaultLibs(filePath) {
+        return path.join(this.getDefaultLibsPath(), filePath);
+    }
+    getToolsPath() {
+        return path.normalize(this.getModuleDirectory() + '/../');
+    }
+    getFontsPath() {
+        return path.normalize(this.getToolsPath() + "fonts");
+    }
+    getDefaultLibsPath() {
+        if (this.useDefaultLibsPath !== null) {
+            return this.useDefaultLibsPath;
+        }
+        return path.normalize(this.getToolsPath() + "libs");
+    }
+    async prepareSVGEnvironmentInternal(fontsPath) {
+        try {
+            const dynamicImport = new Function('specifier', 'return import(specifier)');
+            const { config, createSVGWindow } = await dynamicImport('svgdom');
+            this.globalCreateSVGWindow = createSVGWindow;
+            if (fontsPath !== null) {
+                await config.setFontDir(fontsPath)
+                    .setFontFamilyMappings(this.supportedFonts)
+                    .preloadFonts();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load svgdom ESM module: ${error}`);
+        }
+    }
+    createSVGWindow() {
+        if (this.globalCreateSVGWindow === null) {
+            throw new Error("SVG environment is not set up yet. Call prepareSVGEnvironment() first.");
+        }
+        return this.globalCreateSVGWindow();
+    }
+    textMeasurementCanvas;
+    getCanvasWindow() {
+        if (this.textMeasurementCanvas === undefined) {
+            const window = this.createSVGWindow();
+            const { document } = window;
+            registerWindow(window, document);
+            this.textMeasurementCanvas = SVG(document.documentElement);
+        }
+        return this.textMeasurementCanvas;
+    }
+    prepareSVGEnvironment() {
+        return this.prepareSVGEnvironmentInternal(this.getFontsPath());
+    }
+    async readFile(path, options) {
+        return fs.promises.readFile(path, options);
+    }
+    async exists(path) {
+        try {
+            fs.promises.access(path, fs.constants.F_OK);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}

package/dist/esm/{execute.mjs → execute.js}

@@ -1,15 +1,16 @@
-import { BlockTypes, ComponentTypes, GlobalNames, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide } from './globals.mjs';
-import { ClassComponent, ModuleComponent } from './objects/ClassComponent.mjs';
-import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.mjs';
-import { Net } from './objects/Net.mjs';
-import { numeric } from './objects/ParamDefinition.mjs';
-import { PortSide } from './objects/PinDefinition.mjs';
-import { DeclaredReference, Direction } from './objects/types.mjs';
-import { Wire } from './objects/Wire.mjs';
-import { Frame } from './objects/Frame.mjs';
-import { CalculatePinPositions } from './layout.mjs';
-import { UnitDimension } from './helpers.mjs';
-import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
+import { BlockTypes, ComponentTypes, Delimiter1, GlobalNames, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide } from './globals.js';
+import { ClassComponent, ModuleComponent } from './objects/ClassComponent.js';
+import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.js';
+import { Net } from './objects/Net.js';
+import { numeric } from './objects/ParamDefinition.js';
+import { PortSide } from './objects/PinDefinition.js';
+import { DeclaredReference, Direction } from './objects/types.js';
+import { Wire } from './objects/Wire.js';
+import { Frame } from './objects/Frame.js';
+import { CalculatePinPositions } from './layout.js';
+import { UnitDimension } from './helpers.js';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
+import { getBlockTypeString, RuntimeExecutionError } from './utils.js';
 export class ExecutionContext {
     name;
     namespace;
@@ -18,6 +19,7 @@ export class ExecutionContext {
     scope;
     tmpPointId = 0;
     resolveNet = null;
+    resolveComponentPinNet;
     stopFurtherExpressions = false;
     returnValue = null;
     silent = false;
@@ -34,13 +36,6 @@ export class ExecutionContext {
         this.scope = ExecutionScope.create();
         this.scope.indentLevel = indentLevel;
         this.setupRoot();
-        if (name === '__') {
-            this.scope.sequence.push([
-                SequenceAction.At,
-                this.scope.componentRoot,
-                this.scope.currentPin
-            ]);
-        }
         this.silent = silent;
         this.log('create new execution context', this.namespace, this.name, this.scope.indentLevel);
         this.parentContext = parent;
@@ -66,12 +61,12 @@ export class ExecutionContext {
         this.scope.componentRoot = componentRoot;
     }
     getUniqueInstanceName() {
-        const tmpName = 'COMP_' + this.scope.unnamedCounter;
+        const tmpName = `COMP${Delimiter1}${this.scope.unnamedCounter}`;
         this.scope.unnamedCounter += 1;
         return tmpName;
     }
     getUniqueNetName() {
-        const tmpName = 'NET_' + this.scope.netCounter;
+        const tmpName = `NET${Delimiter1}${this.scope.netCounter}`;
         this.scope.netCounter++;
         return tmpName;
     }
@@ -81,7 +76,7 @@ export class ExecutionContext {
     linkComponentPinNet(component1, component1Pin, component2, component2Pin) {
         const net1 = this.scope.getNet(component1, component1Pin);
         const net2 = this.scope.getNet(component2, component2Pin);
-        this.log('link nets', component1, component1Pin, net1, 'to', component2, component2Pin, net2);
+        this.log('link nets', component1, component1Pin, net1, 'priority:' + net1?.priority, 'to', component2, component2Pin, net2, 'priority:' + net2?.priority);
         let returnNet;
         if (net1 === null && net2 === null) {
             const tmpNet = new Net(this.netNamespace, this.getUniqueNetName());
@@ -105,7 +100,7 @@ export class ExecutionContext {
                 returnNet = net1;
             }
         }
-        this.log('final net after link: ', returnNet);
+        this.log('final net after link: ', returnNet, returnNet.priority);
         return returnNet;
     }
     mergeNets(net1, net2) {
@@ -166,8 +161,9 @@ export class ExecutionContext {
                 tmpNet = new Net(this.netNamespace, netName, priority);
                 this.log('net not found, added net instance', tmpNet.namespace, tmpNet.name);
             }
-            this.scope.setNet(component, 1, tmpNet);
-            this.log('set net', netName, 'component', component);
+            const defaultPin = 1;
+            this.scope.setNet(component, defaultPin, tmpNet);
+            this.log('set net', netName, 'component', component, defaultPin);
         }
         const { pins: pinSides, maxPositions } = getPortSide(component.pins, component.arrangeProps);
         component.pinsMaxPositions = maxPositions;
@@ -209,14 +205,13 @@ export class ExecutionContext {
         this.atComponent(component, nextPin, {
             addSequence: true
         });
-        this.printPoint();
         return this.getCurrentPoint();
     }
     toComponent(component, pinId, options) {
         this.log('to component');
         const { addSequence = false } = options ?? {};
         if (!(component instanceof ClassComponent)) {
-            throw "Not a valid component!";
+            throw new RuntimeExecutionError("Not a valid component!");
         }
         if (pinId === null) {
             pinId = component.getDefaultPin();
@@ -227,7 +222,7 @@ export class ExecutionContext {
             }
             else {
                 console.trace();
-                throw ('Invalid pin number ' +
+                throw new RuntimeExecutionError('Invalid pin number ' +
                     pinId +
                     ' in ' +
                     component.instanceName);
@@ -283,6 +278,7 @@ export class ExecutionContext {
         return this.getCurrentPoint();
     }
     copyComponent(component) {
+        this.log('create clone of net component:', component);
         let componentCopy = null;
         if (!this.scope.copyIDs.has(component.instanceName)) {
             this.scope.copyIDs.set(component.instanceName, 0);
@@ -295,14 +291,24 @@ export class ExecutionContext {
         const cloneInstanceName = component.instanceName + ':' + idNum;
         this.scope.instances.set(cloneInstanceName, componentCopy);
         componentCopy.instanceName = cloneInstanceName;
-        this.linkComponentPinNet(component, 1, componentCopy, 1);
+        const defaultPin = 1;
+        if (this.scope.getNet(component, defaultPin) === null) {
+            const foundNet = this.resolveComponentPinNet(component, defaultPin);
+            if (foundNet !== null) {
+                this.log('found net in upper scopes', foundNet);
+                this.scope.setNet(component, defaultPin, foundNet);
+            }
+        }
+        this.linkComponentPinNet(component, defaultPin, componentCopy, defaultPin);
         this.log('created clone of net component:', cloneInstanceName);
         return componentCopy;
     }
     enterBlocks(blockType) {
-        if (blockType === BlockTypes.Point || blockType === BlockTypes.Parallel) {
-            const key = blockType === BlockTypes.Point ? 'point' : 'parallel';
-            this.addPoint(`_${key}.${this.name}.${this.tmpPointId}`, false);
+        if (blockType === BlockTypes.Point
+            || blockType === BlockTypes.Parallel
+            || blockType === BlockTypes.Branch) {
+            const key = getBlockTypeString(blockType);
+            this.addPoint(`${Delimiter1}${key}.${this.name}.${this.tmpPointId}`, false);
             this.tmpPointId += 1;
         }
         this.scope.blockStack.set(this.scope.indentLevel, {
@@ -341,6 +347,7 @@ export class ExecutionContext {
         const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
         stackRef['block_index'] = blockIndex;
         const { type: blockType } = stackRef;
+        const blockTypeName = getBlockTypeString(blockType);
         stackRef['inner_blocks'].set(blockIndex, {
             last_net: null,
             ignore_last_net: false,
@@ -353,7 +360,7 @@ export class ExecutionContext {
             const { entered_at: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
-        this.log(`enter inner block of type (${blockType}) >>>`);
+        this.log(`enter inner block of type (${blockTypeName}) >>>`);
         this.scope.indentLevel += 1;
     }
     exitBlock(blockIndex) {
@@ -377,7 +384,7 @@ export class ExecutionContext {
         }
         else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
             if (blockIndex === 0) {
-                const pointIdName = (blockType === BlockTypes.Join) ? '_join' : '_parallel';
+                const pointIdName = `${Delimiter1}${getBlockTypeString(blockType)}`;
                 this.addPoint(`${pointIdName}.${this.name}.${this.tmpPointId}`, false);
                 this.tmpPointId += 1;
                 stackRef['final_point'] = [
@@ -411,7 +418,7 @@ export class ExecutionContext {
             const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1 - i);
             const { entered_at } = stackRef;
             const component = entered_at[0];
-            if (component.instanceName.startsWith('_point.')) {
+            if (component.instanceName.startsWith(`${Delimiter1}point.`)) {
                 return entered_at;
             }
         }
@@ -526,14 +533,12 @@ export class ExecutionContext {
         const currentComponent = this.scope.currentComponent;
         const currentPin = this.scope.currentPin;
         const currentWireId = this.scope.currentWireId;
-        const gndCopyIdOffset = 0;
         const tmpInstances = childScope.instances;
         const tmpNets = childScope.getNets();
         for (const [instanceName, component] of tmpInstances) {
             const newInstanceName = `${namespace}.${instanceName}`;
             component.instanceName = newInstanceName;
-            if (component === childScope.componentGnd ||
-                component === childScope.componentRoot) {
+            if (component === childScope.componentRoot) {
                 continue;
             }
             if (!this.scope.instances.has(newInstanceName)) {
@@ -543,6 +548,16 @@ export class ExecutionContext {
                 throw "Invalid instance name to merge into parent scope!";
             }
         }
+        const childScopeUniqueNets = new Set(tmpNets.map(([, , net]) => net));
+        childScopeUniqueNets.forEach(net => {
+            if (net.priority === 0
+                && this.scope.getNetWithNamespacePath(net.namespace, net.name) !== null) {
+                this.log('net namespace and name already used in parent scope', net);
+                const newNetName = this.getUniqueNetName();
+                net.name = newNetName;
+                this.log('assigned new name: ', net);
+            }
+        });
         tmpNets.forEach(([component, pin, net]) => {
             this.scope.setNet(component, pin, net);
         });
@@ -557,7 +572,6 @@ export class ExecutionContext {
                     this.scope.setNet(currentComponent, currentPin, netConnectedToRoot);
                     currentNet = tmpNet;
                 }
-                netConnectedToRoot.priority = currentNet.priority - 1;
                 this.toComponent(tmpRoot, 1);
             }
         }
@@ -646,25 +660,65 @@ export class ExecutionContext {
             this.log('Warning: ' + pointId + ' is being redefined');
         }
         const useName = userDefined ? 'point.' + pointId : pointId;
-        const componentPoint = ClassComponent.simple(useName, 1, "point");
-        componentPoint.displayProp = this.getPointSymbol();
+        const componentPoint = ClassComponent.simple(useName, 1);
+        componentPoint.displayProp = this.getPointSymbol(useName);
         componentPoint.typeProp = ComponentTypes.net;
+        let usePointLinkComponent = null;
+        if (this.scope.currentComponent._pointLinkComponent) {
+            usePointLinkComponent = this.scope.currentComponent._pointLinkComponent;
+        }
+        else {
+            usePointLinkComponent = this.scope.currentComponent;
+        }
+        componentPoint._pointLinkComponent = usePointLinkComponent;
         this.scope.instances.set(pointId, componentPoint);
         this.toComponent(componentPoint, 1, { addSequence: true });
         return this.getCurrentPoint();
     }
-    getPointSymbol() {
-        return new SymbolDrawingCommands(() => {
-            return [
-                [PlaceHolderCommands.pin,
-                    [numeric(1), numeric(0), numeric(0),
-                        numeric(0), numeric(0)],
+    getPointSymbol(name = "") {
+        const commands = [
+            [PlaceHolderCommands.pin,
+                [numeric(1), numeric(0), numeric(0),
+                    numeric(0), numeric(0)],
+                new Map([
+                    ["display_pin_id", false]
+                ]),
+                null
+            ]
+        ];
+        if (false) {
+            commands.push(...[
+                [PlaceHolderCommands.lineColor,
+                    ["red"],
+                    new Map(), null
+                ],
+                [PlaceHolderCommands.hline,
+                    [numeric(-25), numeric(0), numeric(50)],
+                    new Map(),
+                    null
+                ],
+                [PlaceHolderCommands.vline,
+                    [numeric(0), numeric(-25), numeric(50)],
+                    new Map(),
+                    null
+                ],
+                [PlaceHolderCommands.hline,
+                    [numeric(0), numeric(0),
+                        numeric(10)],
+                    new Map([]), null
+                ],
+                [PlaceHolderCommands.text,
+                    [],
                     new Map([
-                        ["display_pin_id", false]
+                        ["content", name],
+                        ["fontSize", numeric(10)],
                     ]),
                     null
                 ]
-            ];
+            ]);
+        }
+        return new SymbolDrawingCommands(() => {
+            return commands;
         });
     }
     setProperty(nameWithProp, value) {
@@ -800,12 +854,11 @@ function isWireSegmentsEndAuto(segments) {
 }
 export function getPortSide(pins, arrangeProps) {
     const result = [];
-    const maxPositions = {
-        [SymbolPinSide.Left]: 0,
-        [SymbolPinSide.Right]: 0,
-        [SymbolPinSide.Top]: 0,
-        [SymbolPinSide.Bottom]: 0,
-    };
+    const maxPositions = new Map();
+    maxPositions.set(SymbolPinSide.Left, 0);
+    maxPositions.set(SymbolPinSide.Right, 0);
+    maxPositions.set(SymbolPinSide.Top, 0);
+    maxPositions.set(SymbolPinSide.Bottom, 0);
     if (arrangeProps === null) {
         let counter = 0;
         for (const [pinId] of pins) {
@@ -823,8 +876,8 @@ export function getPortSide(pins, arrangeProps) {
         const rightSideItems = result.filter(item => {
             return item.side === PortSide.EAST;
         });
-        maxPositions[SymbolPinSide.Left] = leftSideItems.length;
-        maxPositions[SymbolPinSide.Right] = rightSideItems.length;
+        maxPositions.set(SymbolPinSide.Left, leftSideItems.length);
+        maxPositions.set(SymbolPinSide.Right, rightSideItems.length);
     }
     else {
         let counter = pins.size;
@@ -871,7 +924,7 @@ export function getPortSide(pins, arrangeProps) {
                     }
                 }
             });
-            maxPositions[key] = position;
+            maxPositions.set(key, position);
         }
     }
     return {

package/dist/esm/{export.mjs → export.js}

@@ -1,5 +1,5 @@
-import { ComponentTypes, NoNetText } from "./globals.mjs";
-import { NumericValue } from "./objects/ParamDefinition.mjs";
+import { ComponentTypes, NoNetText } from "./globals.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
 export function generateKiCADNetList(netlist) {
     const componentsList = [];
     const nets = {};

package/dist/esm/{geometry.mjs → geometry.js}

@@ -1,9 +1,9 @@
 import Flatten from '@flatten-js/core';
-import { measureTextSize2 } from './sizing.mjs';
-import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from './globals.mjs';
-import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
-import { AllPinTypes, PinTypes } from './objects/PinTypes.mjs';
-import { roundValue } from './utils.mjs';
+import { measureTextSize2 } from './sizing.js';
+import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from './globals.js';
+import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { AllPinTypes, PinTypes } from './objects/PinTypes.js';
+import { roundValue } from './utils.js';
 export class Textbox extends Flatten.Polygon {
     id;
     text;
@@ -384,6 +384,7 @@ export class Geometry {
                             replaceSegments(existingSegments, j, splitCurrentSegments);
                             replaceSegments(newSegments, k, splitNewSegments);
                             j = Math.max(0, j - 1);
+                            break;
                         }
                     }
                 }

package/dist/esm/{globals.mjs → globals.js}

@@ -1,7 +1,10 @@
-import { numeric } from "./objects/ParamDefinition";
+import { numeric } from "./objects/ParamDefinition.js";
+export const TOOL_VERSION = '0.1.5';
+export const Delimiter1 = '-';
+export const DoubleDelimiter1 = `${Delimiter1}${Delimiter1}`;
 export var GlobalNames;
 (function (GlobalNames) {
-    GlobalNames["__root"] = "__root";
+    GlobalNames["__root"] = "--root";
     GlobalNames["symbol"] = "symbol";
 })(GlobalNames || (GlobalNames = {}));
 export const NoNetText = 'NO_NET';
@@ -26,6 +29,9 @@ export var SymbolPinSide;
     SymbolPinSide["Top"] = "top";
     SymbolPinSide["Bottom"] = "bottom";
 })(SymbolPinSide || (SymbolPinSide = {}));
+export const ValidPinSides = [
+    SymbolPinSide.Left, SymbolPinSide.Right, SymbolPinSide.Top, SymbolPinSide.Bottom
+];
 export var LengthUnit;
 (function (LengthUnit) {
     LengthUnit["mm"] = "mm";
@@ -108,3 +114,4 @@ export const RenderFlags = {
     ShowLabelBoxBounds: false,
     ShowLabelOrigin: false,
 };
+export const SymbolValidatorContext = '_sym';