circuitscript 0.1.5 → 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,

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)
@@ -33,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");
@@ -46,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");
@@ -65,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);
+    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;
@@ -14,6 +14,7 @@ export class ClassComponent {
     _cachedParams;
     _copyID = null;
     _copyFrom = null;
+    _pointLinkComponent;
     arrangeProps = null;
     displayProp = null;
     widthProp = null;

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

@@ -1,3 +1,4 @@
+import { Property_key_exprContext } from '../antlr/CircuitScriptParser.js';
 export class ExecutionScope {
     scopeId;
     nets = [];
@@ -6,6 +7,8 @@ export class ExecutionScope {
     variables = new Map();
     symbols = new Map();
     blockStack = new Map();
+    contextStack = [];
+    onPropertyHandler = [];
     breakStack = [];
     wires = [];
     frames = [];
@@ -122,6 +125,36 @@ export class ExecutionScope {
             this.currentPin = null;
         }
     }
+    enterContext(context) {
+        this.contextStack.push(context);
+    }
+    exitContext() {
+        return this.contextStack.pop();
+    }
+    findPropertyKeyTree() {
+        const keyNames = [];
+        for (let i = this.contextStack.length - 1; i >= 0; i--) {
+            const ctx = this.contextStack[i];
+            if (ctx instanceof Property_key_exprContext) {
+                keyNames.push([ctx, ctx.getText()]);
+            }
+            else if (typeof ctx === 'number') {
+                keyNames.push(['index', ctx]);
+            }
+        }
+        return keyNames.reverse();
+    }
+    setOnPropertyHandler(handler) {
+        this.onPropertyHandler.push(handler);
+    }
+    popOnPropertyHandler() {
+        return this.onPropertyHandler.pop();
+    }
+    triggerPropertyHandler(value, valueCtx) {
+        const lastHandler = this.onPropertyHandler[this.onPropertyHandler.length - 1];
+        const propertyTree = this.findPropertyKeyTree();
+        lastHandler && lastHandler(propertyTree, value, valueCtx);
+    }
 }
 export var SequenceAction;
 (function (SequenceAction) {

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

@@ -1,4 +1,4 @@
-import { FrameType } from "../globals.mjs";
+import { FrameType } from "../globals.js";
 export class Frame {
     parameters = new Map();
     frameId;

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

@@ -1,4 +1,4 @@
-import { getNumberExponential, getNumberExponentialText, resolveToNumericValue } from "../utils";
+import { getNumberExponential, getNumberExponentialText, resolveToNumericValue } from "../utils.js";
 import { Big } from 'big.js';
 export class ParamDefinition {
     paramName;

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

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