mlogjs 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -26,12 +26,58 @@ 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) {
@@ -125,11 +171,10 @@ const singleOperators = [...unaryOperators, ...updateOperators];
 const operators = [...leftRightOperators, ...singleOperators];
 
 class VoidValue {
-    constructor(scope) {
+    constructor() {
         this.owner = null;
         this.mutability = EMutability.mutable;
         this.macro = false;
-        this.scope = scope;
     }
     eval(_scope) {
         throw new CompilerError(`${this} cannot eval.`);
@@ -159,6 +204,8 @@ for (const key of operators) {
 
 class InstructionBase {
     constructor(...args) {
+        this.intent = EInstIntent.none;
+        this.alwaysRuns = true;
         this._hidden = false;
         this.args = args;
     }
@@ -235,6 +282,7 @@ var EJumpKind;
 class JumpInstruction extends InstructionBase {
     constructor(address, kind, left = null, right = null) {
         super("jump", address, kind, left, right);
+        this.address = address;
     }
 }
 
@@ -253,43 +301,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);
-    }
-}
-
-class ValueOwner {
-    /**
-     * Creates a new `ValueOwner`, if `value` is already owned,
-     * `this` will be aliased to `value`, else `this` will own `value`
-     */
-    constructor({ scope, constant = false, value, identifier, name, }) {
-        this.scope = scope;
-        this.constant = constant;
-        this.value = value;
-        this.identifier = identifier;
-        this.name = name ?? scope.makeTempName();
-        this.persistent = !!name;
-        this.owned = new Set();
-        if (!value.owner?.persistent)
-            this.own(value);
-    }
-    own(target) {
-        target.owner = this;
-        this.owned.add(target);
-    }
-    replace(target) {
-        this.value.owner = null;
-        this.owned.delete(this.value);
-        this.value = target;
-        this.own(target);
-    }
-    moveInto(owner) {
-        this.owned.forEach(value => owner.own(value));
-        this.owned.clear();
+        this.intent = EInstIntent.continue;
     }
 }
 
@@ -301,7 +319,7 @@ class BaseValue extends VoidValue {
             temp,
             [
                 ...inst,
-                new OperationInstruction("sub", temp, new LiteralValue(scope, 0), that),
+                new OperationInstruction("sub", temp, new LiteralValue(0), that),
             ],
         ];
     }
@@ -309,8 +327,19 @@ class BaseValue extends VoidValue {
         // TODO: should it return 0 + this ?
         return this.eval(scope);
     }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    "!"(scope) {
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
+        const falseLiteral = new LiteralValue(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)]];
     }
 }
 const operatorMap$1 = {
@@ -353,18 +382,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,23 +416,20 @@ for (const key of updateOperators) {
             inst.push(...tempInst);
         }
         const kind = key === "++" ? "+=" : "-=";
-        return [
-            ret,
-            [...inst, ...this[kind](scope, new LiteralValue(scope, 1))[1]],
-        ];
+        return [ret, [...inst, ...this[kind](scope, new LiteralValue(1))[1]]];
     };
 }
 
 const literalMethods = {
-    length: function (scope) {
+    length: function () {
         if (typeof this.data !== "string")
             throw new CompilerError("Length method only works on string literal values.");
-        return new LiteralValue(scope, this.data.length);
+        return new LiteralValue(this.data.length);
     },
 };
 class LiteralValue extends BaseValue {
-    constructor(scope, data) {
-        super(scope);
+    constructor(data) {
+        super();
         this.mutability = EMutability.constant;
         this.data = data;
     }
@@ -443,9 +457,10 @@ class LiteralValue extends BaseValue {
             return 1;
         return this.data;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "literal"), []];
+    typeof() {
+        return [new LiteralValue("literal"), []];
     }
+    ensureOwned() { }
 }
 const operatorMap = {
     "==": (a, b) => +(a == b),
@@ -477,18 +492,19 @@ 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(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) {
+    LiteralValue.prototype[key] = function () {
         const fn = unaryOperatorMap[key];
-        return [new LiteralValue(scope, fn(this.num)), []];
+        return [new LiteralValue(fn(this.data)), []];
     };
 }
 
@@ -543,8 +559,60 @@ const itemNames = [
 /**
  * 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");
+}
+
+class ValueOwner {
+    /**
+     * Creates a new `ValueOwner`, if `value` is already owned,
+     * `this` will be aliased to `value`, else `this` will own `value`
+     */
+    constructor({ scope, constant = false, value, identifier, name, }) {
+        this.scope = scope;
+        this.constant = constant;
+        this.value = value;
+        this.identifier = identifier;
+        this.name = name ?? scope.makeTempName();
+        this.persistent = !!name;
+        this.owned = new Set();
+        if (!value.owner?.persistent)
+            this.own(value);
+    }
+    own(target) {
+        target.owner = this;
+        this.owned.add(target);
+    }
+    replace(target) {
+        this.value.owner = null;
+        this.owned.delete(this.value);
+        this.value = target;
+        this.own(target);
+    }
+    moveInto(owner) {
+        this.owned.forEach(value => owner.own(value));
+        this.owned.clear();
+    }
 }
 
 /**
@@ -553,11 +621,12 @@ function assign(obj, props) {
  */
 class StoreValue extends BaseValue {
     constructor(scope) {
-        super(scope);
+        super();
+        this.scope = scope;
         this.mutability = EMutability.mutable;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "store"), []];
+    typeof() {
+        return [new LiteralValue("store"), []];
     }
     "="(scope, value) {
         if (this.mutability !== EMutability.mutable)
@@ -584,30 +653,34 @@ class StoreValue extends BaseValue {
         this.ensureOwned();
         return [this, []];
     }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
     toString() {
         return this.owner?.name ?? discardedName;
     }
 }
 
 class ObjectValue extends VoidValue {
-    constructor(scope, data = {}) {
-        super(scope);
+    constructor(data = {}) {
+        super();
         this.mutability = EMutability.constant;
         this.macro = true;
         this.data = data;
     }
-    static fromArray(scope, items) {
+    static fromArray(items, intialData) {
         const data = {
-            length: new LiteralValue(scope, items.length),
+            ...intialData,
+            length: new LiteralValue(items.length),
         };
         items.forEach((item, i) => {
             if (item)
                 data[i] = item;
         });
-        return new ObjectValue(scope, data);
+        return new ObjectValue(data);
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "object"), []];
+    typeof() {
+        return [new LiteralValue("object"), []];
     }
     get(scope, key) {
         // avoids naming collisions with keys like
@@ -644,9 +717,7 @@ class ObjectValue extends VoidValue {
             return super.call(scope, args);
         return $call.call(scope, args);
     }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
-    }
+    ensureOwned() { }
 }
 for (const op of operators) {
     ObjectValue.prototype[op] = function (...args) {
@@ -698,7 +769,9 @@ 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`);
@@ -713,8 +786,8 @@ class SenseableValue extends StoreValue {
  * each of them to their counterparts on the right hand value.
  */
 class DestructuringValue extends VoidValue {
-    constructor(scope, members) {
-        super(scope);
+    constructor(members) {
+        super();
         this.members = members;
         this.macro = true;
     }
@@ -823,7 +896,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
@@ -833,24 +906,24 @@ 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]);
+        throw new CompilerError("Constants must be initialized.", node);
     if (kind === "const" && init?.mutability === EMutability.constant) {
         const owner = new ValueOwner({
             scope,
@@ -867,9 +940,7 @@ 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")
@@ -888,39 +959,38 @@ 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
-            ? [new LiteralValue(scope, key.name), []]
+        const keyInst = key.type === "Identifier" && !prop.computed
+            ? [new LiteralValue(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), []];
+const Literal = (_c, scope, node) => [new LiteralValue(node.value), []];
 const NumericLiteral = Literal;
 const StringLiteral = Literal;
-const NullLiteral = (_c, scope) => [
-    new LiteralValue(scope, null),
+const NullLiteral = () => [
+    new LiteralValue(null),
     [],
 ];
-const BooleanLiteral = (_c, scope, node) => [new LiteralValue(scope, +node.value), []];
+const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
 
 const LRExpression = (c, scope, node) => {
     const [left, leftInst] = c.handleConsume(scope, node.left);
@@ -929,7 +999,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(null);
+    const endAdress = new LiteralValue(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
@@ -965,13 +1062,13 @@ const ConditionalExpression = (c, scope, node) => {
     result.ensureOwned();
     const consequent = c.handleEval(scope, node.consequent);
     const alternate = c.handleEval(scope, node.alternate);
-    const alternateStartAdress = new LiteralValue(scope, null);
-    const endExpressionAdress = new LiteralValue(scope, null);
+    const alternateStartAdress = new LiteralValue(null);
+    const endExpressionAdress = new LiteralValue(null);
     return [
         result,
         [
             ...testInst,
-            new JumpInstruction(alternateStartAdress, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
+            new JumpInstruction(alternateStartAdress, EJumpKind.Equal, test, new LiteralValue(0)),
             ...consequent[1],
             ...result["="](scope, consequent[0])[1],
             new JumpInstruction(endExpressionAdress, EJumpKind.Always),
@@ -991,12 +1088,12 @@ const ExpressionStatement = (c, scope, node) => {
     return c.handle(scope, node.expression);
 };
 const BreakStatement = (_, scope) => {
-    const addr = new LiteralValue(scope, null);
+    const addr = new LiteralValue(null);
     scope.break.bind(addr);
     return [null, [new BreakInstruction(addr)]];
 };
 const ContinueStatement = (_, scope) => {
-    const addr = new LiteralValue(scope, null);
+    const addr = new LiteralValue(null);
     scope.continue.bind(addr);
     return [null, [new ContinueInstruction(addr)]];
 };
@@ -1018,19 +1115,81 @@ const IfStatement = (c, scope, node) => {
             inst.push(...c.handle(scope, node.alternate)[1]);
         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));
-    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));
+    const endIfAddr = new LiteralValue(null);
+    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(0)), ...withAlwaysRuns(c.handle(scope, node.consequent), false)[1], new AddressResolver(endIfAddr));
+    const endElseAddr = new LiteralValue(null);
+    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(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(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);
-    const startLoopAddr = new LiteralValue(scope, null);
-    const endLoopAddr = new LiteralValue(scope, null);
+    const startLoopAddr = new LiteralValue(null);
+    const endLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
     const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
     if (test instanceof LiteralValue) {
@@ -1039,13 +1198,13 @@ 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(0)), ...withAlwaysRuns(c.handle(scope, node.body), false)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
     return [null, lines];
 };
 const DoWhileStatement = (c, scope, node) => {
     const lines = [];
     const [test, testLines] = c.handleConsume(scope, node.test);
-    const startLoopAddr = new LiteralValue(scope, null);
+    const startLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
     const [, bodyLines] = c.handle(scope, node.body);
     if (test instanceof LiteralValue) {
@@ -1061,7 +1220,7 @@ const DoWhileStatement = (c, scope, node) => {
             ],
         ];
     }
-    lines.push(startLoopLine, ...bodyLines, ...testLines, new JumpInstruction(startLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 1)));
+    lines.push(startLoopLine, ...bodyLines, ...testLines, new JumpInstruction(startLoopAddr, EJumpKind.Equal, test, new LiteralValue(1)));
     return [null, lines];
 };
 
@@ -1070,10 +1229,10 @@ const ForStatement = (c, scope, node) => {
     const initInst = node.init ? c.handle(scope, node.init)[1] : [];
     const [test, testLines] = node.test
         ? c.handleConsume(scope, node.test)
-        : [new LiteralValue(scope, 1), []];
+        : [new LiteralValue(1), []];
     const updateLines = node.update ? c.handle(scope, node.update)[1] : [];
-    const startLoopAddr = new LiteralValue(scope, null);
-    const endLoopAddr = new LiteralValue(scope, null);
+    const startLoopAddr = new LiteralValue(null);
+    const endLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
     const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
     return [
@@ -1082,8 +1241,8 @@ const ForStatement = (c, scope, node) => {
             ...initInst,
             startLoopLine,
             ...testLines,
-            new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
-            ...c.handle(scope, node.body)[1],
+            new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)),
+            ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
             ...updateLines,
             new JumpInstruction(startLoopAddr, EJumpKind.Always),
             endLoopLine,
@@ -1092,20 +1251,20 @@ const ForStatement = (c, scope, node) => {
 };
 
 class FunctionValue extends VoidValue {
-    constructor({ scope, params, body, c, node, }) {
-        super(scope);
+    constructor({ scope, params, body, c, }) {
+        super();
         this.mutability = EMutability.constant;
         this.macro = true;
         this.paramOwners = [];
         this.bundled = false;
         this.initialized = false;
+        this.scope = scope;
         this.body = body;
         this.c = c;
-        this.node = node;
         this.params = params;
     }
-    typeof(scope) {
-        return [new LiteralValue(scope, "function"), []];
+    typeof() {
+        return [new LiteralValue("function"), []];
     }
     initScope(name) {
         this.childScope = this.scope.createFunction(name);
@@ -1114,7 +1273,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,
             });
@@ -1131,7 +1292,7 @@ class FunctionValue extends VoidValue {
         this.initialized = true;
         const { name } = this.owner;
         this.initScope(name);
-        this.addr = new LiteralValue(this.childScope, null);
+        this.addr = new LiteralValue(null);
         this.temp = new ValueOwner({
             scope: this.childScope,
             name: `${internalPrefix}f${name}`,
@@ -1149,18 +1310,23 @@ 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)
             this.childScope.inst.push(...this.inst);
         this.bundled = true;
-        const callAddressLiteral = new LiteralValue(scope, null);
+        const callAddressLiteral = new LiteralValue(null);
         const inst = this.paramOwners
             .map(({ value: param }, i) => param["="](scope, args[i])[1])
             .reduce((s, c) => s.concat(c), [])
@@ -1169,7 +1335,12 @@ 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
@@ -1179,7 +1350,6 @@ class FunctionValue extends VoidValue {
                 mutability: EMutability.mutable,
             }),
         });
-        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
@@ -1194,16 +1364,13 @@ class FunctionValue extends VoidValue {
                 name: owner.name,
             }));
         });
+        this.inlineEnd = new LiteralValue(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];
@@ -1248,11 +1415,14 @@ 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({
-            node,
             scope,
             params: params,
             body,
@@ -1294,16 +1464,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(template.quasis.map(quasi => new LiteralValue(quasi.value.cooked ?? "")), {
+        raw: ObjectValue.fromArray(template.quasis.map(quasi => new LiteralValue(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;
@@ -1314,20 +1500,21 @@ 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];
+    return [new ObjectValue(data), inst];
 };
 const ArrayExpression = (c, scope, node) => {
     const items = [];
@@ -1339,13 +1526,13 @@ const ArrayExpression = (c, scope, node) => {
         items.push(value);
         inst.push(...valueInst);
     });
-    return [ObjectValue.fromArray(scope, items), inst];
+    return [ObjectValue.fromArray(items), inst];
 };
 const MemberExpression = (c, scope, node) => {
     const [obj, objInst] = c.handleConsume(scope, node.object);
     const [prop, propInst] = node.computed
         ? c.handleConsume(scope, node.property)
-        : [new LiteralValue(scope, node.property.name), []];
+        : [new LiteralValue(node.property.name), []];
     const [got, gotInst] = obj.get(scope, prop);
     return [got, [...objInst, ...propInst, ...gotInst]];
 };
@@ -1358,13 +1545,11 @@ 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]);
+        members.set(new LiteralValue(i), valueInst[0]);
     }
-    return [new DestructuringValue(scope, members), inst];
+    return [new DestructuringValue(members), inst];
 };
 const ObjectPattern = (c, scope, node) => {
     const inst = [];
@@ -1376,31 +1561,20 @@ const ObjectPattern = (c, scope, node) => {
             continue;
         const { key } = prop;
         const keyInst = !prop.computed && key.type === "Identifier"
-            ? [new LiteralValue(scope, key.name), []]
+            ? [new LiteralValue(key.name), []]
             : c.handleConsume(scope, prop.key);
         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];
+    return [new DestructuringValue(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) => {
@@ -1433,14 +1607,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)];
+            : [new LiteralValue(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;
@@ -1453,7 +1625,7 @@ const TSEnumDeclaration = (c, scope, node) => {
     }
     scope.set(new ValueOwner({
         scope,
-        value: new ObjectValue(scope, data),
+        value: new ObjectValue(data),
         constant: true,
         identifier: node.id.name,
         name: nodeName(node, !c.compactNames && node.id.name),
@@ -1486,6 +1658,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     ContinueStatement: ContinueStatement,
     ReturnStatement: ReturnStatement,
     IfStatement: IfStatement,
+    SwitchStatement: SwitchStatement,
     WhileStatement: WhileStatement,
     DoWhileStatement: DoWhileStatement,
     ForStatement: ForStatement,
@@ -1495,6 +1668,7 @@ var handlers = /*#__PURE__*/Object.freeze({
     ObjectMethod: ObjectMethod,
     CallExpression: CallExpression,
     NewExpression: NewExpression,
+    TaggedTemplateExpression: TaggedTemplateExpression,
     ObjectExpression: ObjectExpression,
     ArrayExpression: ArrayExpression,
     MemberExpression: MemberExpression,
@@ -1512,14 +1686,14 @@ var handlers = /*#__PURE__*/Object.freeze({
 });
 
 class MacroFunction extends VoidValue {
-    constructor(scope, fn) {
-        super(scope);
+    constructor(fn) {
+        super();
         this.macro = true;
         this.constant = true;
         this.fn = fn;
     }
     call(scope, args) {
-        return this.fn.apply(this, args);
+        return this.fn.apply(this, [scope, ...args]);
     }
     eval(_scope) {
         return [this, []];
@@ -1550,16 +1724,16 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
-function createMacroMathOperations(scope) {
+function createMacroMathOperations() {
     const macroMathOperations = {};
     for (const key in mathOperations) {
         const fn = mathOperations[key];
-        macroMathOperations[key] = new MacroFunction(scope, (a, b) => {
+        macroMathOperations[key] = new MacroFunction((scope, a, b) => {
             if (b) {
                 if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
                     if (typeof a.data !== "number" || typeof b.data !== "number")
                         throw new CompilerError("Cannot do math operation with non-numerical literals.");
-                    return [new LiteralValue(scope, fn(a.num, b.num)), []];
+                    return [new LiteralValue(fn(a.num, b.num)), []];
                 }
                 const temp = new StoreValue(scope);
                 return [temp, [new OperationInstruction(key, temp, a, b)]];
@@ -1567,7 +1741,7 @@ function createMacroMathOperations(scope) {
             if (fn && a instanceof LiteralValue) {
                 if (typeof a.data !== "number")
                     throw new CompilerError("Cannot do math operation with non-numerical literal.");
-                return [new LiteralValue(scope, fn(a.num)), []];
+                return [new LiteralValue(fn(a.num)), []];
             }
             const temp = new StoreValue(scope);
             return [temp, [new OperationInstruction(key, temp, a, b)]];
@@ -1576,74 +1750,190 @@ function createMacroMathOperations(scope) {
     return macroMathOperations;
 }
 class MlogMath extends ObjectValue {
-    constructor(scope) {
-        super(scope, createMacroMathOperations(scope));
+    constructor() {
+        super(createMacroMathOperations());
     }
 }
 // op angle result a b
 // op len result a b
 
 class Concat extends MacroFunction {
-    constructor(scope) {
-        super(scope, (...values) => {
+    constructor() {
+        super((scope, ...values) => {
             for (const value of values)
                 if (!(value instanceof LiteralValue))
                     throw new CompilerError("Concat arguments must all be literal values.");
             return [
-                new LiteralValue(scope, values.map(v => v.data).join("")),
+                new LiteralValue(values.map(v => v.data).join("")),
                 [],
             ];
         });
     }
 }
 
-class Draw extends MacroFunction {
-    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;
-                    })),
-                ],
-            ];
+/** 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({ 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(scope, 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(scope, key, ...handlerParams);
         });
     }
+    return result;
+}
+
+class Draw extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            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(scope, overload, ...args) {
+                return [null, [new InstructionBase("draw", overload, ...args)]];
+            },
+        });
+        super(data);
+    }
 }
 
 class Print extends MacroFunction {
-    constructor(scope) {
-        super(scope, (...values) => {
+    constructor() {
+        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(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(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) => {
+    constructor() {
+        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)]];
@@ -1651,9 +1941,12 @@ class PrintFlush extends MacroFunction {
     }
 }
 
+const defaultTargetName = "display1";
 class DrawFlush extends MacroFunction {
-    constructor(scope) {
-        super(scope, (target) => {
+    constructor() {
+        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)]];
@@ -1661,9 +1954,32 @@ class DrawFlush extends MacroFunction {
     }
 }
 
+class GetBlock extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                floor: { args: ["x", "y"] },
+                ore: { args: ["x", "y"] },
+                block: { args: ["x", "y"] },
+                building: { args: ["x", "y"] },
+            },
+            handler(scope, overload, x, y) {
+                const output = overload === "building"
+                    ? new SenseableValue(scope)
+                    : new StoreValue(scope);
+                return [
+                    output,
+                    [new InstructionBase("getblock", overload, output, x, y)],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
 class GetLink extends MacroFunction {
-    constructor(scope) {
-        super(scope, (index) => {
+    constructor() {
+        super((scope, index) => {
             if (!(index instanceof StoreValue) &&
                 (!(index instanceof LiteralValue) || typeof index.data !== "number"))
                 throw new CompilerError("The getlink index must be a number literal or a store");
@@ -1673,21 +1989,26 @@ class GetLink extends MacroFunction {
     }
 }
 
-const validKinds$1 = ["enabled", "shoot", "shootp", "config", "color"];
-class Control extends MacroFunction {
-    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)],
-            ];
-        });
+class Control extends ObjectValue {
+    constructor() {
+        super(createOverloadNamespace({
+            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(scope, overload, ...args) {
+                return [null, [new InstructionBase("control", overload, ...args)]];
+            },
+        }));
     }
 }
 
@@ -1709,29 +2030,26 @@ const validRadarSorts = [
     "maxHealth",
 ];
 class Radar extends MacroFunction {
-    constructor(scope) {
-        super(scope, (building, filter1, filter2, filter3, order, sort) => {
+    constructor() {
+        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,
@@ -1744,21 +2062,23 @@ class Radar extends MacroFunction {
 }
 
 class Sensor extends MacroFunction {
-    constructor(scope) {
-        super(scope, (property, target) => {
+    constructor() {
+        super((scope, property, target) => {
             if (!(property instanceof StoreValue))
                 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)]];
         });
     }
 }
 
 class Wait extends MacroFunction {
-    constructor(scope) {
-        super(scope, seconds => {
+    constructor() {
+        super((scope, seconds) => {
             if (!(seconds instanceof StoreValue) &&
                 !(seconds instanceof LiteralValue && typeof seconds.data === "number"))
                 throw new CompilerError("The wait seconds must be either a number literal or a store");
@@ -1767,32 +2087,102 @@ class Wait extends MacroFunction {
     }
 }
 
-const validKinds = ["block", "unit", "item", "liquid"];
-class Lookup extends MacroFunction {
-    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)]];
+class Lookup extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                block: { args: ["index"] },
+                unit: { args: ["index"] },
+                item: { args: ["index"] },
+                liquid: { args: ["index"] },
+            },
+            handler(scope, overload, index) {
+                const output = new StoreValue(scope);
+                return [
+                    output,
+                    [new InstructionBase("lookup", overload, output, index)],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
+class PackColor extends MacroFunction {
+    constructor() {
+        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)]];
         });
     }
 }
 
 class End extends MacroFunction {
-    constructor(scope) {
-        super(scope, () => [null, [new EndInstruction()]]);
+    constructor() {
+        super(() => [null, [new EndInstruction()]]);
+    }
+}
+
+class SetBlock extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                floor: { args: ["x", "y", "to"] },
+                ore: { args: ["x", "y", "to"] },
+                block: {
+                    named: "options",
+                    args: ["x", "y", "to", "team", { key: "rotation", default: "0" }],
+                },
+            },
+            handler(scope, overload, x, y, to, team, rotation) {
+                return [
+                    null,
+                    [
+                        new InstructionBase("setblock", overload, to, x, y, team ?? "@delerict", rotation ?? "0"),
+                    ],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
+class SpawnUnit extends MacroFunction {
+    constructor() {
+        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() {
+        super(() => [null, [new InstructionBase("stop")]]);
     }
 }
 
 class UnitBind extends MacroFunction {
-    constructor(scope) {
-        super(scope, type => {
+    constructor() {
+        super((scope, type) => {
             if (!(type instanceof StoreValue))
                 throw new CompilerError("The unitBind type must be a store");
             return [null, [new InstructionBase("ubind", type)]];
@@ -1800,82 +2190,84 @@ 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 {
-    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;
+class UnitControl extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            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(scope, overload, ...args) {
+                let result = null;
+                let extraArgs = [];
+                switch (overload) {
+                    case "getBlock": {
+                        const outType = new StoreValue(scope);
+                        const outBuilding = new SenseableValue(scope);
+                        result = ObjectValue.fromArray([outType, outBuilding]);
+                        extraArgs = [outType, outBuilding, new LiteralValue(0)];
+                        break;
+                    }
+                    case "within": {
+                        const temp = new StoreValue(scope);
+                        result = temp;
+                        extraArgs = [temp, new LiteralValue(0)];
+                        break;
+                    }
                 }
-            }
-            return [
-                result,
-                [new InstructionBase("ucontrol", mode.data, ...args, ...extraArgs)],
-            ];
+                return [
+                    result,
+                    [new InstructionBase("ucontrol", overload, ...args, ...extraArgs)],
+                ];
+            },
         });
+        super(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");
+    constructor() {
+        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,
@@ -1888,7 +2280,6 @@ class UnitRadar extends MacroFunction {
     }
 }
 
-const validFinds = ["ore", "building", "spawn", "damaged"];
 const validBuildingGroups = [
     "core",
     "storage",
@@ -1900,86 +2291,333 @@ const validBuildingGroups = [
     "battery",
     "reactor",
 ];
-class UnitLocate extends MacroFunction {
-    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");
+class UnitLocate extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                ore: {
+                    args: ["ore"],
+                },
+                building: { named: "options", args: ["group", "enemy"] },
+                spawn: {
+                    args: [],
+                },
+                damaged: {
+                    args: [],
+                },
+            },
+            handler(scope, 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,
-                    ...(find.data !== "ore" ? [outBuilding] : []),
-                ]),
-                [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
-            ];
+                return [
+                    ObjectValue.fromArray([
+                        outFound,
+                        outX,
+                        outY,
+                        ...(overload !== "ore" ? [outBuilding] : []),
+                    ]),
+                    [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
+                ];
+            },
         });
+        super(data);
     }
 }
 
-class MemoryEntry extends ObjectValue {
-    constructor(scope, mem, prop) {
-        super(scope, {
-            $eval: new MacroFunction(scope, () => {
-                if (this.store)
-                    return [this.store, []];
-                const temp = new StoreValue(scope);
-                return [temp, [new InstructionBase("read", temp, mem.cell, prop)]];
-            }),
-            $consume: new MacroFunction(scope, () => {
-                if (this.store)
-                    return [this.store, []];
-                this.ensureOwned();
-                this.store = new StoreValue(scope);
-                this.owner.own(this.store);
+const validEffects = [
+    "burning",
+    "freezing",
+    "unmoving",
+    "wet",
+    "melting",
+    "sapped",
+    "electrified",
+    "spore-slowed",
+    "tarred",
+    "overdrive",
+    "overclock",
+    "boss",
+    "shocked",
+    "blasted",
+];
+class ApplyStatus extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                apply: {
+                    args: ["status", "unit", { key: "duration", default: "10" }],
+                },
+                clear: { args: ["status", "unit"] },
+            },
+            handler(scope, 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 [
-                    this.store,
-                    [new InstructionBase("read", this.store, mem.cell, prop)],
+                    null,
+                    [
+                        new InstructionBase("status", String(overload !== "apply"), effect.data, unit, duration),
+                    ],
                 ];
-            }),
-            "$=": new MacroFunction(scope, value => {
-                const [data, dataInst] = value.consume(scope);
+            },
+        });
+        super(data);
+    }
+}
+
+class SpawnWave extends MacroFunction {
+    constructor() {
+        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 [
+                null,
+                [
+                    new InstructionBase("spawnwave", x ?? "10", y ?? "10", String(!!natural.data)),
+                ],
+            ];
+        });
+    }
+}
+
+class SetRule extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            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(scope, 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(data);
+    }
+}
+
+class FlushMessage extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                notify: { args: [] },
+                mission: { args: [] },
+                announce: { args: ["duration"] },
+                toast: { args: ["duration"] },
+            },
+            handler(scope, overload, duration) {
+                return [null, [new InstructionBase("message", overload, duration)]];
+            },
+        });
+        super(data);
+    }
+}
+
+class Cutscene extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                pan: { named: "options", args: ["x", "y", "speed"] },
+                zoom: { args: ["level"] },
+                stop: { args: [] },
+            },
+            handler(scope, overload, ...args) {
+                const params = Object.assign(["100", "100", "0.06", "0"], args);
+                return [null, [new InstructionBase("cutscene", overload, ...params)]];
+            },
+        });
+        super(data);
+    }
+}
+
+class Explosion extends MacroFunction {
+    constructor() {
+        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() {
+        super((scope, ipt) => [null, [new InstructionBase("setrate", ipt)]]);
+    }
+}
+
+class Fetch extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            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(scope, 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 [
-                    data,
-                    [...dataInst, new InstructionBase("write", data, mem.cell, prop)],
+                    output,
+                    [new InstructionBase("fetch", overload, output, team, ...params)],
                 ];
-            }),
+            },
         });
+        super(data);
+    }
+}
+
+class GetFlag extends MacroFunction {
+    constructor() {
+        super((scope, flag) => {
+            const result = new StoreValue(scope);
+            return [result, [new InstructionBase("getflag", result, flag)]];
+        });
+    }
+}
+
+class SetFlag extends MacroFunction {
+    constructor() {
+        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 BaseValue {
+    constructor(scope, mem, prop) {
+        super();
+        this.scope = scope;
+        this.mem = mem;
+        this.prop = prop;
+        this.macro = true;
         this.store = null;
     }
+    eval(scope) {
+        if (this.store)
+            return [this.store, []];
+        const temp = new StoreValue(scope);
+        return [
+            temp,
+            [new InstructionBase("read", temp, this.mem.cell, this.prop)],
+        ];
+    }
+    consume(scope) {
+        if (this.store)
+            return [this.store, []];
+        this.ensureOwned();
+        this.store = new StoreValue(scope);
+        this.owner.own(this.store);
+        return [
+            this.store,
+            [new InstructionBase("read", this.store, this.mem.cell, this.prop)],
+        ];
+    }
+    "="(scope, value) {
+        const [data, dataInst] = value.consume(scope);
+        return [
+            data,
+            [
+                ...dataInst,
+                new InstructionBase("write", data, this.mem.cell, this.prop),
+            ],
+        ];
+    }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
 }
 for (const operator of operators) {
     if (operator === "=")
@@ -1990,9 +2628,9 @@ for (const operator of operators) {
     };
 }
 class MemoryMacro extends ObjectValue {
-    constructor(scope, cell, size) {
-        super(scope, {
-            $get: new MacroFunction(scope, (prop) => {
+    constructor(cell, size) {
+        super({
+            $get: new MacroFunction((scope, prop) => {
                 if (prop instanceof LiteralValue && typeof prop.data !== "number")
                     throw new CompilerError(`Invalid memory object property: "${prop.data}"`);
                 const obj = new MemoryEntry(scope, this, prop);
@@ -2002,21 +2640,20 @@ class MemoryMacro extends ObjectValue {
             size,
         });
         this.cell = cell;
-        this.name = cell.toString();
     }
     toString() {
-        return this.name;
+        return this.cell.toString();
     }
 }
 class MemoryBuilder extends ObjectValue {
-    constructor(scope) {
-        super(scope, {
-            $call: new MacroFunction(scope, (cell, size = new LiteralValue(scope, 64)) => {
+    constructor() {
+        super({
+            $call: new MacroFunction((scope, cell, size = new LiteralValue(64)) => {
                 if (!(cell instanceof SenseableValue))
                     throw new CompilerError("Memory cell must be a senseable value.");
                 if (!(size instanceof LiteralValue && typeof size.data === "number"))
                     throw new CompilerError("The memory size must be a number literal.");
-                return [new MemoryMacro(scope, cell, size), []];
+                return [new MemoryMacro(cell, size), []];
             }),
         });
     }
@@ -2024,9 +2661,9 @@ class MemoryBuilder extends ObjectValue {
 
 const dynamicVars = ["time", "tick"];
 class NamespaceMacro extends ObjectValue {
-    constructor(scope, { changeCasing = false } = {}) {
-        super(scope, {
-            $get: new MacroFunction(scope, prop => {
+    constructor({ changeCasing = false } = {}) {
+        super({
+            $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 = this.changeCasing
@@ -2050,7 +2687,7 @@ class NamespaceMacro extends ObjectValue {
 }
 class VarsNamespace extends NamespaceMacro {
     constructor(scope) {
-        super(scope);
+        super();
         Object.assign(this.data, {
             unit: new ValueOwner({
                 scope,
@@ -2064,29 +2701,11 @@ 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: assign(new StoreValue(scope), {
-                    mutability: EMutability.constant,
-                }),
-            });
-            return [owner.value, []];
-        });
-    }
 }
 
 class GetGlobal extends MacroFunction {
-    constructor(scope, mutability) {
-        super(scope, (name) => {
+    constructor(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({
@@ -2101,66 +2720,163 @@ class GetGlobal extends MacroFunction {
     }
 }
 
+class Asm extends MacroFunction {
+    constructor() {
+        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(i));
+                args.push(item.data);
+                args.push(values[i]);
+            }
+            const { length } = stringsArray.data;
+            const [tail] = stringsArray.get(scope, new LiteralValue(length.data - 1));
+            args.push(tail.data);
+            return [null, formatInstructions(args)];
+        });
+    }
+}
+/** Splits multiline asm calls and formats each line. */
+function formatInstructions(args) {
+    const instructions = [];
+    let buffer = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg !== "string" || !arg.includes("\n")) {
+            buffer.push(arg);
+            continue;
+        }
+        const segments = arg.split("\n");
+        const params = [...buffer, segments[0]];
+        if (validateInstructionArgs(params)) {
+            instructions.push(new ZeroSpaceInstruction(...params));
+            buffer = [];
+        }
+        // iterates over all segments except the first and last
+        // the first segment was already processed above
+        // the last segment will be added to the buffer because there might
+        // be an interpolation after it
+        // and putting it in the buffer makes sure it has a proper output format
+        for (let i = 1; i < segments.length - 1; i++) {
+            const trimmed = segments[i].trim();
+            if (trimmed.length == 0)
+                continue;
+            instructions.push(new ZeroSpaceInstruction(trimmed));
+        }
+        if (segments.length > 1) {
+            buffer.push(segments[segments.length - 1]);
+        }
+    }
+    if (buffer.length > 0 && validateInstructionArgs(buffer)) {
+        instructions.push(new ZeroSpaceInstruction(...buffer));
+    }
+    return instructions;
+}
+/** Determines if an asm line should be generated and trims it at the start and end */
+function validateInstructionArgs(args) {
+    if (args.length === 0)
+        return false;
+    if (args.length === 1) {
+        const item = args[0];
+        if (typeof item !== "string")
+            return true;
+        args[0] = item.trim();
+        return args[0].length !== 0;
+    }
+    const first = args[0];
+    const last = args[args.length - 1];
+    if (typeof first === "string")
+        args[0] = first.trimStart();
+    if (typeof last === "string")
+        args[args.length - 1] = last.trimEnd();
+    return true;
+}
+
 /**
  * Adds all the compiler globals to `scope`
  */
 function initScope(scope) {
     // namespaces
-    scope.hardSet("ControlKind", new NamespaceMacro(scope));
+    scope.hardSet("ControlKind", new NamespaceMacro());
     scope.hardSet("Vars", new VarsNamespace(scope));
-    scope.hardSet("Items", new NamespaceMacro(scope, { changeCasing: true }));
-    scope.hardSet("Liquids", new NamespaceMacro(scope));
-    scope.hardSet("Units", new NamespaceMacro(scope));
-    scope.hardSet("LAccess", new NamespaceMacro(scope));
-    scope.hardSet("UnitCommands", new UCommandsNamespace(scope));
-    scope.hardSet("Blocks", new NamespaceMacro(scope, { changeCasing: true }));
+    scope.hardSet("Teams", new NamespaceMacro());
+    scope.hardSet("Items", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("Liquids", new NamespaceMacro());
+    scope.hardSet("Units", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("LAccess", new NamespaceMacro());
+    scope.hardSet("Blocks", new NamespaceMacro({ changeCasing: true }));
     // helper methods
-    scope.hardSet("getBuilding", new GetGlobal(scope, EMutability.constant));
-    scope.hardSet("getVar", new GetGlobal(scope, EMutability.mutable));
-    scope.hardSet("concat", new Concat(scope));
-    scope.hardSet("Math", new MlogMath(scope));
-    scope.hardSet("Memory", new MemoryBuilder(scope));
+    scope.hardSet("getBuilding", new GetGlobal(EMutability.constant));
+    scope.hardSet("getVar", new GetGlobal(EMutability.mutable));
+    scope.hardSet("concat", new Concat());
+    scope.hardSet("asm", new Asm());
+    scope.hardSet("Math", new MlogMath());
+    scope.hardSet("Memory", new MemoryBuilder());
     // commands
-    scope.hardSet("draw", new Draw(scope));
-    scope.hardSet("print", new Print(scope));
-    scope.hardSet("printFlush", new PrintFlush(scope));
-    scope.hardSet("drawFlush", new DrawFlush(scope));
-    scope.hardSet("getLink", new GetLink(scope));
-    scope.hardSet("control", new Control(scope));
-    scope.hardSet("radar", new Radar(scope));
-    scope.hardSet("sensor", new Sensor(scope));
-    scope.hardSet("wait", new Wait(scope));
-    scope.hardSet("lookup", new Lookup(scope));
-    scope.hardSet("endScript", new End(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));
+    scope.hardSet("draw", new Draw());
+    scope.hardSet("print", new Print());
+    scope.hardSet("printFlush", new PrintFlush());
+    scope.hardSet("drawFlush", new DrawFlush());
+    scope.hardSet("getLink", new GetLink());
+    scope.hardSet("control", new Control());
+    scope.hardSet("radar", new Radar());
+    scope.hardSet("sensor", new Sensor());
+    scope.hardSet("wait", new Wait());
+    scope.hardSet("lookup", new Lookup());
+    scope.hardSet("packColor", new PackColor());
+    scope.hardSet("endScript", new End());
+    scope.hardSet("stopScript", new Stop());
+    scope.hardSet("unitBind", new UnitBind());
+    scope.hardSet("unitControl", new UnitControl());
+    scope.hardSet("unitRadar", new UnitRadar());
+    scope.hardSet("unitLocate", new UnitLocate());
+    // world processor commands
+    scope.hardSet("getBlock", new GetBlock());
+    scope.hardSet("setBlock", new SetBlock());
+    scope.hardSet("spawnUnit", new SpawnUnit());
+    scope.hardSet("applyStatus", new ApplyStatus());
+    scope.hardSet("spawnWave", new SpawnWave());
+    scope.hardSet("setRule", new SetRule());
+    scope.hardSet("flushMessage", new FlushMessage());
+    scope.hardSet("cutscene", new Cutscene());
+    scope.hardSet("explosion", new Explosion());
+    scope.hardSet("setRate", new SetRate());
+    scope.hardSet("fetch", new Fetch());
+    scope.hardSet("getFlag", new GetFlag());
+    scope.hardSet("setFlag", new SetFlag());
 }
 
 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;
@@ -2180,40 +2896,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;