mlogjs 0.3.0 → 0.4.1

package/dist/{types/instructions → instructions}/ControlInstructions.d.ts

@@ -1,8 +1,10 @@
-import { IBindableValue } from "../types";
+import { EInstIntent, IBindableValue } from "../types";
 import { JumpInstruction } from "./JumpInstruction";
 export declare class BreakInstruction extends JumpInstruction {
+    intent: EInstIntent;
     constructor(address: IBindableValue);
 }
 export declare class ContinueInstruction extends JumpInstruction {
+    intent: EInstIntent;
     constructor(address: IBindableValue);
 }

package/dist/{types/instructions → instructions}/InstructionBase.d.ts

@@ -1,9 +1,13 @@
-import { IInstruction, IValue } from "../types";
+import { SourceLocation } from "@babel/types";
+import { EInstIntent, IInstruction, IValue } from "../types";
 export declare class InstructionBase implements IInstruction {
+    intent: EInstIntent;
+    alwaysRuns: boolean;
     protected _hidden: boolean;
     get hidden(): boolean;
     set hidden(value: boolean);
     args: (string | IValue | null)[];
+    source?: SourceLocation;
     constructor(...args: (string | IValue | null)[]);
     resolve(_i: number): void;
     toString(): string;

package/dist/{types/instructions → instructions}/JumpInstruction.d.ts

@@ -11,5 +11,6 @@ export declare enum EJumpKind {
     Always = "always"
 }
 export declare class JumpInstruction extends InstructionBase {
+    address: IBindableValue;
     constructor(address: IBindableValue, kind: EJumpKind, left?: IValue | null, right?: IValue | null);
 }

package/dist/macros/Asm.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "./Function";
+export declare class Asm extends MacroFunction<null> {
+    constructor();
+}

package/dist/{types/macros → macros}/Function.d.ts

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

package/dist/macros/GetGlobal.d.ts

@@ -0,0 +1,5 @@
+import { EMutability } from "../types";
+import { MacroFunction } from "./Function";
+export declare class GetGlobal extends MacroFunction {
+    constructor(mutability: EMutability);
+}

package/dist/{types/macros → 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/{types/macros → macros}/Memory.d.ts

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

package/dist/{types/macros → macros}/Namespace.d.ts

@@ -5,12 +5,9 @@ interface NamespaceMacroOptions {
 }
 export declare class NamespaceMacro extends ObjectValue {
     changeCasing: boolean;
-    constructor(scope: IScope, { changeCasing }?: NamespaceMacroOptions);
+    constructor({ changeCasing }?: NamespaceMacroOptions);
 }
 export declare class VarsNamespace extends NamespaceMacro {
     constructor(scope: IScope);
 }
-export declare class UCommandsNamespace extends NamespaceMacro {
-    constructor(scope: IScope);
-}
 export {};

package/dist/{types/macros → macros}/Other.d.ts

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

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

@@ -0,0 +1,4 @@
+import { ObjectValue } from "../../values";
+export declare class ApplyStatus extends ObjectValue {
+    constructor();
+}

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

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

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

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

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

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

package/dist/{types/macros → 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/{types/macros → 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

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

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

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

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

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

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

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

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

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

package/dist/{types/macros → 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

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

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

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

package/dist/{types/macros → 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/{types/macros → 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

@@ -0,0 +1,6 @@
+import { MacroFunction } from "..";
+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();
+}

package/dist/{types/macros → 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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/{types/macros → 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

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

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

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

package/dist/{types/macros → 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/{types/macros → 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/commands/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./Draw";
+export * from "./Print";
+export * from "./PrintFlush";
+export * from "./DrawFlush";
+export * from "./GetBlock";
+export * from "./GetLink";
+export * from "./Control";
+export { Radar } from "./Radar";
+export * from "./Sensor";
+export * from "./Wait";
+export * from "./Lookup";
+export * from "./PackColor";
+export * from "./End";
+export * from "./SetBlock";
+export * from "./SpawnUnit";
+export * from "./Stop";
+export * from "./UnitBind";
+export * from "./UnitControl";
+export * from "./UnitRadar";
+export * from "./UnitLocate";
+export * from "./ApplyStatus";
+export * from "./SpawnWave";
+export * from "./SetRule";
+export * from "./FlushMessage";
+export * from "./Cutscene";
+export * from "./Explosion";
+export * from "./SetRate";
+export * from "./Fetch";
+export * from "./GetFlag";
+export * from "./SetFlag";

package/dist/macros/util.d.ts

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

package/dist/{types/types.d.ts → types.d.ts}

@@ -1,11 +1,25 @@
 export * as es from "@babel/types";
+import * as es from "@babel/types";
 import { Compiler } from "./Compiler";
 import { AddressResolver } from "./instructions";
 import { MacroFunction } from "./macros";
 import { LeftRightOperator, UnaryOperator, UpdateOperator } from "./operators";
+export declare enum EInstIntent {
+    none = 0,
+    break = 1,
+    continue = 2,
+    return = 3
+}
 export interface IInstruction {
+    intent: EInstIntent;
     hidden: boolean;
     resolve(i: number): void;
+    source?: es.SourceLocation;
+    /**
+     * Helps analyzing control flow, handlers should
+     * indicate which instructions returned are guaranteed to run
+     */
+    alwaysRuns: boolean;
 }
 export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, arg: any) => TValueInstructions<T>;
 /**
@@ -184,7 +198,6 @@ export declare enum EMutability {
 }
 export interface IValue extends IValueOperators {
     owner: IValueOwner | null;
-    scope: IScope;
     mutability: EMutability;
     macro: boolean;
     /**

package/dist/utils.d.ts

@@ -0,0 +1,47 @@
+import { es, IValue, TValueInstructions } from "./types";
+import { IObjectValueData, LiteralValue, ObjectValue } from "./values";
+/**
+ * The prefix for internal variables inside the compiler output
+ */
+export declare const internalPrefix = "&";
+export declare const discardedName: string;
+/**
+ * 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;
+export declare const itemNames: 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;
+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>;
+export declare function isTemplateObjectArray(value: IValue): value is ObjectValue & {
+    data: IObjectValueData & {
+        raw: ObjectValue & {
+            data: IObjectValueData & {
+                length: LiteralValue & {
+                    data: number;
+                };
+            };
+        };
+        length: LiteralValue & {
+            data: number;
+        };
+    };
+};

package/dist/{types/values → values}/BaseValue.d.ts

@@ -1,7 +1,8 @@
-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;
-    ensureOwned(): asserts this is IOwnedValue;
+    "!"(scope: IScope): TValueInstructions;
+    "~"(scope: IScope): TValueInstructions;
 }

package/dist/{types/values → 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/{types/values → 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;
@@ -23,17 +23,16 @@ export declare class FunctionValue extends VoidValue implements IFunctionValue {
     private c;
     private callSize;
     private inlineTemp;
-    private inlineEnd;
+    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/{types/values → 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/{types/values → 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][]): 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/{types/values → 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/{types/values → 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>;