mlogjs 0.5.2 → 0.6.0

package/dist/index.mjs

@@ -1,4267 +1,3 @@
-import { parse } from '@babel/parser';
-import * as es from '@babel/types';
-
-class CompilerError extends Error {
-    constructor(message, source) {
-        super(message);
-        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";
-    /**
-     * This is used by the `end` and `stop` instructions.
-     * Means that the processor will restart or shutdown.
-     */
-    EInstIntent[EInstIntent["exit"] = 4] = "exit";
-})(EInstIntent || (EInstIntent = {}));
-/** Defines the possible types of mutability of a value */
-var EMutability;
-(function (EMutability) {
-    /**
-     * The value can be changed by the user's code,
-     * by the mlog runtime, or us
-     */
-    EMutability[EMutability["mutable"] = 0] = "mutable";
-    /**
-     * The value cannot be directly assigned,
-     * but it's still not safe from mutations coming from the runtime.
-     */
-    EMutability[EMutability["readonly"] = 1] = "readonly";
-    /** Constant values, won't change during execution */
-    EMutability[EMutability["constant"] = 2] = "constant";
-    /** An immutable value that hasn't been initialized yet */
-    EMutability[EMutability["init"] = 3] = "init";
-})(EMutability || (EMutability = {}));
-
-const arithmeticBinaryOperators = [
-    "*",
-    "**",
-    "+",
-    "-",
-    "/",
-    "%",
-];
-const comparisonBinaryOperators = [
-    "!=",
-    "!==",
-    "<",
-    "<=",
-    "==",
-    "===",
-    ">",
-    ">=",
-];
-const bitwiseBinaryOperators = [
-    "&",
-    "<<",
-    ">>",
-    ">>>",
-    "^",
-    "|",
-];
-const binaryOperators = [
-    ...arithmeticBinaryOperators,
-    ...comparisonBinaryOperators,
-    ...bitwiseBinaryOperators,
-    "instanceof",
-    "in",
-];
-const logicalOperators = ["&&", "??", "||"];
-const arithmeticAssignmentOperators = [
-    "%=",
-    "&=",
-    "*=",
-    "**=",
-    "+=",
-    "-=",
-    "/=",
-];
-const logicalAssignmentOperators = ["&&=", "||=", "??="];
-const bitwiseAssignmentOperators = [
-    "<<=",
-    ">>=",
-    ">>>=",
-    "^=",
-    "|=",
-];
-const assignmentOperators = [
-    ...arithmeticAssignmentOperators,
-    ...logicalAssignmentOperators,
-    ...bitwiseAssignmentOperators,
-    "=",
-];
-const leftRightOperators = [
-    ...binaryOperators,
-    ...logicalOperators,
-    ...assignmentOperators,
-];
-const unaryOperators = [
-    "!",
-    "u+",
-    "u-",
-    "delete",
-    "typeof",
-    "void",
-    "~",
-];
-const updateOperators = ["++", "--"];
-const singleOperators = [...unaryOperators, ...updateOperators];
-const operators = [...leftRightOperators, ...singleOperators];
-const operatorMap$2 = {
-    "==": "equal",
-    "===": "strictEqual",
-    "!=": "notEqual",
-    "<": "lessThan",
-    ">": "greaterThan",
-    "<=": "lessThanEq",
-    ">=": "greaterThanEq",
-    "+": "add",
-    "-": "sub",
-    "*": "mul",
-    "/": "div",
-    "%": "mod",
-    "**": "pow",
-    "|": "or",
-    "&": "and",
-    "^": "xor",
-    ">>": "shr",
-    ">>>": "shr",
-    "<<": "shl",
-    "&&": "land",
-    "||": "or",
-};
-const orderIndependentOperators = [
-    "!=",
-    "!==",
-    "&&",
-    "&",
-    "*",
-    "+",
-    "==",
-    "===",
-    "|",
-    "||",
-];
-
-class VoidValue {
-    constructor() {
-        this.mutability = EMutability.mutable;
-        this.macro = false;
-    }
-    eval(_scope, _out) {
-        throw new CompilerError(`[${this.debugString()}] cannot be evaluated into a value.`);
-    }
-    call(_scope, _args, _out) {
-        throw new CompilerError(`[${this.debugString()}] is not callable.`);
-    }
-    get(_scope, name) {
-        throw new CompilerError(`The member [${name.debugString()}] does not exist in [${this.debugString()}]`);
-    }
-    hasProperty(_scope, _prop) {
-        return false;
-    }
-    preCall(_scope, _out) {
-        return;
-    }
-    postCall(_scope) { }
-    toOut() {
-        return this;
-    }
-    debugString() {
-        return "VoidValue";
-    }
-    toString() {
-        return '"[macro VoidValue]"';
-    }
-}
-for (const key of operators) {
-    VoidValue.prototype[key] = function () {
-        console.log(this);
-        throw new CompilerError(`The operator '${key}' is not defined for [${this.debugString()}].`);
-    };
-}
-
-class InstructionBase {
-    get hidden() {
-        return this._hidden;
-    }
-    set hidden(value) {
-        this._hidden = value;
-    }
-    constructor(...args) {
-        this.intent = EInstIntent.none;
-        this.alwaysRuns = true;
-        this._hidden = false;
-        this.args = args;
-    }
-    resolve(_i) { }
-    toString() {
-        return this.args.filter(arg => arg).join(" ");
-    }
-}
-
-class OperationInstruction extends InstructionBase {
-    constructor(kind, temp, left, right) {
-        super("op", kind, temp, left, right);
-    }
-}
-
-/**
- * The prefix for internal variables inside the compiler output
- */
-const internalPrefix = "&";
-const discardedName = `${internalPrefix}_`;
-const itemNames = [
-    "copper",
-    "lead",
-    "metaglass",
-    "graphite",
-    "sand",
-    "coal",
-    "titanium",
-    "thorium",
-    "scrap",
-    "silicon",
-    "plastanium",
-    "phaseFabric",
-    "surgeAlloy",
-    "sporePod",
-    "blastCompound",
-    "pyratite",
-    "beryllium",
-    "tungsten",
-    "oxide",
-    "carbide",
-    "fissileMatter",
-    "dormantCyst",
-];
-/** The name of a special processor variable, controls the instruction pointer */
-const counterName = "@counter";
-
-/**
- * Returns a string that has the format: [line]:[column].
- *
- * If `name` is provided, and it is a string, the resulting string will
- * have the format: [name]:[line]:[column].
- */
-function nodeName(node, name) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const { line, column } = node.loc.start;
-    if (typeof name === "string")
-        return `${name}:${line}:${column}`;
-    return `${line}:${column}`;
-}
-/**
- * Converts a camel case string into a dash case one.
- *
- * As an example `camelCase` becomes `camel-case`
- * @example
- * ```
- * camelToDashCase("camelCase") // returns "camel-case"
- * ```
- */
-function camelToDashCase(name) {
-    return name.replace(/[A-Z]/g, str => `-${str.toLowerCase()}`);
-}
-/**
- * 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);
-}
-/** Lazily computes and caches an expression */
-function lazy(fn) {
-    let value;
-    return () => (value ??= fn());
-}
-
-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;
-}
-/** Removes jump instructions that point right to the next line */
-function hideRedundantJumps(inst) {
-    for (let i = inst.length - 1; i >= 0; 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];
-        }
-    }
-}
-/** A helper that appends the instructions from `value` into `inst` and returns it's `IValue` instance */
-function pipeInsts(value, inst) {
-    inst.push(...value[1]);
-    return value[0];
-}
-function usesAddressResolver(resolver, instructions) {
-    for (let i = 0; i < instructions.length; i++) {
-        const inst = instructions[i];
-        if (inst instanceof JumpInstruction &&
-            resolver.bonds.includes(inst.address))
-            return true;
-    }
-    return false;
-}
-
-function isTemplateObjectArray(value) {
-    return (value instanceof ObjectValue &&
-        value.data.length instanceof LiteralValue &&
-        value.data.length.isNumber() &&
-        value.data.raw instanceof ObjectValue &&
-        value.data.raw.data.length instanceof LiteralValue &&
-        value.data.raw.data.length.isNumber());
-}
-function extractOutName(out) {
-    if (!out || typeof out === "string")
-        return out;
-    return out.name;
-}
-function extractDestrucuringOut(out, field) {
-    if (isDiscardedOut(out))
-        return discardedName;
-    if (!(out instanceof DestructuringValue))
-        return;
-    return out.fields[field] ?? discardedName;
-}
-/** Asserts that `value` is a `LiteralValue` that contains a string */
-function assertStringLiteral(value, name) {
-    if (!(value instanceof LiteralValue) || !value.isString())
-        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) {
-        const { length } = value.data;
-        if (length instanceof LiteralValue && length.isNumber())
-            return;
-    }
-    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;
-}
-function isDiscardedOut(out) {
-    if (!out)
-        return false;
-    if (typeof out === "string")
-        return out === discardedName;
-    return out.name === discardedName;
-}
-
-class SetInstruction extends InstructionBase {
-    constructor(store, value) {
-        super("set", store, value);
-    }
-    get store() {
-        return this.args[1];
-    }
-    get value() {
-        return this.args[2];
-    }
-    get hidden() {
-        const { store, value } = this;
-        return (this._hidden ||
-            // assignment to discarded value
-            store.name === discardedName ||
-            // self assignment of a store
-            (!!store.name &&
-                store instanceof StoreValue &&
-                value instanceof StoreValue &&
-                store.name === value.name));
-    }
-}
-
-class EndInstruction extends InstructionBase {
-    constructor() {
-        super("end");
-        this.intent = EInstIntent.exit;
-    }
-}
-
-class AddressResolver extends InstructionBase {
-    get hidden() {
-        return true;
-    }
-    set hidden(value) { }
-    constructor(...bonds) {
-        super();
-        this.bonds = bonds;
-    }
-    resolve(i) {
-        for (const literal of this.bonds)
-            literal.data = i;
-    }
-    bind(bond) {
-        this.bonds.push(bond);
-    }
-    bindBreak(scope) {
-        scope.break = this;
-        return this;
-    }
-    bindContinue(scope) {
-        scope.continue = this;
-        return this;
-    }
-}
-
-var EJumpKind;
-(function (EJumpKind) {
-    EJumpKind["Equal"] = "equal";
-    EJumpKind["NotEqual"] = "notEqual";
-    EJumpKind["LessThan"] = "lessThan";
-    EJumpKind["LessThanEq"] = "lessThanEq";
-    EJumpKind["GreaterThan"] = "greaterThan";
-    EJumpKind["GreaterThanEq"] = "greaterThanEq";
-    EJumpKind["StrictEqual"] = "strictEqual";
-    EJumpKind["Always"] = "always";
-})(EJumpKind || (EJumpKind = {}));
-class JumpInstruction extends InstructionBase {
-    constructor(address, kind, left = null, right = null) {
-        super("jump", address, kind, left, right);
-        this.address = address;
-    }
-    /**
-     * Works with the `JumpOutValue` class to determine
-     * wether a jump should be added if the expression wasn't jump compressed.
-     */
-    static or(test, out) {
-        if (test === out)
-            return [];
-        return [
-            new JumpInstruction(out.address, out.whenTrue ? EJumpKind.NotEqual : EJumpKind.Equal, test, new LiteralValue(0)),
-        ];
-    }
-}
-
-class SetCounterInstruction extends InstructionBase {
-    constructor(value) {
-        super("set", counterName, value);
-    }
-}
-
-class ZeroSpaceInstruction extends InstructionBase {
-    toString() {
-        return this.args.join("");
-    }
-}
-
-class BreakInstruction extends JumpInstruction {
-    constructor(address) {
-        super(address, EJumpKind.Always);
-        this.intent = EInstIntent.break;
-    }
-}
-class ContinueInstruction extends JumpInstruction {
-    constructor(address) {
-        super(address, EJumpKind.Always);
-        this.intent = EInstIntent.continue;
-    }
-}
-
-const operatorMap$1 = {
-    "!=": EJumpKind.NotEqual,
-    "<": EJumpKind.LessThan,
-    "<=": EJumpKind.LessThanEq,
-    "==": EJumpKind.Equal,
-    "===": EJumpKind.StrictEqual,
-    ">": EJumpKind.GreaterThan,
-    ">=": EJumpKind.GreaterThanEq,
-};
-const invertedOperatorMap = {
-    "==": operatorMap$1["!="],
-    "!=": operatorMap$1["=="],
-    "!==": operatorMap$1["==="],
-    ">": operatorMap$1["<="],
-    "<": operatorMap$1[">="],
-    ">=": operatorMap$1["<"],
-    "<=": operatorMap$1[">"],
-};
-class JumpOutValue extends VoidValue {
-    constructor(node, address, whenTrue) {
-        super();
-        this.node = node;
-        this.address = address;
-        this.whenTrue = whenTrue;
-        this.macro = true;
-    }
-    canHandle(operator) {
-        if (this.whenTrue)
-            return operator in operatorMap$1;
-        return operator in invertedOperatorMap;
-    }
-    handle(operator, left, right) {
-        let kind;
-        if (this.whenTrue) {
-            if (operator === "!==")
-                throw new CompilerError('Unsupported jump compression operator "!=="');
-            kind = operatorMap$1[operator];
-        }
-        else {
-            if (operator === "===")
-                throw new CompilerError('Unsupported jump compression operator "==="');
-            kind = invertedOperatorMap[operator];
-        }
-        const jump = new JumpInstruction(this.address, kind, left, right);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        jump.source = this.node.loc;
-        return jump;
-    }
-    eval(_scope, _out) {
-        return [this, []];
-    }
-    debugString() {
-        return "JumpOutValue";
-    }
-    toString() {
-        return '"[macro JumpOutValue]"';
-    }
-}
-
-class BaseValue extends VoidValue {
-    "u-"(scope, out) {
-        const [that, inst] = this.eval(scope);
-        const temp = StoreValue.from(scope, out);
-        return [
-            temp,
-            [
-                ...inst,
-                new OperationInstruction("sub", temp, new LiteralValue(0), that),
-            ],
-        ];
-    }
-    "u+"(scope, out) {
-        const inst = [];
-        const value = pipeInsts(this.eval(scope), inst);
-        const zero = new LiteralValue(0);
-        const result = pipeInsts(zero["+"](scope, value, out), inst);
-        return [result, inst];
-    }
-    "!"(scope, out) {
-        const inst = [];
-        const falseLiteral = new LiteralValue(0);
-        const that = pipeInsts(this.eval(scope), inst);
-        const result = pipeInsts(that["=="](scope, falseLiteral, out), inst);
-        return [result, inst];
-    }
-    "~"(scope, out) {
-        const [that, inst] = this.eval(scope);
-        const temp = StoreValue.from(scope, out);
-        return [temp, [...inst, new OperationInstruction("not", temp, that, null)]];
-    }
-    // requires special handling
-    // the handler should give an object value to allow the lazy evaluation
-    "??"(scope, other, out) {
-        const result = SenseableValue.from(scope, out, EMutability.mutable);
-        const nullLiteral = new LiteralValue(null);
-        const endAdress = new LiteralValue(null);
-        const [left, leftInst] = this.eval(scope, result);
-        const [right, rightInst] = other.eval(scope, result);
-        const [test, testInst] = left["==="](scope, nullLiteral);
-        return [
-            result,
-            [
-                ...leftInst,
-                ...result["="](scope, left)[1],
-                ...testInst,
-                new JumpInstruction(endAdress, EJumpKind.Equal, test, new LiteralValue(0)),
-                ...rightInst,
-                ...result["="](scope, right)[1],
-                new AddressResolver(endAdress),
-            ],
-        ];
-    }
-    "!=="(scope, other, out) {
-        if (out instanceof JumpOutValue && out.canHandle("!==")) {
-            const [left, leftInst] = this.eval(scope);
-            const [right, rightInst] = other.eval(scope);
-            return [out, [...leftInst, ...rightInst, out.handle("!==", left, right)]];
-        }
-        const [equal, equalInst] = this["==="](scope, other);
-        const [result, resultInst] = equal["!"](scope, out);
-        return [result, [...equalInst, ...resultInst]];
-    }
-}
-for (const key in operatorMap$2) {
-    const kind = operatorMap$2[key];
-    BaseValue.prototype[key] = function (scope, value, out) {
-        const [left, leftInst] = this.eval(scope);
-        const [right, rightInst] = value.eval(scope);
-        if (out instanceof JumpOutValue && out.canHandle(key)) {
-            const jump = out.handle(key, left, right);
-            return [out, [...leftInst, ...rightInst, jump]];
-        }
-        const temp = StoreValue.from(scope, out);
-        return [
-            temp,
-            [
-                ...leftInst,
-                ...rightInst,
-                new OperationInstruction(kind, temp, left, right),
-            ],
-        ];
-    };
-}
-const assignmentToBinary = {
-    "+=": "+",
-    "-=": "-",
-    "*=": "*",
-    "/=": "/",
-    "%=": "%",
-    "**=": "**",
-    "|=": "|",
-    "&=": "&",
-    "^=": "^",
-    ">>=": ">>",
-    ">>>=": ">>>",
-    "<<=": "<<",
-    "&&=": "&&",
-    "||=": "||",
-    "??=": "??",
-};
-for (const k in assignmentToBinary) {
-    const op = k;
-    BaseValue.prototype[op] = function (scope, value) {
-        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this.toOut());
-        const [retValue, retInst] = this["="](scope, opValue);
-        return [retValue, [...opInst, ...retInst]];
-    };
-}
-for (const key of updateOperators) {
-    BaseValue.prototype[key] = function (scope, prefix, out) {
-        let [ret, inst] = this.eval(scope);
-        if (!prefix && !isDiscardedOut(out)) {
-            const temp = StoreValue.from(scope, out);
-            pipeInsts(temp["="](scope, ret), inst);
-            ret = temp;
-        }
-        const kind = key === "++" ? "+=" : "-=";
-        pipeInsts(this[kind](scope, new LiteralValue(1)), inst);
-        return [ret, inst];
-    };
-}
-
-const literalMethods = {
-    length: function () {
-        if (!this.isString())
-            throw new CompilerError("Length method only works on string literal values.");
-        return new LiteralValue(this.data.length);
-    },
-};
-class LiteralValue extends BaseValue {
-    constructor(data) {
-        super();
-        this.mutability = EMutability.constant;
-        this.data = data;
-        this.name = this.toString();
-    }
-    eval(_scope) {
-        return [this, []];
-    }
-    toString() {
-        return JSON.stringify(this.data);
-    }
-    get(scope, name) {
-        if (!(name instanceof LiteralValue && name.isString()))
-            return super.get(scope, name);
-        const method = literalMethods[name.data];
-        if (!method)
-            throw new CompilerError(`The member [${name.debugString()}] does not exist on literal values.`);
-        return [method.apply(this, [scope]), []];
-    }
-    hasProperty(scope, prop) {
-        if (this.isString() && prop instanceof LiteralValue && prop.isString())
-            return Object.prototype.hasOwnProperty.call(literalMethods, prop.data);
-        return false;
-    }
-    get num() {
-        if (this.data === null)
-            return 0;
-        if (typeof this.data === "string")
-            return 1;
-        return this.data;
-    }
-    "??"(scope, other, out) {
-        if (this.data === null)
-            return other.eval(scope, out);
-        return [this, []];
-    }
-    typeof() {
-        return [new LiteralValue("literal"), []];
-    }
-    isString() {
-        return typeof this.data === "string";
-    }
-    isNumber() {
-        return typeof this.data === "number";
-    }
-    debugString() {
-        return this.toString();
-    }
-}
-const operatorMap = {
-    "==": (a, b) => +(a == b),
-    "===": (a, b) => +(a === b),
-    "!=": (a, b) => +(a != b),
-    "!==": (a, b) => +(a !== b),
-    "<": (a, b) => +(a < b),
-    ">": (a, b) => +(a > b),
-    "<=": (a, b) => +(a <= b),
-    ">=": (a, b) => +(a >= b),
-    "+": (a, b) => a + b,
-    "-": (a, b) => a - b,
-    "*": (a, b) => a * b,
-    "/": (a, b) => a / b,
-    "%": (a, b) => a % b,
-    "**": (a, b) => a ** b,
-    "|": (a, b) => a | b,
-    "&": (a, b) => a & b,
-    "^": (a, b) => a ^ b,
-    ">>": (a, b) => a >> b,
-    ">>>": (a, b) => a >> b,
-    "<<": (a, b) => a << b,
-    "&&": (a, b) => +(a && b),
-    "||": (a, b) => +(a || b),
-};
-for (const k in operatorMap) {
-    const key = k;
-    const fn = operatorMap[key];
-    LiteralValue.prototype[key] = function (scope, value, out) {
-        if (key === "&&") {
-            if (this.data)
-                return [value, []];
-            return [new LiteralValue(0), []];
-        }
-        if (key === "||") {
-            if (!this.data)
-                return [value, []];
-            return [new LiteralValue(1), []];
-        }
-        if (!(value instanceof LiteralValue)) {
-            return BaseValue.prototype[key].apply(this, [scope, value, out]);
-        }
-        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 () {
-        const fn = unaryOperatorMap[key];
-        return [new LiteralValue(fn(this.data)), []];
-    };
-}
-
-/**
- * `StoreValue` represents values unknown at compile time,
- * mostly used with mutable variables and temporary values
- */
-class StoreValue extends BaseValue {
-    constructor(name, mutability = EMutability.mutable) {
-        super();
-        this.name = name;
-        this.mutability = mutability;
-    }
-    static from(scope, out, mutability = EMutability.mutable) {
-        if (out instanceof StoreValue)
-            return out;
-        const name = typeof out === "string" ? out : scope.makeTempName();
-        return new StoreValue(name, mutability);
-    }
-    static out(scope, out, mutability = EMutability.mutable) {
-        if (!out || typeof out === "string") {
-            return new StoreValue(out ?? scope.makeTempName(), mutability);
-        }
-        return out;
-    }
-    typeof() {
-        return [new LiteralValue("store"), []];
-    }
-    "="(scope, value) {
-        if (this.mutability !== EMutability.mutable &&
-            this.mutability !== EMutability.init)
-            throw new CompilerError(`Cannot assign to immutable value: [${this.debugString()}].`);
-        if (compareStores(this, value))
-            return [this, []];
-        const [evalValue, evalInst] = value.eval(scope, this);
-        if (evalValue.macro)
-            throw new CompilerError(`Cannot assign a macro to a store (attempted to assign [${evalValue.debugString()}] to [${this.debugString()}])`);
-        return [evalValue, [...evalInst, new SetInstruction(this, evalValue)]];
-    }
-    "=="(scope, value, out) {
-        if (compareStores(this, value))
-            return [new LiteralValue(1), []];
-        return super["=="](scope, value, out);
-    }
-    "==="(scope, value, out) {
-        if (compareStores(this, value))
-            return [new LiteralValue(1), []];
-        return super["==="](scope, value, out);
-    }
-    "!="(scope, value, out) {
-        if (compareStores(this, value))
-            return [new LiteralValue(0), []];
-        return super["!="](scope, value, out);
-    }
-    "!=="(scope, value, out) {
-        if (compareStores(this, value))
-            return [new LiteralValue(0), []];
-        return super["!=="](scope, value, out);
-    }
-    eval(_scope) {
-        return [this, []];
-    }
-    debugString() {
-        return `StoreValue("${this.name}")`;
-    }
-    toString() {
-        return this.name;
-    }
-}
-function compareStores(left, right) {
-    return right instanceof StoreValue && right.name === left.name;
-}
-
-class ObjectValue extends VoidValue {
-    constructor(data = {}) {
-        super();
-        this.mutability = EMutability.constant;
-        this.macro = true;
-        this.data = data;
-    }
-    static fromArray(items, initialData) {
-        const data = {
-            ...initialData,
-            length: new LiteralValue(items.length),
-        };
-        items.forEach((item, i) => {
-            if (item)
-                data[i] = item;
-        });
-        return new ObjectValue(data);
-    }
-    typeof(scope, out) {
-        const { $typeof } = this.data;
-        if ($typeof)
-            return $typeof.call(scope, [], out);
-        return [new LiteralValue("object"), []];
-    }
-    get(scope, key, out) {
-        if (key instanceof LiteralValue && (key.isNumber() || key.isString())) {
-            // avoids naming collisions with keys like
-            // constructor or toString
-            if (Object.prototype.hasOwnProperty.call(this.data, key.data)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return [this.data[key.data], []];
-            }
-        }
-        const { $get } = this.data;
-        if (!$get)
-            throw new CompilerError(`The member [${key.debugString()}] is not present in [${this.debugString()}]`);
-        return $get.call(scope, [key], out);
-    }
-    hasProperty(scope, prop) {
-        if (prop instanceof LiteralValue && (prop.isNumber() || prop.isString())) {
-            const hasMember = Object.prototype.hasOwnProperty.call(this.data, prop.data);
-            return hasMember;
-        }
-        return false;
-    }
-    eval(scope, out) {
-        const { $eval } = this.data;
-        if (!$eval)
-            return [this, []];
-        return $eval.call(scope, [], out);
-    }
-    call(scope, args, out) {
-        const { $call } = this.data;
-        if (!$call)
-            return super.call(scope, args, out);
-        return $call.call(scope, args, out);
-    }
-    "??"(scope, other, out) {
-        const $ = this.data["$??"];
-        if ($)
-            return $.call(scope, [other], out);
-        return [this, []];
-    }
-    debugString() {
-        if (this.name)
-            return `ObjectValue("${this.name}")`;
-        return "ObjectValue";
-    }
-    toString() {
-        return '"[macro ObjectValue]"';
-    }
-}
-for (const op of leftRightOperators) {
-    if (op === "??")
-        continue;
-    ObjectValue.prototype[op] = function (scope, value, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, value, out]);
-        return $.call(scope, [value], out);
-    };
-}
-for (const op of unaryOperators) {
-    if (op === "typeof")
-        continue;
-    ObjectValue.prototype[op] = function (scope, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, out]);
-        return $.call(scope, [], out);
-    };
-}
-for (const op of updateOperators) {
-    ObjectValue.prototype[op] = function (scope, prefix, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, prefix, out]);
-        return $.call(scope, [new LiteralValue(+prefix)], out);
-    };
-}
-
-/**
- * Properties that should return a new `SenseableValue`
- */
-const senseableProps = ["controller"];
-/**
- * Senseable values are "objects" in the mlog runtime that
- * have special properties that can be accessed
- * via the `sense` instruction.
- *
- * This class extends `StoreValue` to allow dynamic behavior
- * that is not possible with object macros.
- *
- * Note that these values are constant by default, so make sure
- * to set that field to `EMutability.mutable` if you want them to be assignable. Example:
- * ```
- * const value = new SenseableValue(name, EMutability.mutable);
- * ```
- */
-class SenseableValue extends StoreValue {
-    constructor(name, mutability = EMutability.constant) {
-        super(name, mutability);
-    }
-    static from(scope, out, mutability = EMutability.constant) {
-        if (out instanceof SenseableValue)
-            return out;
-        const name = typeof out === "string" ? out : scope.makeTempName();
-        return new SenseableValue(name, mutability);
-    }
-    static out(scope, out, mutability = EMutability.mutable) {
-        if (!out || typeof out === "string") {
-            return new SenseableValue(out ?? scope.makeTempName(), mutability);
-        }
-        return out;
-    }
-    get(scope, prop, out) {
-        const mutability = EMutability.readonly;
-        if (prop instanceof LiteralValue && prop.isString()) {
-            const name = itemNames.includes(prop.data)
-                ? camelToDashCase(prop.data)
-                : prop.data;
-            const result = senseableProps.includes(prop.data)
-                ? SenseableValue.from(scope, out, mutability)
-                : StoreValue.from(scope, out, mutability);
-            return [
-                result,
-                [new InstructionBase("sensor", result, this, `@${name}`)],
-            ];
-        }
-        if (prop instanceof StoreValue) {
-            const temp = SenseableValue.from(scope, out, mutability);
-            return [temp, [new InstructionBase("sensor", temp, this, prop)]];
-        }
-        throw new CompilerError(`The property [${prop.debugString()}] cannot be sensed`);
-    }
-    debugString() {
-        return `SenseableValue("${this.name}")`;
-    }
-    hasProperty(scope, prop) {
-        return ((prop instanceof LiteralValue && prop.isString()) ||
-            prop instanceof StoreValue);
-    }
-}
-
-/**
- * Specific case class, required on the ArrayPattern and ObjectPattern handlers
- * in order to keep the separation of concerns and make the code more modular.
- *
- * When it is assign a value, it will get it's own properties and recursively assign
- * each of them to their counterparts on the right hand value.
- */
-class DestructuringValue extends VoidValue {
-    constructor(members) {
-        super();
-        this.members = members;
-        this.macro = true;
-        this.fields = {};
-        for (const [key, { value }] of this.members) {
-            if (key instanceof LiteralValue && (key.isString() || key.isNumber())) {
-                this.fields[key.data] = value;
-            }
-        }
-    }
-    "="(scope, right) {
-        const inst = [];
-        for (const [key, { value, handler }] of this.members) {
-            pipeInsts(handler(() => right.get(scope, key, value), () => right.hasProperty(scope, key), scope), inst);
-        }
-        return [right, inst];
-    }
-    eval(_scope) {
-        return [this, []];
-    }
-    debugString() {
-        return "DestructuringValue";
-    }
-    toString() {
-        return '"[macro DestructuringValue]"';
-    }
-}
-
-/**
- * This class is used to handle some cases where the value
- * can't be directly evaluated by the node handler
- */
-class LazyValue extends VoidValue {
-    constructor(evalutate) {
-        super();
-        this.eval = evalutate;
-    }
-    debugString() {
-        return "LazyValue";
-    }
-    toString() {
-        return '"[macro LazyValue]"';
-    }
-}
-
-class AssignmentValue extends VoidValue {
-    constructor(left, right) {
-        super();
-        this.left = left;
-        this.right = right;
-        this.name = left.name;
-    }
-    "="(scope, value, out) {
-        const inst = [];
-        const input = pipeInsts(value["??"](scope, this.right, this.left.toOut()), inst);
-        const output = pipeInsts(this.left["="](scope, input, out), inst);
-        return [output, inst];
-    }
-    toOut() {
-        return this.left.toOut();
-    }
-    debugString() {
-        return "AssignmentValue";
-    }
-    toString() {
-        return '"[macro AssignmentValue]"';
-    }
-}
-
-class Scope {
-    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = [], operationCache = {}, cacheDependencies = {}) {
-        this.parent = parent;
-        this.stacked = stacked;
-        this.ntemp = ntemp;
-        this.name = name;
-        this.inst = inst;
-        this.operationCache = operationCache;
-        this.cacheDependencies = cacheDependencies;
-        // Only `unchecked` is supposed to change this
-        this.checkIndexes = true;
-        this.data = values;
-    }
-    copy() {
-        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst, { ...this.operationCache }, { ...this.cacheDependencies });
-        scope.break = this.break;
-        scope.continue = this.continue;
-        scope.function = this.function;
-        return scope;
-    }
-    createScope() {
-        const scope = this.copy();
-        scope.data = {};
-        scope.operationCache = {};
-        scope.cacheDependencies = {};
-        scope.parent = this;
-        return scope;
-    }
-    createFunction(name, stacked = this.stacked) {
-        return new Scope({}, this, stacked, 0, name, this.inst);
-    }
-    has(identifier) {
-        if (identifier in this.data)
-            return true;
-        if (this.parent)
-            return this.parent.has(identifier);
-        return false;
-    }
-    get(identifier) {
-        const value = this.data[identifier];
-        if (value)
-            return value;
-        if (this.parent)
-            return this.parent.get(identifier);
-        throw new CompilerError(`${identifier} is not declared.`);
-    }
-    set(name, value) {
-        if (name in this.data)
-            throw new CompilerError(`${name} is already declared.`);
-        return this.hardSet(name, value);
-    }
-    hardSet(name, value) {
-        if (!name)
-            throw new CompilerError("Values in a scope must have an identifier");
-        this.data[name] = value;
-        return value;
-    }
-    make(identifier, name) {
-        const value = assign(new SenseableValue(name), {
-            mutability: EMutability.mutable,
-        });
-        return this.set(identifier, value);
-    }
-    makeTempName() {
-        let result = `${internalPrefix}t${this.ntemp}`;
-        if (this.name)
-            result += `:${this.name}`;
-        this.ntemp++;
-        return result;
-    }
-    addCachedOperation(op, result, left, right) {
-        if (!left.name || !result.name || (right && !right.name))
-            return;
-        const id = formatCacheId(op, left, right);
-        this.operationCache[id] = result;
-        this.clearDependentCache(result);
-        addCacheDependency(this, left.name, id);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        if (right)
-            addCacheDependency(this, right.name, id);
-        addCacheDependency(this, result.name, id);
-    }
-    getCachedOperation(op, left, right) {
-        const id = formatCacheId(op, left, right);
-        const result = this.operationCache[id];
-        if (result)
-            return result;
-        if (this.parent)
-            return this.parent.getCachedOperation(op, left, right);
-    }
-    clearDependentCache(value) {
-        if (!value.name)
-            return;
-        const dependents = this.cacheDependencies[value.name];
-        if (dependents) {
-            for (const id of dependents) {
-                delete this.operationCache[id];
-            }
-        }
-        if (this.parent)
-            this.parent.clearDependentCache(value);
-    }
-}
-function formatCacheId(op, left, right) {
-    if (right)
-        return `{${op}}{${left.name}}{${right.name}}`;
-    return `{${op}}{${left.name}}`;
-}
-function addCacheDependency(scope, name, id) {
-    (scope.cacheDependencies[name] ??= []).push(id);
-}
-
-const Program = (c, scope, node) => {
-    return c.handleMany(scope ?? new Scope({}), node.body);
-};
-
-const VariableDeclaration = (c, scope, node) => {
-    return c.handleMany(scope, node.declarations, child => VariableDeclarator(c, scope, child, undefined, node.kind));
-};
-const VariableDeclarator = (c, scope, node, out, kind = "let") => {
-    const { init } = node;
-    const [value, inst] = Declare(c, scope, node.id, kind);
-    if (init) {
-        const [result, resultInst] = c.handleEval(scope, init, value.out);
-        pipeInsts(value.handler(result, resultInst), inst);
-    }
-    else {
-        pipeInsts(value.handler(null, []), inst);
-    }
-    return [null, inst];
-};
-const Declare = (c, scope, node, kind) => {
-    return c.handle(scope, node, () => {
-        switch (node.type) {
-            case "Identifier":
-                return DeclareIdentifier(c, scope, node, kind);
-            case "ArrayPattern":
-                return DeclareArrayPattern(c, scope, node, kind);
-            case "ObjectPattern":
-                return DeclareObjectPattern(c, scope, node, kind);
-            case "AssignmentPattern":
-                return DeclareAssignmentPattern(c, scope, node, kind);
-            default:
-                throw new CompilerError(`Unsupported declaration type: ${node.type}`, node);
-        }
-    });
-};
-const DeclareIdentifier = (c, scope, node, kind) => {
-    const { name: identifier } = node;
-    const name = nodeName(node, !c.compactNames && identifier);
-    const out = new SenseableValue(name, kind === "const" ? EMutability.init : EMutability.mutable);
-    const declarationValue = new DeclarationValue({
-        c,
-        scope,
-        node,
-        out,
-        handler(init, inst) {
-            if (kind === "const" && !init)
-                throw new CompilerError("Constants must be initialized.", node);
-            if (kind === "const" && init?.mutability === EMutability.constant) {
-                scope.set(identifier, init);
-                return [null, inst];
-            }
-            else {
-                const value = scope.make(identifier, name);
-                if (init) {
-                    if (init.macro)
-                        throw new CompilerError("Macro values must be held by constants", node);
-                    pipeInsts(value["="](scope, init), inst);
-                }
-                if (kind === "const")
-                    value.mutability = EMutability.constant;
-                return [null, inst];
-            }
-        },
-    });
-    return [declarationValue, []];
-};
-const DeclareArrayPattern = (c, scope, node, kind) => {
-    const members = new Map();
-    const { elements } = node;
-    const inst = [];
-    for (let i = 0; i < elements.length; i++) {
-        const element = elements[i];
-        if (!element)
-            continue;
-        const value = pipeInsts(Declare(c, scope, element, kind), inst);
-        members.set(new LiteralValue(i), {
-            value: value.out,
-            handler(get, propExists, scope) {
-                const [init, inst] = c.handle(scope, element, () => {
-                    let [init, initInst] = propExists()
-                        ? get()
-                        : [value.defaultInit ? new LiteralValue(null) : null, []];
-                    if (!init)
-                        throw new CompilerError(`The target object does not have a value at index ${i}`, element);
-                    const getDefault = value.defaultInit;
-                    if (getDefault) {
-                        init = pipeInsts(init["??"](scope, new LazyValue(() => getDefault()), value.out), initInst);
-                    }
-                    return [init, initInst];
-                });
-                return value.handler(init, inst);
-            },
-        });
-    }
-    const out = new DestructuringValue(members);
-    const value = new DeclarationValue({
-        c,
-        scope,
-        node,
-        out,
-        handler(init, initInst) {
-            if (!(init instanceof ObjectValue))
-                throw new CompilerError("The value being destructured must be an object value");
-            pipeInsts(out["="](scope, init), initInst);
-            return [null, initInst];
-        },
-    });
-    return [value, inst];
-};
-const DeclareObjectPattern = (c, scope, node, kind) => {
-    const members = new Map();
-    const { properties } = node;
-    const propertiesInst = c.handleMany(scope, properties, prop => {
-        if (prop.type === "RestElement")
-            throw new CompilerError("The rest operator is not supported", prop);
-        const { key, value: propValue } = prop;
-        const keyInst = key.type === "Identifier" && !prop.computed
-            ? [new LiteralValue(key.name), []]
-            : c.handleEval(scope, prop.key);
-        const [value, valueInst] = Declare(c, scope, propValue, kind);
-        members.set(keyInst[0], {
-            value: value.out,
-            handler(get, propExists, scope) {
-                const [init, inst] = c.handle(scope, prop, () => {
-                    let [init, initInst] = propExists() || !value.defaultInit
-                        ? get()
-                        : [new LiteralValue(null), []];
-                    const getDefault = value.defaultInit;
-                    if (getDefault) {
-                        init = pipeInsts(init["??"](scope, new LazyValue(() => getDefault()), value.out), initInst);
-                    }
-                    return [init, [...keyInst[1], ...initInst]];
-                });
-                return value.handler(init, inst);
-            },
-        });
-        return [null, valueInst];
-    });
-    const out = new DestructuringValue(members);
-    const declarationValue = new DeclarationValue({
-        c,
-        scope,
-        node,
-        out,
-        handler(init, initInst) {
-            if (!init)
-                throw new CompilerError("Cannot use object destructuring without an initializer", node);
-            pipeInsts(out["="](scope, init), initInst);
-            return [null, initInst];
-        },
-    });
-    return [declarationValue, propertiesInst[1]];
-};
-const DeclareAssignmentPattern = (c, scope, node, kind) => {
-    const [value, inst] = Declare(c, scope, node.left, kind);
-    value.defaultInit = () => c.handleEval(scope, node.right, value.out);
-    return [value, inst];
-};
-class DeclarationValue extends VoidValue {
-    constructor({ c, scope, node, out, handler, }) {
-        super();
-        this.out = out;
-        this.c = c;
-        this.scope = scope;
-        this.node = node;
-        this.handle = handler;
-    }
-    handler(init, inst) {
-        return this.c.handle(this.scope, this.node, () => this.handle(init, inst));
-    }
-    debugString() {
-        return "DeclarationValue";
-    }
-    toString() {
-        return '"[macro DeclarationValue]"';
-    }
-}
-
-const Literal = (_c, scope, node) => [new LiteralValue(node.value), []];
-const NumericLiteral = Literal;
-const StringLiteral = Literal;
-const NullLiteral = () => {
-    throw new CompilerError("`null` is no longer supported, use `undefined` instead");
-};
-const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
-
-const LRExpression = (c, scope, node, out) => {
-    const [left, leftInst] = c.handleEval(scope, node.left);
-    const [right, rightInst] = c.handleEval(scope, node.right);
-    if (!(left instanceof LiteralValue) || !(right instanceof LiteralValue)) {
-        const cachedResult = scope.getCachedOperation(node.operator, left, right);
-        if (cachedResult)
-            return [cachedResult, [...leftInst, ...rightInst]];
-        // because a * b is the same as b * a
-        if (orderIndependentOperators.includes(node.operator)) {
-            const cachedResult = scope.getCachedOperation(node.operator, right, left);
-            if (cachedResult)
-                return [cachedResult, [...leftInst, ...rightInst]];
-        }
-    }
-    const [op, opInst] = left[node.operator](scope, right, out);
-    if (!(op instanceof LiteralValue)) {
-        scope.addCachedOperation(node.operator, op, left, right);
-    }
-    return [op, [...leftInst, ...rightInst, ...opInst]];
-};
-const BinaryExpression = LRExpression;
-const LogicalExpression = (c, scope, node, out) => {
-    if (node.operator !== "??")
-        return LRExpression(c, scope, node, out);
-    const other = new LazyValue((scope, out) => c.handleEval(scope, node.right, out));
-    const [left, leftInst] = c.handleValue(scope, node.left);
-    const [result, resultInst] = left["??"](scope, other, out);
-    return [result, [...leftInst, ...resultInst]];
-};
-const AssignmentExpression = (c, scope, node) => {
-    const [left, leftInst] = c.handleValue(scope, node.left);
-    const leftOutput = left.toOut();
-    const [right, rightInst] = node.operator !== "??="
-        ? c.handleEval(scope, node.right, node.operator === "=" ? leftOutput : undefined)
-        : [
-            new LazyValue((scope, out) => c.handleEval(scope, node.right, out)),
-            [],
-        ];
-    const [op, opInst] = left[node.operator](scope, right);
-    scope.clearDependentCache(left);
-    scope.clearDependentCache(leftOutput);
-    return [op, [...leftInst, ...rightInst, ...opInst]];
-};
-const UnaryExpression = (c, scope, { argument, operator }, out) => {
-    const [arg, argInst] = c.handleEval(scope, argument);
-    const cachedResult = scope.getCachedOperation(operator, arg);
-    if (cachedResult)
-        return [cachedResult, argInst];
-    const operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
-    if (operatorId === "throw")
-        throw new CompilerError("throw operator is not supported");
-    const [op, opInst] = arg[operatorId](scope, out);
-    scope.addCachedOperation(operator, op, arg);
-    return [op, [...argInst, ...opInst]];
-};
-const UpdateExpression = (c, scope, { argument, operator, prefix }, out) => {
-    const [arg, argInst] = c.handleValue(scope, argument);
-    scope.clearDependentCache(arg);
-    const [op, opInst] = arg[operator](scope, prefix, out);
-    return [op, [...argInst, ...opInst]];
-};
-const ConditionalExpression = (c, scope, node, out) => {
-    const alternateStartAdress = new LiteralValue(null);
-    const endExpressionAdress = new LiteralValue(null);
-    const testOut = new JumpOutValue(node, alternateStartAdress, false);
-    const [test, testInst] = c.handleEval(scope, node.test, testOut);
-    if (test instanceof LiteralValue) {
-        if (test.data)
-            return c.handleEval(scope, node.consequent, out);
-        return c.handleEval(scope, node.alternate, out);
-    }
-    const result = SenseableValue.from(scope, out, EMutability.mutable);
-    const consequent = c.handleEval(scope, node.consequent, result);
-    const alternate = c.handleEval(scope, node.alternate, result);
-    return [
-        result,
-        [
-            ...testInst,
-            ...JumpInstruction.or(test, testOut),
-            ...consequent[1],
-            ...result["="](scope, consequent[0])[1],
-            new JumpInstruction(endExpressionAdress, EJumpKind.Always),
-            new AddressResolver(alternateStartAdress),
-            ...alternate[1],
-            ...result["="](scope, alternate[0])[1],
-            new AddressResolver(endExpressionAdress),
-        ],
-    ];
-};
-const SequenceExpression = (c, scope, node, out) => {
-    const { expressions } = node;
-    const inst = [];
-    // compute every expression except the last one
-    for (let i = 0; i < expressions.length - 1; i++) {
-        pipeInsts(c.handleEval(scope, expressions[i], discardedName), inst);
-    }
-    const value = pipeInsts(c.handleEval(scope, expressions[expressions.length - 1], out), inst);
-    return [value, inst];
-};
-
-const Identifier = (c, scope, node) => {
-    return [scope.get(node.name), []];
-};
-
-const ExpressionStatement = (c, scope, node) => {
-    return c.handle(scope, node.expression, undefined, discardedName);
-};
-const BreakStatement = (_, scope, node) => {
-    const label = node.label?.name;
-    const target = label ? findScopeLabel(scope, label) : scope;
-    const addr = new LiteralValue(null);
-    target.break.bind(addr);
-    return [null, [new BreakInstruction(addr)]];
-};
-const ContinueStatement = (_, scope, node) => {
-    const addr = new LiteralValue(null);
-    const label = node.label?.name;
-    const target = label ? findScopeLabel(scope, label) : scope;
-    target.continue.bind(addr);
-    return [null, [new ContinueInstruction(addr)]];
-};
-const ReturnStatement = (c, scope, node, out) => {
-    const { argument } = node;
-    const [arg, argInst] = argument
-        ? [new LazyValue((scope, out) => c.handleEval(scope, argument, out)), []]
-        : [new LiteralValue(null), []];
-    const [ret, retInst] = scope.function.return(scope, arg, out);
-    return [ret, [...argInst, ...retInst]];
-};
-const EmptyStatement = () => [null, []];
-const LabeledStatement = (c, scope, node) => {
-    const inner = scope.createScope();
-    inner.label = node.label.name;
-    const end = new LiteralValue(null);
-    const endAdress = new AddressResolver(end).bindBreak(inner);
-    const [, bodyInst] = c.handle(inner, node.body);
-    if (usesAddressResolver(endAdress, bodyInst))
-        bodyInst.push(endAdress);
-    return [null, bodyInst];
-};
-function findScopeLabel(scope, label) {
-    let current = scope;
-    while (current !== null) {
-        if (current.label === label)
-            return current;
-        current = current.parent;
-    }
-    throw new CompilerError(`Could not find label "${label}"`);
-}
-
-const IfStatement = (c, scope, node) => {
-    const inst = [];
-    const endIfAddr = new LiteralValue(null);
-    const testOut = createJumpOut(c, scope, node, endIfAddr);
-    const mergedJumps = testOut.whenTrue;
-    const test = pipeInsts(c.handleEval(scope, node.test, testOut), inst);
-    if (test instanceof LiteralValue) {
-        if (test.data)
-            return [null, c.handle(scope, node.consequent)[1]];
-        else if (node.alternate)
-            return [null, c.handle(scope, node.alternate)[1]];
-        return [null, []];
-    }
-    const consequent = !mergedJumps
-        ? withAlwaysRuns(c.handle(scope, node.consequent), false)
-        : [null, []];
-    inst.push(...JumpInstruction.or(test, testOut), ...consequent[1]);
-    if (!node.alternate) {
-        inst.push(new AddressResolver(endIfAddr));
-    }
-    else {
-        const endElseAddr = new LiteralValue(null);
-        const needsJump = !endsWithControlFlow(consequent[1]) && !mergedJumps;
-        if (needsJump)
-            inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always));
-        inst.push(new AddressResolver(endIfAddr), ...withAlwaysRuns(c.handle(scope, node.alternate), false)[1]);
-        if (needsJump)
-            inst.push(new AddressResolver(endElseAddr));
-    }
-    return [null, inst];
-};
-/**
- * Returns `true` if the instruction array ends with an instruction
- * that already changes the control flow of the script (like `jump x always`, `end` , `stop`, etc)
- */
-function endsWithControlFlow(inst) {
-    for (let i = inst.length - 1; i >= 0; i--) {
-        const instruction = inst[i];
-        if (instruction instanceof AddressResolver)
-            return false;
-        if (instruction.hidden)
-            continue;
-        return instruction.intent !== EInstIntent.none;
-    }
-    return false;
-}
-function createJumpOut(c, scope, node, endIfAddr) {
-    const jumpNode = asMergeableJumpNode(node.consequent);
-    if (!jumpNode)
-        return new JumpOutValue(node, endIfAddr, false);
-    const jump = c.handle(scope, jumpNode)[1][0];
-    return new JumpOutValue(node, jump.address, true);
-}
-function asMergeableJumpNode(body) {
-    if (body.type === "ContinueStatement" || body.type === "BreakStatement")
-        return body;
-    if (body.type !== "BlockStatement")
-        return;
-    if (body.body.length == 0)
-        return;
-    return asMergeableJumpNode(body.body[0]);
-}
-
-const SwitchStatement = (c, scope, node) => {
-    const innerScope = scope.createScope();
-    const [ref, refInst] = c.handleEval(scope, node.discriminant);
-    const inst = [];
-    const endAdress = new LiteralValue(null);
-    const endLine = new AddressResolver(endAdress).bindBreak(innerScope);
-    const caseJumps = [];
-    let defaultJump;
-    // if there is a case that is guaranteed to run
-    let constantCase = false;
-    let onlyConstantTests = true;
-    for (const scase of node.cases) {
-        const bodyInst = lazy(() => c.handleMany(createCaseScope(innerScope), scase.consequent)[1]);
-        const bodyAdress = new LiteralValue(null);
-        const bodyLine = new AddressResolver(bodyAdress);
-        const canFallInto = !endsWithoutFalltrough(inst, endLine);
-        let includeJump = !constantCase;
-        const includeBody = !constantCase || canFallInto;
-        if (!scase.test) {
-            if (includeJump) {
-                [defaultJump] = c.handle(innerScope, scase, () => [
-                    null,
-                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
-                ])[1];
-            }
-            if (includeBody)
-                inst.push(bodyLine, ...bodyInst());
-            continue;
-        }
-        const [test, testInst] = c.handleEval(innerScope, scase.test);
-        if (onlyConstantTests)
-            onlyConstantTests = test.mutability === EMutability.constant;
-        let jump;
-        // check if it can be evaluated at compile time
-        // the scope copy prevents unecessary increases in the temp counter
-        const [comp] = ref["=="](innerScope.copy(), test);
-        if (comp instanceof LiteralValue) {
-            // whether other cases can falltrough and reach this one
-            const noFallInto = !canFallInto;
-            const isLastCase = scase === node.cases[node.cases.length - 1];
-            if (!comp.data) {
-                // this case is not accessible in any way
-                if (noFallInto)
-                    continue;
-                includeJump = false;
-            }
-            else {
-                // this case is only accessible via the comparison jump
-                // and all the other cases will never run
-                if (noFallInto &&
-                    onlyConstantTests &&
-                    (isLastCase || endsWithoutFalltrough(bodyInst(), endLine))) {
-                    return [null, [...bodyInst(), endLine]];
-                }
-                jump = c.handle(innerScope, scase, () => [
-                    null,
-                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
-                ])[1];
-                constantCase = true;
-            }
-        }
-        // makes sourcemapping for the jump more specific
-        jump ??= c.handle(innerScope, scase, () => [
-            null,
-            [new JumpInstruction(bodyAdress, EJumpKind.StrictEqual, ref, test)],
-        ])[1];
-        if (includeJump)
-            caseJumps.push(...testInst, ...jump);
-        if (includeBody)
-            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, [...caseJumps.slice(1), defaultJump]], false);
-        withAlwaysRuns([null, inst], false);
-    }
-    return [
-        null,
-        [
-            ...refInst,
-            ...caseJumps,
-            ...(caseJumps.length > 0 && !constantCase ? [defaultJump] : []),
-            ...inst,
-            ...(usesEndLine(endLine, inst, defaultJump) ? [endLine] : []),
-        ],
-    ];
-};
-function endsWithoutFalltrough(inst, endLine) {
-    if (inst.length === 0)
-        return true;
-    for (let i = inst.length - 1; i >= 0; i--) {
-        const instruction = inst[i];
-        // this means that there is an instruction trying to reference
-        // the final function `set @counter` instruction
-        // of course this generates an unecessary
-        // `set @counter` in cases where a control flow
-        // structure contains a fallback return statement
-        // TODO: fix this with static analysis
-        if (instruction instanceof AddressResolver)
-            return false;
-        if (instruction.hidden)
-            continue;
-        return (instruction instanceof SetCounterInstruction ||
-            instruction.intent === EInstIntent.return ||
-            (instruction instanceof BreakInstruction &&
-                endLine.bonds.includes(instruction.address)));
-    }
-    return false;
-}
-function usesEndLine(endLine, inst, defaultJump) {
-    if (endLine.bonds.includes(defaultJump.address))
-        return true;
-    return usesAddressResolver(endLine, inst);
-}
-function createCaseScope(scope) {
-    // prevents the operation cache from propagating
-    // but also allows the case to declare variables
-    // that can be used by other cases
-    const child = scope.createScope();
-    child.data = scope.data;
-    return child;
-}
-
-const WhileStatement = (c, scope, node) => {
-    const startLoopAddr = new LiteralValue(null);
-    const endLoopAddr = new LiteralValue(null);
-    const hasEmptyBody = isEmptyBody(node.body);
-    const testOut = hasEmptyBody
-        ? new JumpOutValue(node, startLoopAddr, true)
-        : new JumpOutValue(node, endLoopAddr, false);
-    const [test, testLines] = c.handleEval(scope, node.test, testOut);
-    const childScope = scope.createScope();
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
-    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(childScope);
-    if (scope.label) {
-        startLoopLine.bindContinue(scope);
-    }
-    if (test instanceof LiteralValue) {
-        if (!test.data)
-            return [null, []];
-        const bodyInst = c.handle(childScope, node.body)[1];
-        return [
-            null,
-            [
-                startLoopLine,
-                ...bodyInst,
-                new JumpInstruction(startLoopAddr, EJumpKind.Always),
-                ...(usesAddressResolver(endLoopLine, bodyInst) ? [endLoopLine] : []),
-            ],
-        ];
-    }
-    return [
-        null,
-        [
-            startLoopLine,
-            ...testLines,
-            ...JumpInstruction.or(test, testOut),
-            ...withAlwaysRuns(c.handle(childScope, node.body), false)[1],
-            ...(hasEmptyBody
-                ? []
-                : [new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine]),
-        ],
-    ];
-};
-const DoWhileStatement = (c, scope, node) => {
-    const startLoopAddr = new LiteralValue(null);
-    const endLoopAddr = new LiteralValue(null);
-    const testOut = new JumpOutValue(node, startLoopAddr, true);
-    const [test, testLines] = c.handleEval(scope, node.test, testOut);
-    const childScope = scope.createScope();
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
-    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(childScope);
-    if (scope.label) {
-        startLoopLine.bindContinue(scope);
-    }
-    const [, bodyLines] = c.handle(childScope, node.body);
-    if (test instanceof LiteralValue) {
-        if (!test.data)
-            return [null, bodyLines];
-        return [
-            null,
-            [
-                startLoopLine,
-                ...bodyLines,
-                new JumpInstruction(startLoopAddr, EJumpKind.Always),
-                ...(usesAddressResolver(endLoopLine, bodyLines) ? [endLoopLine] : []),
-            ],
-        ];
-    }
-    return [
-        null,
-        [
-            startLoopLine,
-            ...bodyLines,
-            ...testLines,
-            ...JumpInstruction.or(test, testOut),
-            ...(usesAddressResolver(endLoopLine, bodyLines) ? [endLoopLine] : []),
-        ],
-    ];
-};
-function isEmptyBody(node) {
-    if (node.type === "EmptyStatement")
-        return true;
-    if (node.type === "BlockStatement")
-        return node.body.length === 0;
-    return false;
-}
-
-const ForStatement = (c, parentScope, node) => {
-    const startLoopAddr = new LiteralValue(null);
-    // continue statements jump here to run the loop update lines
-    const beforeEndAddr = new LiteralValue(null);
-    const endLoopAddr = new LiteralValue(null);
-    const scope = parentScope.createScope();
-    const testOut = new JumpOutValue(node, endLoopAddr, false);
-    const initInst = node.init ? c.handle(scope, node.init)[1] : [];
-    const [test, testLines] = node.test
-        ? c.handleEval(scope, node.test, testOut)
-        : [new LiteralValue(1), []];
-    const updateLines = node.update
-        ? c.handle(scope, node.update, undefined, discardedName)[1]
-        : [];
-    const startLoopLine = new AddressResolver(startLoopAddr);
-    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
-    const beforeEndLine = new AddressResolver(beforeEndAddr).bindContinue(scope);
-    if (parentScope.label) {
-        beforeEndLine.bindContinue(parentScope);
-    }
-    if (test instanceof LiteralValue && !test.data) {
-        return [null, [...initInst]];
-    }
-    const isInfiniteLoop = test instanceof LiteralValue;
-    return [
-        null,
-        [
-            ...initInst,
-            startLoopLine,
-            ...testLines,
-            ...(isInfiniteLoop ? [] : JumpInstruction.or(test, testOut)),
-            ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
-            beforeEndLine,
-            ...updateLines,
-            new JumpInstruction(startLoopAddr, EJumpKind.Always),
-            ...(isInfiniteLoop ? [] : [endLoopLine]),
-        ],
-    ];
-};
-
-class FunctionValue extends VoidValue {
-    constructor({ scope, params, body, c, out, }) {
-        super();
-        this.mutability = EMutability.constant;
-        this.macro = true;
-        this.paramValues = [];
-        this.paramNames = new Map();
-        this.destructuringKeyData = new Map();
-        this.paramOuts = [];
-        this.minimumArgumentCount = 0;
-        this.maximumArgumentCount = 0;
-        this.bundled = false;
-        this.initialized = false;
-        this.scope = scope;
-        this.body = body;
-        this.c = c;
-        this.params = params;
-        this.name = extractOutName(out) ?? scope.makeTempName();
-    }
-    typeof() {
-        return [new LiteralValue("function"), []];
-    }
-    initScope() {
-        this.childScope = this.scope.createFunction(this.name);
-        this.childScope.function = this;
-        for (let i = 0; i < this.params.length; i++) {
-            const value = this.unwrapParameter(this.params[i]);
-            this.paramValues.push(value);
-            this.paramOuts.push(value.toOut());
-            if (!(value instanceof AssignmentValue))
-                this.minimumArgumentCount = i + 1;
-        }
-        this.callSize = this.paramValues.length + 2;
-        this.maximumArgumentCount = this.params.length;
-    }
-    ensureInit() {
-        if (this.initialized)
-            return;
-        this.initialized = true;
-        this.initScope();
-        this.addr = new LiteralValue(null);
-        this.temp = new SenseableValue(`${internalPrefix}f${this.name}`, EMutability.mutable);
-        this.ret = new StoreValue(`${internalPrefix}r${this.name}`);
-        this.inst = [
-            new AddressResolver(this.addr),
-            ...this.c.handle(this.childScope, this.body)[1],
-        ];
-        if (!endsWithReturn(this, this.inst)) {
-            pipeInsts(this.temp["="](this.scope, new LiteralValue(null)), this.inst);
-            this.inst.push(assign(new SetCounterInstruction(this.ret), {
-                intent: EInstIntent.return,
-                intentSource: this,
-            }));
-        }
-    }
-    normalReturn(scope, arg) {
-        const inst = [];
-        if (arg) {
-            const value = pipeInsts(arg.eval(scope, this.temp), inst);
-            pipeInsts(this.temp["="](scope, value), inst);
-        }
-        const returnInst = assign(new SetCounterInstruction(this.ret), {
-            intent: EInstIntent.return,
-            intentSource: this,
-        });
-        return [null, [...inst, returnInst]];
-    }
-    // TODO: use static analysis to determine if
-    // we can safely skip the temp value assignment
-    normalCall(scope, args, out) {
-        if (!this.bundled)
-            this.childScope.inst.push(...this.inst);
-        this.bundled = true;
-        const callAddressLiteral = new LiteralValue(null);
-        // the value will be stored somewhere
-        // no need to save it in a temporary variable
-        const temp = out
-            ? this.temp
-            : SenseableValue.from(scope, undefined, EMutability.mutable);
-        const inst = this.paramValues
-            .map((param, i) => param["="](scope, args[i] ?? new LiteralValue(null))[1])
-            .reduce((s, c) => s.concat(c), [])
-            .concat(...this.ret["="](scope, callAddressLiteral)[1], new JumpInstruction(this.addr, EJumpKind.Always), new AddressResolver(callAddressLiteral), 
-        // ensures that functions can be called multiple times inside expressions
-        ...temp["="](scope, this.temp)[1]);
-        return [temp, inst];
-    }
-    inlineReturn(scope, arg) {
-        if (!this.inlineEnd)
-            throw new CompilerError("Error during inline attempt: missing inline end adress");
-        const inst = [];
-        if (arg) {
-            const value = pipeInsts(arg.eval(scope, this.inlineTemp), inst);
-            pipeInsts(this.inlineTemp["="](scope, value), inst);
-        }
-        const jump = assign(new JumpInstruction(this.inlineEnd, EJumpKind.Always), {
-            intent: EInstIntent.return,
-            intentSource: this,
-        });
-        return [null, [...inst, jump]];
-    }
-    inlineCall(scope, args, out) {
-        // create return value
-        this.inlineTemp = SenseableValue.from(this.childScope, out, EMutability.mutable);
-        // make a copy of the function scope
-        const fnScope = this.childScope.copy();
-        this.tryingInline = true;
-        let inst = [];
-        // hard set variables within the function scope
-        for (let i = 0; i < this.paramValues.length; i++) {
-            inst.push(...this.hardSetParameter(fnScope, this.paramValues[i], args[i]));
-        }
-        this.inlineEnd = new LiteralValue(null);
-        inst.push(...this.c.handle(fnScope, this.body)[1]);
-        this.tryingInline = false;
-        const returnIndex = inst.findIndex(i => i.alwaysRuns &&
-            i.intent === EInstIntent.return &&
-            i.intentSource === this);
-        if (returnIndex !== -1)
-            inst = inst.slice(0, returnIndex + 1);
-        inst.push(new AddressResolver(this.inlineEnd));
-        // return the function value
-        return [this.inlineTemp, inst];
-    }
-    call(scope, args, out) {
-        this.ensureInit();
-        const min = this.minimumArgumentCount;
-        const max = this.maximumArgumentCount;
-        if (args.length < min || args.length > max) {
-            if (min !== max)
-                throw new CompilerError(`Cannot call: expected ${min}-${max} arguments but got: ${args.length}`);
-            throw new CompilerError(`Cannot call: expected ${min} arguments but got: ${args.length}`);
-        }
-        validateParameters(args, this.paramValues);
-        const inlineCall = this.inlineCall(scope, args, out);
-        hideRedundantJumps(inlineCall[1]);
-        const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
-        if (this.inline || inlineSize <= this.callSize)
-            return inlineCall;
-        return this.normalCall(scope, args, out);
-    }
-    return(scope, arg) {
-        this.ensureInit();
-        if (arg && arg.macro) {
-            this.inline = true;
-            return [null, []];
-        }
-        if (this.inline || this.tryingInline)
-            return this.inlineReturn(scope, arg);
-        return this.normalReturn(scope, arg);
-    }
-    eval(_scope) {
-        return [this, []];
-    }
-    preCall() {
-        this.ensureInit();
-        if (this.inline || this.tryingInline)
-            return;
-        return this.paramOuts;
-    }
-    debugString() {
-        return `FunctionValue("${this.name}")`;
-    }
-    toString() {
-        return '"[macro FunctionValue]"';
-    }
-    unwrapParameter(param) {
-        switch (param.type) {
-            case "Identifier": {
-                const name = nodeName(param, !this.c.compactNames && param.name);
-                const value = new SenseableValue(name, EMutability.mutable);
-                this.childScope.set(param.name, value);
-                this.paramNames.set(value, param.name);
-                return value;
-            }
-            case "AssignmentPattern": {
-                const left = this.unwrapParameter(param.left);
-                const [rightValue, rightInst] = this.c.handleEval(this.childScope, param.right, left);
-                const right = new LazyValue(scope => {
-                    if (this.inline || this.tryingInline) {
-                        return this.c.handleEval(scope, param.right, left);
-                    }
-                    return [rightValue, [...rightInst]];
-                });
-                return new AssignmentValue(left, right);
-            }
-            case "ObjectPattern": {
-                const members = new Map();
-                for (const prop of param.properties) {
-                    if (prop.type === "RestElement")
-                        throw new CompilerError("Rest parameters are not supported");
-                    const { key: propKey, value: propValue } = prop;
-                    const propInst = [];
-                    const key = propKey.type === "Identifier" && !prop.computed
-                        ? new LiteralValue(propKey.name)
-                        : pipeInsts(this.c.handleEval(this.childScope, propKey), propInst);
-                    const value = this.unwrapParameter(propValue);
-                    const hasDefault = value instanceof AssignmentValue;
-                    this.destructuringKeyData.set(key, { inst: propInst, value });
-                    members.set(key, {
-                        value: value.toOut(),
-                        handler: (get, propExists, scope) => {
-                            return this.c.handle(scope, prop, () => {
-                                const inst = [...propInst];
-                                if (propExists() || !hasDefault) {
-                                    const input = pipeInsts(get(), inst);
-                                    // assigns the output to the target value
-                                    const output = pipeInsts(value["="](scope, input), inst);
-                                    return [output, inst];
-                                }
-                                const result = pipeInsts(value["="](scope, new LiteralValue(null)), inst);
-                                return [result, inst];
-                            });
-                        },
-                    });
-                }
-                return new DestructuringValue(members);
-            }
-            case "ArrayPattern": {
-                const members = new Map();
-                for (let i = 0; i < param.elements.length; i++) {
-                    const element = param.elements[i];
-                    if (!element)
-                        continue;
-                    const value = this.unwrapParameter(element);
-                    const hasDefault = value instanceof AssignmentValue;
-                    if (!value)
-                        throw new CompilerError("Destructuring element must resolve to a value", element);
-                    const key = new LiteralValue(i);
-                    this.destructuringKeyData.set(key, { inst: [], value });
-                    members.set(key, {
-                        value: value.toOut(),
-                        handler: (get, propExists, scope) => {
-                            return this.c.handle(scope, element, () => {
-                                if (propExists() || !hasDefault) {
-                                    const inst = get();
-                                    // assigns the output to the target value
-                                    pipeInsts(value["="](scope, inst[0]), inst[1]);
-                                    return inst;
-                                }
-                                return value["="](scope, new LiteralValue(null));
-                            });
-                        },
-                    });
-                }
-                return new DestructuringValue(members);
-            }
-            default:
-                throw new CompilerError(`Unsupported function parameter type: ${param.type}`);
-        }
-    }
-    hardSetParameter(scope, param, value = new LiteralValue(null)) {
-        if (param instanceof SenseableValue) {
-            const name = this.paramNames.get(param);
-            scope.hardSet(name, value);
-            return [];
-        }
-        if (param instanceof AssignmentValue) {
-            const [result, inst] = value["??"](scope, param.right, param.left);
-            inst.push(...this.hardSetParameter(scope, param.left, result));
-            return inst;
-        }
-        const inst = [];
-        for (const [key, { value: out }] of param.members) {
-            const data = this.destructuringKeyData.get(key);
-            if (!data)
-                continue;
-            inst.push(...data.inst);
-            const hasDefault = data.value instanceof AssignmentValue;
-            const input = value.hasProperty(scope, key) || !hasDefault
-                ? pipeInsts(value.get(scope, key, out), inst)
-                : new LiteralValue(null);
-            inst.push(...this.hardSetParameter(scope, data.value, input));
-        }
-        return inst;
-    }
-}
-function endsWithReturn(fun, inst) {
-    for (let i = inst.length - 1; i >= 0; i--) {
-        const instruction = inst[i];
-        // this means that there is an instruction trying to reference
-        // the final function `set @counter` instruction
-        // of course this generates an unecessary
-        // `set @counter` in cases where a control flow
-        // structure contains a fallback return statement
-        // TODO: fix this with static analysis
-        if (instruction instanceof AddressResolver)
-            return false;
-        if (instruction.hidden)
-            continue;
-        return (instruction.intent === EInstIntent.exit ||
-            (instruction.intent === EInstIntent.return &&
-                instruction.intentSource === fun));
-    }
-    return false;
-}
-function validateParameters(args, params) {
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        const param = params[i];
-        if (arg instanceof StoreValue &&
-            param instanceof AssignmentValue &&
-            param.left.macro) {
-            throw new CompilerError("Cannot pass a store to a function parameter that has a macro as a default value.");
-        }
-    }
-}
-
-function handleFunctionNode(c, scope, node, out) {
-    let { params, body } = node;
-    if (es.isExpression(body)) {
-        const { loc } = body;
-        const statement = es.returnStatement(body);
-        statement.loc = loc;
-        body = es.blockStatement([statement]);
-        body.loc = loc;
-    }
-    return [
-        new FunctionValue({
-            scope,
-            params: params,
-            body,
-            c,
-            out,
-        }),
-        [],
-    ];
-}
-const ArrowFunctionExpression = (c, scope, node, out) => {
-    return handleFunctionNode(c, scope, node, out);
-};
-const FunctionDeclaration = (c, scope, node) => {
-    const identifier = node.id.name;
-    const name = nodeName(node, !c.compactNames && identifier);
-    const functionIns = handleFunctionNode(c, scope, node, name);
-    scope.set(identifier, functionIns[0]);
-    return functionIns;
-};
-const FunctionExpression = ArrowFunctionExpression;
-const ObjectMethod = ArrowFunctionExpression;
-
-const CallExpression = (c, scope, node, out) => {
-    const inst = [];
-    const callee = pipeInsts(c.handleEval(scope, node.callee), inst);
-    const paramOuts = callee.preCall(scope, out);
-    const args = node.arguments.map((node, index) => {
-        const out = paramOuts?.[index];
-        return pipeInsts(c.handleEval(scope, node, out), inst);
-    });
-    const callValue = pipeInsts(callee.call(scope, args, out), inst);
-    callee.postCall(scope);
-    return [callValue, inst];
-};
-const NewExpression = CallExpression;
-const TaggedTemplateExpression = (c, scope, node, out) => {
-    const [tag, tagInst] = c.handleEval(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 = pipeInsts(c.handleEval(scope, expression), expressionInsts);
-        expressions.push(value);
-    });
-    const [result, resultInst] = tag.call(scope, [stringsObject, ...expressions], out);
-    return [result, [...expressionInsts, ...tagInst, ...resultInst]];
-};
-
-const ObjectExpression = (c, scope, node, out) => {
-    const data = {};
-    const inst = [];
-    for (const prop of node.properties) {
-        if (prop.type === "SpreadElement")
-            throw new CompilerError("Cannot handle spread element", prop);
-        if (prop.computed)
-            throw new CompilerError("Cannot handle computed property.", prop);
-        const { key } = prop;
-        const value = prop.type === "ObjectProperty" ? prop.value : prop;
-        let index;
-        if (key.type === "Identifier") {
-            index = key.name;
-        }
-        else if (key.type === "StringLiteral" || key.type === "NumericLiteral") {
-            index = `${key.value}`;
-        }
-        else {
-            throw new CompilerError(`Unsupported object key type: ${key.type}`, key);
-        }
-        const memberOut = extractDestrucuringOut(out, index);
-        const member = pipeInsts(c.handleEval(scope, value, memberOut), inst);
-        data[index] = member;
-    }
-    return [new ObjectValue(data), inst];
-};
-const ArrayExpression = (c, scope, node, out) => {
-    const items = [];
-    const inst = [];
-    node.elements.forEach((element, i) => {
-        if (!element) {
-            items.push(undefined);
-            return;
-        }
-        const value = pipeInsts(c.handleEval(scope, element, extractDestrucuringOut(out, i)), inst);
-        items.push(value);
-    });
-    return [ObjectValue.fromArray(items), inst];
-};
-const MemberExpression = (c, scope, node, out, optional = false) => {
-    const [prop, propInst] = node.computed
-        ? c.handleEval(scope, node.property)
-        : [new LiteralValue(node.property.name), []];
-    if (!out) {
-        const [obj, objInst] = c.handleEval(scope, node.object);
-        if (optional && obj instanceof LiteralValue && obj.data === null)
-            return [obj, [...objInst, ...propInst]];
-        const [got, gotInst] = obj.get(scope, prop);
-        return [got, [...objInst, ...propInst, ...gotInst]];
-    }
-    const temp = SenseableValue.out(scope, out);
-    const objOut = new DestructuringValue(new Map([
-        [
-            prop,
-            {
-                value: temp,
-                // a direct assignment should NOT happen
-                handler: () => {
-                    throw new CompilerError("Unexpected destructuring assignment");
-                },
-            },
-        ],
-    ]));
-    const [obj, objInst] = c.handleEval(scope, node.object, objOut);
-    if (optional && obj instanceof LiteralValue && obj.data === null)
-        return [obj, [...objInst, ...propInst]];
-    const [got, gotInst] = obj.get(scope, prop, temp);
-    return [got, [...objInst, ...propInst, ...gotInst]];
-};
-const ArrayPattern = (c, scope, node) => {
-    const inst = [];
-    const members = new Map();
-    for (let i = 0; i < node.elements.length; i++) {
-        const element = node.elements[i];
-        if (!element)
-            continue;
-        const value = pipeInsts(c.handleValue(scope, element), inst);
-        const hasDefault = value instanceof AssignmentValue;
-        members.set(new LiteralValue(i), {
-            value: value.toOut(),
-            handler(get, propExists, scope) {
-                return c.handle(scope, element, () => {
-                    if (propExists() || !hasDefault) {
-                        const inst = get();
-                        // assigns the output to the target value
-                        pipeInsts(value["="](scope, inst[0]), inst[1]);
-                        return inst;
-                    }
-                    return value["="](scope, new LiteralValue(null));
-                });
-            },
-        });
-    }
-    return [new DestructuringValue(members), inst];
-};
-const ObjectPattern = (c, scope, node) => {
-    const inst = [];
-    const members = new Map();
-    for (const prop of node.properties) {
-        if (prop.type === "RestElement")
-            throw new CompilerError("The rest operator is not supported");
-        if (!prop)
-            continue;
-        const propKey = prop.key;
-        const [key, keyInst] = propKey.type === "Identifier" && !prop.computed
-            ? [new LiteralValue(propKey.name), []]
-            : c.handleEval(scope, propKey);
-        const value = pipeInsts(c.handleValue(scope, prop.value), inst);
-        const hasDefault = value instanceof AssignmentValue;
-        members.set(key, {
-            value: value.toOut(),
-            handler(get, propExists, scope) {
-                return c.handle(scope, prop, () => {
-                    const inst = keyInst;
-                    if (propExists() || !hasDefault) {
-                        const input = pipeInsts(get(), inst);
-                        // assigns the output to the target value
-                        const output = pipeInsts(value["="](scope, input), inst);
-                        return [output, inst];
-                    }
-                    const result = pipeInsts(value["="](scope, new LiteralValue(null)), inst);
-                    return [result, inst];
-                });
-            },
-        });
-    }
-    return [new DestructuringValue(members), inst];
-};
-// the mlog runtime already does this check for us
-const OptionalMemberExpression = (c, scope, node, out) => MemberExpression(c, scope, node, out, true);
-const AssignmentPattern = (c, scope, node) => {
-    const [left, inst] = c.handleValue(scope, node.left);
-    const right = new LazyValue((_, out) => c.handleEval(scope, node.right, out));
-    return [new AssignmentValue(left, right), inst];
-};
-
-const TemplateLiteral = () => {
-    throw new CompilerError("Template strings can only be used in tagged template literals. To inline mlog code use the asm function.");
-};
-
-const BlockStatement = (c, scope, node) => {
-    return c.handleMany(scope.createScope(), node.body);
-};
-
-const File = (c, scope, node) => {
-    return c.handle(scope ?? new Scope({}), node.program);
-};
-
-const TypeCastExpression = (c, scope, node, out) => {
-    return c.handle(scope, node.expression, undefined, out);
-};
-const TSAsExpression = TypeCastExpression;
-const TSTypeAssertion = TypeCastExpression;
-const IgnoredHandler = () => [null, []];
-const TSInterfaceDeclaration = IgnoredHandler;
-const TSTypeAliasDeclaration = IgnoredHandler;
-const TSEnumDeclaration = (c, scope, node) => {
-    if (!node.const)
-        throw new CompilerError("All enums must be declared with the const keyword before enum");
-    let counter = 0;
-    let lastType = "number";
-    const data = {};
-    for (const member of node.members) {
-        if (lastType === "string" && !member.initializer)
-            throw new CompilerError("This enum member must be initialized", member);
-        const [value] = member.initializer
-            ? c.handleEval(scope, member.initializer)
-            : [new LiteralValue(counter)];
-        if (!(value instanceof LiteralValue))
-            throw new CompilerError("Enum members must contain literal values", member);
-        if (value.isNumber()) {
-            lastType = "number";
-            counter = value.data + 1;
-        }
-        else {
-            lastType = "string";
-        }
-        const name = member.id.type === "Identifier" ? member.id.name : member.id.value;
-        data[name] = value;
-    }
-    const value = new ObjectValue(data);
-    value.name = nodeName(node, !c.compactNames && node.id.name);
-    scope.set(node.id.name, value);
-    return [null, []];
-};
-const TSNonNullExpression = (c, scope, node, out) => {
-    return c.handle(scope, node.expression, undefined, out);
-};
-const TSSatisfiesExpression = (c, scope, node, out) => c.handle(scope, node.expression, undefined, out);
-
-var handlers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ArrayExpression: ArrayExpression,
-    ArrayPattern: ArrayPattern,
-    ArrowFunctionExpression: ArrowFunctionExpression,
-    AssignmentExpression: AssignmentExpression,
-    AssignmentPattern: AssignmentPattern,
-    BinaryExpression: BinaryExpression,
-    BlockStatement: BlockStatement,
-    BooleanLiteral: BooleanLiteral,
-    BreakStatement: BreakStatement,
-    CallExpression: CallExpression,
-    ConditionalExpression: ConditionalExpression,
-    ContinueStatement: ContinueStatement,
-    DoWhileStatement: DoWhileStatement,
-    EmptyStatement: EmptyStatement,
-    ExpressionStatement: ExpressionStatement,
-    File: File,
-    ForStatement: ForStatement,
-    FunctionDeclaration: FunctionDeclaration,
-    FunctionExpression: FunctionExpression,
-    Identifier: Identifier,
-    IfStatement: IfStatement,
-    LRExpression: LRExpression,
-    LabeledStatement: LabeledStatement,
-    LogicalExpression: LogicalExpression,
-    MemberExpression: MemberExpression,
-    NewExpression: NewExpression,
-    NullLiteral: NullLiteral,
-    NumericLiteral: NumericLiteral,
-    ObjectExpression: ObjectExpression,
-    ObjectMethod: ObjectMethod,
-    ObjectPattern: ObjectPattern,
-    OptionalMemberExpression: OptionalMemberExpression,
-    Program: Program,
-    ReturnStatement: ReturnStatement,
-    SequenceExpression: SequenceExpression,
-    StringLiteral: StringLiteral,
-    SwitchStatement: SwitchStatement,
-    TSAsExpression: TSAsExpression,
-    TSEnumDeclaration: TSEnumDeclaration,
-    TSInterfaceDeclaration: TSInterfaceDeclaration,
-    TSNonNullExpression: TSNonNullExpression,
-    TSSatisfiesExpression: TSSatisfiesExpression,
-    TSTypeAliasDeclaration: TSTypeAliasDeclaration,
-    TSTypeAssertion: TSTypeAssertion,
-    TaggedTemplateExpression: TaggedTemplateExpression,
-    TemplateLiteral: TemplateLiteral,
-    UnaryExpression: UnaryExpression,
-    UpdateExpression: UpdateExpression,
-    VariableDeclaration: VariableDeclaration,
-    VariableDeclarator: VariableDeclarator,
-    WhileStatement: WhileStatement
-});
-
-class MacroFunction extends VoidValue {
-    constructor(fn, paramOuts) {
-        super();
-        this.paramOuts = paramOuts;
-        this.macro = true;
-        this.mutability = EMutability.constant;
-        this.fn = fn;
-    }
-    call(scope, args, out) {
-        return this.fn.apply(this, [scope, out, ...args]);
-    }
-    eval(_scope) {
-        return [this, []];
-    }
-    preCall(_scope, _out) {
-        return this.paramOuts;
-    }
-    debugString() {
-        return "MacroFunction";
-    }
-    toString() {
-        return '"[macro MacroFunction]"';
-    }
-}
-
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const toRadians = (degrees) => (degrees * Math.PI) / 180;
-const toDegrees = (radians) => (radians * 180) / Math.PI;
-const mathOperations = {
-    max: (a, b) => Math.max(a, b),
-    min: (a, b) => Math.min(a, b),
-    angle: (x, y) => {
-        const angle = toDegrees(Math.atan2(y, x));
-        return angle < 0 ? angle + 360 : angle;
-    },
-    len: (a, b) => Math.sqrt(a ** 2 + b ** 2),
-    noise: null,
-    abs: a => Math.abs(a),
-    log: a => Math.log(a),
-    log10: a => Math.log10(a),
-    sin: a => Math.sin(toRadians(a)),
-    cos: a => Math.cos(toRadians(a)),
-    tan: a => Math.tan(toRadians(a)),
-    floor: a => Math.floor(a),
-    ceil: a => Math.ceil(a),
-    sqrt: a => Math.sqrt(a),
-    asin: a => toDegrees(Math.asin(a)),
-    acos: a => toDegrees(Math.acos(a)),
-    atan: a => toDegrees(Math.atan(a)),
-    // yes, this doesn't work with negative numbers
-    // but the game also implements it this way.
-    idiv: (a, b) => Math.floor(a / b),
-    pow: (a, b) => Math.pow(a, b),
-    rand: null,
-};
-const orderIndependentOperations = ["max", "min", "len"];
-function createMacroMathOperations() {
-    const macroMathOperations = {
-        PI: new StoreValue("@pi", EMutability.constant),
-        E: new StoreValue("@e", EMutability.constant),
-        degToRad: new StoreValue("@degToRad", EMutability.constant),
-        radToDeg: new StoreValue("@radToDeg", EMutability.constant),
-    };
-    for (const key in mathOperations) {
-        const fn = mathOperations[key];
-        macroMathOperations[key] = new MacroFunction((scope, out, a, b) => {
-            const argumentCount = +!!a + +!!b;
-            if (fn && argumentCount != fn.length) {
-                throw new CompilerError(`Expected ${fn.length} arguments, but got ${argumentCount}`);
-            }
-            const cacheKey = getCacheKey(key);
-            if (b) {
-                if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
-                    if (!a.isNumber() || !b.isNumber())
-                        throw new CompilerError("Cannot do math operation with non-numerical literals.");
-                    return [new LiteralValue(fn(a.num, b.num)), []];
-                }
-                const cachedResult = scope.getCachedOperation(cacheKey, a, b);
-                if (cachedResult)
-                    return [cachedResult, []];
-                // max, min and len do not change if the arguments change in order
-                if (orderIndependentOperations.includes(key)) {
-                    const cachedResult = scope.getCachedOperation(cacheKey, b, a);
-                    if (cachedResult)
-                        return [cachedResult, []];
-                }
-                const temp = StoreValue.from(scope, out);
-                scope.addCachedOperation(cacheKey, temp, a, b);
-                return [temp, [new OperationInstruction(key, temp, a, b)]];
-            }
-            if (fn && a instanceof LiteralValue) {
-                if (!a.isNumber())
-                    throw new CompilerError("Cannot do math operation with non-numerical literal.");
-                return [new LiteralValue(fn(a.num)), []];
-            }
-            const cachedResult = scope.getCachedOperation(cacheKey, a);
-            if (cachedResult)
-                return [cachedResult, []];
-            const temp = StoreValue.from(scope, out);
-            // ensures that operations like `rand` are not cached
-            if (mathOperations[key])
-                scope.addCachedOperation(cacheKey, temp, a);
-            return [temp, [new OperationInstruction(key, temp, a, null)]];
-        });
-    }
-    return macroMathOperations;
-}
-function getCacheKey(key) {
-    if (key === "pow")
-        return "**";
-    return key;
-}
-class MlogMath extends ObjectValue {
-    constructor() {
-        super(createMacroMathOperations());
-    }
-}
-// op angle result a b
-// op len result a b
-
-class Concat extends MacroFunction {
-    constructor() {
-        super((scope, out, ...values) => {
-            const [first] = values;
-            if (!isTemplateObjectArray(first)) {
-                assertLiterals(values, "Concat arguments must be all literal values");
-                let text = "";
-                for (const value of values)
-                    text += value.data;
-                return [new LiteralValue(text), []];
-            }
-            let text = "";
-            const [, ...interpolated] = values;
-            assertLiterals(interpolated, "Interpolated values in concat must be literals");
-            for (let i = 0; i < values.length; i++) {
-                const [string] = first.get(scope, new LiteralValue(i));
-                text += string.data;
-                if (i < interpolated.length)
-                    text += interpolated[i].data;
-            }
-            return [new LiteralValue(text), []];
-        });
-    }
-}
-function assertLiterals(values, message) {
-    for (const value of values) {
-        if (!(value instanceof LiteralValue))
-            throw new CompilerError(message);
-    }
-}
-
-/** 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, out, options) => {
-                assertIsObjectMacro(options, named);
-                return handler(scope, key, out, ...assertObjectFields(options, args));
-            });
-            continue;
-        }
-        result[key] = new MacroFunction((scope, out, ...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, out, ...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: "" }],
-                },
-                col: {
-                    args: ["rgbaData"],
-                },
-                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, out, ...args) {
-                return [null, [new InstructionBase("draw", overload, ...args)]];
-            },
-        });
-        super(data);
-    }
-}
-
-class Print extends MacroFunction {
-    constructor() {
-        super((scope, out, ...values) => {
-            const [first] = values;
-            const inst = [];
-            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() {
-        super((scope, out, 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)]];
-        });
-    }
-}
-
-const defaultTargetName = "display1";
-class DrawFlush extends MacroFunction {
-    constructor() {
-        super((scope, out, 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)]];
-        });
-    }
-}
-
-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, out, x, y) {
-                const output = overload === "building"
-                    ? SenseableValue.from(scope, out, EMutability.constant)
-                    : StoreValue.from(scope, out, EMutability.constant);
-                return [
-                    output,
-                    [new InstructionBase("getblock", overload, output, x, y)],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class GetLink extends MacroFunction {
-    constructor() {
-        super((scope, out, index) => {
-            if (!(index instanceof StoreValue) &&
-                (!(index instanceof LiteralValue) || !index.isNumber()))
-                throw new CompilerError("The getlink index must be a number literal or a store");
-            const outBuild = SenseableValue.from(scope, out, EMutability.constant);
-            return [outBuild, [new InstructionBase("getlink", outBuild, index)]];
-        });
-    }
-}
-
-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", "rgbaData"] },
-            },
-            handler(scope, overload, out, ...args) {
-                return [null, [new InstructionBase("control", overload, ...args)]];
-            },
-        }));
-    }
-}
-
-const validRadarFilters = [
-    "any",
-    "enemy",
-    "ally",
-    "player",
-    "attacker",
-    "flying",
-    "boss",
-    "ground",
-];
-const validRadarSorts = [
-    "distance",
-    "health",
-    "shield",
-    "armor",
-    "maxHealth",
-];
-class Radar extends MacroFunction {
-    constructor() {
-        super((scope, out, 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");
-            assertIsArrayMacro(filters, "filters");
-            const { length } = filters.data;
-            if (!(length instanceof LiteralValue) || !length.isNumber())
-                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");
-            assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
-            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
-            return [
-                outUnit,
-                [
-                    new InstructionBase("radar", filter1.data, filter2.data, filter3.data, sort.data, building, order, outUnit),
-                ],
-            ];
-        });
-    }
-}
-
-class Sensor extends MacroFunction {
-    constructor() {
-        super((scope, out, 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 = SenseableValue.from(scope, out, EMutability.readonly);
-            return [temp, [new InstructionBase("sensor", temp, target, property)]];
-        });
-    }
-}
-
-class Wait extends MacroFunction {
-    constructor() {
-        super((scope, out, seconds) => {
-            if (!(seconds instanceof StoreValue) &&
-                !(seconds instanceof LiteralValue && seconds.isNumber()))
-                throw new CompilerError("The wait seconds must be either a number literal or a store");
-            return [null, [new InstructionBase("wait", seconds)]];
-        });
-    }
-}
-
-class Lookup extends ObjectValue {
-    constructor() {
-        const data = createOverloadNamespace({
-            overloads: {
-                block: { args: ["index"] },
-                unit: { args: ["index"] },
-                item: { args: ["index"] },
-                liquid: { args: ["index"] },
-            },
-            handler(scope, overload, out, index) {
-                const output = StoreValue.from(scope, out);
-                return [
-                    output,
-                    [new InstructionBase("lookup", overload, output, index)],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class PackColor extends MacroFunction {
-    constructor() {
-        super((scope, out, ...args) => {
-            if (args.length !== 4) {
-                throw new CompilerError(`Expected 4 arguments, received ${args.length}`);
-            }
-            if (!args.every((value) => value instanceof StoreValue ||
-                (value instanceof LiteralValue && value.isNumber()))) {
-                throw new CompilerError("packColor arguments must be either stores or number literals");
-            }
-            const output = StoreValue.from(scope, out);
-            return [output, [new InstructionBase("packcolor", output, ...args)]];
-        });
-    }
-}
-
-class End extends MacroFunction {
-    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, out, x, y, to, team, rotation) {
-                return [
-                    null,
-                    [
-                        new InstructionBase("setblock", overload, to, x, y, team ?? "@derelict", rotation ?? "0"),
-                    ],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class SpawnUnit extends MacroFunction {
-    constructor() {
-        super((scope, out, 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 = SenseableValue.from(scope, out, EMutability.constant);
-            return [
-                output,
-                [
-                    new InstructionBase("spawn", type, x, y, rotation ?? "0", team, output),
-                ],
-            ];
-        });
-    }
-}
-
-class Stop extends MacroFunction {
-    constructor() {
-        super(() => [
-            null,
-            [
-                assign(new InstructionBase("stop"), {
-                    intent: EInstIntent.exit,
-                }),
-            ],
-        ]);
-    }
-}
-
-class UnitBind extends MacroFunction {
-    constructor() {
-        super((scope, out, unit) => {
-            if (!(unit instanceof StoreValue))
-                throw new CompilerError("The unitBind unit must be a store");
-            return [null, [new InstructionBase("ubind", unit)]];
-        });
-    }
-}
-
-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"],
-                },
-                unbind: {
-                    args: [],
-                },
-            },
-            handler(scope, overload, out, ...args) {
-                let result = null;
-                let extraArgs = [];
-                switch (overload) {
-                    case "getBlock": {
-                        const outType = StoreValue.from(scope, extractDestrucuringOut(out, 0));
-                        const outBuilding = SenseableValue.from(scope, extractDestrucuringOut(out, 1));
-                        const outFloor = StoreValue.from(scope, extractDestrucuringOut(out, 2));
-                        result = ObjectValue.fromArray([outType, outBuilding, outFloor]);
-                        extraArgs = [outType, outBuilding, outFloor];
-                        break;
-                    }
-                    case "within": {
-                        result = StoreValue.from(scope, out);
-                        extraArgs = [result, new LiteralValue(0)];
-                        break;
-                    }
-                }
-                return [
-                    result,
-                    [new InstructionBase("ucontrol", overload, ...args, ...extraArgs)],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class UnitRadar extends MacroFunction {
-    constructor() {
-        super((scope, out, options) => {
-            assertIsObjectMacro(options, "The radar options");
-            const { filters, order, sort } = options.data;
-            assertIsArrayMacro(filters, "filters");
-            const { length } = filters.data;
-            if (!(length instanceof LiteralValue) || !length.isNumber())
-                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");
-            assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
-            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
-            return [
-                outUnit,
-                [
-                    new InstructionBase("uradar", filter1.data, filter2.data, filter3.data, sort.data, "0", // I don't know why, but mindustry requires this extra parameter
-                    order, outUnit),
-                ],
-            ];
-        });
-    }
-}
-
-const validBuildingGroups = [
-    "core",
-    "storage",
-    "generator",
-    "turret",
-    "factory",
-    "repair",
-    "rally",
-    "battery",
-    "reactor",
-];
-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, out, ...args) {
-                const outFound = StoreValue.from(scope, extractDestrucuringOut(out, 0));
-                const outX = StoreValue.from(scope, extractDestrucuringOut(out, 1));
-                const outY = StoreValue.from(scope, extractDestrucuringOut(out, 2));
-                const outBuilding = SenseableValue.from(scope, overload === "ore" ? discardedName : extractDestrucuringOut(out, 3));
-                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;
-                    }
-                }
-                return [
-                    ObjectValue.fromArray([
-                        outFound,
-                        outX,
-                        outY,
-                        ...(overload !== "ore" ? [outBuilding] : []),
-                    ]),
-                    [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-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, out, effect, unit, duration) {
-                if (!(effect instanceof LiteralValue))
-                    throw new CompilerError("The status effect must be a string literal");
-                assertLiteralOneOf(effect, validEffects, "The status effect");
-                return [
-                    null,
-                    [
-                        new InstructionBase("status", String(overload !== "apply"), effect.data, unit, duration),
-                    ],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class SpawnWave extends MacroFunction {
-    constructor() {
-        super((scope, out, 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"] },
-                unitCost: { 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, out, ...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 "unitCost":
-                    case "unitDamage":
-                    case "blockHealth":
-                    case "blockDamage":
-                    case "rtsMinWeight":
-                    case "rtsMinSquad": {
-                        const [team, value] = args;
-                        params[1] = team;
-                        params[0] = 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, out, 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, out, ...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, out, 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, out, 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, out, team, ...rest) {
-                const output = SenseableValue.from(scope, out, EMutability.constant);
-                const params = ["0", "@conveyor"];
-                if (overload === "buildCount") {
-                    params[1] = rest[0];
-                }
-                else {
-                    Object.assign(params, rest);
-                }
-                return [
-                    output,
-                    [new InstructionBase("fetch", overload, output, team, ...params)],
-                ];
-            },
-        });
-        super(data);
-    }
-}
-
-class GetFlag extends MacroFunction {
-    constructor() {
-        super((scope, out, flag) => {
-            const result = StoreValue.from(scope, out);
-            return [result, [new InstructionBase("getflag", result, flag)]];
-        });
-    }
-}
-
-class SetFlag extends MacroFunction {
-    constructor() {
-        super((scope, out, 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, out) {
-        if (this.store)
-            return [this.store, []];
-        const temp = (this.store = StoreValue.from(scope, out));
-        return [
-            temp,
-            [new InstructionBase("read", temp, this.mem.cell, this.prop)],
-        ];
-    }
-    "="(scope, value) {
-        const [data, dataInst] = value.eval(scope);
-        return [
-            data,
-            [
-                ...dataInst,
-                new InstructionBase("write", data, this.mem.cell, this.prop),
-            ],
-        ];
-    }
-    debugString() {
-        return "MemoryEntry";
-    }
-    toString() {
-        return '"[macro MemoryEntry]"';
-    }
-}
-class MemoryMacro extends ObjectValue {
-    constructor(cell, size) {
-        super({
-            length: size,
-            size,
-        });
-        this.cell = cell;
-    }
-    get(scope, key, out) {
-        if (super.hasProperty(scope, key))
-            return super.get(scope, key, out);
-        if (key instanceof LiteralValue && !key.isNumber())
-            throw new CompilerError(`The member [${key.debugString()}] is not present in [${this.debugString()}]`);
-        const entry = new MemoryEntry(scope, this, key);
-        if (out)
-            return entry.eval(scope, out);
-        return [entry, []];
-    }
-    hasProperty(scope, prop) {
-        if ((prop instanceof LiteralValue && prop.isNumber()) ||
-            prop instanceof StoreValue)
-            return true;
-        return super.hasProperty(scope, prop);
-    }
-    debugString() {
-        return `Memory("${this.cell.toString()}")`;
-    }
-    toString() {
-        return '"[macro Memory]"';
-    }
-}
-class MemoryBuilder extends MacroFunction {
-    constructor() {
-        super((scope, out, cell, size = new LiteralValue(64)) => {
-            if (!(cell instanceof SenseableValue))
-                throw new CompilerError("Memory cell must be a senseable value.");
-            if (!(size instanceof LiteralValue && size.isNumber()) &&
-                !(size instanceof StoreValue))
-                throw new CompilerError("The memory size must be a number literal or a store.");
-            if (size.mutability === EMutability.constant) {
-                return [new MemoryMacro(cell, size), []];
-            }
-            const name = extractOutName(out) ?? scope.makeTempName();
-            const store = new StoreValue(`${name}.&len`);
-            const [, inst] = store["="](scope, size);
-            store.mutability = EMutability.constant;
-            return [new MemoryMacro(cell, store), inst];
-        });
-    }
-}
-
-const dynamicVars = ["time", "tick"];
-class NamespaceMacro extends ObjectValue {
-    constructor({ changeCasing = false } = {}) {
-        super();
-        this.changeCasing = changeCasing;
-    }
-    get(scope, key, out) {
-        if (super.hasProperty(scope, key))
-            return super.get(scope, key, out);
-        if (!(key instanceof LiteralValue) || !key.isString())
-            throw new CompilerError("Cannot use dynamic properties on namespace macros");
-        const symbolName = this.changeCasing ? camelToDashCase(key.data) : key.data;
-        const mutability = dynamicVars.includes(symbolName)
-            ? EMutability.readonly
-            : EMutability.constant;
-        const result = new StoreValue(`@${symbolName}`, mutability);
-        return [result, []];
-    }
-    hasProperty(scope, prop) {
-        return prop instanceof LiteralValue && prop.isString();
-    }
-}
-class VarsNamespace extends NamespaceMacro {
-    constructor() {
-        super();
-        Object.assign(this.data, {
-            unit: new SenseableValue("@unit"),
-            this: new SenseableValue("@this"),
-        });
-    }
-}
-
-/**
- * The size of a dynamic array iteration item.
- * Includes the set counter instruction
- */
-const itemSize = 2;
-class DynamicArray extends ObjectValue {
-    constructor(scope, name, values, dynamic) {
-        const getterName = `${name}.&read`;
-        const setterName = `${name}.&write`;
-        const returnName = `${name}.&rt`;
-        const lengthName = getLengthName(name);
-        const lengthStore = new StoreValue(lengthName);
-        const sizeValue = new LiteralValue(values.length);
-        super({
-            fill: new MacroFunction((scope, out, value) => {
-                if (!value)
-                    throw new CompilerError("Missing argument: value");
-                this.initFill();
-                const inst = [];
-                const returnAddress = new LiteralValue(null);
-                pipeInsts(values[0]["="](scope, value), inst);
-                pipeInsts(this.returnTemp["="](scope, returnAddress), inst);
-                inst.push(new JumpInstruction(this.fillAddr, EJumpKind.Always));
-                inst.push(new AddressResolver(returnAddress));
-                if (this.lengthStore) {
-                    pipeInsts(this.lengthStore["="](scope, new LiteralValue(values.length)), inst);
-                }
-                return [null, inst];
-            }, [values[0]]),
-            at: new MacroFunction((scope, out, index) => {
-                const inst = [];
-                const isLiteral = index instanceof LiteralValue;
-                if (isLiteral) {
-                    assertBounds(index, -values.length, values.length - 1);
-                }
-                const indexTemp = isLiteral ? index : StoreValue.from(scope);
-                const address = new LiteralValue(null);
-                if (!isLiteral) {
-                    pipeInsts(indexTemp["="](scope, index), inst);
-                    inst.push(new JumpInstruction(address, EJumpKind.GreaterThanEq, indexTemp, new LiteralValue(0)));
-                }
-                const finalIndex = isLiteral && index.data >= 0
-                    ? index
-                    : pipeInsts(indexTemp["+"](scope, this.lengthStore ?? sizeValue, indexTemp), inst);
-                if (!isLiteral)
-                    inst.push(new AddressResolver(address));
-                const entry = new DynamicArrayEntry({
-                    scope,
-                    array: this,
-                    index: finalIndex,
-                    checked: scope.checkIndexes,
-                });
-                const result = pipeInsts(entry.eval(scope, out), inst);
-                return [result, inst];
-            }),
-            size: sizeValue,
-            ...(dynamic
-                ? {
-                    length: new StoreValue(lengthName, EMutability.readonly),
-                    push: new MacroFunction((scope, out, item) => {
-                        const checked = scope.checkIndexes;
-                        const entry = new DynamicArrayEntry({
-                            scope,
-                            array: this,
-                            index: lengthStore,
-                            checked,
-                        });
-                        const [, inst] = entry["="](scope, item);
-                        return [new LiteralValue(null), inst];
-                    }, [setterName]),
-                    pop: new MacroFunction((scope, out) => {
-                        const checked = scope.checkIndexes;
-                        const inst = [];
-                        const index = pipeInsts(lengthStore["-"](scope, new LiteralValue(1)), inst);
-                        const failAddress = new LiteralValue(null);
-                        const entry = new DynamicArrayEntry({
-                            scope,
-                            array: this,
-                            index,
-                            checked,
-                            newLength: index,
-                            failAddress,
-                        });
-                        const nullLiteral = new LiteralValue(null);
-                        const hasOut = !isDiscardedOut(out);
-                        const result = hasOut
-                            ? pipeInsts(entry.eval(scope, out), inst)
-                            : nullLiteral;
-                        // only add checks if the scope is checked and
-                        // aren't any previous checks
-                        entry.checked = checked && !hasOut;
-                        pipeInsts(entry["="](scope, nullLiteral), inst);
-                        inst.push(new AddressResolver(failAddress));
-                        return [result, inst];
-                    }),
-                    removeAt: new MacroFunction((scope, out, index) => {
-                        if (!index)
-                            throw new CompilerError("Missing index argument");
-                        this.initRemoveAt();
-                        if (index instanceof LiteralValue) {
-                            assertBounds(index, 0, values.length - 1);
-                        }
-                        const checked = scope.checkIndexes;
-                        const hasOut = !isDiscardedOut(out);
-                        const { returnTemp } = this;
-                        const inst = [];
-                        let result = new LiteralValue(null);
-                        const returnAdress = new LiteralValue(null);
-                        const failAddress = new LiteralValue(null);
-                        const upperBound = new JumpInstruction(failAddress, EJumpKind.GreaterThanEq, index, lengthStore);
-                        if (hasOut) {
-                            const entry = new DynamicArrayEntry({
-                                scope,
-                                array: this,
-                                checked: scope.checkIndexes,
-                                index,
-                                failAddress,
-                                upperBound,
-                            });
-                            if (index instanceof LiteralValue) {
-                                const value = pipeInsts(entry.eval(scope), inst);
-                                result = StoreValue.from(scope, out);
-                                pipeInsts(result["="](scope, value), inst);
-                            }
-                            else {
-                                result = pipeInsts(entry.eval(scope, out), inst);
-                            }
-                        }
-                        if (checked) {
-                            if (!hasOut && !(index instanceof LiteralValue)) {
-                                inst.push(new JumpInstruction(failAddress, EJumpKind.LessThan, index, new LiteralValue(0)));
-                            }
-                            if (!hasOut || index instanceof LiteralValue)
-                                inst.push(upperBound);
-                        }
-                        pipeInsts(returnTemp["="](scope, returnAdress), inst);
-                        const counter = new StoreValue(counterName);
-                        inst.push(new InstructionBase("op", "add", counter, this.removeAtAddr, index));
-                        inst.push(new AddressResolver(returnAdress));
-                        pipeInsts(lengthStore["--"](scope, true), inst);
-                        inst.push(new AddressResolver(failAddress));
-                        return [result, inst];
-                    }),
-                }
-                : {}),
-        });
-        this.scope = scope;
-        this.name = name;
-        this.values = values;
-        this.dynamic = dynamic;
-        this.bundledSetter = false;
-        this.bundledGetter = false;
-        this.bundledRemoveAt = false;
-        this.bundledFill = false;
-        this.scope = scope;
-        this.name = name;
-        this.values = values;
-        this.getterTemp = new SenseableValue(getterName, EMutability.mutable);
-        this.setterTemp = new SenseableValue(setterName, EMutability.mutable);
-        this.returnTemp = new StoreValue(returnName);
-        if (dynamic)
-            this.lengthStore = lengthStore;
-        this.getterAddr = new LiteralValue(null);
-        this.setterAddr = new LiteralValue(null);
-        this.removeAtAddr = new LiteralValue(null);
-        this.fillAddr = new LiteralValue(null);
-    }
-    get(scope, index, out) {
-        if (super.hasProperty(scope, index))
-            return super.get(scope, index, out);
-        const { values } = this;
-        if (index instanceof LiteralValue) {
-            assertBounds(index, 0, values.length - 1);
-        }
-        const entry = new DynamicArrayEntry({
-            scope,
-            array: this,
-            index,
-            checked: scope.checkIndexes,
-        });
-        if (out)
-            return entry.eval(scope, out);
-        return [entry, []];
-    }
-    hasProperty(scope, prop) {
-        if (prop instanceof LiteralValue && prop.isNumber()) {
-            return prop.data >= 0 && prop.data < this.values.length;
-        }
-        if (prop instanceof StoreValue)
-            return true;
-        return super.hasProperty(scope, prop);
-    }
-    initGetter() {
-        if (this.bundledGetter)
-            return;
-        this.bundledGetter = true;
-        this.scope.inst.push(new AddressResolver(this.getterAddr));
-        for (const value of this.values) {
-            this.scope.inst.push(new SetInstruction(this.getterTemp, value), new SetCounterInstruction(this.returnTemp));
-        }
-    }
-    initSetter() {
-        if (this.bundledSetter)
-            return;
-        this.bundledSetter = true;
-        this.scope.inst.push(new AddressResolver(this.setterAddr));
-        for (const value of this.values) {
-            this.scope.inst.push(new SetInstruction(value, this.setterTemp), new SetCounterInstruction(this.returnTemp));
-        }
-    }
-    initRemoveAt() {
-        if (this.bundledRemoveAt)
-            return;
-        this.bundledRemoveAt = true;
-        const { inst } = this.scope;
-        inst.push(new AddressResolver(this.removeAtAddr));
-        for (let i = 0; i < this.values.length - 1; i++) {
-            const value = this.values[i];
-            const next = this.values[i + 1];
-            pipeInsts(value["="](this.scope, next), inst);
-        }
-        const last = this.values[this.values.length - 1];
-        pipeInsts(last["="](this.scope, new LiteralValue(null)), inst);
-        inst.push(new SetCounterInstruction(this.returnTemp));
-    }
-    initFill() {
-        if (this.bundledFill)
-            return;
-        this.bundledFill = true;
-        const { inst } = this.scope;
-        inst.push(new AddressResolver(this.fillAddr));
-        const firstValue = this.values[0];
-        for (let i = 1; i < this.values.length; i++) {
-            const value = this.values[i];
-            pipeInsts(value["="](this.scope, firstValue), inst);
-        }
-        inst.push(new SetCounterInstruction(this.returnTemp));
-    }
-    debugString() {
-        const id = this.dynamic ? "DynamicArray" : "MutableArray";
-        return `${id}("${this.name}")`;
-    }
-    toString() {
-        const id = this.dynamic ? "DynamicArray" : "MutableArray";
-        return `"[macro ${id}]"`;
-    }
-}
-class DynamicArrayEntry extends BaseValue {
-    constructor({ array, checked, index, scope, newLength, failAddress, upperBound, }) {
-        super();
-        this.macro = true;
-        this.array = array;
-        this.scope = scope;
-        this.checked = checked;
-        this.index = index;
-        this.newLength = newLength;
-        this.failAddress = failAddress;
-        this.upperBound = upperBound;
-    }
-    eval(scope, out) {
-        const { checked, index } = this;
-        if (index instanceof LiteralValue) {
-            return [this.array.values[index.data], []];
-        }
-        this.array.initGetter();
-        const inst = [];
-        const { getterTemp, values, getterAddr, returnTemp } = this.array;
-        // the value will be stored somewhere
-        // no need to save it in a temporary variable
-        const temp = out instanceof StoreValue
-            ? out
-            : out
-                ? getterTemp
-                : SenseableValue.from(scope, undefined, EMutability.mutable);
-        // used in checked mode, jumps to this address
-        // if the index is out of bounds
-        const failAddr = this.failAddress ?? new LiteralValue(null);
-        if (checked) {
-            inst.push(...temp["="](scope, new LiteralValue(null))[1], new JumpInstruction(failAddr, EJumpKind.LessThan, index, new LiteralValue(0)), this.upperBound ??
-                new JumpInstruction(failAddr, EJumpKind.GreaterThan, index, new LiteralValue(values.length - 1)));
-        }
-        const returnAdress = new LiteralValue(null);
-        pipeInsts(returnTemp["="](scope, returnAdress), inst);
-        const counter = new StoreValue(counterName);
-        const doubleIndex = pipeInsts(index["*"](scope, new LiteralValue(itemSize)), inst);
-        const line = pipeInsts(getterAddr["+"](scope, doubleIndex, counter), inst);
-        pipeInsts(counter["="](scope, line), inst);
-        inst.push(new AddressResolver(returnAdress));
-        // without this you can't access the array twice inside the same expression
-        pipeInsts(temp["="](scope, getterTemp), inst);
-        if (checked && !this.failAddress) {
-            inst.push(new AddressResolver(failAddr));
-        }
-        return [temp, inst];
-    }
-    "="(scope, value) {
-        const { checked, index } = this;
-        const { setterTemp, values, setterAddr, returnTemp, lengthStore } = this.array;
-        const inst = [];
-        // where to jump in checked mode if the index is out of range
-        const failAddress = this.failAddress ?? new LiteralValue(null);
-        if (index instanceof LiteralValue) {
-            const member = values[index.data];
-            pipeInsts(member["="](scope, value), inst);
-        }
-        else {
-            this.array.initSetter();
-            // used in both checked and unchecked modes
-            // indicates where to jump after success
-            const returnAdress = new LiteralValue(null);
-            if (checked) {
-                inst.push(new JumpInstruction(failAddress, EJumpKind.LessThan, index, new LiteralValue(0)), this.upperBound ??
-                    new JumpInstruction(failAddress, EJumpKind.GreaterThan, index, new LiteralValue(values.length - 1)));
-            }
-            pipeInsts(setterTemp["="](scope, value), inst);
-            pipeInsts(returnTemp["="](scope, returnAdress), inst);
-            const counter = new StoreValue(counterName);
-            const doubleIndex = pipeInsts(index["*"](scope, new LiteralValue(itemSize)), inst);
-            const line = pipeInsts(setterAddr["+"](scope, doubleIndex, counter), inst);
-            pipeInsts(counter["="](scope, line), inst);
-            inst.push(new AddressResolver(returnAdress));
-        }
-        if (lengthStore) {
-            if (this.newLength) {
-                pipeInsts(lengthStore["="](scope, this.newLength), inst);
-            }
-            else {
-                const indexIsLength = index.name === lengthStore.name;
-                const len = pipeInsts(index["+"](scope, new LiteralValue(1), indexIsLength ? lengthStore : undefined), inst);
-                if (!indexIsLength)
-                    inst.push(new OperationInstruction("max", lengthStore, len, lengthStore));
-            }
-        }
-        if (!this.failAddress)
-            inst.push(new AddressResolver(failAddress));
-        return [value, inst];
-    }
-    toOut() {
-        return this.array.setterTemp;
-    }
-    debugString() {
-        const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
-        return `${name}Entry`;
-    }
-    toString() {
-        const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
-        return `"[macro ${name}Entry]"`;
-    }
-}
-class DynamicArrayConstructor extends MacroFunction {
-    constructor(dynamic) {
-        super((scope, out, init) => {
-            const name = extractOutName(out) ?? scope.makeTempName();
-            const inst = [];
-            const values = [];
-            let length;
-            if (init instanceof LiteralValue && typeof init.data === "number") {
-                length = init.data;
-            }
-            else if (init instanceof ObjectValue) {
-                assertIsArrayMacro(init, "The array initializer");
-                length = init.data.length.data;
-            }
-            else {
-                throw new CompilerError("The dynamic array initializer must be an array macro or a number literal");
-            }
-            for (let i = 0; i < length; i++) {
-                values.push(new SenseableValue(`${name}->${i}`, EMutability.mutable));
-            }
-            if (init instanceof ObjectValue) {
-                const length = init.data.length.data;
-                for (let i = 0; i < length; i++) {
-                    const value = pipeInsts(init.get(scope, new LiteralValue(i), values[i]), inst);
-                    pipeInsts(values[i]["="](scope, value), inst);
-                }
-            }
-            if (dynamic) {
-                const lengthStore = new StoreValue(getLengthName(name));
-                pipeInsts(lengthStore["="](scope, new LiteralValue(init instanceof ObjectValue ? length : 0)), inst);
-            }
-            return [new DynamicArray(scope, name, values, dynamic), inst];
-        });
-    }
-}
-const getLengthName = (name) => `${name}.&len`;
-function assertBounds(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-index, min, max) {
-    if (!index.isNumber())
-        throw new CompilerError("The index must be a store or a number literal");
-    if (index.data < min || index.data > max)
-        throw new CompilerError(`The index "${index.data}" is out of bounds: [${min}, ${max}]`);
-}
-
-class Unchecked extends MacroFunction {
-    constructor() {
-        super((scope, out, expression) => [expression, []]);
-    }
-    preCall(scope, out) {
-        scope.checkIndexes = false;
-        if (out)
-            return [out];
-    }
-    postCall(scope) {
-        scope.checkIndexes = true;
-    }
-}
-
-class GetGlobal extends MacroFunction {
-    constructor(mutability) {
-        super((scope, out, name) => {
-            if (!(name instanceof LiteralValue) || !name.isString())
-                throw new CompilerError("The name parameter must be a string literal.");
-            const result = new SenseableValue(name.data, mutability);
-            return [result, []];
-        });
-    }
-}
-
-class Asm extends MacroFunction {
-    constructor() {
-        super((scope, out, 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) {
-    scope.hardSet("undefined", new LiteralValue(null));
-    // namespaces
-    scope.hardSet("ControlKind", new NamespaceMacro());
-    scope.hardSet("Vars", new VarsNamespace());
-    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(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());
-    scope.hardSet("MutableArray", new DynamicArrayConstructor(false));
-    scope.hardSet("DynamicArray", new DynamicArrayConstructor(true));
-    scope.hardSet("unchecked", new Unchecked());
-    // commands
-    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, 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);
-            if (needsEndInstruction(valueInst[1], scope)) {
-                valueInst[1].push(new EndInstruction());
-            }
-            valueInst[1].push(...scope.inst);
-            hideRedundantJumps(valueInst[1]);
-            this.resolve(valueInst);
-            output = this.serialize(valueInst) + "\n";
-            if (this.sourcemap) {
-                sourcemaps = this.mapSources(valueInst);
-            }
-        }
-        catch (error) {
-            const err = error instanceof CompilerError ? error : CompilerError.from(error);
-            return [null, err];
-        }
-        return [output, null, sourcemaps];
-    }
-    resolve(valueInst) {
-        let i = 0;
-        for (const inst of valueInst[1]) {
-            inst.resolve(i);
-            if (!inst.hidden)
-                i++;
-        }
-    }
-    serialize(resLines) {
-        const [, inst] = resLines;
-        return inst.filter(l => !l.hidden).join("\n");
-    }
-    parse(script) {
-        return parse(script, {
-            ranges: true,
-            plugins: ["typescript"],
-        });
-    }
-    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], out) {
-        try {
-            if (!handler)
-                throw new CompilerError("Missing handler for " + node.type);
-            const result = handler(this, scope, node, out, null);
-            if (this.sourcemap)
-                return appendSourceLocations(result, node);
-            return result;
-        }
-        catch (error) {
-            if (error instanceof CompilerError) {
-                error.loc ??= node.loc;
-            }
-            throw error;
-        }
-    }
-    /** Handles the node and asserts that it resolves to a value. */
-    handleValue(scope, node, handler = this.handlers[node.type], out) {
-        const result = this.handle(scope, node, handler, out);
-        if (!result[0])
-            throw new CompilerError(`This node (${node.type}) did not return a value`, node);
-        return result;
-    }
-    handleEval(scope, node, out) {
-        const [res, inst] = this.handleValue(scope, node, undefined, out);
-        const [evaluated, evaluatedInst] = res.eval(scope, out);
-        const result = [evaluated, [...inst, ...evaluatedInst]];
-        if (this.sourcemap)
-            return appendSourceLocations(result, node);
-        return result;
-    }
-    /**
-     * 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}
-     * and {@link handleMany})
-     *
-     */
-    handleMany(scope, nodes, handler) {
-        const lines = [];
-        for (const node of hoistedFunctionNodes(nodes)) {
-            pipeInsts(this.handle(scope, node, handler && (() => handler(node))), lines);
-        }
-        return [null, lines];
-    }
-}
-function* hoistedFunctionNodes(nodes) {
-    // sorting is O(n long n) while this is just O(n)
-    // besides, it's better not to modify the node array
-    for (const node of nodes) {
-        if (node.type === "FunctionDeclaration") {
-            yield node;
-        }
-    }
-    for (const node of nodes) {
-        if (node.type !== "FunctionDeclaration") {
-            yield node;
-        }
-    }
-}
-function needsEndInstruction(inst, scope) {
-    const last = inst[inst.length - 1];
-    if (last instanceof AddressResolver)
-        return true;
-    return scope.inst.length > 0;
-}
-
-export { Compiler, CompilerError };
+export { C as Compiler, a as CompilerError } from './Compiler-7GMG4MDr.js';
+import '@babel/parser';
+import '@babel/types';