circuitscript 0.1.5 → 0.1.8

package/dist/esm/helpers.js

@@ -0,0 +1,394 @@
+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) {
+            if (context !== null) {
+                errors.push(new ParseSyntaxError(message, context.start, context.stop));
+            }
+            else {
+                if (error.recognizer) {
+                    const recognizer = error.recognizer;
+                    errors.push(new ParseSyntaxError(message, {
+                        line: recognizer.currentTokenStartLine,
+                        column: recognizer.currentTokenColumn
+                    }));
+                }
+                else {
+                    errors.push(new ParseSyntaxError(message));
+                }
+            }
+        }
+        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 {
+                    svgOutput: null,
+                    errors,
+                };
+            }
+            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 graphlib, { Graph } from '@dagrejs/graphlib';
+const { alg } = graphlib;
+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 = [];
@@ -29,7 +30,7 @@ export class LayoutEngine {
         return "[" + value + "]" + padding;
     }
     runLayout(sequence, nets) {
-        const logNodesAndEdges = false;
+        const logNodesAndEdges = true;
         this.print('===== creating graph and populating with nodes =====');
         const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
         this.print('===== done populating graph =====');
@@ -46,7 +47,7 @@ export class LayoutEngine {
             this.print('===== graph nodes =====');
             const nodes = graph.nodes();
             nodes.forEach(node => {
-                this.print(node, graph.node(node));
+                this.print(`name:${node}, value:${graph.node(node)}`);
             });
             this.print('===== end nodes =====');
             this.print('');
@@ -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,
@@ -584,7 +606,7 @@ export class LayoutEngine {
         let previousNode = null;
         let previousPin = null;
         const graph = new Graph({
-            directed: false,
+            directed: true,
             compound: true,
         });
         this.print('sequence length:', sequence.length);
@@ -602,7 +624,7 @@ export class LayoutEngine {
                     const tmpInstanceName = component.instanceName;
                     if (!graph.hasNode(tmpInstanceName)) {
                         this.print('create instance', tmpInstanceName);
-                        const { displayProp = null, widthProp = null, heightProp = null } = component;
+                        const { displayProp = null } = component;
                         let tmpSymbol;
                         if (displayProp instanceof SymbolDrawing) {
                             tmpSymbol = new SymbolPlaceholder(displayProp);
@@ -618,26 +640,6 @@ export class LayoutEngine {
                             }
                         }
                         applyComponentParamsToSymbol(component, tmpSymbol);
-                        if (component.parameters.has(ParamKeys.angle)) {
-                            const value = component.parameters.get(ParamKeys.angle).toNumber();
-                            tmpSymbol.angle = value;
-                        }
-                        if (component.parameters.has(ParamKeys.flipX)) {
-                            tmpSymbol.flipX =
-                                component.parameters.get(ParamKeys.flipX);
-                        }
-                        if (component.parameters.has(ParamKeys.flipY)) {
-                            tmpSymbol.flipY =
-                                component.parameters.get(ParamKeys.flipY);
-                        }
-                        if (tmpSymbol instanceof SymbolCustom) {
-                            if (widthProp) {
-                                tmpSymbol.bodyWidth = milsToMM(widthProp);
-                            }
-                            if (heightProp) {
-                                tmpSymbol.bodyHeight = milsToMM(heightProp);
-                            }
-                        }
                         tmpSymbol.refreshDrawing();
                         const { width: useWidth, height: useHeight } = tmpSymbol.size();
                         tmpComponent = new RenderComponent(component, useWidth, useHeight);
@@ -743,7 +745,11 @@ export class LayoutEngine {
         };
     }
     setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
         graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
     }
     sizeSubGraphs(graph) {
         const subGraphs = alg.components(graph);
@@ -800,7 +806,6 @@ export class LayoutEngine {
         this.placeSubgraphV2(graph, firstNodeId, subgraphEdges);
     }
     placeSubgraphV2(graph, firstNodeId, subgraphEdges) {
-        let firstNodePlaced = false;
         const originNodes = [];
         const originNodeGroups = new Map();
         function findOriginNode(node) {
@@ -826,14 +831,6 @@ export class LayoutEngine {
             const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
             const [, node1] = graph.node(nodeId1);
             const [, node2] = graph.node(nodeId2);
-            if (nodeId1 === firstNodeId && !firstNodePlaced) {
-                this.print('first node placed at origin');
-                this.placeNodeAtPosition(numeric(0), numeric(0), node1, pin1);
-                firstNodePlaced = true;
-                node1.isFloating = false;
-                originNodes.push(node1);
-                originNodeGroups.set(node1.toString(), [node1]);
-            }
             this.print('edge:', '[', node1, pin1, node1.isFloating, ']', '[', node2, pin2, node2.isFloating, ']');
             if (!node1.isFloating && node2.isFloating) {
                 fixedNode = node1;
@@ -911,6 +908,7 @@ export class LayoutEngine {
                     this.print(`set wire auto end at: ${untilX} ${untilY}`);
                 }
             });
+            this.print('----');
         });
     }
     mergeOriginNodes(node1, pin1, node2, pin2, originNode1, originNode2, originNodes, originNodeGroups) {
@@ -1110,11 +1108,32 @@ function generateLayoutPinDefinition(component) {
     return symbolPinDefinitions;
 }
 export function applyComponentParamsToSymbol(component, symbol) {
+    const { widthProp = null, heightProp = null } = component;
     const newMap = new Map(component.parameters);
     if (!newMap.has('refdes')) {
         newMap.set('refdes', component.assignedRefDes ?? "?");
     }
     symbol.drawing.variables = newMap;
+    if (component.parameters.has(ParamKeys.angle)) {
+        const value = component.parameters.get(ParamKeys.angle).toNumber();
+        symbol.angle = value;
+    }
+    if (component.parameters.has(ParamKeys.flipX)) {
+        symbol.flipX =
+            component.parameters.get(ParamKeys.flipX);
+    }
+    if (component.parameters.has(ParamKeys.flipY)) {
+        symbol.flipY =
+            component.parameters.get(ParamKeys.flipY);
+    }
+    if (symbol instanceof SymbolCustom) {
+        if (widthProp) {
+            symbol.bodyWidth = milsToMM(widthProp);
+        }
+        if (heightProp) {
+            symbol.bodyHeight = milsToMM(heightProp);
+        }
+    }
 }
 function calculateSymbolAngle(symbol, pin, direction) {
     let directionVector = 0;

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;