mlogjs 0.3.0-beta.0 → 0.4.0

package/dist/index.cjs

@@ -26,12 +26,75 @@ function _interopNamespace(e) {
 var es__namespace = /*#__PURE__*/_interopNamespace(es);
 
 class CompilerError extends Error {
-    constructor(message, nodeStack = []) {
+    constructor(message, source) {
         super(message);
-        this.nodeStack = nodeStack;
+        this.loc = source;
+    }
+    get loc() {
+        return this._loc;
+    }
+    set loc(value) {
+        if (!value)
+            return;
+        if ("type" in value) {
+            this._loc = value.loc;
+        }
+        else if ("start" in value) {
+            this._loc = value;
+        }
+        else {
+            this._loc = {
+                start: value,
+                end: value,
+            };
+        }
+    }
+    static from(error, source) {
+        let message;
+        if (error && typeof error === "object" && "loc" in error) {
+            const err = error;
+            message = err.toString();
+            source ??= err.loc;
+        }
+        else if (error instanceof Error) {
+            message = error.message;
+        }
+        else if (typeof error === "string") {
+            message = error;
+        }
+        else {
+            message = `Unknown error: ${error}`;
+        }
+        const result = new CompilerError(message, source);
+        result.inner = error;
+        return result;
     }
 }
 
+var EInstIntent;
+(function (EInstIntent) {
+    EInstIntent[EInstIntent["none"] = 0] = "none";
+    EInstIntent[EInstIntent["break"] = 1] = "break";
+    EInstIntent[EInstIntent["continue"] = 2] = "continue";
+    EInstIntent[EInstIntent["return"] = 3] = "return";
+})(EInstIntent || (EInstIntent = {}));
+/** Defines the possible types of mutability of a value */
+var EMutability;
+(function (EMutability) {
+    /**
+     * The value can be changed by the user's code,
+     * by the mlog runtime, or us
+     */
+    EMutability[EMutability["mutable"] = 0] = "mutable";
+    /**
+     * The value cannot be directly assigned,
+     * but it's still not safe from mutations coming from the runtime.
+     */
+    EMutability[EMutability["readonly"] = 1] = "readonly";
+    /** Constant values, won't change during execution */
+    EMutability[EMutability["constant"] = 2] = "constant";
+})(EMutability || (EMutability = {}));
+
 const arithmeticBinaryOperators = [
     "*",
     "**",
@@ -110,7 +173,7 @@ const operators = [...leftRightOperators, ...singleOperators];
 class VoidValue {
     constructor(scope) {
         this.owner = null;
-        this.constant = false;
+        this.mutability = EMutability.mutable;
         this.macro = false;
         this.scope = scope;
     }
@@ -142,6 +205,8 @@ for (const key of operators) {
 
 class InstructionBase {
     constructor(...args) {
+        this.intent = EInstIntent.none;
+        this.alwaysRuns = true;
         this._hidden = false;
         this.args = args;
     }
@@ -218,6 +283,7 @@ var EJumpKind;
 class JumpInstruction extends InstructionBase {
     constructor(address, kind, left = null, right = null) {
         super("jump", address, kind, left, right);
+        this.address = address;
     }
 }
 
@@ -236,11 +302,13 @@ class ZeroSpaceInstruction extends InstructionBase {
 class BreakInstruction extends JumpInstruction {
     constructor(address) {
         super(address, EJumpKind.Always);
+        this.intent = EInstIntent.break;
     }
 }
 class ContinueInstruction extends JumpInstruction {
     constructor(address) {
         super(address, EJumpKind.Always);
+        this.intent = EInstIntent.continue;
     }
 }
 
@@ -292,6 +360,20 @@ class BaseValue extends VoidValue {
         // TODO: should it return 0 + this ?
         return this.eval(scope);
     }
+    "!"(scope) {
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
+        const falseLiteral = new LiteralValue(scope, 0);
+        return [
+            temp,
+            [...inst, new OperationInstruction("equal", temp, that, falseLiteral)],
+        ];
+    }
+    "~"(scope) {
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
+        return [temp, [...inst, new OperationInstruction("not", temp, that, null)]];
+    }
     ensureOwned() {
         this.owner ??= new ValueOwner({ scope: this.scope, value: this });
     }
@@ -336,18 +418,6 @@ for (const key in operatorMap$1) {
         ];
     };
 }
-const unaryOperatorMap$1 = {
-    "!": "not",
-    "~": "flip",
-};
-for (const key in unaryOperatorMap$1) {
-    const name = unaryOperatorMap$1[key];
-    BaseValue.prototype[key] = function (scope) {
-        const [that, inst] = this.consume(scope);
-        const temp = new StoreValue(scope);
-        return [temp, [...inst, new OperationInstruction(name, temp, that, null)]];
-    };
-}
 const assignmentToBinary = {
     "+=": "+",
     "-=": "-",
@@ -399,7 +469,7 @@ const literalMethods = {
 class LiteralValue extends BaseValue {
     constructor(scope, data) {
         super(scope);
-        this.constant = true;
+        this.mutability = EMutability.constant;
         this.data = data;
     }
     eval(_scope) {
@@ -460,18 +530,22 @@ for (const key in operatorMap) {
         if (!(value instanceof LiteralValue)) {
             return BaseValue.prototype[key].apply(this, [scope, value]);
         }
-        return [new LiteralValue(scope, fn(this.num, value.num)), []];
+        return [
+            new LiteralValue(scope, fn(this.data, value.data)),
+            [],
+        ];
     };
 }
 const unaryOperatorMap = {
     "!": v => +!v,
     "~": v => ~v,
     "u-": v => -v,
+    "u+": v => +v,
 };
 for (const key in unaryOperatorMap) {
     LiteralValue.prototype[key] = function (scope) {
         const fn = unaryOperatorMap[key];
-        return [new LiteralValue(scope, fn(this.num)), []];
+        return [new LiteralValue(scope, fn(this.data)), []];
     };
 }
 
@@ -522,7 +596,33 @@ const itemNames = [
     "sporePod",
     "blastCompound",
     "pyratite",
-];
+];
+/**
+ * A more type safe version of `Object.assign`
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function assign(obj, props) {
+    return Object.assign(obj, props);
+}
+function appendSourceLocations(valueInst, node) {
+    for (const inst of valueInst[1]) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        inst.source ??= node.loc;
+    }
+    return valueInst;
+}
+function withAlwaysRuns(valueInst, value) {
+    valueInst[1].forEach(inst => (inst.alwaysRuns = value));
+    return valueInst;
+}
+function isTemplateObjectArray(value) {
+    return (value instanceof ObjectValue &&
+        value.data.length instanceof LiteralValue &&
+        typeof value.data.length.data === "number" &&
+        value.data.raw instanceof ObjectValue &&
+        value.data.raw.data.length instanceof LiteralValue &&
+        typeof value.data.raw.data.length.data === "number");
+}
 
 /**
  * `StoreValue` represents values unknown at compile time,
@@ -531,13 +631,13 @@ const itemNames = [
 class StoreValue extends BaseValue {
     constructor(scope) {
         super(scope);
-        this.constant = false;
+        this.mutability = EMutability.mutable;
     }
     typeof(scope) {
         return [new LiteralValue(scope, "store"), []];
     }
     "="(scope, value) {
-        if (this.constant)
+        if (this.mutability !== EMutability.mutable)
             throw new CompilerError(`Cannot assign to immutable store '${this}'.`);
         if (this.owner) {
             if (this.owner === value.owner && value instanceof StoreValue)
@@ -569,12 +669,13 @@ class StoreValue extends BaseValue {
 class ObjectValue extends VoidValue {
     constructor(scope, data = {}) {
         super(scope);
-        this.constant = true;
+        this.mutability = EMutability.constant;
         this.macro = true;
         this.data = data;
     }
-    static fromArray(scope, items) {
+    static fromArray(scope, items, intialData) {
         const data = {
+            ...intialData,
             length: new LiteralValue(scope, items.length),
         };
         items.forEach((item, i) => {
@@ -651,14 +752,15 @@ const senseableProps = ["controller"];
  * Note that these values are constant by default, so make sure
  * to set that field to `false` if you want them to be assignable. Example:
  * ```
- * const value = new SenseableValue(scope)
- * value.constant = false
+ * const value = assign(new SenseableValue(scope), {
+ *   mutability: EMutability.mutable
+ * })
  * ```
  */
 class SenseableValue extends StoreValue {
     constructor(scope) {
         super(scope);
-        this.constant = true;
+        this.mutability = EMutability.constant;
     }
     get(scope, prop) {
         if (prop instanceof LiteralValue && typeof prop.data === "string") {
@@ -674,14 +776,13 @@ class SenseableValue extends StoreValue {
             ];
         }
         if (prop instanceof StoreValue) {
-            const temp = new StoreValue(scope);
+            const temp = assign(new SenseableValue(scope), {
+                mutability: EMutability.readonly,
+            });
             return [temp, [new InstructionBase("sensor", temp, this, prop)]];
         }
         throw new CompilerError(`Cannot sense "${prop}" property`);
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "senseable"), []];
-    }
 }
 
 /**
@@ -778,11 +879,11 @@ class Scope {
         return owner.value;
     }
     make(identifier, name) {
-        const value = new SenseableValue(this);
-        value.constant = false;
         const owner = new ValueOwner({
             scope: this,
-            value,
+            value: assign(new SenseableValue(this), {
+                mutability: EMutability.mutable,
+            }),
             identifier,
             name,
         });
@@ -802,7 +903,7 @@ const Program = (c, scope, node) => {
 };
 
 const VariableDeclaration = (c, scope, node) => {
-    return c.handleMany(scope, node.declarations, (scope, child) => VariableDeclarator(c, scope, child, node.kind));
+    return c.handleMany(scope, node.declarations, child => VariableDeclarator(c, scope, child, node.kind));
 };
 const VariableDeclarator = (c, scope, node, kind = "let") => {
     const [init, inst] = node.init
@@ -812,25 +913,25 @@ const VariableDeclarator = (c, scope, node, kind = "let") => {
     return [null, inst];
 };
 const Declare = (c, scope, node, kind, init) => {
-    switch (node.type) {
-        case "Identifier":
-            return DeclareIdentifier(c, scope, node, kind, init);
-        case "ArrayPattern":
-            return DeclareArrayPattern(c, scope, node, kind, init);
-        case "ObjectPattern":
-            return DeclareObjectPattern(c, scope, node, kind, init);
-        default:
-            throw new CompilerError(`Unsupported declaration type: ${node.type}`, [
-                node,
-            ]);
-    }
+    return c.handle(scope, node, () => {
+        switch (node.type) {
+            case "Identifier":
+                return DeclareIdentifier(c, scope, node, kind, init);
+            case "ArrayPattern":
+                return DeclareArrayPattern(c, scope, node, kind, init);
+            case "ObjectPattern":
+                return DeclareObjectPattern(c, scope, node, kind, init);
+            default:
+                throw new CompilerError(`Unsupported declaration type: ${node.type}`, node);
+        }
+    });
 };
 const DeclareIdentifier = (c, scope, node, kind, init) => {
     const { name: identifier } = node;
     const name = nodeName(node, !c.compactNames && identifier);
     if (kind === "const" && !init)
-        throw new CompilerError("Constants must be initialized.", [node]);
-    if (kind === "const" && init?.constant) {
+        throw new CompilerError("Constants must be initialized.", node);
+    if (kind === "const" && init?.mutability === EMutability.constant) {
         const owner = new ValueOwner({
             scope,
             identifier,
@@ -846,13 +947,11 @@ const DeclareIdentifier = (c, scope, node, kind, init) => {
         const inst = [];
         if (init) {
             if (init.macro)
-                throw new CompilerError("Macro values must be held by constants", [
-                    node,
-                ]);
+                throw new CompilerError("Macro values must be held by constants", node);
             inst.push(...value["="](scope, init)[1]);
         }
         if (kind === "const")
-            value.constant = true;
+            value.mutability = EMutability.constant;
         return [null, inst];
     }
 };
@@ -867,29 +966,28 @@ const DeclareArrayPattern = (c, scope, node, kind, init) => {
             continue;
         const val = init.data[i];
         if (!val)
-            throw new CompilerError(`The target object does not have a value at index ${i}`, [element]);
+            throw new CompilerError(`The target object does not have a value at index ${i}`, element);
         inst.push(...Declare(c, scope, element, kind, val)[1]);
     }
     return [null, inst];
 };
 const DeclareObjectPattern = (c, scope, node, kind, base) => {
     if (!base)
-        throw new CompilerError("Cannot use object destructuring without an initializer", [node]);
+        throw new CompilerError("Cannot use object destructuring without an initializer", node);
     const { properties } = node;
     const [init, inst] = base.consume(scope);
-    for (const prop of properties) {
+    const propertiesInst = c.handleMany(scope, properties, prop => {
         if (prop.type === "RestElement")
-            throw new CompilerError("The rest operator is not supported", [prop]);
+            throw new CompilerError("The rest operator is not supported", prop);
         const { key, value } = prop;
-        const child = key.type === "Identifier" && !prop.computed
+        const keyInst = key.type === "Identifier" && !prop.computed
             ? [new LiteralValue(scope, key.name), []]
             : c.handleConsume(scope, prop.key);
-        inst.push(...child[1]);
-        const propInit = init.get(scope, child[0]);
-        inst.push(...propInit[1]);
-        inst.push(...Declare(c, scope, value, kind, propInit[0])[1]);
-    }
-    return [null, inst];
+        const propInit = init.get(scope, keyInst[0]);
+        const declarationInst = Declare(c, scope, value, kind, propInit[0]);
+        return [null, [...keyInst[1], ...propInit[1], ...declarationInst[1]]];
+    });
+    return [null, [...inst, ...propertiesInst[1]]];
 };
 
 const Literal = (_c, scope, node) => [new LiteralValue(scope, node.value), []];
@@ -908,7 +1006,34 @@ const LRExpression = (c, scope, node) => {
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const BinaryExpression = LRExpression;
-const LogicalExpression = LRExpression;
+const LogicalExpression = (c, scope, node) => {
+    if (node.operator !== "??")
+        return LRExpression(c, scope, node);
+    const nullLiteral = new LiteralValue(scope, null);
+    const endAdress = new LiteralValue(scope, null);
+    const [left, leftInst] = c.handleEval(scope, node.left);
+    const [nullTest] = left["=="](scope, nullLiteral);
+    if (nullTest instanceof LiteralValue) {
+        if (nullTest.data)
+            return c.handleEval(scope, node.right);
+        else
+            return [left, leftInst];
+    }
+    const [right, rightInst] = c.handleEval(scope, node.right);
+    const result = new StoreValue(scope);
+    result.ensureOwned();
+    return [
+        result,
+        [
+            ...leftInst,
+            ...result["="](scope, left)[1],
+            new JumpInstruction(endAdress, EJumpKind.NotEqual, result, nullLiteral),
+            ...rightInst,
+            ...result["="](scope, right)[1],
+            new AddressResolver(endAdress),
+        ],
+    ];
+};
 const AssignmentExpression = (c, scope, node) => {
     const [left, leftInst] = c.handle(scope, node.left);
     // doesn't need to consume because the operators already do that
@@ -998,13 +1123,75 @@ const IfStatement = (c, scope, node) => {
         return [null, inst];
     }
     const endIfAddr = new LiteralValue(scope, null);
-    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...c.handle(scope, node.consequent)[1], new AddressResolver(endIfAddr));
+    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1], new AddressResolver(endIfAddr));
     const endElseAddr = new LiteralValue(scope, null);
-    if (node.alternate)
-        inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...c.handle(scope, node.alternate)[1], new AddressResolver(endElseAddr));
+    if (node.alternate) {
+        inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...withAlwaysRuns(c.handle(scope, node.alternate), false)[1], new AddressResolver(endElseAddr));
+    }
     return [null, inst];
 };
 
+const SwitchStatement = (c, scope, node) => {
+    const innerScope = scope.createScope();
+    const [ref, refInst] = c.handleConsume(scope, node.discriminant);
+    const inst = [];
+    const endAdress = new LiteralValue(innerScope, null);
+    const endLine = new AddressResolver(endAdress).bindBreak(innerScope);
+    const caseJumps = [];
+    let defaultJump;
+    for (const scase of node.cases) {
+        const [, bodyInst] = c.handleMany(innerScope, scase.consequent);
+        const bodyAdress = new LiteralValue(innerScope, null);
+        const bodyLine = new AddressResolver(bodyAdress);
+        if (!scase.test) {
+            [defaultJump] = c.handle(innerScope, scase, () => [
+                null,
+                [new JumpInstruction(bodyAdress, EJumpKind.Always)],
+            ])[1];
+            inst.push(bodyLine, ...bodyInst);
+            continue;
+        }
+        const [test, testInst] = c.handleConsume(innerScope, scase.test);
+        // check if it can be evaluated at compile time
+        const [comp] = ref["=="](innerScope, test);
+        // if the constant expression resolves to false
+        // the whole case gets omitted
+        // otherwise it returns the instructions for
+        // the body of this case
+        if (comp instanceof LiteralValue) {
+            if (comp.data)
+                return [null, bodyInst];
+            else
+                continue;
+        }
+        // makes sourcemapping for the jump more specific
+        const [, jump] = c.handle(innerScope, scase, () => [
+            null,
+            [new JumpInstruction(bodyAdress, EJumpKind.StrictEqual, ref, test)],
+        ]);
+        caseJumps.push(...testInst, ...jump);
+        inst.push(bodyLine, ...bodyInst);
+    }
+    // ensures that the processor exits
+    // the switch if no cases match
+    defaultJump ??= new JumpInstruction(endAdress, EJumpKind.Always);
+    if (caseJumps.length > 0) {
+        withAlwaysRuns([null, inst], false);
+        withAlwaysRuns([null, [...caseJumps.slice(1), defaultJump]], false);
+        withAlwaysRuns([null, inst], false);
+    }
+    return [
+        null,
+        [
+            ...refInst,
+            ...caseJumps,
+            ...(caseJumps.length > 0 ? [defaultJump] : []),
+            ...inst,
+            endLine,
+        ],
+    ];
+};
+
 const WhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
@@ -1018,7 +1205,7 @@ const WhileStatement = (c, scope, node) => {
         }
         return [null, lines];
     }
-    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...c.handle(scope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...withAlwaysRuns(c.handle(scope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
     return [null, lines];
 };
 const DoWhileStatement = (c, scope, node) => {
@@ -1062,7 +1249,7 @@ const ForStatement = (c, scope, node) => {
             startLoopLine,
             ...testLines,
             new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
-            ...c.handle(scope, node.body)[1],
+            ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
             ...updateLines,
             new JumpInstruction(startLoopAddr, EJumpKind.Always),
             endLoopLine,
@@ -1073,7 +1260,7 @@ const ForStatement = (c, scope, node) => {
 class FunctionValue extends VoidValue {
     constructor({ scope, params, body, c, node, }) {
         super(scope);
-        this.constant = true;
+        this.mutability = EMutability.constant;
         this.macro = true;
         this.paramOwners = [];
         this.bundled = false;
@@ -1093,7 +1280,9 @@ class FunctionValue extends VoidValue {
             const name = nodeName(id, !this.c.compactNames && id.name);
             const owner = new ValueOwner({
                 scope: this.childScope,
-                value: new StoreValue(this.childScope),
+                value: assign(new SenseableValue(this.childScope), {
+                    mutability: EMutability.mutable,
+                }),
                 identifier: id.name,
                 name,
             });
@@ -1108,15 +1297,16 @@ class FunctionValue extends VoidValue {
         if (this.initialized)
             return;
         this.initialized = true;
-        const name = nodeName(this.node, !this.c.compactNames && this.owner.name);
+        const { name } = this.owner;
         this.initScope(name);
         this.addr = new LiteralValue(this.childScope, null);
         this.temp = new ValueOwner({
             scope: this.childScope,
             name: `${internalPrefix}f${name}`,
-            value: new SenseableValue(this.childScope),
+            value: assign(new SenseableValue(this.childScope), {
+                mutability: EMutability.mutable,
+            }),
         });
-        this.temp.value.constant = false;
         this.ret = new ValueOwner({
             scope: this.childScope,
             name: `${internalPrefix}r${name}`,
@@ -1127,12 +1317,17 @@ class FunctionValue extends VoidValue {
             ...this.c.handle(this.childScope, this.body)[1],
         ];
         if (!endsWithReturn(this.inst)) {
-            this.inst.push(new SetCounterInstruction(this.ret.value));
+            this.inst.push(assign(new SetCounterInstruction(this.ret.value), {
+                intent: EInstIntent.return,
+            }));
         }
     }
     normalReturn(scope, arg) {
         const argInst = arg ? this.temp.value["="](scope, arg)[1] : [];
-        return [null, [...argInst, new SetCounterInstruction(this.ret.value)]];
+        const returnInst = assign(new SetCounterInstruction(this.ret.value), {
+            intent: EInstIntent.return,
+        });
+        return [null, [...argInst, returnInst]];
     }
     normalCall(scope, args) {
         if (!this.bundled)
@@ -1147,16 +1342,21 @@ class FunctionValue extends VoidValue {
     }
     inlineReturn(scope, arg) {
         const argInst = arg ? this.inlineTemp.value["="](scope, arg)[1] : [];
-        return [null, argInst];
+        if (!this.inlineEnd)
+            throw new CompilerError("Error during inline attempt: missing inline end adress");
+        const jump = assign(new JumpInstruction(this.inlineEnd, EJumpKind.Always), {
+            intent: EInstIntent.return,
+        });
+        return [null, [...argInst, jump]];
     }
     inlineCall(scope, args) {
         // create return value
         this.inlineTemp = new ValueOwner({
             scope: this.childScope,
-            value: new SenseableValue(scope),
+            value: assign(new SenseableValue(scope), {
+                mutability: EMutability.mutable,
+            }),
         });
-        this.inlineTemp.value.constant = false;
-        this.inlineEnd = new LiteralValue(scope, null);
         // make a copy of the function scope
         const fnScope = this.childScope.copy();
         // hard set variables within the function scope
@@ -1171,16 +1371,13 @@ class FunctionValue extends VoidValue {
                 name: owner.name,
             }));
         });
+        this.inlineEnd = new LiteralValue(scope, null);
         this.tryingInline = true;
-        const inst = this.c.handle(fnScope, this.body)[1];
+        let inst = this.c.handle(fnScope, this.body)[1];
         this.tryingInline = false;
-        // removing useless instruction
-        // get the last instructions
-        // const [jump] = inst.slice(-1);
-        // if (jump instanceof JumpInstruction) {
-        // 	// remove useless jump
-        // 	if (jump.args[1] === this.inlineEnd) inst.pop();
-        // }
+        const returnIndex = inst.findIndex(i => i.alwaysRuns && i.intent === EInstIntent.return);
+        if (returnIndex !== -1)
+            inst = inst.slice(0, returnIndex + 1);
         inst.push(new AddressResolver(this.inlineEnd));
         // return the function value
         return [this.inlineTemp.value, inst];
@@ -1225,7 +1422,11 @@ function endsWithReturn(inst) {
 function handleFunctionNode(c, scope, node) {
     let { params, body } = node;
     if (es__namespace.isExpression(body)) {
-        body = es__namespace.blockStatement([es__namespace.returnStatement(body)]);
+        const { loc } = body;
+        const statement = es__namespace.returnStatement(body);
+        statement.loc = loc;
+        body = es__namespace.blockStatement([statement]);
+        body.loc = loc;
     }
     return [
         new FunctionValue({
@@ -1271,16 +1472,32 @@ const CallExpression = (c, scope, node) => {
     inst.push(...callInst);
     return [callValue, inst];
 };
-const NewExpression = CallExpression;
+const NewExpression = CallExpression;
+const TaggedTemplateExpression = (c, scope, node) => {
+    const [tag, tagInst] = c.handleConsume(scope, node.tag);
+    const template = node.quasi;
+    const stringsObject = ObjectValue.fromArray(scope, template.quasis.map(quasi => new LiteralValue(scope, quasi.value.cooked ?? "")), {
+        raw: ObjectValue.fromArray(scope, template.quasis.map(quasi => new LiteralValue(scope, quasi.value.raw))),
+    });
+    const expressions = [];
+    const expressionInsts = [];
+    template.expressions.forEach(expression => {
+        const [value, inst] = c.handleConsume(scope, expression);
+        expressions.push(value);
+        expressionInsts.push(...inst);
+    });
+    const [result, resultInst] = tag.call(scope, [stringsObject, ...expressions]);
+    return [result, [...expressionInsts, ...tagInst, ...resultInst]];
+};
 
 const ObjectExpression = (c, scope, node) => {
     const data = {};
     const inst = [];
     for (const prop of node.properties) {
         if (prop.type === "SpreadElement")
-            throw new CompilerError("Cannot handle spread element", [prop]);
+            throw new CompilerError("Cannot handle spread element", prop);
         if (prop.computed)
-            throw new CompilerError("Cannot handle computed property.", [prop]);
+            throw new CompilerError("Cannot handle computed property.", prop);
         const { key } = prop;
         const value = prop.type === "ObjectProperty" ? prop.value : prop;
         let index;
@@ -1291,17 +1508,18 @@ const ObjectExpression = (c, scope, node) => {
             index = `${key.value}`;
         }
         else {
-            throw new CompilerError(`Unsupported object key type: ${key.type}`, [
-                key,
-            ]);
+            throw new CompilerError(`Unsupported object key type: ${key.type}`, key);
         }
         const [member, memberInst] = c.handleEval(scope, value);
-        const owner = new ValueOwner({
-            scope,
-            constant: true,
-            value: member,
-        });
-        data[index] = owner.value;
+        // TODO: use an approach that can be defined by each type
+        if (!member.owner && !(member instanceof LiteralValue)) {
+            new ValueOwner({
+                scope,
+                constant: true,
+                value: member,
+            });
+        }
+        data[index] = member;
         inst.push(...memberInst);
     }
     return [new ObjectValue(scope, data), inst];
@@ -1335,9 +1553,7 @@ const ArrayPattern = (c, scope, node) => {
             continue;
         const valueInst = c.handle(scope, element);
         if (!valueInst[0])
-            throw new CompilerError("Destructuring element must resolve to a value", [
-                element,
-            ]);
+            throw new CompilerError("Destructuring element must resolve to a value", element);
         inst.push(...valueInst[1]);
         members.set(new LiteralValue(scope, i), valueInst[0]);
     }
@@ -1358,26 +1574,15 @@ const ObjectPattern = (c, scope, node) => {
         inst.push(...keyInst[1]);
         const valueInst = c.handle(scope, prop.value);
         if (!valueInst[0])
-            throw new CompilerError("Destructuring member must resolve to a value", [
-                prop.value,
-            ]);
+            throw new CompilerError("Destructuring member must resolve to a value", prop.value);
         inst.push(...valueInst[1]);
         members.set(keyInst[0], valueInst[0]);
     }
     return [new DestructuringValue(scope, members), inst];
 };
 
-const TemplateLiteral = (c, scope, node) => {
-    const args = [];
-    const inst = [];
-    node.expressions.forEach((expression, i) => {
-        const [v, vi] = c.handleConsume(scope, expression);
-        inst.push(...vi);
-        args.push(node.quasis[i].value.raw, v);
-    });
-    args.push(node.quasis.slice(-1)[0].value.raw);
-    inst.push(new ZeroSpaceInstruction(...args));
-    return [null, inst];
+const TemplateLiteral = () => {
+    throw new CompilerError("Template strings are currently unavailable. To inline mlog code use the asm function.");
 };
 
 const BlockStatement = (c, scope, node) => {
@@ -1410,14 +1615,12 @@ const TSEnumDeclaration = (c, scope, node) => {
     const data = {};
     for (const member of node.members) {
         if (lastType === "string" && !member.initializer)
-            throw new CompilerError("This enum member must be initialized", [member]);
+            throw new CompilerError("This enum member must be initialized", member);
         const [value] = member.initializer
             ? c.handleEval(scope, member.initializer)
             : [new LiteralValue(scope, counter)];
         if (!(value instanceof LiteralValue))
-            throw new CompilerError("Enum members must contain literal values", [
-                member,
-            ]);
+            throw new CompilerError("Enum members must contain literal values", member);
         if (typeof value.data === "number") {
             lastType = "number";
             counter = value.data + 1;
@@ -1463,6 +1666,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     ContinueStatement: ContinueStatement,
     ReturnStatement: ReturnStatement,
     IfStatement: IfStatement,
+    SwitchStatement: SwitchStatement,
     WhileStatement: WhileStatement,
     DoWhileStatement: DoWhileStatement,
     ForStatement: ForStatement,
@@ -1472,6 +1676,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     ObjectMethod: ObjectMethod,
     CallExpression: CallExpression,
     NewExpression: NewExpression,
+    TaggedTemplateExpression: TaggedTemplateExpression,
     ObjectExpression: ObjectExpression,
     ArrayExpression: ArrayExpression,
     MemberExpression: MemberExpression,
@@ -1574,53 +1779,170 @@ class Concat extends MacroFunction {
     }
 }
 
-class Draw extends MacroFunction {
+/** Asserts that `value` is a `LiteralValue` that contains a string */
+function assertStringLiteral(value, name) {
+    if (!(value instanceof LiteralValue) || typeof value.data !== "string")
+        throw new CompilerError(`${name} must be a string literal`);
+}
+/** Asserts that `value` is a string literal that is part of a given set of `members`*/
+function assertLiteralOneOf(value, members, name) {
+    assertStringLiteral(value, name);
+    if (!members.includes(value.data))
+        throw new CompilerError(`${name} must be one of: ${members
+            .slice(0, -1)
+            .map(member => `"${member}"`)
+            .join(", ")} or "${members[members.length - 1]}"`);
+}
+/** Asserts that `value` is either a store or a literal */
+function assertIsRuntimeValue(value, name) {
+    if (!(value instanceof LiteralValue) && !(value instanceof StoreValue))
+        throw new CompilerError(`${name} must be a valid runtime value`);
+}
+/** Asserts that `value` is an `ObjectValue` */
+function assertIsObjectMacro(value, name) {
+    if (!(value instanceof ObjectValue))
+        throw new CompilerError(`${name} must be an object macro`);
+}
+/** Asserts that `value` is an `ObjectValue` that has a length property */
+function assertIsArrayMacro(value, name) {
+    if (!(value instanceof ObjectValue) || !value.data.length)
+        throw new CompilerError(`${name} must be an array macro`);
+}
+/** Asserts that all of the fields described are present on `value`*/
+function assertObjectFields(value, fields) {
+    const result = [];
+    for (const field of fields) {
+        const param = typeof field === "object" ? field : { key: field };
+        const item = value.data[param.key];
+        if (item) {
+            param.validate?.(item);
+            result.push(item);
+            continue;
+        }
+        if (param.default == undefined)
+            throw new CompilerError(`The field "${param.name ?? param.key}" must be present`);
+        result.push(param.default);
+    }
+    return result;
+}
+
+/** Used to create namespaces that contain multiple methods that map into instructions */
+function createOverloadNamespace({ scope, overloads, handler, }) {
+    const result = {};
+    for (const key in overloads) {
+        const { named, args } = overloads[key];
+        if (named) {
+            result[key] = new MacroFunction(scope, options => {
+                assertIsObjectMacro(options, named);
+                return handler(key, ...assertObjectFields(options, args));
+            });
+            continue;
+        }
+        result[key] = new MacroFunction(scope, (...params) => {
+            const handlerParams = [];
+            // validate the paramters
+            for (let i = 0; i < args.length; i++) {
+                let arg = args[i];
+                if (typeof arg === "string")
+                    arg = { key: arg };
+                const param = params[i];
+                if (!param) {
+                    if (arg.default == undefined)
+                        throw new CompilerError(`Missing argument: ${arg.name ?? arg.key}`);
+                    handlerParams.push(arg.default);
+                    continue;
+                }
+                arg.validate?.(param);
+                handlerParams.push(param);
+            }
+            return handler(key, ...handlerParams);
+        });
+    }
+    return result;
+}
+
+class Draw extends ObjectValue {
     constructor(scope) {
-        super(scope, (kind, ...args) => {
-            if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
-                throw new CompilerError("Draw kind must be a string literal.");
-            if ([
-                "clear",
-                "color",
-                "stroke",
-                "line",
-                "rect",
-                "lineRect",
-                "poly",
-                "linePoly",
-                "triangle",
-                "image",
-            ].indexOf(kind.data) === -1)
-                throw new CompilerError("Invalid draw kind");
-            return [
-                null,
-                [
-                    new InstructionBase("draw", kind.data, ...args.map(v => {
-                        if (v instanceof LiteralValue && typeof v.data === "string")
-                            return v.data;
-                        return v;
-                    })),
-                ],
-            ];
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                clear: {
+                    args: ["r", "g", "b"],
+                },
+                color: {
+                    args: ["r", "g", "b", { key: "a", default: "" }],
+                },
+                stroke: {
+                    args: ["width"],
+                },
+                line: {
+                    named: "options",
+                    args: ["x", "y", "x2", "y2"],
+                },
+                rect: {
+                    named: "options",
+                    args: ["x", "y", "width", "height"],
+                },
+                lineRect: { named: "options", args: ["x", "y", "width", "height"] },
+                linePoly: {
+                    named: "options",
+                    args: ["x", "y", "sides", "radius", "rotation"],
+                },
+                poly: {
+                    named: "options",
+                    args: ["x", "y", "sides", "radius", "rotation"],
+                },
+                triangle: {
+                    named: "options",
+                    args: ["x", "y", "x2", "y2", "x3", "y3"],
+                },
+                image: {
+                    named: "options",
+                    args: ["x", "y", "image", "size", "rotation"],
+                },
+            },
+            handler(overload, ...args) {
+                return [null, [new InstructionBase("draw", overload, ...args)]];
+            },
         });
+        super(scope, data);
     }
 }
 
 class Print extends MacroFunction {
     constructor(scope) {
         super(scope, (...values) => {
+            const [first] = values;
             const inst = [];
-            for (const value of values) {
-                inst.push(new InstructionBase("print", value));
+            if (!isTemplateObjectArray(first)) {
+                for (const value of values) {
+                    inst.push(new InstructionBase("print", value));
+                }
+                return [null, inst];
             }
+            // `first` is likely a template strings array
+            // maybe this should be checked in another way?
+            const { length } = first.data;
+            for (let i = 1; i < values.length; i++) {
+                const [string] = first.get(scope, new LiteralValue(scope, i - 1));
+                if (string.data)
+                    inst.push(new InstructionBase("print", string));
+                inst.push(new InstructionBase("print", values[i]));
+            }
+            const [tail] = first.get(scope, new LiteralValue(scope, length.data - 1));
+            if (tail.data)
+                inst.push(new InstructionBase("print", tail));
             return [null, inst];
         });
     }
 }
 
+const defaultTargetName$1 = "message1";
 class PrintFlush extends MacroFunction {
     constructor(scope) {
         super(scope, (target) => {
+            if (!target)
+                return [null, [new InstructionBase("printflush", defaultTargetName$1)]];
             if (!(target instanceof SenseableValue))
                 throw new CompilerError("The printflush target must be a senseable value");
             return [null, [new InstructionBase("printflush", target)]];
@@ -1628,9 +1950,12 @@ class PrintFlush extends MacroFunction {
     }
 }
 
+const defaultTargetName = "display1";
 class DrawFlush extends MacroFunction {
     constructor(scope) {
         super(scope, (target) => {
+            if (!target)
+                return [null, [new InstructionBase("drawflush", defaultTargetName)]];
             if (!(target instanceof SenseableValue))
                 throw new CompilerError("The drawflush target must be a senseable value");
             return [null, [new InstructionBase("drawflush", target)]];
@@ -1638,6 +1963,30 @@ class DrawFlush extends MacroFunction {
     }
 }
 
+class GetBlock extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                floor: { args: ["x", "y"] },
+                ore: { args: ["x", "y"] },
+                block: { args: ["x", "y"] },
+                building: { args: ["x", "y"] },
+            },
+            handler(overload, x, y) {
+                const output = overload === "building"
+                    ? new SenseableValue(scope)
+                    : new StoreValue(scope);
+                return [
+                    output,
+                    [new InstructionBase("getblock", overload, output, x, y)],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
 class GetLink extends MacroFunction {
     constructor(scope) {
         super(scope, (index) => {
@@ -1650,21 +1999,27 @@ class GetLink extends MacroFunction {
     }
 }
 
-const validKinds$1 = ["enabled", "shoot", "shootp", "config", "color"];
-class Control extends MacroFunction {
+class Control extends ObjectValue {
     constructor(scope) {
-        super(scope, (kind, building, ...args) => {
-            if (!(kind instanceof LiteralValue) || typeof kind.data !== "string")
-                throw new CompilerError("The control kind must be a string literal");
-            if (!validKinds$1.includes(kind.data))
-                throw new CompilerError("Invalid control kind");
-            if (!(building instanceof SenseableValue))
-                throw new CompilerError("The building must be a senseable value");
-            return [
-                null,
-                [new InstructionBase("control", kind.data, building, ...args)],
-            ];
-        });
+        super(scope, createOverloadNamespace({
+            scope,
+            overloads: {
+                enabled: { args: ["building", "value"] },
+                shoot: {
+                    named: "options",
+                    args: ["building", "x", "y", "shoot"],
+                },
+                shootp: {
+                    named: "options",
+                    args: ["building", "unit", "shoot"],
+                },
+                config: { args: ["building", "value"] },
+                color: { args: ["building", "r", "g", "b"] },
+            },
+            handler(overload, ...args) {
+                return [null, [new InstructionBase("control", overload, ...args)]];
+            },
+        }));
     }
 }
 
@@ -1687,28 +2042,25 @@ const validRadarSorts = [
 ];
 class Radar extends MacroFunction {
     constructor(scope) {
-        super(scope, (building, filter1, filter2, filter3, order, sort) => {
+        super(scope, options => {
+            assertIsObjectMacro(options, "The radar options");
+            const { building, filters, order, sort } = options.data;
             if (!(building instanceof SenseableValue))
                 throw new CompilerError("The building must a senseable value");
-            if (!(filter1 instanceof LiteralValue) ||
-                typeof filter1.data !== "string" ||
-                !(filter2 instanceof LiteralValue) ||
-                typeof filter2.data !== "string" ||
-                !(filter3 instanceof LiteralValue) ||
-                typeof filter3.data !== "string")
-                throw new CompilerError("The filters must be string literals");
-            if (!validRadarFilters.includes(filter1.data))
-                throw new CompilerError("Invalid value for filter1");
-            if (!validRadarFilters.includes(filter2.data))
-                throw new CompilerError("Invalid value for filter2");
-            if (!validRadarFilters.includes(filter3.data))
-                throw new CompilerError("Invalid value for filter3");
+            assertIsArrayMacro(filters, "filters");
+            const { length } = filters.data;
+            if (!(length instanceof LiteralValue) || typeof length.data !== "number")
+                throw new CompilerError("The length of an array macro must be");
+            if (length.data !== 3)
+                throw new CompilerError("The filters array must have 3 items");
+            // data is not an array
+            const { 0: filter1, 1: filter2, 2: filter3 } = filters.data;
+            assertLiteralOneOf(filter1, validRadarFilters, "The first filter");
+            assertLiteralOneOf(filter2, validRadarFilters, "The second filter");
+            assertLiteralOneOf(filter3, validRadarFilters, "The third filter");
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
                 throw new CompilerError("The radar order must be a literal or a store");
-            if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
-                throw new CompilerError("The radar sort must be a string literal");
-            if (!validRadarSorts.includes(sort.data))
-                throw new CompilerError("Invalid sort value");
+            assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
             const outUnit = new SenseableValue(scope);
             return [
                 outUnit,
@@ -1727,7 +2079,9 @@ class Sensor extends MacroFunction {
                 throw new CompilerError("The sensor property must be a store");
             if (!(target instanceof SenseableValue))
                 throw new CompilerError("The sensor target must be a senseable value");
-            const temp = new StoreValue(scope);
+            const temp = assign(new SenseableValue(scope), {
+                mutability: EMutability.readonly,
+            });
             return [temp, [new InstructionBase("sensor", temp, target, property)]];
         });
     }
@@ -1744,19 +2098,40 @@ class Wait extends MacroFunction {
     }
 }
 
-const validKinds = ["block", "unit", "item", "liquid"];
-class Lookup extends MacroFunction {
+class Lookup extends ObjectValue {
     constructor(scope) {
-        super(scope, (kind, index) => {
-            if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
-                throw new CompilerError("The lookup kind must be a string literal");
-            if (!validKinds.includes(kind.data))
-                throw new CompilerError("Invalid lookup kind");
-            if (!(index instanceof LiteralValue && typeof index.data === "number") &&
-                !(index instanceof StoreValue))
-                throw new CompilerError("The lookup index must be a number literal or a store");
-            const temp = new StoreValue(scope);
-            return [temp, [new InstructionBase("lookup", kind.data, temp, index)]];
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                block: { args: ["index"] },
+                unit: { args: ["index"] },
+                item: { args: ["index"] },
+                liquid: { args: ["index"] },
+            },
+            handler(overload, index) {
+                const output = new StoreValue(scope);
+                return [
+                    output,
+                    [new InstructionBase("lookup", overload, output, index)],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class PackColor extends MacroFunction {
+    constructor(scope) {
+        super(scope, (...args) => {
+            if (args.length !== 4) {
+                throw new CompilerError(`Expected 4 arguments, received ${args.length}`);
+            }
+            if (!args.every((value) => value instanceof StoreValue ||
+                (value instanceof LiteralValue && typeof value.data === "number"))) {
+                throw new CompilerError("packColor arguments must be either stores or number literals");
+            }
+            const output = new StoreValue(scope);
+            return [output, [new InstructionBase("packcolor", output, ...args)]];
         });
     }
 }
@@ -1767,6 +2142,57 @@ class End extends MacroFunction {
     }
 }
 
+class SetBlock extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                floor: { args: ["x", "y", "to"] },
+                ore: { args: ["x", "y", "to"] },
+                block: {
+                    named: "options",
+                    args: ["x", "y", "to", "team", { key: "rotation", default: "0" }],
+                },
+            },
+            handler(overload, x, y, to, team, rotation) {
+                return [
+                    null,
+                    [
+                        new InstructionBase("setblock", overload, to, x, y, team ?? "@delerict", rotation ?? "0"),
+                    ],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class SpawnUnit extends MacroFunction {
+    constructor(scope) {
+        super(scope, options => {
+            assertIsObjectMacro(options, "The options");
+            const { type, x, y, team, rotation } = options.data;
+            assertIsRuntimeValue(type, "type");
+            assertIsRuntimeValue(x, "x");
+            assertIsRuntimeValue(y, "y");
+            assertIsRuntimeValue(team, "team");
+            const output = new SenseableValue(scope);
+            return [
+                output,
+                [
+                    new InstructionBase("spawn", type, x, y, rotation ?? "0", team, output),
+                ],
+            ];
+        });
+    }
+}
+
+class Stop extends MacroFunction {
+    constructor(scope) {
+        super(scope, () => [null, [new InstructionBase("stop")]]);
+    }
+}
+
 class UnitBind extends MacroFunction {
     constructor(scope) {
         super(scope, type => {
@@ -1777,82 +2203,85 @@ class UnitBind extends MacroFunction {
     }
 }
 
-const validModes = [
-    "idle",
-    "stop",
-    "move",
-    "approach",
-    "boost",
-    "pathfind",
-    "target",
-    "targetp",
-    "itemDrop",
-    "itemTake",
-    "payDrop",
-    "payTake",
-    "payEnter",
-    "mine",
-    "flag",
-    "build",
-    "getBlock",
-    "within",
-];
-class UnitControl extends MacroFunction {
+class UnitControl extends ObjectValue {
     constructor(scope) {
-        super(scope, (mode, ...args) => {
-            if (!(mode instanceof LiteralValue) || typeof mode.data !== "string")
-                throw new CompilerError("The unitControl mode must be a string literal");
-            if (!validModes.includes(mode.data))
-                throw new CompilerError("Invalid unitControl mode");
-            if (args.some(value => !(value instanceof StoreValue || value instanceof LiteralValue)))
-                throw new CompilerError("The others arguments of unitControl must be literals or stores");
-            let result = null;
-            let extraArgs = [];
-            switch (mode.data) {
-                case "getBlock": {
-                    const outType = new StoreValue(scope);
-                    const outBuilding = new SenseableValue(scope);
-                    result = ObjectValue.fromArray(scope, [outType, outBuilding]);
-                    extraArgs = [outType, outBuilding, new LiteralValue(scope, 0)];
-                    break;
-                }
-                case "within": {
-                    const temp = new StoreValue(scope);
-                    result = temp;
-                    extraArgs = [temp, new LiteralValue(scope, 0)];
-                    break;
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                idle: { args: [] },
+                stop: { args: [] },
+                move: { args: ["x", "y"] },
+                approach: { named: "options", args: ["x", "y", "radius"] },
+                boost: { args: ["enable"] },
+                pathfind: { args: [] },
+                target: { named: "options", args: ["x", "y", "shoot"] },
+                targetp: { named: "options", args: ["unit", "shoot"] },
+                itemDrop: { args: ["target", "amount"] },
+                itemTake: { args: ["target", "item", "amount"] },
+                payDrop: { args: [] },
+                payTake: { named: "options", args: ["takeUnits"] },
+                payEnter: { args: [] },
+                mine: { args: ["x", "y"] },
+                flag: { args: ["value"] },
+                build: {
+                    named: "options",
+                    args: ["x", "y", "block", "rotation", { key: "config", default: "" }],
+                },
+                getBlock: {
+                    args: ["x", "y"],
+                },
+                within: {
+                    named: "options",
+                    args: ["x", "y", "radius"],
+                },
+            },
+            handler(overload, ...args) {
+                let result = null;
+                let extraArgs = [];
+                switch (overload) {
+                    case "getBlock": {
+                        const outType = new StoreValue(scope);
+                        const outBuilding = new SenseableValue(scope);
+                        result = ObjectValue.fromArray(scope, [outType, outBuilding]);
+                        extraArgs = [outType, outBuilding, new LiteralValue(scope, 0)];
+                        break;
+                    }
+                    case "within": {
+                        const temp = new StoreValue(scope);
+                        result = temp;
+                        extraArgs = [temp, new LiteralValue(scope, 0)];
+                        break;
+                    }
                 }
-            }
-            return [
-                result,
-                [new InstructionBase("ucontrol", mode.data, ...args, ...extraArgs)],
-            ];
+                return [
+                    result,
+                    [new InstructionBase("ucontrol", overload, ...args, ...extraArgs)],
+                ];
+            },
         });
+        super(scope, data);
     }
 }
 
 class UnitRadar extends MacroFunction {
     constructor(scope) {
-        super(scope, (filter1, filter2, filter3, order, sort) => {
-            if (!(filter1 instanceof LiteralValue) ||
-                typeof filter1.data !== "string" ||
-                !(filter2 instanceof LiteralValue) ||
-                typeof filter2.data !== "string" ||
-                !(filter3 instanceof LiteralValue) ||
-                typeof filter3.data !== "string")
-                throw new CompilerError("The filters must be string literals");
-            if (!validRadarFilters.includes(filter1.data))
-                throw new CompilerError("Invalid value for filter1");
-            if (!validRadarFilters.includes(filter2.data))
-                throw new CompilerError("Invalid value for filter2");
-            if (!validRadarFilters.includes(filter3.data))
-                throw new CompilerError("Invalid value for filter3");
+        super(scope, options => {
+            assertIsObjectMacro(options, "The radar options");
+            const { filters, order, sort } = options.data;
+            assertIsArrayMacro(filters, "filters");
+            const { length } = filters.data;
+            if (!(length instanceof LiteralValue) || typeof length.data !== "number")
+                throw new CompilerError("The length of an array macro must be");
+            if (length.data !== 3)
+                throw new CompilerError("The filters array must have 3 items");
+            // data is not an array
+            const { 0: filter1, 1: filter2, 2: filter3 } = filters.data;
+            assertLiteralOneOf(filter1, validRadarFilters, "The first filter");
+            assertLiteralOneOf(filter2, validRadarFilters, "The second filter");
+            assertLiteralOneOf(filter3, validRadarFilters, "The third filter");
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
                 throw new CompilerError("The radar order must be a literal or a store");
-            if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
-                throw new CompilerError("The radar sort must be a string literal");
-            if (!validRadarSorts.includes(sort.data))
-                throw new CompilerError("Invalid sort value");
+            assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
             const outUnit = new SenseableValue(scope);
             return [
                 outUnit,
@@ -1865,7 +2294,6 @@ class UnitRadar extends MacroFunction {
     }
 }
 
-const validFinds = ["ore", "building", "spawn", "damaged"];
 const validBuildingGroups = [
     "core",
     "storage",
@@ -1877,56 +2305,297 @@ const validBuildingGroups = [
     "battery",
     "reactor",
 ];
-class UnitLocate extends MacroFunction {
+class UnitLocate extends ObjectValue {
     constructor(scope) {
-        super(scope, (find, ...args) => {
-            if (!(find instanceof LiteralValue && typeof find.data === "string"))
-                throw new CompilerError("The unitLocate find must be a string literal");
-            if (!validFinds.includes(find.data))
-                throw new CompilerError("Invalid find value");
-            if (args.some(value => !(value instanceof StoreValue || value instanceof LiteralValue)))
-                throw new CompilerError("The others arguments of unitLocate must be literals or stores");
-            const outFound = new StoreValue(scope);
-            const outX = new StoreValue(scope);
-            const outY = new StoreValue(scope);
-            const outBuilding = new SenseableValue(scope);
-            const outArgs = [outX, outY, outFound, outBuilding];
-            let inputArgs = [];
-            switch (find.data) {
-                case "ore": {
-                    const [ore] = args;
-                    inputArgs = [find.data, "core", "true", ore];
-                    break;
-                }
-                case "building": {
-                    const [group, enemy] = args;
-                    if (!(group instanceof LiteralValue && typeof group.data === "string")) {
-                        throw new CompilerError("The building group must be a string literal");
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                ore: {
+                    args: ["ore"],
+                },
+                building: { named: "options", args: ["group", "enemy"] },
+                spawn: {
+                    args: [],
+                },
+                damaged: {
+                    args: [],
+                },
+            },
+            handler(overload, ...args) {
+                const outFound = new StoreValue(scope);
+                const outX = new StoreValue(scope);
+                const outY = new StoreValue(scope);
+                const outBuilding = new SenseableValue(scope);
+                const outArgs = [outX, outY, outFound, outBuilding];
+                let inputArgs = [];
+                switch (overload) {
+                    case "ore": {
+                        const [ore] = args;
+                        inputArgs = [overload, "core", "true", ore];
+                        break;
+                    }
+                    case "building": {
+                        const [group, enemy] = args;
+                        if (!(group instanceof LiteralValue))
+                            throw new CompilerError("The building group must be a string literal");
+                        assertLiteralOneOf(group, validBuildingGroups, "The building group");
+                        inputArgs = [overload, group.data, enemy, "@copper"];
+                        break;
+                    }
+                    case "spawn":
+                    case "damaged": {
+                        inputArgs = [overload, "core", "true", "@copper"];
+                        break;
                     }
-                    if (!validBuildingGroups.includes(group.data))
-                        throw new CompilerError("Invalid building group");
-                    inputArgs = [find.data, group.data, enemy, "@copper"];
-                    break;
-                }
-                case "spawn":
-                case "damaged": {
-                    inputArgs = [find.data, "core", "true", "@copper"];
-                    break;
                 }
-            }
+                return [
+                    ObjectValue.fromArray(scope, [
+                        outFound,
+                        outX,
+                        outY,
+                        ...(overload !== "ore" ? [outBuilding] : []),
+                    ]),
+                    [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+const validEffects = [
+    "burning",
+    "freezing",
+    "unmoving",
+    "wet",
+    "melting",
+    "sapped",
+    "electrified",
+    "spore-slowed",
+    "tarred",
+    "overdrive",
+    "overclock",
+    "boss",
+    "shocked",
+    "blasted",
+];
+class ApplyStatus extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                apply: {
+                    args: ["status", "unit", { key: "duration", default: "10" }],
+                },
+                clear: { args: ["status", "unit"] },
+            },
+            handler(overload, effect, unit, duration) {
+                if (!(effect instanceof LiteralValue))
+                    throw new CompilerError("The status effect must be a string literal");
+                assertLiteralOneOf(effect, validEffects, "The status effect");
+                return [
+                    null,
+                    [
+                        new InstructionBase("status", String(overload !== "apply"), effect.data, unit, duration),
+                    ],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class SpawnWave extends MacroFunction {
+    constructor(scope) {
+        super(scope, (natural, x, y) => {
+            if (!(natural instanceof LiteralValue) ||
+                (natural.data !== 1 && natural.data !== 0))
+                throw new CompilerError("The 'natural' argument must be a boolean literal");
             return [
-                ObjectValue.fromArray(scope, [
-                    outFound,
-                    outX,
-                    outY,
-                    ...(find.data !== "ore" ? [outBuilding] : []),
-                ]),
-                [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
+                null,
+                [
+                    new InstructionBase("spawnwave", x ?? "10", y ?? "10", String(!!natural.data)),
+                ],
             ];
         });
     }
 }
 
+class SetRule extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                currentWaveTime: { args: ["seconds"] },
+                waveTimer: { args: ["enabled"] },
+                waves: { args: ["enabled"] },
+                wave: { args: ["number"] },
+                waveSpacing: { args: ["seconds"] },
+                waveSending: { args: ["enabled"] },
+                attackMode: { args: ["enabled"] },
+                enemyCoreBuildRadius: { args: ["radius"] },
+                dropZoneRadius: { args: ["radius"] },
+                unitCap: { args: ["cap"] },
+                mapArea: { named: "options", args: ["x", "y", "width", "height"] },
+                lighting: { args: ["enabled"] },
+                ambientLight: { args: ["rgbaData"] },
+                solarMultiplier: { args: ["multiplier"] },
+                buildSpeed: { args: ["team", "multiplier"] },
+                unitBuildSpeed: { args: ["team", "multiplier"] },
+                unitDamage: { args: ["team", "multiplier"] },
+                blockHealth: { args: ["team", "multiplier"] },
+                blockDamage: { args: ["team", "multiplier"] },
+                rtsMinWeight: { args: ["team", "value"] },
+                rtsMinSquad: { args: ["team", "value"] },
+            },
+            handler(overload, ...args) {
+                const params = ["10", "0", "0", "100", "100"];
+                switch (overload) {
+                    case "mapArea": {
+                        const [x, y, width, height] = args;
+                        params[1] = x;
+                        params[2] = y;
+                        params[3] = width;
+                        params[4] = height;
+                        break;
+                    }
+                    case "buildSpeed":
+                    case "unitBuildSpeed":
+                    case "unitDamage":
+                    case "blockHealth":
+                    case "blockDamage":
+                    case "rtsMinWeight":
+                    case "rtsMinSquad": {
+                        const [team, value] = args;
+                        params[1] = team;
+                        params[2] = value;
+                        break;
+                    }
+                    default:
+                        params[0] = args[0]; // the general value
+                }
+                return [null, [new InstructionBase("setrule", overload, ...params)]];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class FlushMessage extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                notify: { args: [] },
+                mission: { args: [] },
+                announce: { args: ["duration"] },
+                toast: { args: ["duration"] },
+            },
+            handler(overload, duration) {
+                return [null, [new InstructionBase("message", overload, duration)]];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class Cutscene extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                pan: { named: "options", args: ["x", "y", "speed"] },
+                zoom: { args: ["level"] },
+                stop: { args: [] },
+            },
+            handler(overload, ...args) {
+                const params = Object.assign(["100", "100", "0.06", "0"], args);
+                return [null, [new InstructionBase("cutscene", overload, ...params)]];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class Explosion extends MacroFunction {
+    constructor(scope) {
+        super(scope, options => {
+            assertIsObjectMacro(options, "The options");
+            const params = assertObjectFields(options, [
+                "team",
+                "x",
+                "y",
+                "radius",
+                "damage",
+                "air",
+                "ground",
+                "pierce",
+            ]);
+            return [null, [new InstructionBase("explosion", ...params)]];
+        });
+    }
+}
+
+class SetRate extends MacroFunction {
+    constructor(scope) {
+        super(scope, ipt => [null, [new InstructionBase("setrate", ipt)]]);
+    }
+}
+
+class Fetch extends ObjectValue {
+    constructor(scope) {
+        const data = createOverloadNamespace({
+            scope,
+            overloads: {
+                unit: { args: ["team", "index"] },
+                unitCount: { args: ["team"] },
+                player: { args: ["team", "index"] },
+                playerCount: { args: ["team"] },
+                core: { args: ["team", "index"] },
+                coreCount: { args: ["team"] },
+                build: { args: ["team", "index", "block"] },
+                buildCount: { args: ["team", "block"] },
+            },
+            handler(overload, team, ...rest) {
+                const output = new SenseableValue(scope);
+                const params = ["0", "@conveyor"];
+                if (overload === "buildCount") {
+                    params[1] = rest[0];
+                }
+                else {
+                    Object.assign(params, rest);
+                }
+                return [
+                    output,
+                    [new InstructionBase("fetch", overload, output, team, ...params)],
+                ];
+            },
+        });
+        super(scope, data);
+    }
+}
+
+class GetFlag extends MacroFunction {
+    constructor(scope) {
+        super(scope, flag => {
+            const result = new StoreValue(scope);
+            return [result, [new InstructionBase("getflag", result, flag)]];
+        });
+    }
+}
+
+class SetFlag extends MacroFunction {
+    constructor(scope) {
+        super(scope, (flag, value) => {
+            if (!flag)
+                throw new CompilerError("Missing flag argument");
+            if (!value)
+                throw new CompilerError("Missing flag value");
+            return [null, [new InstructionBase("setflag", flag, value)]];
+        });
+    }
+}
+
 class MemoryEntry extends ObjectValue {
     constructor(scope, mem, prop) {
         super(scope, {
@@ -1999,6 +2668,7 @@ class MemoryBuilder extends ObjectValue {
     }
 }
 
+const dynamicVars = ["time", "tick"];
 class NamespaceMacro extends ObjectValue {
     constructor(scope, { changeCasing = false } = {}) {
         super(scope, {
@@ -2008,9 +2678,14 @@ class NamespaceMacro extends ObjectValue {
                 const symbolName = this.changeCasing
                     ? camelToDashCase(prop.data)
                     : prop.data;
+                const mutability = dynamicVars.includes(symbolName)
+                    ? EMutability.readonly
+                    : EMutability.constant;
                 const owner = new ValueOwner({
                     scope,
-                    value: new StoreValue(scope),
+                    value: assign(new StoreValue(scope), {
+                        mutability,
+                    }),
                     name: `@${symbolName}`,
                 });
                 return [owner.value, []];
@@ -2035,39 +2710,44 @@ class VarsNamespace extends NamespaceMacro {
             }).value,
         });
     }
-}
-class UCommandsNamespace extends NamespaceMacro {
-    constructor(scope) {
-        super(scope);
-        this.data.$get = new MacroFunction(scope, prop => {
-            if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
-                throw new CompilerError("Cannot use dynamic properties on namespace macros");
-            const symbolName = prop.data[0].toUpperCase() + prop.data.slice(1);
-            const owner = new ValueOwner({
-                scope,
-                name: `@command${symbolName}`,
-                value: new StoreValue(scope),
-            });
-            return [owner.value, []];
-        });
-    }
 }
 
 class GetGlobal extends MacroFunction {
-    constructor(scope) {
+    constructor(scope, mutability) {
         super(scope, (name) => {
             if (!(name instanceof LiteralValue) || typeof name.data !== "string")
                 throw new CompilerError("The name parameter must be a string literal.");
             const owner = new ValueOwner({
                 scope,
                 name: name.data,
-                value: new SenseableValue(scope),
+                value: assign(new SenseableValue(scope), {
+                    mutability,
+                }),
             });
             return [owner.value, []];
         });
     }
 }
 
+class Asm extends MacroFunction {
+    constructor(scope) {
+        super(scope, (stringsArray, ...values) => {
+            if (!isTemplateObjectArray(stringsArray))
+                throw new CompilerError("Expected to receive a template strings array");
+            const args = [];
+            for (let i = 0; i < values.length; i++) {
+                const [item] = stringsArray.get(scope, new LiteralValue(scope, i));
+                args.push(item.data);
+                args.push(values[i]);
+            }
+            const { length } = stringsArray.data;
+            const [tail] = stringsArray.get(scope, new LiteralValue(scope, length.data - 1));
+            args.push(tail.data);
+            return [null, [new ZeroSpaceInstruction(...args)]];
+        });
+    }
+}
+
 /**
  * Adds all the compiler globals to `scope`
  */
@@ -2075,16 +2755,17 @@ function initScope(scope) {
     // namespaces
     scope.hardSet("ControlKind", new NamespaceMacro(scope));
     scope.hardSet("Vars", new VarsNamespace(scope));
+    scope.hardSet("Teams", new NamespaceMacro(scope));
     scope.hardSet("Items", new NamespaceMacro(scope, { changeCasing: true }));
     scope.hardSet("Liquids", new NamespaceMacro(scope));
-    scope.hardSet("Units", new NamespaceMacro(scope));
+    scope.hardSet("Units", new NamespaceMacro(scope, { changeCasing: true }));
     scope.hardSet("LAccess", new NamespaceMacro(scope));
-    scope.hardSet("UnitCommands", new UCommandsNamespace(scope));
     scope.hardSet("Blocks", new NamespaceMacro(scope, { changeCasing: true }));
     // helper methods
-    scope.hardSet("getBuilding", new GetGlobal(scope));
-    scope.hardSet("getVar", new GetGlobal(scope));
+    scope.hardSet("getBuilding", new GetGlobal(scope, EMutability.constant));
+    scope.hardSet("getVar", new GetGlobal(scope, EMutability.mutable));
     scope.hardSet("concat", new Concat(scope));
+    scope.hardSet("asm", new Asm(scope));
     scope.hardSet("Math", new MlogMath(scope));
     scope.hardSet("Memory", new MemoryBuilder(scope));
     // commands
@@ -2098,36 +2779,58 @@ function initScope(scope) {
     scope.hardSet("sensor", new Sensor(scope));
     scope.hardSet("wait", new Wait(scope));
     scope.hardSet("lookup", new Lookup(scope));
+    scope.hardSet("packColor", new PackColor(scope));
     scope.hardSet("endScript", new End(scope));
+    scope.hardSet("stopScript", new Stop(scope));
     scope.hardSet("unitBind", new UnitBind(scope));
     scope.hardSet("unitControl", new UnitControl(scope));
     scope.hardSet("unitRadar", new UnitRadar(scope));
     scope.hardSet("unitLocate", new UnitLocate(scope));
+    // world processor commands
+    scope.hardSet("getBlock", new GetBlock(scope));
+    scope.hardSet("setBlock", new SetBlock(scope));
+    scope.hardSet("spawnUnit", new SpawnUnit(scope));
+    scope.hardSet("applyStatus", new ApplyStatus(scope));
+    scope.hardSet("spawnWave", new SpawnWave(scope));
+    scope.hardSet("setRule", new SetRule(scope));
+    scope.hardSet("flushMessage", new FlushMessage(scope));
+    scope.hardSet("cutscene", new Cutscene(scope));
+    scope.hardSet("explosion", new Explosion(scope));
+    scope.hardSet("setRate", new SetRate(scope));
+    scope.hardSet("fetch", new Fetch(scope));
+    scope.hardSet("getFlag", new GetFlag(scope));
+    scope.hardSet("setFlag", new SetFlag(scope));
 }
 
 class Compiler {
-    constructor({ stackName, compactNames = false } = {}) {
+    constructor({ stackName, compactNames = false, sourcemap = false, } = {}) {
         this.handlers = handlers;
         this.usingStack = !!stackName;
         this.stackName = stackName;
         this.compactNames = compactNames;
+        this.sourcemap = sourcemap;
     }
     compile(script) {
         let output;
+        let sourcemaps;
         try {
             const program = this.parse(script);
             const scope = new Scope({});
             initScope(scope);
             const valueInst = this.handle(scope, program);
             valueInst[1].push(new EndInstruction(), ...scope.inst);
+            hideRedundantJumps(valueInst[1]);
             this.resolve(valueInst);
             output = this.serialize(valueInst) + "\n";
+            if (this.sourcemap) {
+                sourcemaps = this.mapSources(valueInst);
+            }
         }
         catch (error) {
-            const nodeStack = error instanceof CompilerError ? error.nodeStack : [];
-            return [null, error, nodeStack];
+            const err = error instanceof CompilerError ? error : CompilerError.from(error);
+            return [null, err];
         }
-        return [output, null, []];
+        return [output, null, sourcemaps];
     }
     resolve(valueInst) {
         let i = 0;
@@ -2147,40 +2850,92 @@ class Compiler {
             plugins: ["typescript"],
         });
     }
-    handle(scope, node) {
+    mapSources(valueInst) {
+        const result = [];
+        for (const inst of valueInst[1]) {
+            if (!inst.hidden)
+                result.push(inst.source);
+        }
+        return result;
+    }
+    handle(scope, node, handler = this.handlers[node.type]) {
         try {
-            const handler = this.handlers[node.type];
             if (!handler)
                 throw new CompilerError("Missing handler for " + node.type);
-            return handler(this, scope, node, null);
+            const result = handler(this, scope, node, null);
+            if (this.sourcemap)
+                return appendSourceLocations(result, node);
+            return result;
         }
         catch (error) {
             if (error instanceof CompilerError) {
-                error.nodeStack.push(node);
+                error.loc ??= node.loc;
             }
             throw error;
         }
     }
     handleEval(scope, node) {
         const [res, inst] = this.handle(scope, node);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (!res)
+            throw new CompilerError("Cannot eval null", node);
         const [evaluated, evaluatedInst] = res.eval(scope);
-        return [evaluated, [...inst, ...evaluatedInst]];
+        const result = [evaluated, [...inst, ...evaluatedInst]];
+        if (this.sourcemap)
+            return appendSourceLocations(result, node);
+        return result;
     }
     handleConsume(scope, node) {
         const [res, inst] = this.handle(scope, node);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (!res)
+            throw new CompilerError("Cannot consume null", node);
         const [evaluated, evaluatedInst] = res.consume(scope);
-        return [evaluated, [...inst, ...evaluatedInst]];
+        const result = [evaluated, [...inst, ...evaluatedInst]];
+        if (this.sourcemap)
+            return appendSourceLocations(result, node);
+        return result;
     }
-    handleMany(scope, nodes, handler = this.handle.bind(this)) {
+    /**
+     * 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(scope, nodes, handler) {
         const lines = [];
         for (const node of nodes) {
-            const [, nodeLines] = handler(scope, node);
+            const [, nodeLines] = this.handle(scope, node, handler && (() => handler(node)));
             lines.push(...nodeLines);
         }
         return [null, lines];
     }
+}
+/** Removes jump instructions that point right to the next line */
+function hideRedundantJumps(inst) {
+    for (let i = 0; i < inst.length; i++) {
+        const instruction = inst[i];
+        if (!(instruction instanceof JumpInstruction))
+            continue;
+        const { address } = instruction;
+        let searchIndex = i + 1;
+        let current = inst[searchIndex];
+        while (current.hidden) {
+            if (current instanceof AddressResolver &&
+                current.bonds.includes(address)) {
+                // only gets assigned if `current` is an adress resolver
+                // that resolves the jump adress
+                // and that is also right next to the jump,
+                // without any actual instructions in between
+                instruction.hidden = true;
+                break;
+            }
+            searchIndex++;
+            current = inst[searchIndex];
+        }
+    }
 }
 
 exports.Compiler = Compiler;