circuitscript 0.5.4 → 0.5.5

package/dist/cjs/BaseVisitor.js

@@ -14,7 +14,7 @@ const types_js_1 = require("./objects/types.js");
 const globals_js_1 = require("./globals.js");
 const utils_js_1 = require("./utils.js");
 const builtinMethods_js_1 = require("./builtinMethods.js");
-const utils_js_2 = require("./utils.js");
+const errors_js_1 = require("./errors.js");
 const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
 const hash_js_1 = require("./cache/hash.js");
 const storage_js_1 = require("./cache/storage.js");
@@ -34,6 +34,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
             types_js_1.Direction.Right, types_js_1.Direction.Left];
         this.resultData = new Map;
         this.componentCtxLinks = new Map;
+        this.wireCtxLinks = new Map;
         this.onErrorHandler = null;
         this.importedFiles = [];
         this.warnings = [];
@@ -312,7 +313,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
             this.setResult(ctx, returnList);
         };
         this.visitImport_expr = (ctx) => {
-            throw new utils_js_2.RuntimeExecutionError("Cannot parse imports here", ctx);
+            throw new errors_js_1.RuntimeExecutionError("Cannot parse imports here", ctx);
         };
         this.visitFunction_return_expr = (ctx) => {
             const executor = this.getExecutor();
@@ -360,14 +361,14 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
             const arrayItem = this.visitResult(ctxArray);
             const indexValue = this.visitResult(ctxArrayIndex);
             if (!Array.isArray(arrayItem)) {
-                throw new utils_js_2.RuntimeExecutionError("Invalid array", ctxArray);
+                throw new errors_js_1.RuntimeExecutionError("Invalid array", ctxArray);
             }
             if (!(indexValue instanceof NumericValue_js_1.NumericValue)) {
-                throw new utils_js_2.RuntimeExecutionError("Invalid index value", ctxArrayIndex);
+                throw new errors_js_1.RuntimeExecutionError("Invalid index value", ctxArrayIndex);
             }
             const indexValueNumber = indexValue.toNumber();
             if (isNaN(indexValueNumber)) {
-                throw new utils_js_2.RuntimeExecutionError("Invalid index value", ctxArrayIndex);
+                throw new errors_js_1.RuntimeExecutionError("Invalid index value", ctxArrayIndex);
             }
             if (Array.isArray(arrayItem)) {
                 this.setResult(ctx, arrayItem[indexValueNumber]);
@@ -738,7 +739,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
             const invalidImportCondition2 = alreadyImportedFlag !== types_js_1.ImportFunctionHandling.AllWithNamespace &&
                 importHandling === types_js_1.ImportFunctionHandling.AllWithNamespace;
             if (invalidImportCondition1 || invalidImportCondition2) {
-                throw new utils_js_2.RuntimeExecutionError(`Namespace import and wildcard/specific imports cannot be mixed: ${name}`, ctx);
+                throw new errors_js_1.RuntimeExecutionError(`Namespace import and wildcard/specific imports cannot be mixed: ${name}`, ctx);
             }
             if (isMergedNamespace) {
                 if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace) {
@@ -866,7 +867,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
             }
         }
         if (errorMessage !== null && ctx) {
-            throw new utils_js_2.RuntimeExecutionError(errorMessage, ctx);
+            throw new errors_js_1.RuntimeExecutionError(errorMessage, ctx);
         }
         const newImportedFile = {
             id: name.trim(),
@@ -892,7 +893,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
                 }
                 catch (err) {
                     this.log(`failed to cache library: ${libName}`);
-                    throw new utils_js_2.RuntimeExecutionError(`Failed to cache library: ${libName}`);
+                    throw new errors_js_1.RuntimeExecutionError(`Failed to cache library: ${libName}`);
                 }
             }
         }
@@ -1037,7 +1038,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
         return value.slice(1, value.length - 1);
     }
     throwWithContext(context, messageOrError) {
-        (0, utils_js_2.throwWithContext)(context, messageOrError);
+        (0, errors_js_1.throwWithContext)(context, messageOrError);
     }
     validateType(value, context, validateFunction, expectedType) {
         if (value === undefined) {
@@ -1045,7 +1046,7 @@ class BaseVisitor extends CircuitScriptParserVisitor_js_1.CircuitScriptParserVis
         }
         const result = validateFunction(value);
         if (!result) {
-            throw new utils_js_2.RuntimeExecutionError(`Invalid ${expectedType}`, context);
+            throw new errors_js_1.RuntimeExecutionError(`Invalid ${expectedType}`, context);
         }
         return result;
     }

package/dist/cjs/builtinMethods.js

@@ -8,17 +8,18 @@ const big_js_1 = __importDefault(require("big.js"));
 const NumericValue_js_1 = require("./objects/NumericValue.js");
 const types_js_1 = require("./objects/types.js");
 const utils_js_1 = require("./utils.js");
+const errors_js_1 = require("./errors.js");
 const globals_js_1 = require("./globals.js");
 const ClassComponent_js_1 = require("./objects/ClassComponent.js");
 const Net_js_1 = require("./objects/Net.js");
 const builtInMethods = [
     ['enumerate', enumerate],
-    ['toMils', toMils],
+    ['to_mils', toMils],
     ['range', range],
     ['len', objectLength],
-    ['arrayPush', arrayPush],
-    ['arrayGet', arrayGet],
-    ['arraySet', arraySet],
+    ['array_push', arrayPush],
+    ['array_get', arrayGet],
+    ['array_set', arraySet],
     ['print', null],
 ];
 exports.buildInMethodNamesList = builtInMethods.map(item => item[0]);
@@ -120,7 +121,7 @@ function arrayGet(arrayObject, index) {
         useValue = index;
     }
     if (isNaN(useValue)) {
-        throw new utils_js_1.RuntimeExecutionError("Invalid index for arrayGet");
+        throw new errors_js_1.RuntimeExecutionError("Invalid index for arrayGet");
     }
     return arrayObject[useValue];
 }

package/dist/cjs/environment/environment.js

@@ -9,7 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const crypto_js_1 = __importDefault(require("crypto-js"));
 const globals_js_1 = require("../globals.js");
-const utils_js_1 = require("../utils.js");
+const errors_js_1 = require("../errors.js");
 class NodeScriptEnvironment {
     constructor() {
         this.useModuleDirectoryPath = null;
@@ -71,7 +71,7 @@ class NodeScriptEnvironment {
                 return finalPath;
             }
         }
-        throw new utils_js_1.RuntimeExecutionError("Failed to get current module directory");
+        throw new errors_js_1.RuntimeExecutionError("Failed to get current module directory");
     }
     getRelativeToModule(filePath) {
         return path_1.default.join(this.getModuleDirectory(), filePath);

package/dist/cjs/errors.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printErrorChain = exports.collectErrorChain = exports.ParseError = exports.ParseSyntaxError = exports.RuntimeExecutionError = exports.AutoWireFailedError = exports.AutoWireFailedError_ = exports.RenderError = exports.throwWithTokenRange = exports.throwWithContext = exports.getLinePositionAsString = exports.BaseError = void 0;
+const antlr4ng_1 = require("antlr4ng");
+class BaseError extends Error {
+    constructor(message, startTokenOrCtx, endToken, filePath, options) {
+        super(message, options);
+        this.name = 'BaseError';
+        this.message = message;
+        if (startTokenOrCtx instanceof antlr4ng_1.ParserRuleContext) {
+            this.startToken = startTokenOrCtx.start;
+            this.endToken = startTokenOrCtx.stop;
+        }
+        else {
+            this.startToken = startTokenOrCtx;
+            this.endToken = endToken;
+        }
+        this.filePath = filePath;
+    }
+    toString() {
+        const parts = [this.name];
+        const linePosition = getLinePositionAsString({
+            start: this.startToken,
+            stop: this.endToken
+        });
+        if (linePosition !== null) {
+            parts.push(linePosition);
+        }
+        parts.push(`: ${this.message}`);
+        return parts.join('');
+    }
+}
+exports.BaseError = BaseError;
+function getLinePositionAsString(ctx) {
+    if (ctx === null || ctx === undefined) {
+        return null;
+    }
+    const { start: startToken, stop: stopToken } = ctx;
+    let result = null;
+    if (startToken) {
+        const { line, column } = startToken;
+        let stopLine = 0;
+        let stopCol = 0;
+        if (stopToken && (stopToken.line !== startToken.line || stopToken.column !== startToken.column)) {
+            stopLine = stopToken.line;
+            stopCol = stopToken.column + (stopToken.stop - stopToken.start);
+        }
+        else if (startToken === stopToken || startToken) {
+            stopLine = line;
+            stopCol = column + 1 + (startToken.stop - startToken.start);
+        }
+        else {
+            stopCol = -1;
+        }
+        result = ` at ${line}:${column + 1}`;
+        if (stopCol !== -1) {
+            result += `-${stopLine}:${stopCol + 1}`;
+        }
+    }
+    return result;
+}
+exports.getLinePositionAsString = getLinePositionAsString;
+function throwWithContext(context, messageOrError) {
+    if (messageOrError instanceof BaseError) {
+        throw messageOrError;
+    }
+    throwWithTokenRange(messageOrError, context.start, context.stop);
+}
+exports.throwWithContext = throwWithContext;
+function throwWithTokenRange(message, startToken, endToken) {
+    throw new ParseError(message, startToken, endToken);
+}
+exports.throwWithTokenRange = throwWithTokenRange;
+class RenderError extends Error {
+    constructor(message, stage, options) {
+        super(message, options);
+        this.name = 'RenderError';
+        this.stage = stage;
+    }
+}
+exports.RenderError = RenderError;
+class AutoWireFailedError_ extends Error {
+    constructor(message, wire) {
+        super(message);
+        this.name = 'AutoWireFailedError_';
+        this.wire = wire;
+    }
+}
+exports.AutoWireFailedError_ = AutoWireFailedError_;
+class AutoWireFailedError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = 'AutoWireFailedError';
+    }
+}
+exports.AutoWireFailedError = AutoWireFailedError;
+class RuntimeExecutionError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = 'RuntimeExecutionError';
+    }
+}
+exports.RuntimeExecutionError = RuntimeExecutionError;
+class ParseSyntaxError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ParseSyntaxError';
+    }
+}
+exports.ParseSyntaxError = ParseSyntaxError;
+class ParseError extends ParseSyntaxError {
+    constructor() {
+        super(...arguments);
+        this.name = 'ParseError';
+    }
+}
+exports.ParseError = ParseError;
+function collectErrorChain(error) {
+    const items = [];
+    let currentError = error;
+    for (let i = 0; i < 100; i++) {
+        if (currentError.cause) {
+            items.push(currentError.cause);
+            currentError = currentError.cause;
+        }
+        else {
+            break;
+        }
+    }
+    return items;
+}
+exports.collectErrorChain = collectErrorChain;
+function printErrorChain(error) {
+    const errors = collectErrorChain(error);
+    errors.reverse();
+    for (const err of errors) {
+        console.log("  " + err.toString());
+    }
+}
+exports.printErrorChain = printErrorChain;

package/dist/cjs/execute.js

@@ -16,6 +16,7 @@ const layout_js_1 = require("./render/layout.js");
 const helpers_js_1 = require("./helpers.js");
 const draw_symbols_js_1 = require("./render/draw_symbols.js");
 const utils_js_1 = require("./utils.js");
+const errors_js_1 = require("./errors.js");
 class ExecutionContext {
     constructor(name, namespace, netNamespace, executionLevel = 0, scopeLevel = 0, silent = false, logger, warnings, parent) {
         this.tmpPointId = 0;
@@ -347,7 +348,7 @@ class ExecutionContext {
         this.log('to component');
         const { addSequence = false } = options ?? {};
         if (!(component instanceof ClassComponent_js_1.ClassComponent)) {
-            throw new utils_js_1.RuntimeExecutionError("Not a valid component!");
+            throw new errors_js_1.RuntimeExecutionError("Not a valid component!");
         }
         if (pinId === null) {
             pinId = component.getDefaultPin();
@@ -358,7 +359,7 @@ class ExecutionContext {
             }
             else {
                 console.trace();
-                throw new utils_js_1.RuntimeExecutionError('Invalid pin number ' +
+                throw new errors_js_1.RuntimeExecutionError('Invalid pin number ' +
                     pinId +
                     ' in ' +
                     component.instanceName);
@@ -400,7 +401,7 @@ class ExecutionContext {
             usePinId = component.getPin(pinId);
         }
         else {
-            throw new utils_js_1.RuntimeExecutionError('Invalid pin number '
+            throw new errors_js_1.RuntimeExecutionError('Invalid pin number '
                 + pinId + ' in ' + component);
         }
         this.scope.setCurrent(component, usePinId);
@@ -484,7 +485,13 @@ class ExecutionContext {
             const { start_point: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
-        this.scope.blockStack.delete(scopeLevel);
+        const scopeLevels = Array.from(this.scope.blockStack.keys());
+        for (const level of scopeLevels) {
+            if (level >= scopeLevel) {
+                this.log(`blockstack delete level ${level}`);
+                this.scope.blockStack.delete(level);
+            }
+        }
         this.log('exit blocks');
     }
     closeOpenPathBlocks() {
@@ -901,7 +908,7 @@ class ExecutionContext {
         this.log('-- done merging scope --');
         return mergedInstances;
     }
-    addWire(segments) {
+    addWire(segments, ctx) {
         if (this.scope.currentComponent === null) {
             throw "No current component";
         }

package/dist/cjs/main.js

@@ -9,6 +9,7 @@ const figlet_1 = __importDefault(require("figlet"));
 const fs_1 = require("fs");
 const pipeline_js_1 = require("./pipeline.js");
 const environment_js_1 = require("./environment/environment.js");
+const errors_js_1 = require("./errors.js");
 async function main() {
     const env = new environment_js_1.NodeScriptEnvironment();
     environment_js_1.NodeScriptEnvironment.setInstance(env);
@@ -139,8 +140,8 @@ async function parseFile(scriptData, outputPath, scriptOptions) {
         return output;
     }
     catch (error) {
-        console.error(`Unexpected Error: ${error}`);
-        console.log(error.stack);
+        console.error(`Unexpected Error:`);
+        (0, errors_js_1.printErrorChain)(error);
     }
     return null;
 }

package/dist/cjs/objects/ClassComponent.js

@@ -5,7 +5,7 @@ const draw_symbols_js_1 = require("../render/draw_symbols.js");
 const PinDefinition_js_1 = require("./PinDefinition.js");
 const PinTypes_js_1 = require("./PinTypes.js");
 const globals_js_1 = require("../globals.js");
-const utils_js_1 = require("../utils.js");
+const errors_js_1 = require("../errors.js");
 class ComponentUnit {
     get instanceName() {
         return `${this.parent.instanceName},${this.unitId}`;
@@ -190,7 +190,7 @@ class ClassComponent {
                 }
             }
         }
-        throw new utils_js_1.RuntimeExecutionError(`Could not find pin '${pinId}' on component '${this.instanceName}'`);
+        throw new errors_js_1.RuntimeExecutionError(`Could not find pin '${pinId}' on component '${this.instanceName}'`);
     }
     getNextPinAfter(pinIndex) {
         const pins = Array.from(this.pins.keys());
@@ -321,14 +321,14 @@ class ClassComponent {
     }
     getUnitForPin(pinId) {
         if (typeof pinId === "number") {
-            throw new utils_js_1.RuntimeExecutionError("Invalid pin id");
+            throw new errors_js_1.RuntimeExecutionError("Invalid pin id");
         }
         for (const [tmpPin, componentUnit] of this.pinUnitMap) {
             if (tmpPin.equals(pinId)) {
                 return componentUnit;
             }
         }
-        throw new utils_js_1.RuntimeExecutionError("Could not find unit for pin: " + pinId);
+        throw new errors_js_1.RuntimeExecutionError("Could not find unit for pin: " + pinId);
     }
 }
 exports.ClassComponent = ClassComponent;

package/dist/cjs/objects/ExecutionScope.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActiveObject = exports.FrameAction = exports.SequenceAction = exports.ExecutionScope = void 0;
 const CircuitScriptParser_js_1 = require("../antlr/CircuitScriptParser.js");
 const PinDefinition_js_1 = require("./PinDefinition.js");
-const utils_js_1 = require("../utils.js");
+const errors_js_1 = require("../errors.js");
 class ExecutionScope {
     constructor(scopeId) {
         this.nets = [];
@@ -37,7 +37,7 @@ class ExecutionScope {
     }
     findNet(component, pin) {
         if (!(pin instanceof PinDefinition_js_1.PinId)) {
-            throw new utils_js_1.RuntimeExecutionError('Invalid value for PinId: ' + pin);
+            throw new errors_js_1.RuntimeExecutionError('Invalid value for PinId: ' + pin);
         }
         return this.nets.find(([tmpComponent, tmpPin]) => {
             return tmpComponent.isEqual(component) && tmpPin.equals(pin);

package/dist/cjs/objects/NumericValue.js

@@ -27,6 +27,9 @@ class NumericValue {
     toString() {
         return 'numeric:' + this.value;
     }
+    copy() {
+        return this.add(0);
+    }
     toDisplayString() {
         if (typeof this.value === 'number') {
             return this.value.toString();
@@ -81,6 +84,15 @@ class NumericValue {
     eq(value) {
         return this.toBigNumber().eq(value.toBigNumber());
     }
+    floor() {
+        return numeric(Math.floor(this.toNumber()));
+    }
+    ceil() {
+        return numeric(Math.ceil(this.toNumber()));
+    }
+    roundDp() {
+        return roundValue(this.toNumber());
+    }
 }
 exports.NumericValue = NumericValue;
 class NumberOperator {
@@ -191,6 +203,9 @@ function resolveToNumericValue(value) {
 }
 exports.resolveToNumericValue = resolveToNumericValue;
 function roundValue(value) {
+    if (typeof value === "number") {
+        value = numeric(value);
+    }
     return resolveToNumericValue(new big_js_1.Big(value.toBigNumber().toFixed(7)));
 }
 exports.roundValue = roundValue;

package/dist/cjs/objects/PinDefinition.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPinDefinition = exports.isPinId = exports.PortSide = exports.PinIdType = exports.PinDefinition = exports.PinId = void 0;
-const utils_js_1 = require("../utils.js");
+const errors_js_1 = require("../errors.js");
 const NumericValue_js_1 = require("./NumericValue.js");
 const PinTypes_js_1 = require("./PinTypes.js");
 class PinId {
     constructor(value) {
         if (typeof value !== 'string' && typeof value !== 'number') {
-            throw new utils_js_1.RuntimeExecutionError("Invalid value for PinId: " + value);
+            throw new errors_js_1.RuntimeExecutionError("Invalid value for PinId: " + value);
         }
         this.value = value;
         this.type = typeof value === 'number' ? PinIdType.Int : PinIdType.Str;

package/dist/cjs/objects/types.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportFunctionHandling = exports.ImportedLibrary = exports.NetTypes = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
 const globals_js_1 = require("../globals.js");
-const utils_js_1 = require("../utils.js");
+const errors_js_1 = require("../errors.js");
 class CFunctionEntry {
     constructor(namespace, name, execute, source, uniqueId) {
         this.lazyLoaded = false;
@@ -31,7 +31,7 @@ class AnyReference {
         this.referenceName = 'AnyReference';
         if (refType.value instanceof AnyReference
             && refType.value.type !== globals_js_1.ReferenceTypes.function) {
-            throw new utils_js_1.RuntimeExecutionError("Nested reference types!");
+            throw new errors_js_1.RuntimeExecutionError("Nested reference types!");
         }
         this.found = refType.found;
         this.name = refType.name;

package/dist/cjs/parser.js

@@ -4,6 +4,7 @@ exports.CircuitscriptParserErrorListener = exports.parseFileWithVisitor = void 0
 const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
 const lexer_js_1 = require("./lexer.js");
 const utils_js_1 = require("./utils.js");
+const errors_js_1 = require("./errors.js");
 const antlr4ng_1 = require("antlr4ng");
 function parseFileWithVisitor(visitor, data, options) {
     const lexerErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
@@ -42,7 +43,7 @@ function parseFileWithVisitor(visitor, data, options) {
     }
     catch (error) {
         if (visitor.onErrorHandler) {
-            if (error instanceof utils_js_1.RuntimeExecutionError) {
+            if (error instanceof errors_js_1.RuntimeExecutionError) {
                 visitor.onErrorHandler(error.message, null, error);
             }
             else {
@@ -78,7 +79,7 @@ class CircuitscriptParserErrorListener {
         else {
             if (offendingSymbol && msg.match("extraneous input 'import' expecting")) {
                 msg = "Invalid import statement";
-                throw new utils_js_1.ParseSyntaxError("Invalid import statement", offendingSymbol);
+                throw new errors_js_1.ParseSyntaxError("Invalid import statement", offendingSymbol);
             }
             console.log("Syntax error at line", line, ':', column, ' - ', msg);
         }

package/dist/cjs/pipeline.js

@@ -21,6 +21,7 @@ const rules_js_1 = require("./rules-check/rules.js");
 const utils_js_1 = require("./utils.js");
 const visitor_js_1 = require("./visitor.js");
 const styles_js_1 = require("./styles.js");
+const errors_js_1 = require("./errors.js");
 async function renderScript(scriptData, outputPath, options) {
     const parseHandlers = [
         new KiCadNetListOutputHandler_js_1.KiCadNetListOutputHandler(),
@@ -32,28 +33,28 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     const { dumpNets = false, dumpData = false, showStats = false, enableErc = false, enableBom = false, lexerDiagnostics = false, lexerVerbose = false, lexerTokens = false, lexerMapping = false, lexerSummary = false, inputPath = '', bomOutputPath = undefined, environment } = options;
     const errors = [];
     const onErrorHandler = (message, context, error) => {
-        if (error && error instanceof utils_js_1.RuntimeExecutionError) {
+        if (error && error instanceof errors_js_1.RuntimeExecutionError) {
             errors.push(error);
         }
         else if (error && error instanceof antlr4ng_1.RecognitionException) {
             if (context !== null) {
-                errors.push(new utils_js_1.ParseSyntaxError(message, context.start, context.stop));
+                errors.push(new errors_js_1.ParseSyntaxError(message, context.start, context.stop));
             }
             else {
                 if (error.recognizer) {
                     const recognizer = error.recognizer;
-                    errors.push(new utils_js_1.ParseSyntaxError(message, {
+                    errors.push(new errors_js_1.ParseSyntaxError(message, {
                         line: recognizer.currentTokenStartLine,
                         column: recognizer.currentTokenColumn
                     }));
                 }
                 else {
-                    errors.push(new utils_js_1.ParseSyntaxError(message));
+                    errors.push(new errors_js_1.ParseSyntaxError(message));
                 }
             }
         }
         else {
-            errors.push(new utils_js_1.ParseError(message, context.start, context.stop));
+            errors.push(new errors_js_1.ParseError(message, context.start, context.stop));
         }
     };
     const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, environment);
@@ -79,7 +80,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             if (throwError) {
                 importErrorMsg = ": " + throwError.message;
             }
-            throw new utils_js_1.ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
+            throw new errors_js_1.ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
         }
         return { hasError, hasParseError, tree, tokens };
     };
@@ -141,7 +142,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
         visitor.annotateComponents();
     }
     catch (err) {
-        throw new utils_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
+        throw new errors_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
     const componentLinks = visitor.getComponentCtxLinks();
     const importedLibraries = Array.from(visitor.getScope().libraries.values());
@@ -215,7 +216,13 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                 }
             }
             catch (err) {
-                throw new utils_js_1.RenderError(`Error during layout generation: ${err}`, 'layout');
+                let useErr = err;
+                if (err instanceof errors_js_1.AutoWireFailedError_) {
+                    const errCtx = visitor.wireCtxLinks.get(err.wire);
+                    useErr = new errors_js_1.AutoWireFailedError(err.message, errCtx.start, errCtx.stop);
+                }
+                dumpData && environment.writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
+                throw new errors_js_1.RenderError(`Error during layout generation`, 'layout', { cause: useErr });
             }
             layoutEngine.printWarnings();
             showStats && console.log('Layout took:', layoutTimer.lap());
@@ -227,7 +234,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                 svgCanvas = (0, render_js_1.renderSheetsToSVG)(sheetFrames, renderLogger, documentVariable, styles);
             }
             catch (err) {
-                throw new utils_js_1.RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
+                throw new errors_js_1.RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
             }
             showStats && console.log('Render took:', generateSvgTimer.lap());
             dumpData && environment.writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
@@ -238,7 +245,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                 svgOutput = (0, render_js_1.generateSvgOutput)(svgCanvas, outputDefaultZoom);
             }
             catch (err) {
-                throw new utils_js_1.RenderError(`Error generating SVG output: ${err}`, 'svg_output');
+                throw new errors_js_1.RenderError(`Error generating SVG output: ${err}`, 'svg_output');
             }
             if (outputPath) {
                 if (fileExtension === 'svg') {
@@ -246,7 +253,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                         environment.writeFileSync(outputPath, svgOutput);
                     }
                     catch (err) {
-                        throw new utils_js_1.RenderError(`Error writing SVG file: ${err}`, 'file_output');
+                        throw new errors_js_1.RenderError(`Error writing SVG file: ${err}`, 'file_output');
                     }
                 }
                 else if (fileExtension === 'pdf') {
@@ -267,17 +274,17 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                         doc.end();
                     }
                     catch (err) {
-                        throw new utils_js_1.RenderError(`Error generating PDF file: ${err}`, 'pdf_output');
+                        throw new errors_js_1.RenderError(`Error generating PDF file: ${err}`, 'pdf_output');
                     }
                 }
                 else {
-                    throw new utils_js_1.RenderError(`Invalid output format: ${fileExtension}`, 'file_output');
+                    throw new errors_js_1.RenderError(`Invalid output format: ${fileExtension}`, 'file_output');
                 }
                 console.log('Generated file', outputPath);
             }
         }
         catch (err) {
-            throw new utils_js_1.RenderError(`Error during rendering: ${err}`, 'output_generation');
+            throw new errors_js_1.RenderError(`Error during rendering: ${err}`, 'output_generation', { cause: err });
         }
     }
     return {

package/dist/cjs/regenerate-tests.js

@@ -45,14 +45,14 @@ async function regenerateTests(extra = "") {
         cstFiles.forEach(file => {
             const svg1 = 'svgs/' + file + '.svg';
             const svg2 = 'svgs/' + file + '.next.svg';
-            const cleanedName = file.replace('script', '').replace('.cst', '');
-            allFiles.push([file, svg1, svg2, cleanedName]);
+            const cleanedName = file.replace('script', '')
+                .replace('.cst', '')
+                .replace('.annotated', '');
+            allFiles.push([file, svg1, svg2, Number(cleanedName)]);
         });
         const sortedFiles = allFiles.sort((a, b) => {
-            const nameA = a[3];
-            const nameB = b[3];
-            const indexA = Number(nameA);
-            const indexB = Number(nameB);
+            const indexA = a[3];
+            const indexB = b[3];
             if (indexA > indexB) {
                 return 1;
             }