circuitscript 0.1.4 → 0.1.7

package/dist/esm/helpers.js

@@ -0,0 +1,377 @@
+import { writeFileSync, createWriteStream, existsSync, mkdirSync } from "fs";
+import path from "path";
+import PDFDocument from "pdfkit";
+import { generateKiCADNetList, printTree } from "./export.js";
+import { LayoutEngine } from "./layout.js";
+import { parseFileWithVisitor } from "./parser.js";
+import { generatePdfOutput, generateSvgOutput, renderSheetsToSVG } from "./render.js";
+import { generateDebugSequenceAction, ParseError, ParseSyntaxError, RenderError, resolveToNumericValue, RuntimeExecutionError, sequenceActionString, SimpleStopwatch } from "./utils.js";
+import { ParserVisitor } from "./visitor.js";
+import { SymbolValidatorVisitor } from "./validate/SymbolValidatorVisitor.js";
+import { SymbolValidatorResolveVisitor } from "./validate/SymbolValidatorResolveVisitor.js";
+import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy, RecognitionException } from "antlr4ng";
+import { MainLexer } from "./lexer.js";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
+import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
+import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } from "./globals.js";
+import { FrameParamKeys } from "./objects/Frame.js";
+import Big from "big.js";
+import { Logger } from "./logger.js";
+export var JSModuleType;
+(function (JSModuleType) {
+    JSModuleType["CommonJs"] = "cjs";
+    JSModuleType["ESM"] = "mjs";
+})(JSModuleType || (JSModuleType = {}));
+export function prepareFile(textData) {
+    const chars = CharStream.fromString(textData);
+    const lexer = new MainLexer(chars);
+    const lexerTimer = new SimpleStopwatch();
+    const tokens = new CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parser = new CircuitScriptParser(tokens);
+    return {
+        parser,
+        lexer,
+        lexerTimeTaken,
+        tokens
+    };
+}
+export async function getSemanticTokens(scriptData, options) {
+    const { parser, lexer, tokens } = prepareFile(scriptData);
+    const tree = parser.script();
+    const visitor = new SemanticTokensVisitor(true, null, options.environment, lexer, scriptData);
+    parser.removeErrorListeners();
+    visitor.onImportFile = async (visitor, filePath, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('Error while parsing: ', err);
+                hasParseError = true;
+                hasError = true;
+                throw new ParseError(`Error parsing semantic tokens in imported file: ${err}`);
+            }
+        }
+        else {
+            console.log('File does not exist');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    await visitor.visitAsync(tree);
+    const semanticTokens = visitor.getTokens();
+    const parsedTokens = prepareTokens(tokens.getTokens(), lexer, scriptData);
+    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 {
+        visitor,
+        parsedTokens: finalParsedTokens
+    };
+}
+class TokenErrorListener extends BaseErrorListener {
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        console.log(msg);
+    }
+}
+export class ParseErrorStrategy extends DefaultErrorStrategy {
+    reportUnwantedToken(recognizer) {
+        if (this.inErrorRecoveryMode(recognizer)) {
+            return;
+        }
+        this.beginErrorCondition(recognizer);
+        const t = recognizer.getCurrentToken();
+        const tokenName = this.getTokenErrorDisplay(t);
+        const msg = "extraneous input " + tokenName;
+        recognizer.notifyErrorListeners(msg, t, null);
+        this.endErrorCondition(recognizer);
+    }
+}
+export async function validateScript(filePath, scriptData, options) {
+    const { parser } = prepareFile(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new ParseErrorStrategy();
+    parser.addErrorListener(new TokenErrorListener());
+    const tree = parser.script();
+    const visitor = new SymbolValidatorVisitor(true, null, options.environment);
+    visitor.enterFile(filePath);
+    visitor.onImportFile = async (visitor, filePath, textData) => {
+        visitor.enterFile(filePath);
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                await visitor.visitAsync(tree);
+                visitor.exitFile();
+            }
+            catch (err) {
+                console.log('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+                throw new ParseError(`Error parsing validation in imported file: ${err}`);
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    await visitor.visitAsync(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, options.environment);
+    visitorResolver.enterFile(filePath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    await visitorResolver.visitAsync(tree);
+    return visitorResolver;
+}
+export async function renderScript(scriptData, outputPath, options) {
+    const { dumpNets = false, dumpData = false, showStats = false, environment } = options;
+    const errors = [];
+    const onErrorHandler = (message, context, error) => {
+        if (error && error instanceof RuntimeExecutionError) {
+            errors.push(error);
+        }
+        else if (error && error instanceof RecognitionException) {
+            errors.push(new ParseSyntaxError(message, context.start, context.stop));
+        }
+        else {
+            errors.push(new ParseError(message, context.start, context.stop));
+        }
+    };
+    const visitor = new ParserVisitor(true, onErrorHandler, options.environment);
+    visitor.onImportFile = async (visitor, filePath, fileData) => {
+        const { hasError, hasParseError } = await parseFileWithVisitor(visitor, fileData);
+        if (hasError || hasParseError) {
+            throw new ParseError(`Error parsing imported file: ${filePath}`, undefined, undefined, filePath);
+        }
+        return { hasError, hasParseError };
+    };
+    visitor.log('reading file');
+    visitor.log('done reading file');
+    const { tree, parser, parserTimeTaken, lexerTimeTaken } = await parseFileWithVisitor(visitor, scriptData);
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    if (dumpNets) {
+        const nets = visitor.dumpNets();
+        nets.forEach(item => console.log(item.join(" | ")));
+    }
+    const dumpDirectory = environment.getRelativeToModule('/dump/');
+    if (dumpData) {
+        console.log('Dump data to:', dumpDirectory);
+        if (!existsSync(dumpDirectory)) {
+            mkdirSync(dumpDirectory);
+        }
+    }
+    dumpData && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
+    dumpData && writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    let svgOutput = "";
+    if (errors.length === 0) {
+        const { frameComponent } = visitor.applySheetFrameComponent();
+        try {
+            visitor.annotateComponents();
+        }
+        catch (err) {
+            throw new RenderError(`Error during component annotation: ${err}`, 'annotation');
+        }
+        const { sequence, nets } = visitor.getGraph();
+        const tmpSequence = generateDebugSequenceAction(sequence).map(item => sequenceActionString(item));
+        dumpData && writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
+        try {
+            let fileExtension = null;
+            let outputDefaultZoom = defaultZoomScale;
+            if (outputPath) {
+                fileExtension = path.extname(outputPath).substring(1);
+                if (fileExtension === "pdf") {
+                    outputDefaultZoom = 1;
+                }
+            }
+            if (fileExtension === 'net') {
+                const { tree: kicadNetList, missingFootprints } = generateKiCADNetList(visitor.getNetList());
+                missingFootprints.forEach(entry => {
+                    console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
+                });
+                writeFileSync(outputPath, printTree(kicadNetList));
+                console.log('Generated file', outputPath);
+                return null;
+            }
+            const layoutEngine = new LayoutEngine();
+            const layoutTimer = new SimpleStopwatch();
+            let sheetFrames;
+            try {
+                sheetFrames = layoutEngine.runLayout(sequence, nets);
+            }
+            catch (err) {
+                throw new RenderError(`Error during layout generation: ${err}`, 'layout');
+            }
+            layoutEngine.printWarnings();
+            showStats && console.log('Layout took:', layoutTimer.lap());
+            dumpData && writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
+            const generateSvgTimer = new SimpleStopwatch();
+            const renderLogger = new Logger();
+            let svgCanvas;
+            try {
+                svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger);
+            }
+            catch (err) {
+                throw new RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
+            }
+            showStats && console.log('Render took:', generateSvgTimer.lap());
+            dumpData && writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
+            try {
+                svgOutput = generateSvgOutput(svgCanvas, outputDefaultZoom);
+            }
+            catch (err) {
+                throw new RenderError(`Error generating SVG output: ${err}`, 'svg_output');
+            }
+            if (outputPath) {
+                if (fileExtension === 'svg') {
+                    try {
+                        writeFileSync(outputPath, svgOutput);
+                    }
+                    catch (err) {
+                        throw new RenderError(`Error writing SVG file: ${err}`, 'file_output');
+                    }
+                }
+                else if (fileExtension === 'pdf') {
+                    let sheetSize = "A4";
+                    let sheetSizeDefined = false;
+                    if (frameComponent) {
+                        sheetSize = frameComponent.getParam(FrameParamKeys.PaperSize);
+                        sheetSizeDefined = true;
+                    }
+                    try {
+                        const doc = new PDFDocument({
+                            layout: 'landscape',
+                            size: sheetSize
+                        });
+                        const outputStream = createWriteStream(outputPath);
+                        generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
+                        doc.pipe(outputStream);
+                        doc.end();
+                    }
+                    catch (err) {
+                        throw new RenderError(`Error generating PDF file: ${err}`, 'pdf_output');
+                    }
+                }
+                else {
+                    throw new RenderError(`Invalid output format: ${fileExtension}`, 'file_output');
+                }
+                console.log('Generated file', outputPath);
+            }
+        }
+        catch (err) {
+            throw new RenderError(`Error during rendering: ${err}`, 'output_generation');
+        }
+    }
+    return {
+        svgOutput,
+        errors
+    };
+}
+export function detectJSModuleType() {
+    if (typeof __filename === 'undefined' &&
+        typeof __dirname === 'undefined') {
+        return JSModuleType.ESM;
+    }
+    else {
+        return JSModuleType.CommonJs;
+    }
+}
+export class UnitDimension {
+    type;
+    value;
+    constructor(value, type = LengthUnit.mils) {
+        this.value = value;
+        this.type = type;
+    }
+    getMM() {
+        switch (this.type) {
+            case LengthUnit.mm:
+                return this.value;
+            case LengthUnit.mils:
+                return this.value * MilsToMM;
+            case LengthUnit.px:
+                return this.value * PxToMM;
+        }
+    }
+    static mm(value) {
+        return new UnitDimension(value, LengthUnit.mm);
+    }
+    static mils(value) {
+        return new UnitDimension(value, LengthUnit.mils);
+    }
+    static px(value) {
+        return new UnitDimension(value, LengthUnit.px);
+    }
+}
+export function milsToMM(value) {
+    if (typeof value === 'number') {
+        value = resolveToNumericValue(new Big(value));
+    }
+    return resolveToNumericValue(value.toBigNumber().mul(new Big(MilsToMM)).round(6));
+}
+export function pxToMM(value) {
+    return value * PxToMM;
+}
+const PaperSizes = {
+    'A0': [1189, 841],
+    'A1': [841, 594],
+    'A2': [594, 420],
+    'A3': [420, 297],
+    'A4': [297, 210],
+    'A5': [210, 148],
+    'A6': [148, 105],
+};
+export const PaperGridReferences = {
+    'A0': [16, 24],
+    'A1': [12, 16],
+    'A2': [8, 12],
+    'A3': [6, 8],
+    'A4': [4, 6],
+};
+export function isSupportedPaperSize(type) {
+    if (PaperSizes[type]) {
+        return true;
+    }
+    return false;
+}
+export function getPaperSize(type, margin = defaultPageMarginMM) {
+    if (PaperSizes[type]) {
+        const [width, height] = PaperSizes[type];
+        const useWidth = width - margin * 2;
+        const useHeight = height - margin * 2;
+        return {
+            width: Math.floor(useWidth * (1 / MilsToMM)),
+            height: Math.floor(useHeight * (1 / MilsToMM)),
+            widthMM: useWidth,
+            heightMM: useHeight,
+            originalWidthMM: width,
+            originalHeightMM: height,
+        };
+    }
+    else {
+        return getPaperSize('A4');
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+export * from './draw_symbols.js';
+export * from './execute.js';
+export * from './export.js';
+export * from './geometry.js';
+export * from './globals.js';
+export * from './helpers.js';
+export * from './layout.js';
+export * from './lexer.js';
+export * from './logger.js';
+export * from './parser.js';
+export * from './render.js';
+export * from './utils.js';
+export * from './visitor.js';
+export * from './sizing.js';
+export * from './objects/types.js';
+export * from './builtinMethods.js';
+export * from './validate/SymbolTable.js';
+export * from './validate/SymbolValidatorResolveVisitor.js';
+export * from './validate/SymbolValidatorVisitor.js';
+export * from './environment.js';

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

@@ -1,14 +1,15 @@
-import { Graph, alg } from '@dagrejs/graphlib';
-import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.mjs";
-import { FrameAction, SequenceAction } from "./objects/ExecutionScope.mjs";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, SymbolPinSide, WireAutoDirection } from './globals.mjs';
-import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.mjs';
-import { Logger } from './logger.mjs';
-import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.mjs';
-import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.mjs';
-import { Direction } from './objects/types.mjs';
-import { milsToMM, UnitDimension } from './helpers.mjs';
-import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
+import pkg from '@dagrejs/graphlib';
+const { Graph, alg } = pkg;
+import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
+import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
+import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, SymbolPinSide, WireAutoDirection } from './globals.js';
+import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
+import { Logger } from './logger.js';
+import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
+import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
+import { Direction } from './objects/types.js';
+import { milsToMM, UnitDimension } from './helpers.js';
+import { numeric, NumericValue } from './objects/ParamDefinition.js';
 export class LayoutEngine {
     logger;
     layoutWarnings = [];
@@ -109,6 +110,7 @@ export class LayoutEngine {
     findJunctions(wireGroups) {
         const junctions = [];
         const mergedWires = [];
+        const debugSegments = false;
         for (const [key, wires] of wireGroups) {
             const allLines = wires.map(wire => {
                 return wire.points.map(pt => {
@@ -118,15 +120,35 @@ export class LayoutEngine {
                     };
                 });
             });
-            const { intersectPoints, segments } = Geometry.mergeWires(allLines);
-            mergedWires.push({
-                netName: key,
-                segments,
-                intersectPoints,
-            });
-            intersectPoints.forEach(([x, y]) => {
-                junctions.push(new RenderJunction(numeric(x), numeric(y)));
-            });
+            if (debugSegments) {
+                const tmpSegments = [];
+                allLines.forEach(wire => {
+                    for (let i = 1; i < wire.length; i++) {
+                        const pt1 = wire[i - 1];
+                        const pt2 = wire[i];
+                        tmpSegments.push([
+                            [pt1.x.toNumber(), pt1.y.toNumber()],
+                            [pt2.x.toNumber(), pt2.y.toNumber()],
+                        ]);
+                    }
+                });
+                mergedWires.push({
+                    netName: key,
+                    segments: tmpSegments,
+                    intersectPoints: [],
+                });
+            }
+            else {
+                const { intersectPoints, segments } = Geometry.mergeWires(allLines);
+                mergedWires.push({
+                    netName: key,
+                    segments,
+                    intersectPoints,
+                });
+                intersectPoints.forEach(([x, y]) => {
+                    junctions.push(new RenderJunction(numeric(x), numeric(y)));
+                });
+            }
         }
         return {
             junctions,
@@ -346,7 +368,7 @@ export class LayoutEngine {
                         const frameArea = [tmpX1, tmpY1, tmpX2, tmpY2];
                         const overlaps = avoidAreas.filter(area => areasOverlap(frameArea, area));
                         const doesOverlapAreasToAvoid = overlaps.length > 0;
-                        if (doesExceedFrameHeight || doesOverlapAreasToAvoid) {
+                        if (boundPoints.length > 0 && (doesExceedFrameHeight || doesOverlapAreasToAvoid)) {
                             innerFrameY = offsetY;
                             const nextX = numeric(xmax).sub(offsetX).add(frame.gap);
                             innerFrameX = offsetX.add(nextX);
@@ -376,7 +398,7 @@ export class LayoutEngine {
                         const frameArea = [tmpX1, tmpY1, tmpX2, tmpY2];
                         const overlaps = avoidAreas.filter(area => areasOverlap(frameArea, area));
                         const doesOverlapAreasToAvoid = overlaps.length > 0;
-                        if (doesExceedFrameWidth || doesOverlapAreasToAvoid) {
+                        if (boundPoints.length > 0 && (doesExceedFrameWidth || doesOverlapAreasToAvoid)) {
                             innerFrameX = offsetX.add(centeredOffsetX);
                             const { ymax } = getBoundsFromPoints(boundPoints);
                             const nextY = numeric(ymax).sub(offsetY).add(frame.gap);

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

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

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

@@ -1,14 +1,13 @@
 #! /usr/bin/env node
 import { program } from 'commander';
 import figlet from 'figlet';
-import path from 'path';
-import { readFileSync, watch, existsSync } from 'fs';
-import { prepareSVGEnvironment } from './sizing.mjs';
-import { getDefaultLibsPath, getFontsPath, getPackageVersion, renderScript } from './helpers.mjs';
+import { watch } from 'fs';
+import { renderScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 export default async function main() {
-    const fontsPath = getFontsPath();
-    const defaultLibsPath = getDefaultLibsPath();
-    const version = getPackageVersion();
+    const env = new NodeScriptEnvironment();
+    NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
     program
         .description('generate graphical output from circuitscript files')
         .version(version)
@@ -19,7 +18,8 @@ export default async function main() {
         .option('-w, --watch', 'Watch for file changes')
         .option('-n, --dump-nets', 'Dump out net information')
         .option('-d, --dump-data', 'Dump data during parsing')
-        .option('-s, --stats', 'Show stats during generation');
+        .option('-s, --stats', 'Show stats during generation')
+        .option('-x, --skip-output', 'Skip output generation');
     program.addHelpText('before', figlet.textSync('circuitscript', {
         font: 'Small Slant'
     }));
@@ -32,11 +32,13 @@ export default async function main() {
     const watchFileChanges = options.watch;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
-    let currentDirectory = options.currentDirectory ?? null;
+    if (options.currentDirectory) {
+        throw "Parameter not supported yet";
+    }
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
-    await prepareSVGEnvironment(fontsPath);
+    await env.prepareSVGEnvironment();
     let inputFilePath = "";
     if (args.length > 2) {
         console.log("Error: Extra arguments passed");
@@ -45,11 +47,8 @@ export default async function main() {
     let scriptData;
     if (args.length > 0 && args[0]) {
         inputFilePath = args[0];
-        if (existsSync(inputFilePath)) {
-            scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-            if (currentDirectory === null) {
-                currentDirectory = path.dirname(inputFilePath);
-            }
+        if ((await env.exists(inputFilePath))) {
+            scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
         }
         else {
             console.error("Error: File could not be found");
@@ -64,28 +63,42 @@ export default async function main() {
         return;
     }
     const scriptOptions = {
-        currentDirectory,
-        defaultLibsPath,
         dumpNets,
         dumpData,
         showStats: options.stats,
+        environment: env,
     };
     let outputPath = null;
     if (args.length > 0 && args[1]) {
         outputPath = args[1];
     }
-    const output = renderScript(scriptData, outputPath, scriptOptions);
-    if (outputPath === null && output) {
+    const output = await parseFile(scriptData, outputPath, scriptOptions);
+    if (outputPath === null && output && (options.skipOutput === undefined)) {
         console.log(output);
     }
     if (watchFileChanges) {
-        watch(inputFilePath, event => {
+        watch(inputFilePath, async (event) => {
             if (event === 'change') {
-                const scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-                renderScript(scriptData, outputPath, scriptOptions);
-                console.log('done');
+                const scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
+                parseFile(scriptData, outputPath, scriptOptions);
             }
         });
     }
 }
+async function parseFile(scriptData, outputPath, scriptOptions) {
+    try {
+        const { svgOutput: output, errors } = await renderScript(scriptData, outputPath, scriptOptions);
+        errors.forEach((err, index) => {
+            console.log(`[${index}] ${err}`);
+        });
+        if (errors.length > 0) {
+            console.log('Render failed due to syntax or parsing errors');
+        }
+        return output;
+    }
+    catch (error) {
+        console.error(`Unexpected Error: ${error}`);
+    }
+    return null;
+}
 main();

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

@@ -1,7 +1,7 @@
-import { SymbolDrawingCommands } from '../draw_symbols.mjs';
-import { PinDefinition, PinIdType } from './PinDefinition.mjs';
-import { PinTypes } from './PinTypes.mjs';
-import { ParamKeys } from '../globals.mjs';
+import { SymbolDrawingCommands } from '../draw_symbols.js';
+import { PinDefinition, PinIdType } from './PinDefinition.js';
+import { PinTypes } from './PinTypes.js';
+import { ParamKeys } from '../globals.js';
 export class ClassComponent {
     instanceName;
     numPins;
@@ -9,11 +9,12 @@ export class ClassComponent {
     pins = new Map();
     pinNets = new Map();
     pinWires = new Map();
-    pinsMaxPositions = {};
+    pinsMaxPositions = new Map();
     _cachedPins;
     _cachedParams;
     _copyID = null;
     _copyFrom = null;
+    _pointLinkComponent;
     arrangeProps = null;
     displayProp = null;
     widthProp = null;
@@ -145,6 +146,9 @@ export class ClassComponent {
         for (const [key, value] of this.pins) {
             component.pins.set(key, value);
         }
+        for (const [key, value] of this.pinsMaxPositions) {
+            component.pinsMaxPositions.set(key, value);
+        }
         component.refreshCache();
         return component;
     }