mlogjs 0.4.0 → 0.4.2

package/dist/macros/commands/Control.d.ts

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

package/dist/macros/commands/Cutscene.d.ts

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

package/dist/macros/commands/Draw.d.ts

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

package/dist/macros/commands/DrawFlush.d.ts

@@ -1,5 +1,4 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare class DrawFlush extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/End.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class End extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/Explosion.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class Explosion extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/Fetch.d.ts

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

package/dist/macros/commands/FlushMessage.d.ts

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

package/dist/macros/commands/GetBlock.d.ts

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

package/dist/macros/commands/GetFlag.d.ts

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

package/dist/macros/commands/GetLink.d.ts

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

package/dist/macros/commands/Lookup.d.ts

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

package/dist/macros/commands/PackColor.d.ts

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

package/dist/macros/commands/Print.d.ts

@@ -1,5 +1,4 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare class Print extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/PrintFlush.d.ts

@@ -1,5 +1,4 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare class PrintFlush extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/Radar.d.ts

@@ -1,7 +1,6 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare const validRadarFilters: readonly ["any", "enemy", "ally", "player", "attacker", "flying", "boss", "ground"];
 export declare const validRadarSorts: readonly ["distance", "health", "shield", "armor", "maxHealth"];
 export declare class Radar extends MacroFunction {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/Sensor.d.ts

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

package/dist/macros/commands/SetBlock.d.ts

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

package/dist/macros/commands/SetFlag.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class SetFlag extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/SetRate.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class SetRate extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/SetRule.d.ts

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

package/dist/macros/commands/SpawnUnit.d.ts

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

package/dist/macros/commands/SpawnWave.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class SpawnWave extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/Stop.d.ts

@@ -1,5 +1,4 @@
-import { IScope } from "../../types";
 import { MacroFunction } from "../Function";
 export declare class Stop extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/UnitBind.d.ts

@@ -1,5 +1,4 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare class UnitBind extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/commands/UnitControl.d.ts

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

package/dist/macros/commands/UnitLocate.d.ts

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

package/dist/macros/commands/UnitRadar.d.ts

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

package/dist/macros/commands/Wait.d.ts

@@ -1,5 +1,4 @@
 import { MacroFunction } from "..";
-import { IScope } from "../../types";
 export declare class Wait extends MacroFunction<null> {
-    constructor(scope: IScope);
+    constructor();
 }

package/dist/macros/util.d.ts

@@ -2,7 +2,6 @@ import { IParameterDescriptor } from "../assertions";
 import { IScope, IValue, TValueInstructions } from "../types";
 import { MacroFunction } from "./Function";
 interface IOverloadNamespaceOptions<K extends string> {
-    scope: IScope;
     overloads: Record<K, {
         /**
          * Pass the name of the options argument to tell if this overload uses
@@ -11,8 +10,8 @@ interface IOverloadNamespaceOptions<K extends string> {
         named?: string;
         args: (IParameterDescriptor | string)[];
     }>;
-    handler(overload: K, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
+    handler(scope: IScope, overload: K, ...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>({ scope, overloads, handler, }: IOverloadNamespaceOptions<K>): Record<string, MacroFunction<IValue | null>>;
+export declare function createOverloadNamespace<K extends string>({ overloads, handler, }: IOverloadNamespaceOptions<K>): Record<string, MacroFunction<IValue | null>>;
 export {};

package/dist/operators.d.ts

@@ -6,11 +6,11 @@ export declare type BinaryOperator = typeof binaryOperators[number];
 export declare const logicalOperators: readonly ["&&", "??", "||"];
 export declare type LogicalOperator = typeof logicalOperators[number];
 export declare const arithmeticAssignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/="];
-export declare const logicalAssignmentOperators: readonly ["&&=", "||="];
+export declare const logicalAssignmentOperators: readonly ["&&=", "||=", "??="];
 export declare const bitwiseAssignmentOperators: readonly ["<<=", ">>=", ">>>=", "^=", "|="];
-export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
+export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
 export declare type AssignementOperator = typeof assignmentOperators[number];
-export declare const leftRightOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
+export declare const leftRightOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
 export declare type LeftRightOperator = typeof leftRightOperators[number];
 export declare const unaryOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~"];
 export declare type UnaryOperator = typeof unaryOperators[number];
@@ -18,7 +18,7 @@ export declare const updateOperators: readonly ["++", "--"];
 export declare type UpdateOperator = typeof updateOperators[number];
 export declare const singleOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
 export declare type SingleOperator = typeof singleOperators[number];
-export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
+export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "??=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
 export declare type Operator = typeof operators[number];
 export declare const operatorMap: {
     [k in Exclude<BinaryOperator, "instanceof" | "in"> | Exclude<LogicalOperator, "??">]: string;

package/dist/types.d.ts

@@ -38,6 +38,8 @@ export interface IScope {
      * the instructions that make the body of a function
      */
     inst: IInstruction[];
+    /** The label applied to this scope */
+    label?: string;
     /** Where to jump to on a break statement */
     break: AddressResolver;
     /** Where to jump to on a continue statement */
@@ -174,6 +176,7 @@ export interface IValueOperators {
     "/="(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;
@@ -198,7 +201,6 @@ export declare enum EMutability {
 }
 export interface IValue extends IValueOperators {
     owner: IValueOwner | null;
-    scope: IScope;
     mutability: EMutability;
     macro: boolean;
     /**

package/dist/values/BaseValue.d.ts

@@ -1,9 +1,9 @@
-import { IOwnedValue, IScope, IValue, TValueInstructions } from "../types";
+import { IScope, IValue, 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;
-    ensureOwned(): asserts this is IOwnedValue;
+    "??"(scope: IScope, other: IValue): TValueInstructions;
 }

package/dist/values/DestructuringValue.d.ts

@@ -10,7 +10,7 @@ import { VoidValue } from "./VoidValue";
 export declare class DestructuringValue extends VoidValue {
     members: Map<IValue, IValue>;
     macro: boolean;
-    constructor(scope: IScope, members: Map<IValue, IValue>);
+    constructor(members: Map<IValue, IValue>);
     "="(scope: IScope, right: IValue): TValueInstructions;
     eval(_scope: IScope): TValueInstructions<IValue>;
     consume(_scope: IScope): TValueInstructions<IValue>;

package/dist/values/FunctionValue.d.ts

@@ -9,7 +9,7 @@ export declare type TFunctionValueInitParams = (childScope: IScope) => {
 export declare class FunctionValue extends VoidValue implements IFunctionValue {
     mutability: EMutability;
     macro: boolean;
-    private node;
+    scope: IScope;
     private childScope;
     private params;
     private paramOwners;
@@ -26,14 +26,13 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private inlineEnd?;
     private bundled;
     private initialized;
-    constructor({ scope, params, body, c, node, }: {
+    constructor({ scope, params, body, c, }: {
         scope: IScope;
         body: es.BlockStatement;
         c: Compiler;
-        node: es.Function;
         params: es.Identifier[];
     });
-    typeof(scope: IScope): TValueInstructions;
+    typeof(): TValueInstructions;
     private initScope;
     private ensureInit;
     private normalReturn;

package/dist/values/LiteralValue.d.ts

@@ -3,11 +3,12 @@ import { BaseValue } from ".";
 export declare class LiteralValue extends BaseValue implements IBindableValue {
     data: TLiteral;
     mutability: EMutability;
-    constructor(scope: IScope, data: TLiteral);
+    constructor(data: TLiteral);
     eval(_scope: IScope): TValueInstructions;
     consume(_scope: IScope): TValueInstructions;
     toString(): string;
     get(scope: IScope, name: IValue): TValueInstructions;
     get num(): number;
-    typeof(scope: IScope): TValueInstructions;
+    typeof(): TValueInstructions;
+    ensureOwned(): void;
 }

package/dist/values/ObjectValue.d.ts

@@ -12,9 +12,9 @@ export declare class ObjectValue extends VoidValue {
     mutability: EMutability;
     macro: boolean;
     data: IObjectValueData;
-    constructor(scope: IScope, data?: IObjectValueData);
-    static fromArray(scope: IScope, items: IObjectValueData[keyof IObjectValueData][], intialData?: IObjectValueData): ObjectValue;
-    typeof(scope: IScope): TValueInstructions;
+    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;

package/dist/values/StoreValue.d.ts

@@ -1,15 +1,17 @@
 import { BaseValue } from ".";
-import { EMutability, IScope, IValue, TValueInstructions } from "../types";
+import { EMutability, IOwnedValue, IScope, IValue, 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 {
+    scope: IScope;
     mutability: EMutability;
     constructor(scope: IScope);
-    typeof(scope: IScope): TValueInstructions;
+    typeof(): TValueInstructions;
     "="(scope: IScope, value: IValue): TValueInstructions;
     eval(_scope: IScope): TValueInstructions;
     consume(_scope: IScope): TValueInstructions;
+    ensureOwned(): asserts this is IOwnedValue;
     toString(): string;
 }

package/dist/values/VoidValue.d.ts

@@ -1,10 +1,8 @@
 import { EMutability, IScope, IValue, IValueOperators, IValueOwner, TValueInstructions } from "../types";
 export declare class VoidValue implements IValue {
     owner: IValueOwner | null;
-    scope: IScope;
     mutability: EMutability;
     macro: boolean;
-    constructor(scope: IScope);
     eval(_scope: IScope): TValueInstructions;
     consume(_scope: IScope): TValueInstructions<IValue>;
     call(_scope: IScope, _args: IValue[]): TValueInstructions<IValue | null>;