circuitscript 0.0.21 → 0.0.24

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

@@ -1,6 +1,5 @@
-import { SymbolPinSide, defaultFont } from "./globals.js";
-import { Geometry, GeometryProp, HorizontalAlign, Label, VerticalAlign } from "./geometry.js";
-const defaultSymbolLineColor = '#333';
+import { SymbolPinSide, defaultFont } from "./globals.mjs";
+import { Geometry, GeometryProp, HorizontalAlign, Label, VerticalAlign } from "./geometry.mjs";
 const defaultSymbolLineWidth = 2;
 export class SymbolGraphic {
     drawPortsName = true;
@@ -56,13 +55,11 @@ export class SymbolGraphic {
         const [x, y] = pin.start;
         const useX = Math.round(x * 10000) / 10000;
         const useY = Math.round(y * 10000 / 10000);
-        if (pin) {
-            return {
-                x: useX,
-                y: useY,
-                angle: pin.angle,
-            };
-        }
+        return {
+            x: useX,
+            y: useY,
+            angle: pin.angle,
+        };
     }
     drawBounds(group) {
         const bbox = this.drawing.getBoundingBox();
@@ -191,6 +188,7 @@ export class SymbolGraphic {
         if (this.labelTexts.has(labelId)) {
             return this.labelTexts.get(labelId);
         }
+        return undefined;
     }
 }
 export function SymbolFactory(name) {
@@ -198,6 +196,7 @@ export function SymbolFactory(name) {
         case 'point':
             return new SymbolPointHidden();
     }
+    return null;
 }
 export class SymbolPointHidden extends SymbolGraphic {
     generateDrawing() {
@@ -723,7 +722,7 @@ export class SymbolDrawing {
             return item[0] === pinId;
         });
         if (pin) {
-            const [pinId, feature, angle] = pin;
+            const [, feature, angle] = pin;
             const withAngle = Geometry.rotateDegs(feature, this.angle, this.mainOrigin);
             const coords = Geometry.getCoords(withAngle);
             return {
@@ -732,6 +731,7 @@ export class SymbolDrawing {
                 angle,
             };
         }
+        return null;
     }
 }
 export class SymbolDrawingCommands extends SymbolDrawing {

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

@@ -1,10 +1,10 @@
-import { BlockTypes, ComponentTypes, GlobalNames, NoNetText, ParamKeys, ReferenceTypes } from './globals.js';
-import { ClassComponent } from './objects/ClassComponent.js';
-import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.js';
-import { Net } from './objects/Net.js';
-import { PortSide } from './objects/PinDefinition.js';
-import { Wire } from './objects/Wire.js';
-import { Frame } from './objects/Frame.js';
+import { BlockTypes, ComponentTypes, GlobalNames, NoNetText, ParamKeys, ReferenceTypes } from './globals.mjs';
+import { ClassComponent } from './objects/ClassComponent.mjs';
+import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.mjs';
+import { Net } from './objects/Net.mjs';
+import { PortSide } from './objects/PinDefinition.mjs';
+import { Wire } from './objects/Wire.mjs';
+import { Frame } from './objects/Frame.mjs';
 export class ExecutionContext {
     name;
     namespace;
@@ -118,7 +118,7 @@ export class ExecutionContext {
     }
     mergeNets(net1, net2) {
         if (net1 === net2) {
-            return;
+            return net1;
         }
         let tmpNet;
         if (net2.priority > net1.priority) {
@@ -519,6 +519,7 @@ 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) {

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

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

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

@@ -1,7 +1,7 @@
 import Flatten from '@flatten-js/core';
-import { measureTextSize2 } from './sizing.js';
-import { defaultFont } from './globals.js';
-import { NumericValue } from './objects/ParamDefinition.js';
+import { measureTextSize2 } from './sizing.mjs';
+import { defaultFont } from './globals.mjs';
+import { NumericValue } from './objects/ParamDefinition.mjs';
 export class Label extends Flatten.Polygon {
     id;
     text;
@@ -418,10 +418,6 @@ export var VerticalAlign;
     VerticalAlign["Middle"] = "middle";
     VerticalAlign["Bottom"] = "bottom";
 })(VerticalAlign || (VerticalAlign = {}));
-function getArcPoint(centerX, centerY, radius, angleDegrees) {
-    const angleRads = angleDegrees * Math.PI / 180;
-    return getArcPointRadians(centerX, centerY, radius, angleRads);
-}
 function getArcPointRadians(centerX, centerY, radius, angleRads) {
     const dx = Math.cos(angleRads);
     const dy = Math.sin(angleRads);

package/{build/src/helpers.js → dist/esm/helpers.mjs}

@@ -1,11 +1,17 @@
 import { writeFileSync } from "fs";
-import { generateKiCADNetList } from "./export.js";
-import { LayoutEngine } from "./layout.js";
-import { SequenceAction } from "./objects/ExecutionScope.js";
-import { parseFileWithVisitor } from "./parser.js";
-import { generateSVG2 } from "./render.js";
-import { SimpleStopwatch } from "./utils.js";
-import { MainVisitor } from "./visitor.js";
+import { generateKiCADNetList } from "./export.mjs";
+import { LayoutEngine } from "./layout.mjs";
+import { SequenceAction } from "./objects/ExecutionScope.mjs";
+import { parseFileWithVisitor } from "./parser.mjs";
+import { generateSVG2 } from "./render.mjs";
+import { SimpleStopwatch } from "./utils.mjs";
+import { MainVisitor } from "./visitor.mjs";
+import { createContext } from "this-file";
+export var JSModuleType;
+(function (JSModuleType) {
+    JSModuleType["CommonJs"] = "cjs";
+    JSModuleType["ESM"] = "mjs";
+})(JSModuleType || (JSModuleType = {}));
 export function renderScript(scriptData, outputPath, options) {
     const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, kicadNetlistPath = null, showStats = false } = options;
     const visitor = new MainVisitor(true);
@@ -71,3 +77,17 @@ export function renderScript(scriptData, outputPath, options) {
     }
     return svgOutput;
 }
+export function detectJSModuleType() {
+    if (typeof __filename === 'undefined' &&
+        typeof __dirname === 'undefined') {
+        return JSModuleType.ESM;
+    }
+    else {
+        return JSModuleType.CommonJs;
+    }
+}
+const context = createContext();
+export function getCurrentPath() {
+    const filename = context.filename;
+    return { filePath: filename };
+}

package/dist/esm/index.mjs

@@ -0,0 +1,13 @@
+export * from './draw_symbols.mjs';
+export * from './execute.mjs';
+export * from './export.mjs';
+export * from './geometry.mjs';
+export * from './globals.mjs';
+export * from './helpers.mjs';
+export * from './layout.mjs';
+export * from './lexer.mjs';
+export * from './logger.mjs';
+export * from './parser.mjs';
+export * from './render.mjs';
+export * from './utils.mjs';
+export * from './visitor.mjs';

package/{build/src/layout.js → dist/esm/layout.mjs}

@@ -1,12 +1,12 @@
-import graphlib from '@dagrejs/graphlib';
-import { SymbolCustom, SymbolDrawing, SymbolFactory, SymbolPlaceholder, SymbolText } from "./draw_symbols.js";
-import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { GlobalNames, ParamKeys } from './globals.js';
-import { NumericValue } from './objects/ParamDefinition.js';
-import { Geometry } from './geometry.js';
-import { Logger } from './logger.js';
-import { Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
-import { getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, toNearestGrid } from './utils.js';
+import { Graph, alg } from '@dagrejs/graphlib';
+import { SymbolCustom, SymbolDrawing, SymbolFactory, SymbolPlaceholder, SymbolText } from "./draw_symbols.mjs";
+import { FrameAction, SequenceAction } from "./objects/ExecutionScope.mjs";
+import { GlobalNames, ParamKeys } from './globals.mjs';
+import { NumericValue } from './objects/ParamDefinition.mjs';
+import { Geometry } from './geometry.mjs';
+import { Logger } from './logger.mjs';
+import { Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.mjs';
+import { getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, toNearestGrid } from './utils.mjs';
 export class LayoutEngine {
     logger;
     placeSubgraphVersion = 2;
@@ -350,7 +350,7 @@ export class LayoutEngine {
     generateLayoutGraph(sequence, nets) {
         let previousNode = null;
         let previousPin = null;
-        const graph = new graphlib.Graph({
+        const graph = new Graph({
             directed: false,
             compound: true,
         });
@@ -498,7 +498,7 @@ export class LayoutEngine {
         graph.setEdge(node1, node2, edgeValue);
     }
     sizeSubGraphs(graph) {
-        const subGraphs = graphlib.alg.components(graph);
+        const subGraphs = alg.components(graph);
         const subGraphsStarts = [];
         this.print('===== placing subgraphs =====');
         this.print('number of subgraphs: ', subGraphs.length);

package/{build/src/lexer.js → dist/esm/lexer.mjs}

@@ -1,6 +1,6 @@
 import { CommonToken } from "antlr4";
-import CircuitScriptParser from "./antlr/CircuitScriptParser.js";
-import CircuitScriptLexer from "./antlr/CircuitScriptLexer.js";
+import CircuitScriptParser from "./antlr/CircuitScriptParser.mjs";
+import CircuitScriptLexer from "./antlr/CircuitScriptLexer.mjs";
 export class MainLexer extends CircuitScriptLexer {
     tokens;
     indents;

package/{build/src/main.js → dist/esm/main.mjs}

@@ -2,12 +2,12 @@
 import { program } from 'commander';
 import figlet from 'figlet';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { readFileSync, watch } from 'fs';
-import { prepareSizing } from './sizing.js';
-import { renderScript } from './helpers.js';
+import { prepareSVGEnvironment } from './sizing.mjs';
+import { getCurrentPath, renderScript } from './helpers.mjs';
 export default async function main() {
-    const toolSrcPath = fileURLToPath(import.meta.url);
+    const { filePath } = getCurrentPath();
+    const toolSrcPath = filePath;
     const toolDirectory = path.dirname(toolSrcPath) + '/../../';
     const fontsPath = toolDirectory + '/fonts';
     const defaultLibsPath = toolDirectory + '/libs';
@@ -43,7 +43,7 @@ export default async function main() {
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
-    await prepareSizing(fontsPath);
+    await prepareSVGEnvironment(fontsPath);
     let inputFilePath = null;
     let scriptData;
     if (options.input) {

package/{build/src/objects/ClassComponent.js → dist/esm/objects/ClassComponent.mjs}

@@ -1,6 +1,6 @@
-import { SymbolDrawingCommands } from '../draw_symbols.js';
-import { PinDefinition, PinIdType } from './PinDefinition.js';
-import { PinTypes } from './PinTypes.js';
+import { SymbolDrawingCommands } from '../draw_symbols.mjs';
+import { PinDefinition, PinIdType } from './PinDefinition.mjs';
+import { PinTypes } from './PinTypes.mjs';
 export class ClassComponent {
     instanceName;
     numPins;

package/{build/src/objects/PinDefinition.js → dist/esm/objects/PinDefinition.mjs}

@@ -1,4 +1,4 @@
-import { PinTypes } from './PinTypes.js';
+import { PinTypes } from './PinTypes.mjs';
 export class PinDefinition {
     id;
     idType;

package/dist/esm/parser.mjs

@@ -0,0 +1,269 @@
+import { CharStream, CommonTokenStream, ErrorListener, ParseTreeVisitor } from 'antlr4';
+import CircuitScriptParser, { Atom_exprContext, Create_component_exprContext, Create_graphic_exprContext, Function_def_exprContext, Property_key_exprContext, Sub_exprContext } from './antlr/CircuitScriptParser.mjs';
+import { MainLexer } from './lexer.mjs';
+import { SimpleStopwatch } from './utils.mjs';
+export function parseFileWithVisitor(visitor, data) {
+    const chars = new CharStream(data);
+    const lexer = new MainLexer(chars);
+    const lexerTimer = new SimpleStopwatch();
+    const tokens = new CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parserTimer = new SimpleStopwatch();
+    const parser = new CircuitScriptParser(tokens);
+    parser.removeErrorListeners();
+    const errorListener = new CircuitscriptParserErrorListener();
+    parser.addErrorListener(errorListener);
+    const tree = parser.script();
+    let hasError = false;
+    try {
+        visitor.visit(tree);
+    }
+    catch (err) {
+        err.print(data);
+        hasError = true;
+    }
+    const parserTimeTaken = parserTimer.lap();
+    const semanticTokenVisitor = new SemanticTokensVisitor(lexer, data);
+    semanticTokenVisitor.visit(tree);
+    const semanticTokens = semanticTokenVisitor.semanticTokens;
+    const parsedTokens = prepareTokens(tokens.tokens, lexer, data);
+    const finalParsedTokens = [];
+    parsedTokens.forEach(token => {
+        const location = `${token.line}_${token.column}`;
+        if (semanticTokens.has(location)) {
+            finalParsedTokens.push(semanticTokens.get(location));
+        }
+        else {
+            finalParsedTokens.push(token);
+        }
+    });
+    return {
+        tree, parser,
+        hasParseError: errorListener.hasParseErrors(),
+        hasError,
+        parserTimeTaken,
+        lexerTimeTaken,
+        tokens: finalParsedTokens,
+    };
+}
+export class SemanticTokensVisitor extends ParseTreeVisitor {
+    parsedTokens = [];
+    lexer;
+    script;
+    semanticTokens = new Map();
+    constructor(lexer, script) {
+        super();
+        this.lexer = lexer;
+        this.script = script;
+    }
+    visit(ctx) {
+        const here = this;
+        if (Array.isArray(ctx)) {
+            return ctx.map(function (child) {
+                try {
+                    here.checkContext(child);
+                    return child.accept(this);
+                }
+                catch (err) {
+                    this.handleError(child, err);
+                }
+            }, this);
+        }
+        else {
+            try {
+                this.checkContext(ctx);
+                return ctx.accept(this);
+            }
+            catch (err) {
+                this.handleError(ctx, err);
+            }
+        }
+    }
+    handleError(ctx, err) {
+        console.log('error!', err);
+    }
+    checkContext(ctx) {
+        if (ctx instanceof Function_def_exprContext) {
+            this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
+        }
+        else if (ctx instanceof Create_component_exprContext
+            || ctx instanceof Create_graphic_exprContext) {
+            this.addSemanticToken(this.parseToken(ctx.Create(), ['defaultLibrary'], 'function'));
+        }
+        else if (ctx instanceof Atom_exprContext) {
+            if (ctx.ID()) {
+                if (ctx.trailer_expr_list().length > 0) {
+                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
+                }
+                else {
+                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'variable'));
+                }
+            }
+        }
+        else if (ctx instanceof Property_key_exprContext) {
+            let useToken = null;
+            if (ctx.ID()) {
+                useToken = ctx.ID();
+            }
+            else if (ctx.INTEGER_VALUE()) {
+                useToken = ctx.INTEGER_VALUE();
+            }
+            else if (ctx.STRING_VALUE()) {
+                useToken = ctx.STRING_VALUE();
+            }
+            useToken && this.addSemanticToken(this.parseToken(useToken, ['declaration'], 'property'));
+        }
+        else if (ctx instanceof Sub_exprContext) {
+            let useToken = null;
+            if (ctx.ID()) {
+                useToken = ctx.ID();
+            }
+            else if (ctx.Pin()) {
+                useToken = ctx.Pin();
+            }
+            useToken && this.addSemanticToken(this.parseToken(useToken, ['defaultLibrary'], 'function'));
+        }
+    }
+    addSemanticToken(parsedToken) {
+        this.semanticTokens.set(parsedToken.line + "_" + parsedToken.column, parsedToken);
+    }
+    parseToken(node, modifiers, tokenType = null) {
+        const token = node.symbol;
+        let stringValue = "";
+        let textPart = "";
+        if (this.lexer.symbolicNames[token.type] !== null && this.lexer.symbolicNames[token.type] !== undefined) {
+            stringValue = this.lexer.symbolicNames[token.type];
+            if (stringValue !== "NEWLINE") {
+                textPart = this.script.substring(token.start, token.stop + 1);
+            }
+            else {
+                textPart = token.text.length - 1;
+            }
+        }
+        else if (this.lexer.literalNames[token.type] !== null && this.lexer.literalNames[token.type] !== undefined) {
+            stringValue = this.lexer.literalNames[token.type];
+            textPart = this.script.substring(token.start, token.stop + 1);
+        }
+        else {
+            stringValue = token._text;
+        }
+        return {
+            line: token.line,
+            column: token.column,
+            length: token.stop - token.start + 1,
+            tokenType: tokenType !== null ? tokenType : stringValue,
+            tokenModifiers: modifiers,
+            textValue: textPart,
+        };
+    }
+}
+function prepareTokens(tokens, lexer, script) {
+    const parsedTokens = [];
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = script.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = script.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            if (textPart !== 0 && textPart !== '') {
+                parsedTokens.push({
+                    line: item.line,
+                    column: item.column,
+                    length: item.stop - item.start + 1,
+                    tokenType: resolveTokenType(stringValue),
+                    tokenModifiers: resolveTokenModifiers(stringValue),
+                    textValue: textPart,
+                });
+            }
+        }
+    });
+    return parsedTokens;
+}
+const languageKeywords = [
+    'break', 'branch', 'create', 'component',
+    'graphic', 'wire', 'pin', 'add', 'at', 'to',
+    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'true', 'false', 'nc', 'frame',
+];
+const operatorKeywords = [
+    'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
+];
+function resolveTokenType(tokenType) {
+    if (operatorKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'graphKeyword';
+    }
+    else if (languageKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'keyword';
+    }
+    else {
+        switch (tokenType) {
+            case 'INTEGER_VALUE':
+            case 'NUMERIC_VALUE':
+            case 'DECIMAL_VALUE':
+            case 'PERCENTAGE_VALUE':
+                return 'number';
+            case 'STRING_VALUE':
+                return 'string';
+            case 'ID':
+                return 'variable';
+            case 'Define':
+                return 'keyword';
+            case 'COMMENT':
+                return 'comment';
+        }
+        return null;
+    }
+}
+function resolveTokenModifiers(tokenType) {
+    return [];
+}
+function dumpTokens(tokens, lexer, scriptData) {
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = scriptData.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = scriptData.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            console.log('line', item.line + ':' + item.column, `\t${stringValue} (${item.type})`.padEnd(30), textPart);
+        }
+    });
+}
+export class CircuitscriptParserErrorListener extends ErrorListener {
+    syntaxErrorCounter = 0;
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        console.log("Syntax error at line", line, ':', column, ' - ', msg);
+        this.syntaxErrorCounter++;
+    }
+    hasParseErrors() {
+        return (this.syntaxErrorCounter > 0);
+    }
+}

package/{build/src/regenerate-tests.js → dist/esm/regenerate-tests.mjs}

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { renderScript } from './helpers.js';
+import { renderScript } from './helpers.mjs';
 const mainDir = './__tests__/renderData/';
 const cstFiles = [];
 const files = fs.readdirSync(mainDir);

package/{build/src/render.js → dist/esm/render.mjs}

@@ -1,12 +1,11 @@
-import { createSVGWindow } from 'svgdom';
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { RenderFrameType, getBounds } from "./layout.js";
-import { applyFontsToSVG } from './sizing.js';
-import { ParamKeys, bodyColor, junctionColor, junctionSize, wireColor } from './globals.js';
-import { NumericValue } from './objects/ParamDefinition.js';
-import { getBoundsSize } from './utils.js';
+import { RenderFrameType, getBounds } from "./layout.mjs";
+import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
+import { ParamKeys, bodyColor, junctionColor, junctionSize, wireColor } from './globals.mjs';
+import { NumericValue } from './objects/ParamDefinition.mjs';
+import { getBoundsSize } from './utils.mjs';
 export function generateSVG2(graph) {
-    const window = createSVGWindow();
+    const window = getCreateSVGWindow()();
     const document = window.document;
     registerWindow(window, document);
     const canvas = SVG(document.documentElement);
@@ -36,7 +35,7 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         symbolGroup.translate(x, y);
         const { symbol = null } = item;
         if (symbol !== null && symbol) {
-            let extra = {};
+            const extra = {};
             if (item.component.parameters.has('__is_net')) {
                 extra.net_name = item.component.parameters.get(ParamKeys.net_name);
             }
@@ -150,19 +149,3 @@ function drawGrid(group, canvasSize) {
         color: '#aaa'
     });
 }
-function calculateBoundingBox(components) {
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minX = Number.POSITIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    components.forEach(item => {
-        minX = Math.min(item.x, minX);
-        maxX = Math.max(item.x + item.width, maxX);
-        minY = Math.min(item.y, minY);
-        maxY = Math.max(item.y + item.height, maxY);
-    });
-    return {
-        width: (maxX - minX),
-        height: (maxY - minY)
-    };
-}

package/{build/src/sizing.js → dist/esm/sizing.mjs}

@@ -1,13 +1,27 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { config, createSVGWindow } from 'svgdom';
-import { HorizontalAlign, VerticalAlign } from './geometry.js';
-import { defaultFont } from './globals.js';
+import { HorizontalAlign, VerticalAlign } from './geometry.mjs';
+import { defaultFont } from './globals.mjs';
+import { JSModuleType, detectJSModuleType } from './helpers.mjs';
 let MainCanvas = null;
 const supportedFonts = {};
-export async function prepareSizing(fontsPath) {
-    await config.setFontDir(fontsPath)
-        .setFontFamilyMappings(supportedFonts)
-        .preloadFonts();
+let globalCreateSVGWindow;
+export async function prepareSVGEnvironment(fontsPath) {
+    const moduleType = detectJSModuleType();
+    if (moduleType === JSModuleType.CommonJs) {
+        const { config, createSVGWindow } = await import('svgdom');
+        globalCreateSVGWindow = createSVGWindow;
+        if (fontsPath !== null) {
+            await config.setFontDir(fontsPath)
+                .setFontFamilyMappings(supportedFonts)
+                .preloadFonts();
+        }
+    }
+}
+export function getCreateSVGWindow() {
+    if (globalCreateSVGWindow === undefined) {
+        throw "SVG environment is not set up yet";
+    }
+    return globalCreateSVGWindow;
 }
 export function applyFontsToSVG(canvas) {
 }
@@ -18,7 +32,7 @@ const measureTextSizeCache = {};
 const measureTextSizeCacheHits = {};
 export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {
     if (MainCanvas === null) {
-        const window = createSVGWindow();
+        const window = getCreateSVGWindow()();
         const { document } = window;
         registerWindow(window, document);
         MainCanvas = SVG(document.documentElement);