mlogjs 0.4.6 → 0.4.7

package/dist/Compiler.d.ts

@@ -1,5 +1,5 @@
 import { CompilerError } from "./CompilerError";
-import { es, IScope, IValue, THandler, TValueInstructions } from "./types";
+import { es, IScope, IValue, TEOutput, THandler, TValueInstructions } from "./types";
 declare type THandlerMap = {
     [k in es.Node["type"]]?: THandler<IValue | null>;
 };
@@ -21,16 +21,15 @@ export declare class Compiler {
     protected serialize(resLines: TValueInstructions<IValue | null>): string;
     protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
     protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
-    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined): TValueInstructions<IValue | null>;
-    handleEval(scope: IScope, node: es.Node): TValueInstructions;
-    handleConsume(scope: IScope, node: es.Node): TValueInstructions;
+    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions<IValue | null>;
+    handleEval(scope: IScope, node: es.Node, out?: TEOutput): TValueInstructions;
     /**
      * Handles many nodes in order.
      *
      * The usage of this method over a regular loop over an array of nodes
      * is only required if the code inside the loop generates
      * instructions that are not tracked by the compiler
-     * handler methods ({@link handle}, {@link handleEval}, {@link handleConsume}
+     * handler methods ({@link handle}, {@link handleEval}
      * and {@link handleMany})
      *
      */

package/dist/Scope.d.ts

@@ -1,25 +1,25 @@
 import { SenseableValue } from "./values";
 import { AddressResolver } from "./instructions";
-import { IFunctionValue, IInstruction, IOwnedValue, IScope, IValue, IValueOwner } from "./types";
+import { IFunctionValue, IInstruction, INamedValue, IScope, IValue } from "./types";
 export declare class Scope implements IScope {
     parent: IScope | null;
     stacked: boolean;
     ntemp: number;
     name: string;
     inst: IInstruction[];
-    data: Record<string, IValueOwner | null>;
+    data: Record<string, IValue | null>;
     break: AddressResolver;
     continue: AddressResolver;
     function: IFunctionValue;
     label?: string;
-    constructor(values: Record<string, IValueOwner | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
     copy(): IScope;
     createScope(): IScope;
     createFunction(name: string, stacked?: boolean): IScope;
     has(identifier: string): boolean;
-    get(identifier: string): IOwnedValue;
-    set<T extends IValue>(...args: [name: string, value: T] | [owner: IValueOwner<T>]): T;
-    hardSet<T extends IValue>(...args: [name: string, value: T] | [owner: IValueOwner<T>]): T;
+    get(identifier: string): INamedValue;
+    set<T extends IValue>(name: string, value: T): T;
+    hardSet<T extends IValue>(name: string, value: T): T;
     make(identifier: string, name: string): SenseableValue;
     makeTempName(): string;
 }

package/dist/assertions.d.ts

@@ -1,19 +1,19 @@
 import { IValue } from "./types";
 import { LiteralValue, ObjectValue, StoreValue } from "./values";
 /** Asserts that `value` is a `LiteralValue` that contains a string */
-export declare function assertStringLiteral(value: IValue | undefined, name: string): asserts value is LiteralValue & {
-    data: 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 & {
-    data: T[number];
-};
+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;
+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 declare type TOverloadDescriptor<K extends string> = Record<K, (string | IParameterDescriptor)[]>;
 /** Describes an object destructuring paremeter. Generally used with `assertObjectFields` */

package/dist/discardedName.d.ts

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