mlogjs 0.4.6 → 0.4.8

package/dist/macros/DynamicArray.d.ts

@@ -1,22 +1,22 @@
-import { IOwnedValue, IScope, IValue, TValueInstructions } from "../types";
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { LiteralValue, ObjectValue, SenseableValue, StoreValue } from "../values";
-import { ValueOwner } from "../values/ValueOwner";
 import { MacroFunction } from "./Function";
 export declare class DynamicArray extends ObjectValue {
     scope: IScope;
+    name: string;
     values: IValue[];
-    valueTemp: ValueOwner<SenseableValue>;
-    returnTemp: ValueOwner<StoreValue>;
-    getterAddr: LiteralValue;
-    setterAddr: LiteralValue;
+    getterTemp: SenseableValue;
+    setterTemp: SenseableValue;
+    returnTemp: StoreValue;
+    getterAddr: LiteralValue<number | null>;
+    setterAddr: LiteralValue<number | null>;
     bundledSetter: boolean;
     bundledGetter: boolean;
-    constructor(scope: IScope, values: IValue[]);
-    getValue(scope: IScope, index: IValue, checked: boolean): TValueInstructions;
+    constructor(scope: IScope, name: string, values: IValue[]);
+    getValue(scope: IScope, out: TEOutput | undefined, index: IValue, checked: boolean): TValueInstructions;
     setValue(scope: IScope, index: IValue, value: IValue, checked: boolean): TValueInstructions;
     initGetter(): void;
     initSetter(): void;
-    ensureOwned(): asserts this is IOwnedValue;
 }
 export declare class DynamicArrayConstructor extends MacroFunction {
     constructor();

package/dist/macros/Function.d.ts

@@ -1,13 +1,12 @@
-import { EMutability, IScope, IValue, TValueInstructions } from "../types";
+import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { VoidValue } from "../values";
-declare type TFunction<T extends IValue | null> = (scope: IScope, ...args: IValue[]) => TValueInstructions<T>;
+declare type TFunction<T extends IValue | null> = (scope: IScope, out: TEOutput | undefined, ...args: IValue[]) => TValueInstructions<T>;
 export declare class MacroFunction<RT extends IValue | null = IValue> extends VoidValue {
     macro: boolean;
     mutability: EMutability;
     fn: TFunction<RT>;
     constructor(fn: TFunction<RT>);
-    call(scope: IScope, args: IValue[]): TValueInstructions<RT>;
+    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<RT>;
     eval(_scope: IScope): TValueInstructions;
-    consume(_scope: IScope): TValueInstructions;
 }
 export {};

package/dist/macros/Math.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../types";
 import { ObjectValue } from "../values";
 export declare class MlogMath extends ObjectValue {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/Namespace.d.ts

@@ -1,4 +1,3 @@
-import { IScope } from "../types";
 import { ObjectValue } from "../values";
 interface NamespaceMacroOptions {
     changeCasing?: boolean;
@@ -8,6 +7,6 @@ export declare class NamespaceMacro extends ObjectValue {
     constructor({ changeCasing }?: NamespaceMacroOptions);
 }
 export declare class VarsNamespace extends NamespaceMacro {
-    constructor(scope: IScope);
+    constructor();
 }
 export {};

package/dist/macros/util.d.ts

@@ -1,5 +1,5 @@
-import { IParameterDescriptor } from "../assertions";
-import { IScope, IValue, TValueInstructions } from "../types";
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { IParameterDescriptor } from "../utils";
 import { MacroFunction } from "./Function";
 interface IOverloadNamespaceOptions<K extends string> {
     overloads: Record<K, {
@@ -10,7 +10,7 @@ interface IOverloadNamespaceOptions<K extends string> {
         named?: string;
         args: (IParameterDescriptor | string)[];
     }>;
-    handler(scope: IScope, overload: K, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
+    handler(scope: IScope, overload: K, out: TEOutput | undefined, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
 }
 /** Used to create namespaces that contain multiple methods that map into instructions */
 export declare function createOverloadNamespace<K extends string>({ overloads, handler, }: IOverloadNamespaceOptions<K>): Record<string, MacroFunction<IValue | null>>;

package/dist/types.d.ts

@@ -12,6 +12,11 @@ export declare enum EInstIntent {
 }
 export interface IInstruction {
     intent: EInstIntent;
+    /**
+     * Used by function values to check if a return instruction
+     * originates from them or other function.
+     */
+    intentSource?: IValue;
     hidden: boolean;
     resolve(i: number): void;
     source?: es.SourceLocation;
@@ -21,7 +26,17 @@ export interface IInstruction {
      */
     alwaysRuns: boolean;
 }
-export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, arg: any) => TValueInstructions<T>;
+/**
+ * The expression output, either a value or a value name.
+ *
+ * Knowing the output variable can be beneficial for static optimizations.
+ *
+ * A string means that the handler should create a value with the given name.
+ *
+ * An IValue means that the handler should try to use `this` as the output value.
+ */
+export declare type TEOutput = IValue | string;
+export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, out: TEOutput | undefined, arg: any) => TValueInstructions<T>;
 /**
  * The scope manages the source code generated variables and their owners,
  * as well as break and continue statements and they also work as function
@@ -31,7 +46,7 @@ export interface IScope {
     /** Every scope except the top level one has a parent */
     parent: IScope | null;
     /** The registry of variables contained by this scope */
-    data: Record<string, IValueOwner | null>;
+    data: Record<string, IValue | null>;
     name: string;
     /**
      * Additional instructions required by this scope, such as
@@ -64,7 +79,7 @@ export interface IScope {
     /** Checks if there is an owner registered with the specified identifier */
     has(identifier: string): boolean;
     /** Gets a value by their owner's identifier */
-    get(identifier: string): IOwnedValue;
+    get(identifier: string): INamedValue;
     /**
      * Registers `value` with an owner that uses `name` as both it's name and identifier,
      * throws an error if there already is an owner with the same identitifer.
@@ -72,11 +87,6 @@ export interface IScope {
      * @param value
      */
     set<T extends IValue>(name: string, value: T): T;
-    /**
-     * Registers `owner` and it's inner value, throws an error
-     * if there already is an owner with the same identifier.
-     */
-    set<T extends IValue>(owner: IValueOwner<T>): T;
     /**
      * Registers `value` with an owner that uses `name` as both it's name and identifier,
      * overriding any preexisting variables with the same identifier.
@@ -84,12 +94,6 @@ export interface IScope {
      * @param value
      */
     hardSet<T extends IValue>(name: string, value: T): T;
-    /**
-     * Registers `owner` and it's inner value, overriding
-     * any preexisting variables with the same identifier.
-     * @param owner
-     */
-    hardSet<T extends IValue>(owner: IValueOwner<T>): T;
     /**
      * Creates an owned store and registers it to this scope.
      * @param identifier The name of the variable that will hold the store
@@ -106,83 +110,57 @@ export interface IScope {
     /** Creates a temporary mlog variable name */
     makeTempName(): string;
 }
-/**
- * Owners track how variables will behave when it comes to their usage.
- *
- * As an example, Stores use their owners to determine what to do during
- * assignments, like making a compile time alias, moving the values or generating
- * a `set` instruction.
- */
-export interface IValueOwner<T extends IValue = IValue> {
-    scope: IScope;
-    constant: boolean;
-    value: T;
-    /** The name of the variable on the source code that generated this value owner */
-    identifier?: string;
-    /** The name this owner has in it's mlog representation */
-    name: string;
-    /** Whether this owner is temporary or persistent */
-    persistent: boolean;
-    /** Set of values owned by this, can be used to get the owned value count  */
-    owned: Set<T>;
-    /** Adds `target` to the {@link owned set of owned values} and sets its owner to `this` */
-    own(target: T): void;
-    /** Replaces the currently held value by `target` */
-    replace(target: T): void;
-    /** Moves all values owned by `this` into `owner` */
-    moveInto(owner: IValueOwner<T>): void;
-}
 export interface IValueOperators {
-    "!"(scope: IScope): TValueInstructions;
-    "u+"(scope: IScope): TValueInstructions;
-    "u-"(scope: IScope): TValueInstructions;
-    "delete"(scope: IScope): TValueInstructions;
-    "typeof"(scope: IScope): TValueInstructions;
-    "void"(scope: IScope): TValueInstructions;
-    "~"(scope: IScope): TValueInstructions;
-    "++"(scope: IScope, prefix: boolean): TValueInstructions;
-    "--"(scope: IScope, prefix: boolean): TValueInstructions;
-    "*"(scope: IScope, value: IValue): TValueInstructions;
-    "**"(scope: IScope, value: IValue): TValueInstructions;
-    "+"(scope: IScope, value: IValue): TValueInstructions;
-    "-"(scope: IScope, value: IValue): TValueInstructions;
-    "/"(scope: IScope, value: IValue): TValueInstructions;
-    "%"(scope: IScope, value: IValue): TValueInstructions;
-    "!="(scope: IScope, value: IValue): TValueInstructions;
-    "!=="(scope: IScope, value: IValue): TValueInstructions;
-    "<"(scope: IScope, value: IValue): TValueInstructions;
-    "<="(scope: IScope, value: IValue): TValueInstructions;
-    "=="(scope: IScope, value: IValue): TValueInstructions;
-    "==="(scope: IScope, value: IValue): TValueInstructions;
-    ">"(scope: IScope, value: IValue): TValueInstructions;
-    ">="(scope: IScope, value: IValue): TValueInstructions;
-    "&"(scope: IScope, value: IValue): TValueInstructions;
-    "<<"(scope: IScope, value: IValue): TValueInstructions;
-    ">>"(scope: IScope, value: IValue): TValueInstructions;
-    ">>>"(scope: IScope, value: IValue): TValueInstructions;
-    "^"(scope: IScope, value: IValue): TValueInstructions;
-    "|"(scope: IScope, value: IValue): TValueInstructions;
-    instanceof(scope: IScope, value: IValue): TValueInstructions;
-    in(scope: IScope, value: IValue): TValueInstructions;
-    "&&"(scope: IScope, value: IValue): TValueInstructions;
-    "??"(scope: IScope, value: IValue): TValueInstructions;
-    "||"(scope: IScope, value: IValue): TValueInstructions;
-    "%="(scope: IScope, value: IValue): TValueInstructions;
-    "&="(scope: IScope, value: IValue): TValueInstructions;
-    "*="(scope: IScope, value: IValue): TValueInstructions;
-    "**="(scope: IScope, value: IValue): TValueInstructions;
-    "+="(scope: IScope, value: IValue): TValueInstructions;
-    "-="(scope: IScope, value: IValue): TValueInstructions;
-    "/="(scope: IScope, value: IValue): TValueInstructions;
-    "&&="(scope: IScope, value: IValue): TValueInstructions;
-    "||="(scope: IScope, value: IValue): TValueInstructions;
-    "??="(scope: IScope, value: IValue): TValueInstructions;
-    "<<="(scope: IScope, value: IValue): TValueInstructions;
-    ">>="(scope: IScope, value: IValue): TValueInstructions;
-    ">>>="(scope: IScope, value: IValue): TValueInstructions;
-    "^="(scope: IScope, value: IValue): TValueInstructions;
-    "|="(scope: IScope, value: IValue): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
+    "!"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "u+"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "u-"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "delete"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "typeof"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "void"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "~"(scope: IScope, out?: TEOutput): TValueInstructions;
+    "++"(scope: IScope, prefix: boolean, out?: TEOutput): TValueInstructions;
+    "--"(scope: IScope, prefix: boolean, out?: TEOutput): 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;
+    "/"(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;
+    "<"(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;
+    ">"(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;
+    ">>"(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;
+    instanceof(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    in(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;
+    "%="(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;
+    "+="(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;
+    "||="(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;
+    ">>>="(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;
 }
 /** Defines the possible types of mutability of a value */
 export declare enum EMutability {
@@ -197,37 +175,39 @@ export declare enum EMutability {
      */
     readonly = 1,
     /** Constant values, won't change during execution */
-    constant = 2
+    constant = 2,
+    /** An immutable value that hasn't been initialized yet */
+    init = 3
 }
 export interface IValue extends IValueOperators {
-    owner: IValueOwner | null;
+    /** The name is used by values that exist on some form in the runtime */
+    name?: string;
     mutability: EMutability;
     macro: boolean;
     /**
      * Evaluates `this`, returning it's representation in a more basic
      * value like `StoreValue` with the instructions required to compute that value
      */
-    eval(scope: IScope): TValueInstructions;
+    eval(scope: IScope, out?: TEOutput): TValueInstructions;
+    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<IValue | null>;
+    get(scope: IScope, name: IValue, out?: TEOutput): TValueInstructions;
     /**
-     * Does the same thing as {@link IValue.eval eval}, but ensures that the resulting value has an owner.
+     * Returns the output values for the arguments of a callable value, or `null`.
      *
-     * This behaviour is required when dealing with temporary values inside expressions like comparations.
+     * This is used to allow the handler to optimize the argument instructions.
      */
-    consume(scope: IScope): TValueInstructions;
-    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    ensureOwned(): asserts this is IOwnedValue;
+    paramOuts(): readonly IValue[] | undefined;
 }
 /** Helper type that is used in some typescript assertions */
-export interface IOwnedValue extends IValue {
-    owner: Exclude<IValue["owner"], null>;
+export interface INamedValue extends IValue {
+    name: string;
 }
 export declare type TLiteral = string | number;
-export interface IBindableValue extends IValue {
-    data: TLiteral;
+export interface IBindableValue<T extends TLiteral | null = TLiteral> extends IValue {
+    data: T;
 }
 export interface IFunctionValue extends IValue {
-    return(scope: IScope, argument: IValue | null): TValueInstructions<IValue | null>;
+    return(scope: IScope, argument: IValue | null, out?: TEOutput): TValueInstructions<IValue | null>;
 }
 /** Contains a value and the instructions required to compute it */
 export declare type TValueInstructions<Content extends IValue | null = IValue> = [

package/dist/utils/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The prefix for internal variables inside the compiler output
+ */
+export declare const internalPrefix = "&";
+export declare const discardedName: string;
+export declare const itemNames: string[];

package/dist/utils/general.d.ts

@@ -0,0 +1,24 @@
+import { es } from "../types";
+/**
+ * Returns a string that has the format: [line]:[column].
+ *
+ * If `name` is provided, and it is a string, the resulting string will
+ * have the format: [name]:[line]:[column].
+ */
+export declare function nodeName(node: es.Node, name?: false | string): string;
+/**
+ * Converts a camel case string into a dash case one.
+ *
+ * As an example `camelCase` becomes `camel-case`
+ * @example
+ * ```
+ * camelToDashCase("camelCase") // returns "camel-case"
+ * ```
+ */
+export declare function camelToDashCase(name: string): string;
+/**
+ * A more type safe version of `Object.assign`
+ */
+export declare function assign<T extends {}>(obj: T, props: {
+    [K in keyof T as T[K] extends Function ? never : K]?: T[K];
+}): T;

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./general";
+export * from "./instruction";
+export * from "./value";

package/dist/utils/instruction.d.ts

@@ -0,0 +1,5 @@
+import { es, IInstruction, IValue, TValueInstructions } from "../types";
+export declare function appendSourceLocations<T extends IValue | null>(valueInst: TValueInstructions<T>, node: es.Node): TValueInstructions<T>;
+export declare function withAlwaysRuns<T extends IValue | null>(valueInst: TValueInstructions<T>, value: boolean): TValueInstructions<T>;
+/** Removes jump instructions that point right to the next line */
+export declare function hideRedundantJumps(inst: IInstruction[]): void;

package/dist/utils/value.d.ts

@@ -0,0 +1,36 @@
+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 declare 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)[];

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { es, IValue, TValueInstructions } from "./types";
+import { es, IValue, TEOutput, TValueInstructions } from "./types";
 import { IObjectValueData, LiteralValue, ObjectValue } from "./values";
 /**
  * The prefix for internal variables inside the compiler output
@@ -35,13 +35,11 @@ export declare function isTemplateObjectArray(value: IValue): value is ObjectVal
     data: IObjectValueData & {
         raw: ObjectValue & {
             data: IObjectValueData & {
-                length: LiteralValue & {
-                    data: number;
-                };
+                length: LiteralValue<number>;
             };
         };
-        length: LiteralValue & {
-            data: 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;

package/dist/values/BaseValue.d.ts

@@ -1,9 +1,9 @@
-import { IScope, IValue, TValueInstructions } from "../types";
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { VoidValue } from ".";
 export declare class BaseValue extends VoidValue implements IValue {
-    "u-"(scope: IScope): TValueInstructions;
-    "u+"(scope: IScope): TValueInstructions;
-    "!"(scope: IScope): TValueInstructions;
-    "~"(scope: IScope): TValueInstructions;
-    "??"(scope: IScope, other: IValue): TValueInstructions;
+    "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;
 }

package/dist/values/DestructuringValue.d.ts

@@ -1,5 +1,12 @@
 import { IScope, IValue, TValueInstructions } from "../types";
 import { VoidValue } from "./VoidValue";
+export declare 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.
@@ -8,10 +15,16 @@ import { VoidValue } from "./VoidValue";
  * each of them to their counterparts on the right hand value.
  */
 export declare class DestructuringValue extends VoidValue {
-    members: Map<IValue, IValue>;
+    members: TDestructuringMembers;
     macro: boolean;
-    constructor(members: Map<IValue, IValue>);
+    /**
+     * 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>;
-    consume(_scope: IScope): TValueInstructions<IValue>;
 }

package/dist/values/FunctionValue.d.ts

@@ -1,5 +1,5 @@
 import { Compiler } from "../Compiler";
-import { EMutability, es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
+import { EMutability, es, IFunctionValue, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { StoreValue } from "./StoreValue";
 import { VoidValue } from "./VoidValue";
 export declare type TFunctionValueInitParams = (childScope: IScope) => {
@@ -7,12 +7,15 @@ export declare type TFunctionValueInitParams = (childScope: IScope) => {
     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 paramOwners;
+    private paramValues;
+    private paramNames;
     private inst;
     private addr;
     private temp;
@@ -26,11 +29,12 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private inlineEnd?;
     private bundled;
     private initialized;
-    constructor({ scope, params, body, c, }: {
+    constructor({ scope, params, body, c, out, }: {
         scope: IScope;
         body: es.BlockStatement;
         c: Compiler;
         params: es.Identifier[];
+        out?: TEOutput;
     });
     typeof(): TValueInstructions;
     private initScope;
@@ -39,8 +43,8 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private normalCall;
     private inlineReturn;
     private inlineCall;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
+    call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions;
     return(scope: IScope, arg: IValue | null): TValueInstructions<IValue | null>;
     eval(_scope: IScope): TValueInstructions;
-    consume(_scope: IScope): TValueInstructions;
+    paramOuts(): readonly IValue[] | undefined;
 }

package/dist/values/LazyValue.d.ts

@@ -5,5 +5,5 @@ import { VoidValue } from "./VoidValue";
  * can't be directly evaluated by the node handler
  */
 export declare class LazyValue extends VoidValue {
-    constructor(options: Pick<IValue, "eval" | "consume">);
+    constructor(evalutate: IValue["eval"]);
 }

package/dist/values/LiteralValue.d.ts

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

package/dist/values/ObjectValue.d.ts

@@ -1,12 +1,11 @@
 import { MacroFunction } from "../macros";
-import { EMutability, IOwnedValue, IScope, IValue, TOperatorMacroMap, TValueInstructions } from "../types";
+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>;
-    $consume?: MacroFunction<IValue>;
 }
 export declare class ObjectValue extends VoidValue {
     mutability: EMutability;
@@ -14,10 +13,8 @@ export declare class ObjectValue extends VoidValue {
     data: IObjectValueData;
     constructor(data?: IObjectValueData);
     static fromArray(items: IObjectValueData[keyof IObjectValueData][], intialData?: IObjectValueData): ObjectValue;
-    typeof(): TValueInstructions;
-    get(scope: IScope, key: LiteralValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
-    consume(scope: IScope): TValueInstructions;
-    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
-    ensureOwned(): asserts this is IOwnedValue;
+    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>;
 }

package/dist/values/SenseableValue.d.ts

@@ -1,4 +1,4 @@
-import { EMutability, IScope, IValue, TValueInstructions } from "../types";
+import { EMutability, IScope, IValue, TEOutput, TValueInstructions } from "../types";
 import { StoreValue } from "./StoreValue";
 /**
  * Senseable values are "objects" in the mlog runtime that
@@ -17,7 +17,8 @@ import { StoreValue } from "./StoreValue";
  * ```
  */
 export declare class SenseableValue extends StoreValue {
-    mutability: EMutability;
-    constructor(scope: IScope);
-    get(scope: IScope, prop: IValue): TValueInstructions<IValue>;
+    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>;
 }