mlogjs 0.4.10 → 0.5.1

package/dist/utils/value.d.ts

@@ -1,36 +1,41 @@
-import { IValue, TEOutput } from "../types";
-import { IObjectValueData, LiteralValue, ObjectValue, StoreValue } from "../values";
-export declare function isTemplateObjectArray(value: IValue): value is ObjectValue & {
-    data: IObjectValueData & {
-        raw: ObjectValue & {
-            data: IObjectValueData & {
-                length: LiteralValue<number>;
-            };
-        };
-        length: LiteralValue<number>;
-    };
-};
-export declare function extractOutName(out: TEOutput | undefined): string | undefined;
-export declare function extractDestrucuringOut(out: TEOutput | undefined, field: string | number): string | IValue | undefined;
-/** Asserts that `value` is a `LiteralValue` that contains a string */
-export declare function assertStringLiteral(value: IValue | undefined, name: string): asserts value is LiteralValue<string>;
-/** Asserts that `value` is a string literal that is part of a given set of `members`*/
-export declare function assertLiteralOneOf<T extends readonly string[]>(value: IValue | undefined, members: T, name: string): asserts value is LiteralValue<T[number]>;
-/** Asserts that `value` is either a store or a literal */
-export declare function assertIsRuntimeValue(value: IValue | undefined, name: string): asserts value is LiteralValue | StoreValue;
-/** Asserts that `value` is an `ObjectValue` */
-export declare function assertIsObjectMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
-/** Asserts that `value` is an `ObjectValue` that has a length property */
-export declare function assertIsArrayMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
-/** Helper type used to describe the overloads of a macro function. See {@link assertObjectFields} */
-export type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
-/** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */
-export interface IParameterDescriptor {
-    key: string;
-    name?: string;
-    default?: string;
-    /** Throw an error on invalid values */
-    validate?(value: IValue): void;
-}
-/** Asserts that all of the fields described are present on `value`*/
-export declare function assertObjectFields(value: ObjectValue, fields: (string | IParameterDescriptor)[]): (IValue | string)[];
+import { IValue, TEOutput } from "../types";
+import { IObjectValueData, LiteralValue, ObjectValue, StoreValue } from "../values";
+export declare function isTemplateObjectArray(value: IValue): value is ObjectValue & {
+    data: IObjectValueData & {
+        raw: ObjectValue & {
+            data: IObjectValueData & {
+                length: LiteralValue<number>;
+            };
+        };
+        length: LiteralValue<number>;
+    };
+};
+export declare function extractOutName(out: TEOutput | undefined): string | undefined;
+export declare function extractDestrucuringOut(out: TEOutput | undefined, field: string | number): string | IValue | undefined;
+/** Asserts that `value` is a `LiteralValue` that contains a string */
+export declare function assertStringLiteral(value: IValue | undefined, name: string): asserts value is LiteralValue<string>;
+/** Asserts that `value` is a string literal that is part of a given set of `members`*/
+export declare function assertLiteralOneOf<T extends readonly string[]>(value: IValue | undefined, members: T, name: string): asserts value is LiteralValue<T[number]>;
+/** Asserts that `value` is either a store or a literal */
+export declare function assertIsRuntimeValue(value: IValue | undefined, name: string): asserts value is LiteralValue | StoreValue;
+/** Asserts that `value` is an `ObjectValue` */
+export declare function assertIsObjectMacro(value: IValue | undefined, name: string): asserts value is ObjectValue;
+/** Asserts that `value` is an `ObjectValue` that has a length property */
+export declare function assertIsArrayMacro(value: IValue | undefined, name: string): asserts value is ObjectValue & {
+    data: {
+        length: LiteralValue<number>;
+    };
+};
+/** Helper type used to describe the overloads of a macro function. See {@link assertObjectFields} */
+export type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
+/** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */
+export interface IParameterDescriptor {
+    key: string;
+    name?: string;
+    default?: string;
+    /** Throw an error on invalid values */
+    validate?(value: IValue): void;
+}
+/** Asserts that all of the fields described are present on `value`*/
+export declare function assertObjectFields(value: ObjectValue, fields: (string | IParameterDescriptor)[]): (IValue | string)[];
+export declare function isDiscardedOut(out: TEOutput | undefined): boolean;

package/dist/values/AssignmentValue.d.ts

@@ -0,0 +1,11 @@
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { VoidValue } from "./VoidValue";
+export declare class AssignmentValue extends VoidValue {
+    left: IValue;
+    right: IValue;
+    constructor(left: IValue, right: IValue);
+    "="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    toOut(): IValue;
+    debugString(): string;
+    toString(): string;
+}

package/dist/values/BaseValue.d.ts

@@ -1,10 +1,10 @@
-import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
-import { VoidValue } from ".";
-export declare class BaseValue extends VoidValue implements IValue {
-    "u-"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "u+"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "!"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "~"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
-    "!=="(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
-}
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { VoidValue } from ".";
+export declare class BaseValue extends VoidValue implements IValue {
+    "u-"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "u+"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "!"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "~"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    "!=="(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+}

package/dist/values/DestructuringValue.d.ts

@@ -1,30 +1,32 @@
-import { IScope, IValue, TValueInstructions } from "../types";
-import { VoidValue } from "./VoidValue";
-export type TDestructuringMembers = Map<IValue, {
-    value: IValue;
-    /**
-     * Handles the input value, is responsible for the assignment.
-     */
-    handler(get: () => TValueInstructions): TValueInstructions<IValue | null>;
-}>;
-/**
- * Specific case class, required on the ArrayPattern and ObjectPattern handlers
- * in order to keep the separation of concerns and make the code more modular.
- *
- * When it is assign a value, it will get it's own properties and recursively assign
- * each of them to their counterparts on the right hand value.
- */
-export declare class DestructuringValue extends VoidValue {
-    members: TDestructuringMembers;
-    macro: boolean;
-    /**
-     * Contains the keys that are constant strings with their respective values.
-     *
-     * This is used by some macros to avoid creating unecessary temporary values
-     * if the output value is a destructuring value.
-     */
-    fields: Record<string, IValue>;
-    constructor(members: TDestructuringMembers);
-    "="(scope: IScope, right: IValue): TValueInstructions;
-    eval(_scope: IScope): TValueInstructions<IValue>;
-}
+import { IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from "./VoidValue";
+export type TDestructuringMembers = Map<IValue, {
+    value: IValue;
+    /**
+     * Handles the input value, is responsible for the assignment.
+     */
+    handler(get: () => TValueInstructions, propExists: () => boolean, scope: IScope): TValueInstructions<IValue | null>;
+}>;
+/**
+ * Specific case class, required on the ArrayPattern and ObjectPattern handlers
+ * in order to keep the separation of concerns and make the code more modular.
+ *
+ * When it is assign a value, it will get it's own properties and recursively assign
+ * each of them to their counterparts on the right hand value.
+ */
+export declare class DestructuringValue extends VoidValue {
+    members: TDestructuringMembers;
+    macro: boolean;
+    /**
+     * Contains the keys that are constant strings with their respective values.
+     *
+     * This is used by some macros to avoid creating unecessary temporary values
+     * if the output value is a destructuring value.
+     */
+    fields: Record<string, IValue>;
+    constructor(members: TDestructuringMembers);
+    "="(scope: IScope, right: IValue): TValueInstructions;
+    eval(_scope: IScope): TValueInstructions<IValue>;
+    debugString(): string;
+    toString(): string;
+}

package/dist/values/FunctionValue.d.ts

@@ -1,50 +1,57 @@
-import { Compiler } from "../Compiler";
-import { EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-import { VoidValue } from "./VoidValue";
-export type TFunctionValueInitParams = (childScope: IScope) => {
-    paramStores: StoreValue[];
-    paramNames: string[];
-};
-export declare class FunctionValue extends VoidValue implements IFunctionValue {
-    name: string;
-    mutability: EMutability;
-    macro: boolean;
-    scope: IScope;
-    private out?;
-    private childScope;
-    private params;
-    private paramValues;
-    private paramNames;
-    private inst;
-    private addr;
-    private temp;
-    private ret;
-    private inline;
-    private tryingInline;
-    private body;
-    private c;
-    private callSize;
-    private inlineTemp;
-    private inlineEnd?;
-    private bundled;
-    private initialized;
-    constructor({ scope, params, body, c, out, }: {
-        scope: IScope;
-        body: es.BlockStatement;
-        c: Compiler;
-        params: es.Identifier[];
-        out?: TEOutput;
-    });
-    typeof(): TValueInstructions;
-    private initScope;
-    private ensureInit;
-    private normalReturn;
-    private normalCall;
-    private inlineReturn;
-    private inlineCall;
-    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions;
-    return(scope: IScope, arg: IValue | null): TValueInstructions<IValue | null>;
-    eval(_scope: IScope): TValueInstructions;
-    paramOuts(): readonly IValue[] | undefined;
-}
+import { Compiler } from "../Compiler";
+import { EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+import { VoidValue } from "./VoidValue";
+export type TFunctionValueInitParams = (childScope: IScope) => {
+    paramStores: StoreValue[];
+    paramNames: string[];
+};
+export declare class FunctionValue extends VoidValue implements IFunctionValue {
+    name: string;
+    mutability: EMutability;
+    macro: boolean;
+    scope: IScope;
+    private childScope;
+    private params;
+    private paramValues;
+    private paramNames;
+    private destructuringKeyData;
+    private paramOuts;
+    private minimumArgumentCount;
+    private maximumArgumentCount;
+    private inst;
+    private addr;
+    private temp;
+    private ret;
+    private inline;
+    private tryingInline;
+    private body;
+    private c;
+    private callSize;
+    private inlineTemp;
+    private inlineEnd?;
+    private bundled;
+    private initialized;
+    constructor({ scope, params, body, c, out, }: {
+        scope: IScope;
+        body: es.BlockStatement;
+        c: Compiler;
+        params: es.Identifier[];
+        out?: TEOutput;
+    });
+    typeof(): TValueInstructions;
+    private initScope;
+    private ensureInit;
+    private normalReturn;
+    private normalCall;
+    private inlineReturn;
+    private inlineCall;
+    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions;
+    return(scope: IScope, arg: IValue | null): TValueInstructions<IValue | null>;
+    eval(_scope: IScope): TValueInstructions;
+    preCall(): readonly IValue[] | undefined;
+    debugString(): string;
+    toString(): string;
+    private unwrapParameter;
+    private hardSetParameter;
+}

package/dist/values/JumpOutValue.d.ts

@@ -0,0 +1,36 @@
+import { EJumpKind, JumpInstruction } from "../instructions";
+import { es, IBindableValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { VoidValue } from "./VoidValue";
+declare const operatorMap: {
+    readonly "!=": EJumpKind.NotEqual;
+    readonly "<": EJumpKind.LessThan;
+    readonly "<=": EJumpKind.LessThanEq;
+    readonly "==": EJumpKind.Equal;
+    readonly "===": EJumpKind.StrictEqual;
+    readonly ">": EJumpKind.GreaterThan;
+    readonly ">=": EJumpKind.GreaterThanEq;
+};
+declare const invertedOperatorMap: {
+    readonly "==": EJumpKind.NotEqual;
+    readonly "!=": EJumpKind.Equal;
+    readonly "!==": EJumpKind.StrictEqual;
+    readonly ">": EJumpKind.LessThanEq;
+    readonly "<": EJumpKind.GreaterThanEq;
+    readonly ">=": EJumpKind.LessThan;
+    readonly "<=": EJumpKind.GreaterThan;
+};
+type TWhenFalseOperator = keyof typeof invertedOperatorMap;
+type TWhenTrueOperator = keyof typeof operatorMap;
+export declare class JumpOutValue extends VoidValue {
+    node: es.Node;
+    address: IBindableValue<number | null>;
+    whenTrue: boolean;
+    macro: boolean;
+    constructor(node: es.Node, address: IBindableValue<number | null>, whenTrue: boolean);
+    canHandle(operator: string): operator is TWhenTrueOperator | TWhenFalseOperator;
+    handle(operator: TWhenTrueOperator | TWhenFalseOperator, left: IValue, right: IValue): JumpInstruction;
+    eval(_scope: IScope, _out?: TEOutput): TValueInstructions<IValue>;
+    debugString(): string;
+    toString(): string;
+}
+export {};

package/dist/values/LazyValue.d.ts

@@ -1,9 +1,11 @@
-import { IValue } from "../types";
-import { VoidValue } from "./VoidValue";
-/**
- * This class is used to handle some cases where the value
- * can't be directly evaluated by the node handler
- */
-export declare class LazyValue extends VoidValue {
-    constructor(evalutate: IValue["eval"]);
-}
+import { IValue } from "../types";
+import { VoidValue } from "./VoidValue";
+/**
+ * This class is used to handle some cases where the value
+ * can't be directly evaluated by the node handler
+ */
+export declare class LazyValue extends VoidValue {
+    constructor(evalutate: IValue["eval"]);
+    debugString(): string;
+    toString(): string;
+}

package/dist/values/LiteralValue.d.ts

@@ -1,14 +1,18 @@
-import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue, EMutability } from "../types";
-import { BaseValue } from ".";
-export declare class LiteralValue<T extends TLiteral | null = TLiteral> extends BaseValue implements IBindableValue<T> {
-    data: T;
-    mutability: EMutability;
-    constructor(data: T);
-    eval(_scope: IScope): TValueInstructions;
-    toString(): string;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    get num(): 1 | 0 | (T & {});
-    typeof(): TValueInstructions;
-    isString(): this is LiteralValue<string>;
-    isNumber(): this is LiteralValue<number>;
-}
+import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue, EMutability, TEOutput } from "../types";
+import { BaseValue } from ".";
+export declare class LiteralValue<T extends TLiteral | null = TLiteral> extends BaseValue implements IBindableValue<T> {
+    name: string;
+    data: T;
+    mutability: EMutability;
+    constructor(data: T);
+    eval(_scope: IScope): TValueInstructions;
+    toString(): string;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    hasProperty(scope: IScope, prop: IValue): boolean;
+    get num(): 1 | 0 | (T & {});
+    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    typeof(): TValueInstructions;
+    isString(): this is LiteralValue<string>;
+    isNumber(): this is LiteralValue<number>;
+    debugString(): string;
+}

package/dist/values/ObjectValue.d.ts

@@ -1,20 +1,23 @@
-import { MacroFunction } from "../macros";
-import { EMutability, IScope, IValue, TEOutput, TOperatorMacroMap, TValueInstructions } from "../types";
-import { LiteralValue } from "./LiteralValue";
-import { VoidValue } from "./VoidValue";
-export interface IObjectValueData extends TOperatorMacroMap {
-    [k: string]: IValue | undefined;
-    $get?: MacroFunction<IValue>;
-    $eval?: MacroFunction<IValue>;
-}
-export declare class ObjectValue extends VoidValue {
-    mutability: EMutability;
-    macro: boolean;
-    data: IObjectValueData;
-    constructor(data?: IObjectValueData);
-    static fromArray(items: IObjectValueData[keyof IObjectValueData][], intialData?: IObjectValueData): ObjectValue;
-    typeof(scope: IScope, out?: TEOutput): TValueInstructions;
-    get(scope: IScope, key: LiteralValue, out?: TEOutput): TValueInstructions;
-    eval(scope: IScope, out?: TEOutput): TValueInstructions;
-    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<IValue | null>;
-}
+import { MacroFunction } from "../macros";
+import { EMutability, IScope, IValue, TEOutput, TOperatorMacroMap, TValueInstructions } from "../types";
+import { VoidValue } from "./VoidValue";
+export interface IObjectValueData extends TOperatorMacroMap {
+    [k: string]: IValue | undefined;
+    $get?: MacroFunction<IValue>;
+    $eval?: MacroFunction<IValue>;
+}
+export declare class ObjectValue extends VoidValue {
+    mutability: EMutability;
+    macro: boolean;
+    data: IObjectValueData;
+    constructor(data?: IObjectValueData);
+    static fromArray(items: IObjectValueData[keyof IObjectValueData][], initialData?: IObjectValueData): ObjectValue;
+    typeof(scope: IScope, out?: TEOutput): TValueInstructions;
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions;
+    hasProperty(scope: IScope, prop: IValue): boolean;
+    eval(scope: IScope, out?: TEOutput): TValueInstructions;
+    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<IValue | null>;
+    "??"(scope: IScope, other: IValue, out?: TEOutput): TValueInstructions;
+    debugString(): string;
+    toString(): string;
+}

package/dist/values/SenseableValue.d.ts

@@ -1,24 +1,24 @@
-import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-/**
- * Senseable values are "objects" in the mlog runtime that
- * have special properties that can be accessed
- * via the `sense` instruction.
- *
- * This class extends `StoreValue` to allow dynamic behavior
- * that is not possible with object macros.
- *
- * Note that these values are constant by default, so make sure
- * to set that field to `false` if you want them to be assignable. Example:
- * ```
- * const value = assign(new SenseableValue(scope), {
- *   mutability: EMutability.mutable
- * })
- * ```
- */
-export declare class SenseableValue extends StoreValue {
-    constructor(name: string, mutability?: EMutability);
-    static from(scope: IScope, out?: TEOutput, mutability?: EMutability): SenseableValue;
-    static out(scope: IScope, out?: TEOutput, mutability?: EMutability): IValue;
-    get(scope: IScope, prop: IValue, out?: TEOutput): TValueInstructions<IValue>;
-}
+import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+/**
+ * Senseable values are "objects" in the mlog runtime that
+ * have special properties that can be accessed
+ * via the `sense` instruction.
+ *
+ * This class extends `StoreValue` to allow dynamic behavior
+ * that is not possible with object macros.
+ *
+ * Note that these values are constant by default, so make sure
+ * to set that field to `EMutability.mutable` if you want them to be assignable. Example:
+ * ```
+ * const value = new SenseableValue(name, EMutability.mutable);
+ * ```
+ */
+export declare class SenseableValue extends StoreValue {
+    constructor(name: string, mutability?: EMutability);
+    static from(scope: IScope, out?: TEOutput, mutability?: EMutability): SenseableValue;
+    static out(scope: IScope, out?: TEOutput, mutability?: EMutability): IValue;
+    get(scope: IScope, prop: IValue, out?: TEOutput): TValueInstructions<IValue>;
+    debugString(): string;
+    hasProperty(scope: IScope, prop: IValue): boolean;
+}

package/dist/values/StoreValue.d.ts

@@ -1,21 +1,22 @@
-import { BaseValue } from ".";
-import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
-/**
- * `StoreValue` represents values unknown at compile time,
- * mostly used with mutable variables and temporary values
- */
-export declare class StoreValue extends BaseValue implements IValue {
-    name: string;
-    mutability: EMutability;
-    constructor(name: string, mutability?: EMutability);
-    static from(scope: IScope, out?: TEOutput, mutability?: EMutability): StoreValue;
-    static out(scope: IScope, out?: TEOutput, mutability?: EMutability): IValue;
-    typeof(): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
-    "=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "==="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "!="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "!=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    eval(_scope: IScope): TValueInstructions;
-    toString(): string;
-}
+import { BaseValue } from ".";
+import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
+/**
+ * `StoreValue` represents values unknown at compile time,
+ * mostly used with mutable variables and temporary values
+ */
+export declare class StoreValue extends BaseValue implements IValue {
+    name: string;
+    mutability: EMutability;
+    constructor(name: string, mutability?: EMutability);
+    static from(scope: IScope, out?: TEOutput, mutability?: EMutability): StoreValue;
+    static out(scope: IScope, out?: TEOutput, mutability?: EMutability): IValue;
+    typeof(): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+    "=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "==="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "!="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "!=="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    eval(_scope: IScope): TValueInstructions;
+    debugString(): string;
+    toString(): string;
+}

package/dist/values/VoidValue.d.ts

@@ -1,13 +1,17 @@
-import { EMutability, IScope, IValue, IValueOperators, TEOutput, TValueInstructions } from "../types";
-export declare class VoidValue implements IValue {
-    name?: string;
-    mutability: EMutability;
-    macro: boolean;
-    eval(_scope: IScope, _out?: TEOutput): TValueInstructions;
-    call(_scope: IScope, _args: IValue[], _out?: TEOutput): TValueInstructions<IValue | null>;
-    get(_scope: IScope, _name: IValue): TValueInstructions;
-    paramOuts(): readonly IValue[] | undefined;
-    toString(): string;
-}
-export interface VoidValue extends IValueOperators {
-}
+import { EMutability, IScope, IValue, IValueOperators, TEOutput, TValueInstructions } from "../types";
+export declare class VoidValue implements IValue {
+    name?: string;
+    mutability: EMutability;
+    macro: boolean;
+    eval(_scope: IScope, _out?: TEOutput): TValueInstructions;
+    call(_scope: IScope, _args: IValue[], _out?: TEOutput): TValueInstructions<IValue | null>;
+    get(_scope: IScope, name: IValue): TValueInstructions;
+    hasProperty(_scope: IScope, _prop: IValue): boolean;
+    preCall(_scope: IScope, _out?: TEOutput): readonly TEOutput[] | undefined;
+    postCall(_scope: IScope): void;
+    toOut(): IValue;
+    debugString(): string;
+    toString(): string;
+}
+export interface VoidValue extends IValueOperators {
+}

package/dist/values/index.d.ts

@@ -1,8 +1,9 @@
-export * from "./VoidValue";
-export * from "./BaseValue";
-export * from "./LiteralValue";
-export * from "./StoreValue";
-export * from "./ObjectValue";
-export * from "./SenseableValue";
-export * from "./DestructuringValue";
-export * from "./LazyValue";
+export * from "./VoidValue";
+export * from "./BaseValue";
+export * from "./LiteralValue";
+export * from "./StoreValue";
+export * from "./ObjectValue";
+export * from "./SenseableValue";
+export * from "./DestructuringValue";
+export * from "./LazyValue";
+export * from "./AssignmentValue";