circuitscript 0.1.4 → 0.1.7

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 = [];
@@ -16,8 +19,6 @@ export class ExecutionScope {
     currentPin = null;
     currentWireId = -1;
     currentFrameId = -1;
-    netGnd = null;
-    componentGnd = null;
     componentRoot = null;
     copyIDs = new Map();
     sequence = [];
@@ -41,6 +42,12 @@ export class ExecutionScope {
         });
         return found ? found[2] : null;
     }
+    getNetWithNamespacePath(namespace, name) {
+        const found = this.nets.find(([, , net]) => {
+            return net.namespace === namespace && net.name === name;
+        });
+        return found ? found[2] : null;
+    }
     hasNet(component, pin) {
         return this.findNet(component, pin) !== undefined;
     }
@@ -118,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) {
@@ -126,6 +163,7 @@ export var SequenceAction;
     SequenceAction["Wire"] = "wire";
     SequenceAction["WireJump"] = "wire-jump";
     SequenceAction["Frame"] = "frame";
+    SequenceAction["Assign"] = "assign";
 })(SequenceAction || (SequenceAction = {}));
 export var FrameAction;
 (function (FrameAction) {

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;

package/dist/esm/parser.js

@@ -0,0 +1,71 @@
+import { CircuitScriptParser } from './antlr/CircuitScriptParser.js';
+import { MainLexer } from './lexer.js';
+import { ParseSyntaxError, RuntimeExecutionError, SimpleStopwatch } from './utils.js';
+import { CharStream, CommonTokenStream } from 'antlr4ng';
+export async function parseFileWithVisitor(visitor, data) {
+    const lexerErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
+    const parserErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
+    const chars = CharStream.fromString(data);
+    const lexer = new MainLexer(chars);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(lexerErrorListener);
+    const lexerTimer = new SimpleStopwatch();
+    const tokens = new CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parserTimer = new SimpleStopwatch();
+    const parser = new CircuitScriptParser(tokens);
+    parser.removeErrorListeners();
+    parser.addErrorListener(parserErrorListener);
+    const tree = parser.script();
+    try {
+        await visitor.visitAsync(tree);
+    }
+    catch (error) {
+        if (visitor.onErrorHandler) {
+            if (error instanceof RuntimeExecutionError) {
+                visitor.onErrorHandler(error.message, null, error);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    const parserTimeTaken = parserTimer.lap();
+    return {
+        tree, parser,
+        hasParseError: false,
+        hasError: false,
+        parserTimeTaken,
+        lexerTimeTaken,
+    };
+}
+export class CircuitscriptParserErrorListener {
+    syntaxErrorCounter = 0;
+    onErrorHandler = null;
+    constructor(onErrorHandler = null) {
+        this.onErrorHandler = onErrorHandler;
+    }
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        if (this.onErrorHandler && e) {
+            this.onErrorHandler(msg, e.ctx, e);
+        }
+        else {
+            if (offendingSymbol && msg.match("extraneous input 'import' expecting")) {
+                msg = "Invalid import statement";
+                throw new ParseSyntaxError("Invalid import statement", offendingSymbol);
+            }
+            console.log("Syntax error at line", line, ':', column, ' - ', 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/dist/esm/{regenerate-tests.mjs → regenerate-tests.js}

@@ -1,11 +1,11 @@
 import fs from 'fs';
-import { getDefaultLibsPath, getFontsPath, renderScript } from './helpers.mjs';
-import { prepareSVGEnvironment } from './sizing.mjs';
+import { renderScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 const mainDir = './__tests__/renderData/';
-const fontsPath = getFontsPath();
-const defaultLibsPath = getDefaultLibsPath();
+const env = new NodeScriptEnvironment();
+NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
-    await prepareSVGEnvironment(fontsPath);
+    env.prepareSVGEnvironment();
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
@@ -17,9 +17,12 @@ async function regenerateTests(extra = "") {
         const inputPath = mainDir + file;
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
+        env.setModuleDirectory(mainDir);
         renderScript(scriptData, outputPath, {
-            currentDirectory: mainDir,
-            defaultLibsPath,
+            dumpNets: false,
+            dumpData: false,
+            showStats: false,
+            environment: env,
         });
         console.log('generated ', outputPath);
     });

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

@@ -1,15 +1,17 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.mjs";
-import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
-import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
-import { combineMaps, getBoundsSize } from './utils.mjs';
-import { getPaperSize, milsToMM } from './helpers.mjs';
+import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.js";
+import { applyFontsToSVG } from './sizing.js';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
+import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { combineMaps, getBoundsSize } from './utils.js';
+import { getPaperSize, milsToMM } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 import SVGtoPDF from 'svg-to-pdfkit';
-import { FrameParamKeys } from './objects/Frame.mjs';
-import { SymbolPlaceholder } from './draw_symbols.mjs';
+import { FrameParamKeys } from './objects/Frame.js';
+import { SymbolPlaceholder } from './draw_symbols.js';
 function createSvgCanvas() {
-    const window = getCreateSVGWindow()();
+    const env = NodeScriptEnvironment.getInstance();
+    const window = env.createSVGWindow();
     const document = window.document;
     registerWindow(window, document);
     const canvas = SVG(document.documentElement);

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

@@ -1,41 +1,14 @@
-import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.mjs';
-import { defaultFont } from './globals.mjs';
-import { JSModuleType, detectJSModuleType } from './helpers.mjs';
-let MainCanvas = null;
-const supportedFonts = {
-    'Arial': 'Arial.ttf',
-};
-let globalCreateSVGWindow;
-export async function prepareSVGEnvironment(fontsPath) {
-    const moduleType = detectJSModuleType();
-    if (moduleType === JSModuleType.CommonJs) {
-        const { config, createSVGWindow } = await import('svgdom');
-        globalCreateSVGWindow = createSVGWindow;
-        if (fontsPath !== null) {
-            await config.setFontDir(fontsPath)
-                .setFontFamilyMappings(supportedFonts)
-                .preloadFonts();
-        }
-    }
-}
-export function getCreateSVGWindow() {
-    if (globalCreateSVGWindow === undefined) {
-        throw "SVG environment is not set up yet";
-    }
-    return globalCreateSVGWindow;
-}
+import { Big } from 'big.js';
+import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.js';
+import { defaultFont } from './globals.js';
+import { NodeScriptEnvironment } from "./environment.js";
 export function applyFontsToSVG(canvas) {
 }
 const measureTextSizeCache = {};
 const measureTextSizeCacheHits = {};
 export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {
-    if (MainCanvas === null) {
-        const window = getCreateSVGWindow()();
-        const { document } = window;
-        registerWindow(window, document);
-        MainCanvas = SVG(document.documentElement);
-    }
+    const environment = NodeScriptEnvironment.getInstance();
+    const mainCanvas = environment.getCanvasWindow();
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
         let dominantBaseline = VerticalAlignProp.Hanging;
@@ -63,7 +36,7 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
                 break;
         }
         fontFamily = defaultFont;
-        const tmpTextElement = MainCanvas.text(text).font({
+        const tmpTextElement = mainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
             anchor: useAnchor,
@@ -87,9 +60,11 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
         }
         const { width, height } = textbox;
         tmpTextElement.remove();
+        const finalWidth = new Big(width).round(4).toNumber();
+        const finalHeight = new Big(height).round(4).toNumber();
         measureTextSizeCache[key] = {
-            width: Math.round(width * 100) / 100,
-            height: Math.round(height * 100) / 100,
+            width: finalWidth,
+            height: finalHeight,
             box: textbox,
         };
         measureTextSizeCacheHits[key] = 0;

package/dist/esm/utils.js

@@ -0,0 +1,286 @@
+import { Big } from 'big.js';
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
+import { SequenceAction } from './objects/ExecutionScope.js';
+import { BlockTypes } from './globals.js';
+export class SimpleStopwatch {
+    startTime;
+    constructor() {
+        this.startTime = new Date();
+    }
+    lap() {
+        return (new Date()).getTime() - this.startTime.getTime();
+    }
+}
+export function resizeBounds(bounds, value) {
+    return {
+        xmin: bounds.xmin - value,
+        xmax: bounds.xmax + value,
+        ymin: bounds.ymin - value,
+        ymax: bounds.ymax + value
+    };
+}
+export function printBounds(bounds) {
+    if (bounds !== null) {
+        return `[${bounds.xmin}, ${bounds.ymin} to ${bounds.xmax}, ${bounds.ymax}]`;
+    }
+    else {
+        return 'null';
+    }
+}
+function hasRemainder(value, value2) {
+    const tmpValue = Math.abs(value) / value2;
+    const flooredValue = Math.floor(tmpValue);
+    const diff = tmpValue - flooredValue;
+    return diff;
+}
+export function resizeToNearestGrid(bounds, gridSize = 20) {
+    const addXMin = hasRemainder(bounds.xmin, gridSize) === 0 ? -1 : 0;
+    const addYMin = hasRemainder(bounds.ymin, gridSize) === 0 ? -1 : 0;
+    const addXMax = hasRemainder(bounds.xmax, gridSize) === 0 ? 1 : 0;
+    const addYMax = hasRemainder(bounds.ymax, gridSize) === 0 ? 1 : 0;
+    return {
+        xmin: Math.floor((bounds.xmin + addXMin) / gridSize) * gridSize,
+        ymin: Math.floor((bounds.ymin + addYMin) / gridSize) * gridSize,
+        xmax: Math.ceil((bounds.xmax + addXMax) / gridSize) * gridSize,
+        ymax: Math.ceil((bounds.ymax + addYMax) / gridSize) * gridSize,
+    };
+}
+export function toNearestGrid(value, gridSize) {
+    return Math.floor(value / gridSize) * gridSize;
+}
+export function getBoundsSize(bounds) {
+    return {
+        width: bounds.xmax - bounds.xmin,
+        height: bounds.ymax - bounds.ymin,
+    };
+}
+export function getPortType(component) {
+    const drawingCommands = component.displayProp;
+    let foundPinType = null;
+    const commands = drawingCommands.getCommands();
+    commands.some(item => {
+        if (item[0] === 'label' && item[2].has('portType')) {
+            foundPinType = item[2].get('portType');
+            return true;
+        }
+        return false;
+    });
+    return foundPinType;
+}
+export function roundValue(value) {
+    return resolveToNumericValue(new Big(value.toBigNumber().toFixed(7)));
+}
+export function throwWithContext(context, messageOrError) {
+    if (messageOrError instanceof BaseError) {
+        throw messageOrError;
+    }
+    throwWithTokenRange(messageOrError, context.start, context.stop);
+}
+export function throwWithToken(message, token) {
+    throw new ParseError(message, token);
+}
+export function throwWithTokenRange(message, startToken, endToken) {
+    throw new ParseError(message, startToken, endToken);
+}
+export function combineMaps(map1, map2) {
+    const newMap = new Map(map1);
+    map2.forEach((value, key) => {
+        newMap.set(key, value);
+    });
+    return newMap;
+}
+export function getNumberExponential(value) {
+    value = value.trim();
+    switch (value) {
+        case 'G':
+            return 9;
+        case 'M':
+            return 6;
+        case 'k':
+        case 'K':
+            return 3;
+        case 'm':
+            return -3;
+        case 'u':
+            return -6;
+        case 'n':
+            return -9;
+        case 'p':
+            return -12;
+        case 'f':
+            return -15;
+        default:
+            return 0;
+    }
+}
+export function getNumberExponentialText(value) {
+    switch (value) {
+        case -15:
+            return 'f';
+        case -12:
+            return 'p';
+        case -9:
+            return 'n';
+        case -6:
+            return 'u';
+        case -3:
+            return 'm';
+        case 3:
+            return 'k';
+        case 6:
+            return 'M';
+        case 9:
+            return 'G';
+        case 0:
+        default:
+            return '';
+    }
+}
+export function resolveToNumericValue(value) {
+    if (value.toNumber() === 0) {
+        return new NumericValue(0);
+    }
+    const isNeg = value.lt(0);
+    const positiveValue = isNeg ? value.neg() : value;
+    const prefixPart = Math.floor(Math.log10(positiveValue.toNumber()) / 3);
+    let useValue = value;
+    if (prefixPart !== 0) {
+        const tmpValue1 = positiveValue.div(Math.pow(10, prefixPart * 3));
+        useValue = isNeg ? tmpValue1.neg() : tmpValue1;
+    }
+    return new NumericValue(useValue, prefixPart * 3);
+}
+export function isPointWithinArea(point, bounds) {
+    const [xPt, yPt] = point;
+    const [xmin, ymin, xmax, ymax] = bounds;
+    return (xPt > xmin && xPt < xmax && yPt > ymin && yPt < ymax);
+}
+export function areasOverlap(area1, area2) {
+    const [xmin, ymin, xmax, ymax] = area1;
+    const pt1 = [xmin, ymin];
+    const pt2 = [xmin, ymax];
+    const pt3 = [xmax, ymin];
+    const pt4 = [xmax, ymax];
+    return isPointWithinArea(pt1, area2)
+        || isPointWithinArea(pt2, area2)
+        || isPointWithinArea(pt3, area2)
+        || isPointWithinArea(pt4, area2);
+}
+export function sequenceActionString(sequenceAction) {
+    const tmp = [...sequenceAction];
+    const action = tmp[0];
+    if (action === SequenceAction.Wire) {
+        tmp[2] = tmp[2].map(item2 => {
+            const lengthValue = item2.value;
+            const useValue = [item2.direction];
+            if (lengthValue !== null) {
+                useValue.push(lengthValue.value);
+                useValue.push(lengthValue.type);
+            }
+            return useValue.join(",");
+        }).join(" ");
+    }
+    else if (action === SequenceAction.Frame) {
+        tmp[1] = sequenceAction[1].frameId;
+    }
+    else if (action !== SequenceAction.WireJump) {
+        const [, component] = sequenceAction;
+        if (component instanceof ClassComponent) {
+            tmp[1] = sequenceAction[1].instanceName;
+        }
+    }
+    return tmp.join(" | ");
+}
+export function generateDebugSequenceAction(sequence) {
+    const variableMapping = new Map();
+    return sequence.map(item => {
+        const returnResult = [...item];
+        const [action,] = item;
+        if (action === SequenceAction.Assign) {
+            const [, name, component] = item;
+            variableMapping.set(name, component);
+        }
+        else {
+            if (action === SequenceAction.At || action === SequenceAction.To) {
+                const [, component,] = item;
+                const foundIndex = Array.from(variableMapping.values()).findIndex(item2 => {
+                    if (component._copyFrom !== null) {
+                        return component._copyFrom === item2;
+                    }
+                    return component === item2;
+                });
+                if (foundIndex !== -1) {
+                    const name = Array.from(variableMapping.keys())[foundIndex];
+                    returnResult[1] = name + ':' + component._copyID;
+                }
+            }
+        }
+        return returnResult;
+    });
+}
+export function getBlockTypeString(type) {
+    let returnValue = 'branch';
+    switch (type) {
+        case BlockTypes.Branch:
+            returnValue = 'branch';
+            break;
+        case BlockTypes.Join:
+            returnValue = 'join';
+            break;
+        case BlockTypes.Parallel:
+            returnValue = 'parallel';
+            break;
+        case BlockTypes.Point:
+            returnValue = 'point';
+            break;
+    }
+    return returnValue;
+}
+export class BaseError extends Error {
+    name = 'BaseError';
+    message;
+    startToken;
+    endToken;
+    filePath;
+    constructor(message, startToken, endToken, filePath) {
+        super(message);
+        this.message = message;
+        this.startToken = startToken;
+        this.endToken = endToken;
+        this.filePath = filePath;
+    }
+    toString() {
+        const parts = [this.name];
+        if (this.startToken) {
+            const { line, column } = this.startToken;
+            if (this.endToken && (this.endToken.line !== this.startToken.line || this.endToken.column !== this.startToken.column)) {
+                const endLine = this.endToken.line;
+                const endColumn = this.endToken.column + (this.endToken.stop - this.endToken.start);
+                parts.push(` at ${line}:${column}-${endLine}:${endColumn}`);
+            }
+            else {
+                parts.push(` at ${line}:${column}`);
+            }
+        }
+        parts.push(`: ${this.message}`);
+        return parts.join('');
+    }
+}
+export class ParseSyntaxError extends BaseError {
+    name = 'ParseSyntaxError';
+}
+export class ParseError extends ParseSyntaxError {
+    name = 'ParseError';
+}
+export class RuntimeExecutionError extends BaseError {
+    name = 'RuntimeExecutionError';
+}
+export class RenderError extends Error {
+    stage;
+    constructor(message, stage) {
+        super(message);
+        this.name = 'RenderError';
+        this.stage = stage;
+    }
+}

package/dist/esm/validate/SymbolTable.js

@@ -0,0 +1,90 @@
+import { ParseSymbolType } from "../objects/types.js";
+export class SymbolTable {
+    symbols = new Map();
+    executonContextsNamespaces = [];
+    getSymbols() {
+        return this.symbols;
+    }
+    addFunction(token, fileName, executionContext, id, funcDefinedParameters) {
+        return this.add(fileName, executionContext, id, ParseSymbolType.Function, {
+            funcDefinedParameters
+        }, token);
+    }
+    addVariable(token, fileName, executionContext, id, variableValue) {
+        return this.add(fileName, executionContext, id, ParseSymbolType.Variable, {
+            variableValue
+        }, token);
+    }
+    addUndefined(filePath, executionContext, id, token) {
+        return this.add(filePath, executionContext, id, ParseSymbolType.Undefined, {}, token);
+    }
+    add(fileName, executionContext, id, type, extra, token) {
+        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
+            this.executonContextsNamespaces.push(executionContext.namespace);
+        }
+        const item = {
+            id,
+            type,
+            context: executionContext,
+            fileName,
+            extra,
+            token,
+            instances: [],
+        };
+        if (token !== null) {
+            item.instances.push(token);
+        }
+        this.symbols.set(this.idName(executionContext, id), item);
+        return item;
+    }
+    idName(executionContext, id) {
+        return executionContext.namespace + id;
+    }
+    dumpSymbols() {
+        for (const [key, value] of this.symbols) {
+            console.log(value.type.padEnd(10, " "), key);
+        }
+    }
+    exists(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.has(name);
+    }
+    existsAny(executionContext, id) {
+        if (this.exists(executionContext, id)) {
+            return true;
+        }
+        else {
+            return this.searchParentContext(executionContext, id) !== null;
+        }
+    }
+    get(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.get(name);
+    }
+    getParentContexts(executionContext, contextsNamespace) {
+        if (executionContext.parentContext !== null) {
+            contextsNamespace.push(executionContext.parentContext.namespace);
+            this.getParentContexts(executionContext.parentContext, contextsNamespace);
+        }
+        return contextsNamespace;
+    }
+    searchParentContext(executionContext, id) {
+        const contextNames = this.getParentContexts(executionContext, []);
+        for (const [key,] of this.symbols) {
+            if (key.endsWith(`.${id}`)) {
+                const { context } = this.symbols.get(key);
+                if (contextNames.indexOf(context.namespace) !== -1) {
+                    return context;
+                }
+            }
+        }
+        return null;
+    }
+    clearUndefined() {
+        for (const [key, value] of this.symbols) {
+            if (value.type === ParseSymbolType.Undefined) {
+                this.symbols.delete(key);
+            }
+        }
+    }
+}

package/dist/esm/validate/SymbolValidatorResolveVisitor.js

@@ -0,0 +1,10 @@
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+export class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    addSymbolVariable(token, name, value) {
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+        }
+    }
+}