circuitscript 0.0.22 → 0.0.25

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;
@@ -52,8 +52,12 @@ export class Label extends Flatten.Polygon {
         return new Label(id, useText, [x, y], polygon, style, box);
     }
     rotate(angle, origin) {
-        const polygonRotate = super.rotate(angle, origin);
-        return new Label(this.id, this.text, this.anchorPoint, polygonRotate, this.style, this.textMeasurementBounds);
+        const feature = super.rotate(angle, origin);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+    }
+    transform(matrix) {
+        const feature = super.transform(matrix);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
     }
     getLabelPosition() {
         return this.anchorPoint;
@@ -103,6 +107,10 @@ export class Geometry {
         const angleRads = angleDegrees * Math.PI / 180;
         return feature.rotate(angleRads, Geometry.point(center[0], center[1]));
     }
+    static flip(feature, flipX, flipY) {
+        const flipMatrix = (new Flatten.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return feature.transform(flipMatrix);
+    }
     static groupRotate(features, angle, center) {
         const angleRads = angle * Math.PI / 180;
         const rotateAboutPoint = Geometry.point(center[0], center[1]);
@@ -110,6 +118,12 @@ export class Geometry {
             return feature.rotate(angleRads, rotateAboutPoint);
         });
     }
+    static groupFlip(features, flipX, flipY) {
+        const flipMatrix = (new Flatten.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return features.map(feature => {
+            return feature.transform(flipMatrix);
+        });
+    }
     static groupBounds(features) {
         let minX = Number.POSITIVE_INFINITY;
         let minY = Number.POSITIVE_INFINITY;
@@ -171,9 +185,7 @@ export class Geometry {
                 }
                 const startPoint = getArcPointRadians(x, y, radius, item.startAngle);
                 const endPoint = getArcPointRadians(x, y, radius, useEndAngle);
-                paths.push('M ' + startPoint[0] + ' ' + startPoint[1]
-                    + 'A ' + radius + ' ' + radius + ' 0 1 1 '
-                    + endPoint[0] + ' ' + endPoint[1] + extraEnd);
+                paths.push('M', startPoint[0], startPoint[1], 'A', radius, radius, 0, 1, 1, endPoint[0], endPoint[1], extraEnd);
             }
             else {
                 const coords = Geometry.getCoords(item);
@@ -183,19 +195,27 @@ export class Geometry {
                 for (let i = 0; i < coords.length; i++) {
                     const [x, y] = coords[i];
                     const command = (i === 0) ? 'M' : 'L';
-                    path.push(`${command} ${x} ${y}`);
+                    path.push(`${command}`, x, y);
                 }
                 if (isClosedPolygon) {
                     path.push('Z');
                 }
-                paths.push(path.join(' '));
+                paths.push(...path);
             }
         });
         return {
-            path: paths.join(" "),
+            path: this.roundPathValues(paths),
             isClosedPolygon,
         };
     }
+    static roundPathValues(pathItems) {
+        return pathItems.map(item => {
+            if (typeof item === 'number') {
+                return (+item.toFixed(7)).toString();
+            }
+            return item;
+        }).join(" ");
+    }
     static angle(dx, dy) {
         const line = new Flatten.Segment(new Flatten.Point(0, 0), new Flatten.Point(dx, dy));
         return line.slope * 180 / Math.PI;
@@ -418,10 +438,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/dist/esm/helpers.mjs

@@ -0,0 +1,252 @@
+import { readFileSync, writeFileSync } from "fs";
+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 { ParserVisitor, VisitorExecutionException } from "./visitor.mjs";
+import { createContext } from "this-file";
+import { SymbolValidatorResolveVisitor, SymbolValidatorVisitor } from "./SymbolValidatorVisitor.mjs";
+import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy } from "antlr4ng";
+import { MainLexer } from "./lexer.mjs";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
+import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.mjs";
+import path from "path";
+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 function getScriptText(filePath) {
+    try {
+        return readFileSync(filePath, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        return null;
+    }
+}
+export function getSemanticTokens(scriptData, options) {
+    const { parser, lexer, tokens } = prepareFile(scriptData);
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SemanticTokensVisitor(true, null, currentDirectory, defaultLibsPath, lexer, scriptData);
+    parser.removeErrorListeners();
+    visitor.onImportFile = (visitor, 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;
+            }
+        }
+        else {
+            console.log('File does not exist');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(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 function validateScript(scriptData, options) {
+    const { parser } = prepareFile(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new ParseErrorStrategy();
+    parser.addErrorListener(new TokenErrorListener());
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SymbolValidatorVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, 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('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    visitorResolver.visit(tree);
+    return visitorResolver;
+}
+export function renderScript(scriptData, outputPath, options) {
+    const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, kicadNetlistPath = null, showStats = false } = options;
+    const onErrorHandler = (line, column, message, error) => {
+        if (error instanceof VisitorExecutionException) {
+            console.log('Error', line, column, message, error.errorMessage);
+        }
+    };
+    const visitor = new ParserVisitor(true, onErrorHandler, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, fileData) => {
+        const { hasError, hasParseError } = parseFileWithVisitor(visitor, fileData);
+        return { hasError, hasParseError };
+    };
+    visitor.log('reading file');
+    visitor.log('done reading file');
+    const { tree, parser, hasParseError, hasError, parserTimeTaken, lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    dumpNets && console.log(visitor.dumpNets());
+    dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
+    dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
+    if (hasError || hasParseError) {
+        console.log('Error while parsing');
+        return null;
+    }
+    try {
+        visitor.annotateComponents();
+    }
+    catch (err) {
+        console.log('Error during annotation: ', err);
+    }
+    if (kicadNetlistPath) {
+        const kicadNetList = generateKiCADNetList(visitor.getNetList());
+        writeFileSync(kicadNetlistPath, kicadNetList);
+        console.log('Generated KiCad netlist file');
+    }
+    const { sequence, nets } = visitor.getGraph();
+    const tmpSequence = sequence.map(item => {
+        const tmp = [...item];
+        const action = tmp[0];
+        if (action === SequenceAction.Wire) {
+            tmp[2] = tmp[2].map(item2 => {
+                return [item2.direction, item2.value].join(",");
+            }).join(" ");
+        }
+        else if (action === SequenceAction.Frame) {
+            tmp[1] = item[1].frameId;
+        }
+        else if (action !== SequenceAction.WireJump) {
+            tmp[1] = item[1].instanceName;
+        }
+        return tmp.join(" | ");
+    });
+    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
+    let svgOutput = null;
+    try {
+        const layoutEngine = new LayoutEngine();
+        const layoutTimer = new SimpleStopwatch();
+        const graph = layoutEngine.runLayout(sequence, nets);
+        layoutEngine.printWarnings();
+        showStats && console.log('Layout took:', layoutTimer.lap());
+        dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
+        const generateSvgTimer = new SimpleStopwatch();
+        svgOutput = generateSVG2(graph);
+        showStats && console.log('Render took:', generateSvgTimer.lap());
+        if (outputPath) {
+            writeFileSync(outputPath, svgOutput);
+        }
+    }
+    catch (err) {
+        console.log('Error during render: ', err);
+    }
+    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 };
+}
+function getToolsPath() {
+    const { filePath } = getCurrentPath();
+    return path.normalize(path.dirname(filePath) + '/../../');
+}
+export function getFontsPath() {
+    const toolsPath = getToolsPath();
+    return path.normalize(toolsPath + "fonts");
+}
+export function getDefaultLibsPath() {
+    const toolsPath = getToolsPath();
+    return path.normalize(toolsPath + "libs");
+}
+export function getPackageVersion() {
+    const packageJson = JSON.parse(readFileSync(getToolsPath() + 'package.json').toString());
+    const { version } = packageJson;
+    return version;
+}

package/dist/esm/index.mjs

@@ -0,0 +1,15 @@
+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';
+export * from './sizing.mjs';
+export * from './objects/types.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,
         });
@@ -393,6 +393,14 @@ export class LayoutEngine {
                         didSetAngle = true;
                         tmpSymbol.angle = component.parameters.get('angle');
                     }
+                    if (component.parameters.has('flipX')) {
+                        tmpSymbol.flipX =
+                            component.parameters.get('flipX');
+                    }
+                    if (component.parameters.has('flipY')) {
+                        tmpSymbol.flipY =
+                            component.parameters.get('flipY');
+                    }
                     if (tmpSymbol instanceof SymbolCustom && widthProp) {
                         tmpSymbol.bodyWidth = widthProp;
                     }
@@ -498,7 +506,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 { CommonToken } from "antlr4ng";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.mjs";
 export class MainLexer extends CircuitScriptLexer {
     tokens;
     indents;
@@ -22,7 +22,7 @@ export class MainLexer extends CircuitScriptLexer {
         this.tokens.push(token);
     }
     nextToken() {
-        if (this._input.LA(1) === CircuitScriptParser.EOF && this.indents.length) {
+        if (this.inputStream.LA(1) === CircuitScriptParser.EOF && this.indents.length) {
             this.tokens = this.tokens.filter(function (val) {
                 return val.type !== CircuitScriptParser.EOF;
             });
@@ -40,20 +40,20 @@ export class MainLexer extends CircuitScriptLexer {
         return this.commonToken(CircuitScriptParser.DEDENT, "");
     }
     getCharIndex() {
-        return this._input.index;
+        return this.inputStream.index;
     }
     commonToken(type, text) {
         const stop = this.getCharIndex() - 1;
         const start = text.length ? stop - text.length + 1 : stop;
-        const token = new CommonToken([this, this._input], type, 0, start, stop);
-        let tokenTypeString;
+        const token = CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
+        let tokenTypeString = null;
         if (type === CircuitScriptParser.INDENT) {
             tokenTypeString = "indent";
         }
         else if (type === CircuitScriptParser.DEDENT) {
             tokenTypeString = "dedent";
         }
-        if (tokenTypeString) {
+        if (tokenTypeString !== null) {
             token.text = tokenTypeString;
         }
         return token;
@@ -82,8 +82,8 @@ export class MainLexer extends CircuitScriptLexer {
     onNewLine() {
         const newLine = this.text.replace(/[^\r\n]+/g, '');
         const spaces = this.text.replace(/[\r\n]+/g, '');
-        const next = this._input.LA(1);
-        const nextnext = this._input.LA(2);
+        const next = this.inputStream.LA(1);
+        const nextnext = this.inputStream.LA(2);
         if (this.opened > 0 || (nextnext != -1 &&
             (next === 13 || next === 10 || next === 35))) {
             this.skip();

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

@@ -2,18 +2,13 @@
 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 { getDefaultLibsPath, getFontsPath, getPackageVersion, renderScript } from './helpers.mjs';
 export default async function main() {
-    const toolSrcPath = fileURLToPath(import.meta.url);
-    const toolDirectory = path.dirname(toolSrcPath) + '/../../';
-    const fontsPath = toolDirectory + '/fonts';
-    const defaultLibsPath = toolDirectory + '/libs';
-    const packageJson = JSON.parse(readFileSync(toolDirectory + 'package.json').toString());
-    ;
-    const { version } = packageJson;
+    const fontsPath = getFontsPath();
+    const defaultLibsPath = getDefaultLibsPath();
+    const version = getPackageVersion();
     program
         .description('generate graphical output from circuitscript files')
         .version(version)
@@ -43,7 +38,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) {
@@ -56,7 +51,7 @@ export default async function main() {
             currentDirectory = path.dirname(inputFilePath);
         }
     }
-    const renderOptions = {
+    const scriptOptions = {
         currentDirectory,
         defaultLibsPath,
         dumpNets,
@@ -64,7 +59,7 @@ export default async function main() {
         kicadNetlistPath: kicadNetlist,
         showStats: options.stats,
     };
-    const output = renderScript(scriptData, outputPath, renderOptions);
+    const output = renderScript(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output) {
         console.log(output);
     }
@@ -72,7 +67,7 @@ export default async function main() {
         watch(inputFilePath, event => {
             if (event === 'change') {
                 const scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-                renderScript(scriptData, outputPath, renderOptions);
+                renderScript(scriptData, outputPath, scriptOptions);
                 console.log('done');
             }
         });

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;
@@ -129,6 +129,9 @@ export class ClassComponent {
             }
         }
         for (const [key, value] of this.parameters) {
+            if (key === 'flipX' || key === 'flipY' || key === 'angle') {
+                continue;
+            }
             component.parameters.set(key, value);
         }
         for (const [key, value] of this.pins) {

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

@@ -4,6 +4,7 @@ export class ExecutionScope {
     instances = new Map();
     functions = new Map();
     variables = new Map();
+    symbols = new Map();
     blockStack = new Map();
     wires = [];
     frames = [];

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/objects/types.mjs

@@ -0,0 +1,12 @@
+export class UndeclaredReference {
+    reference;
+    constructor(reference) {
+        this.reference = reference;
+    }
+}
+export var ParseSymbolType;
+(function (ParseSymbolType) {
+    ParseSymbolType["Variable"] = "variable";
+    ParseSymbolType["Function"] = "function";
+    ParseSymbolType["Undefined"] = "undefined";
+})(ParseSymbolType || (ParseSymbolType = {}));

package/dist/esm/parser.mjs

@@ -0,0 +1,64 @@
+import { CircuitScriptParser } from './antlr/CircuitScriptParser.mjs';
+import { MainLexer } from './lexer.mjs';
+import { SimpleStopwatch } from './utils.mjs';
+import { CharStream, CommonTokenStream, DefaultErrorStrategy } from 'antlr4ng';
+export function parseFileWithVisitor(visitor, data) {
+    const chars = CharStream.fromString(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);
+    const tree = parser.script();
+    let hasError = false;
+    try {
+        visitor.visit(tree);
+    }
+    catch (err) {
+        console.log(err);
+        hasError = true;
+    }
+    const parserTimeTaken = parserTimer.lap();
+    return {
+        tree, parser,
+        hasParseError: false,
+        hasError,
+        parserTimeTaken,
+        lexerTimeTaken,
+    };
+}
+export class TempErrorStrategy extends DefaultErrorStrategy {
+    recover(recognizer, e) {
+        throw new Error('Method not implemented.');
+    }
+    reportError(recognizer, e) {
+        throw new Error('Method not implemented.');
+    }
+}
+export class CircuitscriptParserErrorListener {
+    syntaxErrorCounter = 0;
+    onErrorHandler = null;
+    constructor(onErrorHandler = null) {
+        this.onErrorHandler = onErrorHandler;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        if (this.onErrorHandler) {
+            this.onErrorHandler(line, charPositionInLine, msg, e);
+        }
+        else {
+            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
+        }
+        this.syntaxErrorCounter++;
+    }
+    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+    }
+    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+    }
+    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+    }
+    hasSyntaxErrors() {
+        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);