circuitscript 0.1.12 → 0.1.13

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -25,8 +25,6 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_block_pin_expr;
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
-    visitBreak_keyword;
-    visitContinue_keyword;
     visitAssignment_expr;
     visitOperator_assignment_expr;
     visitKeyword_assignment_expr;

package/dist/esm/builtinMethods.js

@@ -1,6 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { prepareValue, resolveToNumericValue } from "./utils.js";
+import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -16,8 +16,7 @@ export function linkBuiltInMethods(context, visitor) {
     context.createFunction('print', (params) => {
         const args = getPositionParams(params);
         const items = args.map(item => {
-            const value = prepareValue(item);
-            return toString(value);
+            return toString(unwrapValue(item));
         });
         if (visitor.printToConsole) {
             console.log('::', ...items);
@@ -78,7 +77,7 @@ function toMils(value) {
     return resolveToNumericValue(bigValue);
 }
 function objectLength(obj) {
-    obj = prepareValue(obj);
+    obj = unwrapValue(obj);
     if (Array.isArray(obj)) {
         return numeric(obj.length);
     }
@@ -109,6 +108,9 @@ function arrayGet(arrayObject, index) {
     else {
         useValue = index;
     }
+    if (isNaN(useValue)) {
+        throw new RuntimeExecutionError("Invalid index for arrayGet");
+    }
     return arrayObject[useValue];
 }
 function arraySet(arrayObject, index, setValue) {

package/dist/esm/execute.js

@@ -4,7 +4,7 @@ import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './obj
 import { Net } from './objects/Net.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { PortSide } from './objects/PinDefinition.js';
-import { DeclaredReference, Direction } from './objects/types.js';
+import { AnyReference, DeclaredReference, Direction } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './layout.js';
@@ -562,38 +562,18 @@ export class ExecutionContext {
                 if (isVariable || isComponentInstance) {
                     const scopeList = isVariable ? context.scope.variables
                         : context.scope.instances;
-                    let parentValue = undefined;
-                    let useValue = scopeList.get(idName);
-                    if (trailers.length > 0) {
-                        parentValue = useValue;
-                        const trailersPath = trailers.join(".");
-                        if (!isComponentInstance && (parentValue instanceof ClassComponent)) {
-                            isComponentInstance = true;
-                            isVariable = false;
-                        }
-                        if (isVariable) {
-                            useValue = parentValue[trailersPath];
-                        }
-                        else if (isComponentInstance) {
-                            const tmpComponent = parentValue;
-                            if (tmpComponent.typeProp === ComponentTypes.net) {
-                                const usedNet = this.scope.getNet(tmpComponent, 1);
-                                if (usedNet) {
-                                    const trailerValue = trailers.join(".");
-                                    useValue = usedNet.params.get(trailerValue) ?? null;
-                                }
-                            }
-                            else {
-                                useValue = parentValue.parameters.get(trailersPath);
-                            }
-                        }
+                    const useValue = scopeList.get(idName);
+                    if (!isComponentInstance && (useValue instanceof ClassComponent)) {
+                        isComponentInstance = true;
+                        isVariable = false;
                     }
+                    const tmpReference = this.resolveTrailers(isVariable ? ReferenceTypes.variable : ReferenceTypes.instance, useValue, trailers);
                     return new DeclaredReference({
                         type: isVariable ? ReferenceTypes.variable
                             : ReferenceTypes.instance,
-                        found: (useValue !== undefined),
-                        parentValue,
-                        value: useValue,
+                        found: (tmpReference.value !== undefined),
+                        parentValue: tmpReference.parentValue,
+                        value: tmpReference.value,
                         name: idName,
                         trailers,
                     });
@@ -605,6 +585,37 @@ export class ExecutionContext {
             name: idName,
         });
     }
+    resolveTrailers(type, item, trailers = []) {
+        let parentValue;
+        let useValue = item;
+        if (trailers.length > 0) {
+            parentValue = useValue;
+            const trailersPath = trailers.join(".");
+            if (type === ReferenceTypes.variable) {
+                useValue = parentValue[trailersPath];
+            }
+            else if (type === ReferenceTypes.instance) {
+                const tmpComponent = parentValue;
+                if (tmpComponent.typeProp === ComponentTypes.net) {
+                    const usedNet = this.scope.getNet(tmpComponent, 1);
+                    if (usedNet) {
+                        const trailerValue = trailers.join(".");
+                        useValue = usedNet.params.get(trailerValue) ?? null;
+                    }
+                }
+                else {
+                    useValue = parentValue.parameters.get(trailersPath);
+                }
+            }
+        }
+        return new AnyReference({
+            found: true,
+            type: type,
+            parentValue,
+            trailers,
+            value: useValue,
+        });
+    }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
         if (this.__functionCache[functionName] === undefined) {

package/dist/esm/helpers.js

@@ -184,14 +184,6 @@ export async function renderScript(scriptData, outputPath, options) {
     };
     visitor.log('reading file');
     visitor.log('done reading file');
-    const { tree, parser, parserTimeTaken, lexerTimeTaken } = await parseFileWithVisitor(visitor, scriptData);
-    printWarnings(visitor.getWarnings());
-    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);
@@ -199,8 +191,19 @@ export async function renderScript(scriptData, outputPath, options) {
             mkdirSync(dumpDirectory);
         }
     }
+    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
+    printWarnings(visitor.getWarnings());
+    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(" | ")));
+    }
     dumpData && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
     dumpData && writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    if (throwError) {
+        throw throwError;
+    }
     let svgOutput = "";
     if (errors.length === 0) {
         const { frameComponent } = visitor.applySheetFrameComponent();

package/dist/esm/parser.js

@@ -18,6 +18,7 @@ export async function parseFileWithVisitor(visitor, data) {
     parser.removeErrorListeners();
     parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
+    let throwError;
     try {
         await visitor.visitAsync(tree);
     }
@@ -27,7 +28,7 @@ export async function parseFileWithVisitor(visitor, data) {
                 visitor.onErrorHandler(error.message, null, error);
             }
             else {
-                throw error;
+                throwError = error;
             }
         }
     }
@@ -38,6 +39,7 @@ export async function parseFileWithVisitor(visitor, data) {
         hasError: false,
         parserTimeTaken,
         lexerTimeTaken,
+        throwError
     };
 }
 export class CircuitscriptParserErrorListener {

package/dist/esm/utils.js

@@ -326,7 +326,7 @@ export function printWarnings(warnings) {
         console.log(`Warning: ${message}`);
     });
 }
-export function prepareValue(value) {
+export function unwrapValue(value) {
     if (isReference(value)) {
         return value.value;
     }

package/dist/esm/visitor.js

@@ -4,7 +4,7 @@ import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
-import { prepareValue } from "./utils.js";
+import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
@@ -401,7 +401,7 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitGraphicForExpr = (ctx) => {
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = prepareValue(this.visitResult(ctx.data_expr()));
+        const listItems = unwrapValue(this.visitResult(ctx.data_expr()));
         let keepLooping = true;
         let counter = 0;
         let allCommands = [];
@@ -543,7 +543,7 @@ export class ParserVisitor extends BaseVisitor {
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
             component = this.visitResult(ctxDataExpr);
-            component = prepareValue(component);
+            component = unwrapValue(component);
             componentCtx = ctxDataExpr;
             if (component === null || component === undefined) {
                 this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
@@ -1074,7 +1074,7 @@ export class ParserVisitor extends BaseVisitor {
         this.log('in for loop');
         const forVariableNames = ctx.ID().map(item => item.getText());
         let listItems = this.visitResult(ctx.data_expr());
-        listItems = prepareValue(listItems);
+        listItems = unwrapValue(listItems);
         this.getExecutor().addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, Break_keywordContext, Continue_keywordContext, ExpressionContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
+import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -20,7 +20,6 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     printToConsole: boolean;
     acceptedDirections: Direction[];
     protected resultData: Map<ParserRuleContext, any>;
-    protected paramData: Map<ParserRuleContext, any>;
     pinTypesList: string[];
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
@@ -50,14 +49,14 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
+    private handleFunctionCall;
     visitValue_expr: (ctx: Value_exprContext) => void;
     visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
     visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
     visitParameters: (ctx: ParametersContext) => void;
     visitImport_expr: (ctx: Import_exprContext) => void;
     visitFunction_return_expr: (ctx: Function_return_exprContext) => void;
-    visitBreak_keyword: (ctx: Break_keywordContext) => void;
-    visitContinue_keyword: (ctx: Continue_keywordContext) => void;
+    visitFlow_expressions: (ctx: Flow_expressionsContext) => void;
     visitArray_expr: (ctx: Array_exprContext) => void;
     visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;

package/dist/types/antlr/CircuitScriptParser.d.ts

@@ -94,47 +94,45 @@ export declare class CircuitScriptParser extends antlr.Parser {
     static readonly RULE_at_block_pin_expr = 22;
     static readonly RULE_at_block_pin_expression_simple = 23;
     static readonly RULE_at_block_pin_expression_complex = 24;
-    static readonly RULE_break_keyword = 25;
-    static readonly RULE_continue_keyword = 26;
-    static readonly RULE_assignment_expr = 27;
-    static readonly RULE_operator_assignment_expr = 28;
-    static readonly RULE_keyword_assignment_expr = 29;
-    static readonly RULE_parameters = 30;
-    static readonly RULE_property_set_expr = 31;
-    static readonly RULE_double_dot_property_set_expr = 32;
-    static readonly RULE_data_expr = 33;
-    static readonly RULE_binary_operator = 34;
-    static readonly RULE_unary_operator = 35;
-    static readonly RULE_value_expr = 36;
-    static readonly RULE_function_def_expr = 37;
-    static readonly RULE_function_expr = 38;
-    static readonly RULE_function_args_expr = 39;
-    static readonly RULE_atom_expr = 40;
-    static readonly RULE_trailer_expr = 41;
-    static readonly RULE_function_call_expr = 42;
-    static readonly RULE_net_namespace_expr = 43;
-    static readonly RULE_function_return_expr = 44;
-    static readonly RULE_property_block_expr = 45;
-    static readonly RULE_create_component_expr = 46;
-    static readonly RULE_graphic_expressions_block = 47;
-    static readonly RULE_create_graphic_expr = 48;
-    static readonly RULE_create_module_expr = 49;
-    static readonly RULE_nested_properties_inner = 50;
-    static readonly RULE_graphic_expr = 51;
-    static readonly RULE_property_expr = 52;
-    static readonly RULE_property_key_expr = 53;
-    static readonly RULE_property_value_expr = 54;
-    static readonly RULE_wire_atom_expr = 55;
-    static readonly RULE_wire_expr = 56;
-    static readonly RULE_array_expr = 57;
-    static readonly RULE_point_expr = 58;
-    static readonly RULE_import_expr = 59;
-    static readonly RULE_frame_expr = 60;
-    static readonly RULE_if_expr = 61;
-    static readonly RULE_if_inner_expr = 62;
-    static readonly RULE_else_expr = 63;
-    static readonly RULE_while_expr = 64;
-    static readonly RULE_for_expr = 65;
+    static readonly RULE_assignment_expr = 25;
+    static readonly RULE_operator_assignment_expr = 26;
+    static readonly RULE_keyword_assignment_expr = 27;
+    static readonly RULE_parameters = 28;
+    static readonly RULE_property_set_expr = 29;
+    static readonly RULE_double_dot_property_set_expr = 30;
+    static readonly RULE_data_expr = 31;
+    static readonly RULE_binary_operator = 32;
+    static readonly RULE_unary_operator = 33;
+    static readonly RULE_value_expr = 34;
+    static readonly RULE_function_def_expr = 35;
+    static readonly RULE_function_expr = 36;
+    static readonly RULE_function_args_expr = 37;
+    static readonly RULE_atom_expr = 38;
+    static readonly RULE_trailer_expr = 39;
+    static readonly RULE_function_call_expr = 40;
+    static readonly RULE_net_namespace_expr = 41;
+    static readonly RULE_function_return_expr = 42;
+    static readonly RULE_property_block_expr = 43;
+    static readonly RULE_create_component_expr = 44;
+    static readonly RULE_graphic_expressions_block = 45;
+    static readonly RULE_create_graphic_expr = 46;
+    static readonly RULE_create_module_expr = 47;
+    static readonly RULE_nested_properties_inner = 48;
+    static readonly RULE_graphic_expr = 49;
+    static readonly RULE_property_expr = 50;
+    static readonly RULE_property_key_expr = 51;
+    static readonly RULE_property_value_expr = 52;
+    static readonly RULE_wire_atom_expr = 53;
+    static readonly RULE_wire_expr = 54;
+    static readonly RULE_array_expr = 55;
+    static readonly RULE_point_expr = 56;
+    static readonly RULE_import_expr = 57;
+    static readonly RULE_frame_expr = 58;
+    static readonly RULE_if_expr = 59;
+    static readonly RULE_if_inner_expr = 60;
+    static readonly RULE_else_expr = 61;
+    static readonly RULE_while_expr = 62;
+    static readonly RULE_for_expr = 63;
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -170,8 +168,6 @@ export declare class CircuitScriptParser extends antlr.Parser {
     at_block_pin_expr(): At_block_pin_exprContext;
     at_block_pin_expression_simple(): At_block_pin_expression_simpleContext;
     at_block_pin_expression_complex(): At_block_pin_expression_complexContext;
-    break_keyword(): Break_keywordContext;
-    continue_keyword(): Continue_keywordContext;
     assignment_expr(): Assignment_exprContext;
     operator_assignment_expr(): Operator_assignment_exprContext;
     keyword_assignment_expr(): Keyword_assignment_exprContext;
@@ -236,7 +232,6 @@ export declare class ScriptContext extends antlr.ParserRuleContext {
 export declare class ExpressionContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     graph_expressions(): Graph_expressionsContext | null;
-    flow_expressions(): Flow_expressionsContext | null;
     assignment_expr(): Assignment_exprContext | null;
     operator_assignment_expr(): Operator_assignment_exprContext | null;
     property_set_expr(): Property_set_exprContext | null;
@@ -247,6 +242,7 @@ export declare class ExpressionContext extends antlr.ParserRuleContext {
     import_expr(): Import_exprContext | null;
     atom_expr(): Atom_exprContext | null;
     frame_expr(): Frame_exprContext | null;
+    flow_expressions(): Flow_expressionsContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -255,8 +251,8 @@ export declare class Flow_expressionsContext extends antlr.ParserRuleContext {
     if_expr(): If_exprContext | null;
     while_expr(): While_exprContext | null;
     for_expr(): For_exprContext | null;
-    break_keyword(): Break_keywordContext | null;
-    continue_keyword(): Continue_keywordContext | null;
+    Break(): antlr.TerminalNode | null;
+    Continue(): antlr.TerminalNode | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -451,18 +447,6 @@ export declare class At_block_pin_expression_complexContext extends antlr.Parser
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
-export declare class Break_keywordContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    Break(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
-export declare class Continue_keywordContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    Continue(): antlr.TerminalNode;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
 export declare class Assignment_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     data_expr(): Data_exprContext;

package/dist/types/antlr/CircuitScriptVisitor.d.ts

@@ -24,8 +24,6 @@ import { At_block_expressionsContext } from "./CircuitScriptParser.js";
 import { At_block_pin_exprContext } from "./CircuitScriptParser.js";
 import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser.js";
 import { At_block_pin_expression_complexContext } from "./CircuitScriptParser.js";
-import { Break_keywordContext } from "./CircuitScriptParser.js";
-import { Continue_keywordContext } from "./CircuitScriptParser.js";
 import { Assignment_exprContext } from "./CircuitScriptParser.js";
 import { Operator_assignment_exprContext } from "./CircuitScriptParser.js";
 import { Keyword_assignment_exprContext } from "./CircuitScriptParser.js";
@@ -103,8 +101,6 @@ export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisit
     visitAt_block_pin_expr?: (ctx: At_block_pin_exprContext) => Result;
     visitAt_block_pin_expression_simple?: (ctx: At_block_pin_expression_simpleContext) => Result;
     visitAt_block_pin_expression_complex?: (ctx: At_block_pin_expression_complexContext) => Result;
-    visitBreak_keyword?: (ctx: Break_keywordContext) => Result;
-    visitContinue_keyword?: (ctx: Continue_keywordContext) => Result;
     visitAssignment_expr?: (ctx: Assignment_exprContext) => Result;
     visitOperator_assignment_expr?: (ctx: Operator_assignment_exprContext) => Result;
     visitKeyword_assignment_expr?: (ctx: Keyword_assignment_exprContext) => Result;

package/dist/types/execute.d.ts

@@ -1,11 +1,11 @@
-import { BlockTypes, FrameType } from './globals.js';
+import { BlockTypes, FrameType, ReferenceTypes } from './globals.js';
 import { ExecutionWarning } from "./utils.js";
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
 import { NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
 import { PinDefinition } from './objects/PinDefinition.js';
-import { CFunction, CFunctionResult, CallableParameter, ComponentPin, DeclaredReference } from './objects/types.js';
+import { AnyReference, CFunction, CFunctionResult, CallableParameter, ComponentPin, DeclaredReference } from './objects/types.js';
 import { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -75,6 +75,7 @@ export declare class ExecutionContext {
     hasFunction(functionName: string): boolean;
     getFunction(functionName: string): CFunction;
     resolveVariable(executionStack: ExecutionContext[], idName: string, trailers?: string[]): DeclaredReference;
+    resolveTrailers(type: ReferenceTypes, item: any, trailers?: string[]): AnyReference;
     callFunction(functionName: string, functionParams: CallableParameter[], executionStack: ExecutionContext[], netNamespace: string): CFunctionResult;
     mergeScope(childScope: ExecutionScope, namespace: string): void;
     addWire(segments: [string, (number | UnitDimension)?][]): void;

package/dist/types/parser.d.ts

@@ -8,6 +8,7 @@ export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string)
     hasParseError: boolean;
     parserTimeTaken: number;
     lexerTimeTaken: number;
+    throwError: any;
 }>;
 export declare class CircuitscriptParserErrorListener implements ANTLRErrorListener {
     syntaxErrorCounter: number;

package/dist/types/utils.d.ts

@@ -73,5 +73,5 @@ export type ExecutionWarning = {
     ctx?: ParserRuleContext;
 };
 export declare function printWarnings(warnings: ExecutionWarning[]): void;
-export declare function prepareValue(value: AnyReference | DeclaredReference | any): any;
+export declare function unwrapValue(value: AnyReference | DeclaredReference | any): any;
 export declare function isReference(value: any): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.12",
+    "version": "0.1.13",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {