mlogjs 0.3.0 → 0.4.0

package/dist/macros/Namespace.d.ts

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

package/dist/macros/Other.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+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);
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Function";
+export * from "./Math";
+export * from "./Other";
+export * as commands from "./commands";
+export * from "./Memory";
+export { NamespaceMacro, VarsNamespace } from "./Namespace";

package/dist/macros/util.d.ts

@@ -0,0 +1,18 @@
+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
+         * named parameters.
+         */
+        named?: string;
+        args: (IParameterDescriptor | string)[];
+    }>;
+    handler(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 {};

package/dist/operators.d.ts

@@ -0,0 +1,25 @@
+export declare const arithmeticBinaryOperators: readonly ["*", "**", "+", "-", "/", "%"];
+export declare const comparisonBinaryOperators: readonly ["!=", "!==", "<", "<=", "==", "===", ">", ">="];
+export declare const bitwiseBinaryOperators: readonly ["&", "<<", ">>", ">>>", "^", "|"];
+export declare const binaryOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in"];
+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 bitwiseAssignmentOperators: readonly ["<<=", ">>=", ">>>=", "^=", "|="];
+export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
+export declare type AssignementOperator = typeof assignmentOperators[number];
+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];
+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 type Operator = typeof operators[number];
+export declare const operatorMap: {
+    [k in Exclude<BinaryOperator, "instanceof" | "in"> | Exclude<LogicalOperator, "??">]: string;
+};

package/dist/types/Compiler.d.ts

@@ -7,20 +7,33 @@ export interface CompilerOptions {
     stackName?: string;
     /** Wether the compiler should preserve or compact variable and function names*/
     compactNames?: boolean;
+    sourcemap?: boolean;
 }
 export declare class Compiler {
     protected stackName?: string;
     protected usingStack: boolean;
     protected handlers: THandlerMap;
     readonly compactNames: boolean;
-    constructor({ stackName, compactNames }?: CompilerOptions);
-    compile(script: string): [string, null, es.Node[]] | [null, Error | CompilerError, es.Node[]];
+    readonly sourcemap: boolean;
+    constructor({ stackName, compactNames, sourcemap, }?: CompilerOptions);
+    compile(script: string): [string, null, es.SourceLocation[] | undefined] | [null, CompilerError];
     protected resolve(valueInst: TValueInstructions<IValue | null>): void;
     protected serialize(resLines: TValueInstructions<IValue | null>): string;
     protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
-    handle(scope: IScope, node: es.Node): TValueInstructions<IValue | null>;
+    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;
-    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (scope: IScope, node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
+    /**
+     * 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}
+     * and {@link handleMany})
+     *
+     */
+    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
 }
 export {};

package/dist/types/CompilerError.d.ts

@@ -1,9 +1,33 @@
 import { es } from "./types";
-export declare class CompilerError extends Error {
-    nodeStack: es.Node[];
-    loc?: {
+/**
+ * Error thrown by the babel parser.
+ *
+ * It doesn't export the type so we are writing it ourselves
+ */
+export interface ParsingError extends Error {
+    code: string;
+    reasonCode: string;
+    loc: {
         line: number;
         column: number;
     };
-    constructor(message: string, nodeStack?: es.Node[]);
 }
+declare type CompilerErrorSource = es.Node | es.SourceLocation | {
+    line: number;
+    column: number;
+};
+export declare class CompilerError extends Error {
+    protected _loc?: es.SourceLocation;
+    /**
+     * The error that preceded this `CompilerError`.
+     *
+     * If it's not `undefined` it means that `this` is just wrapping the error to
+     * append extra data like the node stack
+     * */
+    inner?: unknown;
+    constructor(message: string, source?: CompilerErrorSource);
+    get loc(): es.SourceLocation | undefined;
+    set loc(value: CompilerErrorSource | undefined);
+    static from(error: unknown, source?: CompilerErrorSource): CompilerError;
+}
+export {};

package/dist/types/assertions.d.ts

@@ -0,0 +1,28 @@
+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;
+};
+/** 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];
+};
+/** 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/types/handlers/CallExpression.d.ts

@@ -1,3 +1,4 @@
 import { IValue, THandler } from "../types";
 export declare const CallExpression: THandler<IValue | null>;
 export declare const NewExpression: THandler<IValue | null>;
+export declare const TaggedTemplateExpression: THandler<IValue | null>;

package/dist/types/handlers/SwitchStatement.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const SwitchStatement: THandler<null>;

package/dist/types/handlers/index.d.ts

@@ -5,6 +5,7 @@ export * from "./OperationExpressions";
 export * from "./Identifier";
 export * from "./Statements";
 export * from "./IfStatement";
+export * from "./SwitchStatement";
 export * from "./WhileStatement";
 export * from "./ForStatement";
 export * from "./Function";

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export { Compiler, CompilerOptions } from "./Compiler";
 export { CompilerError } from "./CompilerError";
+export { SourceLocation } from "@babel/types";

package/dist/types/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/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/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/types/macros/Asm.d.ts

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

package/dist/types/macros/Namespace.d.ts

@@ -10,7 +10,4 @@ export declare class NamespaceMacro extends ObjectValue {
 export declare class VarsNamespace extends NamespaceMacro {
     constructor(scope: IScope);
 }
-export declare class UCommandsNamespace extends NamespaceMacro {
-    constructor(scope: IScope);
-}
 export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { MacroFunction } from "..";
 import { IScope } from "../../types";
-export declare const validRadarFilters: string[];
-export declare const validRadarSorts: string[];
+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);
 }

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

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

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

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