mlogjs 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,2195 @@
+import { parse } from '@babel/parser';
+import * as es from '@babel/types';
+
+class CompilerError extends Error {
+    constructor(message, nodeStack = []) {
+        super(message);
+        this.nodeStack = nodeStack;
+    }
+}
+
+/** Defines the possible types of mutability of a value */
+var EMutability;
+(function (EMutability) {
+    /**
+     * The value can be changed by the user's code,
+     * by the mlog runtime, or us
+     */
+    EMutability[EMutability["mutable"] = 0] = "mutable";
+    /**
+     * The value cannot be directly assigned,
+     * but it's still not safe from mutations coming from the runtime.
+     */
+    EMutability[EMutability["readonly"] = 1] = "readonly";
+    /** Constant values, won't change during execution */
+    EMutability[EMutability["constant"] = 2] = "constant";
+})(EMutability || (EMutability = {}));
+
+const arithmeticBinaryOperators = [
+    "*",
+    "**",
+    "+",
+    "-",
+    "/",
+    "%",
+];
+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];
+
+class VoidValue {
+    constructor(scope) {
+        this.owner = null;
+        this.mutability = EMutability.mutable;
+        this.macro = false;
+        this.scope = scope;
+    }
+    eval(_scope) {
+        throw new CompilerError(`${this} cannot eval.`);
+    }
+    consume(_scope) {
+        throw new CompilerError(`${this} cannot be consumed.`);
+    }
+    call(_scope, _args) {
+        throw new CompilerError(`${this} cannot call.`);
+    }
+    get(_scope, _name) {
+        throw new CompilerError(`${this} cannot get.`);
+    }
+    ensureOwned() {
+        throw new CompilerError(`${this} cannot be owned`);
+    }
+    toString() {
+        return "void";
+    }
+}
+for (const key of operators) {
+    VoidValue.prototype[key] = function () {
+        console.log(this);
+        throw new CompilerError(`${this} cannot '${key}' operation.`);
+    };
+}
+
+class InstructionBase {
+    constructor(...args) {
+        this._hidden = false;
+        this.args = args;
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+    }
+    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);
+    }
+}
+
+class SetInstruction extends InstructionBase {
+    constructor(store, value) {
+        super("set", store, value);
+    }
+    get hidden() {
+        return this._hidden || !this.args[1].owner;
+    }
+}
+
+class EndInstruction extends InstructionBase {
+    constructor() {
+        super("end");
+    }
+}
+
+class AddressResolver extends InstructionBase {
+    constructor(...bonds) {
+        super();
+        this.bonds = bonds;
+    }
+    get hidden() {
+        return true;
+    }
+    set hidden(value) { }
+    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);
+    }
+}
+
+class SetCounterInstruction extends InstructionBase {
+    constructor(value) {
+        super("set", "@counter", value);
+    }
+}
+
+class ZeroSpaceInstruction extends InstructionBase {
+    toString() {
+        return this.args.join("");
+    }
+}
+
+class BreakInstruction extends JumpInstruction {
+    constructor(address) {
+        super(address, EJumpKind.Always);
+    }
+}
+class ContinueInstruction extends JumpInstruction {
+    constructor(address) {
+        super(address, EJumpKind.Always);
+    }
+}
+
+class ValueOwner {
+    /**
+     * Creates a new `ValueOwner`, if `value` is already owned,
+     * `this` will be aliased to `value`, else `this` will own `value`
+     */
+    constructor({ scope, constant = false, value, identifier, name, }) {
+        this.scope = scope;
+        this.constant = constant;
+        this.value = value;
+        this.identifier = identifier;
+        this.name = name ?? scope.makeTempName();
+        this.persistent = !!name;
+        this.owned = new Set();
+        if (!value.owner?.persistent)
+            this.own(value);
+    }
+    own(target) {
+        target.owner = this;
+        this.owned.add(target);
+    }
+    replace(target) {
+        this.value.owner = null;
+        this.owned.delete(this.value);
+        this.value = target;
+        this.own(target);
+    }
+    moveInto(owner) {
+        this.owned.forEach(value => owner.own(value));
+        this.owned.clear();
+    }
+}
+
+class BaseValue extends VoidValue {
+    "u-"(scope) {
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
+        return [
+            temp,
+            [
+                ...inst,
+                new OperationInstruction("sub", temp, new LiteralValue(scope, 0), that),
+            ],
+        ];
+    }
+    "u+"(scope) {
+        // TODO: should it return 0 + this ?
+        return this.eval(scope);
+    }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
+}
+const operatorMap$1 = {
+    "==": "equal",
+    "===": "strictEqual",
+    "!=": "notEqual",
+    "!==": "notEqual",
+    "<": "lessThan",
+    ">": "greaterThan",
+    "<=": "lessThanEq",
+    ">=": "greaterThanEq",
+    "+": "add",
+    "-": "sub",
+    "*": "mul",
+    "/": "div",
+    "%": "mod",
+    "**": "pow",
+    "|": "or",
+    "&": "and",
+    "^": "xor",
+    ">>": "shr",
+    ">>>": "shr",
+    "<<": "shl",
+    "&&": "land",
+    "||": "or",
+};
+for (const key in operatorMap$1) {
+    const kind = operatorMap$1[key];
+    BaseValue.prototype[key] = function (scope, value) {
+        const [left, leftInst] = this.consume(scope);
+        const [right, rightInst] = value.consume(scope);
+        const temp = new StoreValue(scope);
+        return [
+            temp,
+            [
+                ...leftInst,
+                ...rightInst,
+                new OperationInstruction(kind, temp, left, right),
+            ],
+        ];
+    };
+}
+const unaryOperatorMap$1 = {
+    "!": "not",
+    "~": "flip",
+};
+for (const key in unaryOperatorMap$1) {
+    const name = unaryOperatorMap$1[key];
+    BaseValue.prototype[key] = function (scope) {
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
+        return [temp, [...inst, new OperationInstruction(name, temp, that, null)]];
+    };
+}
+const assignmentToBinary = {
+    "+=": "+",
+    "-=": "-",
+    "*=": "*",
+    "/=": "/",
+    "%=": "%",
+    "**=": "**",
+    "|=": "|",
+    "&=": "&",
+    "^=": "^",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "<<=": "<<",
+    "&&=": "&&",
+    "||=": "||",
+};
+for (const op in assignmentToBinary) {
+    BaseValue.prototype[op] = function (scope, value) {
+        this.ensureOwned();
+        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value);
+        const [retValue, retInst] = this["="](scope, opValue);
+        return [retValue, [...opInst, ...retInst]];
+    };
+}
+for (const key of updateOperators) {
+    BaseValue.prototype[key] = function (scope, prefix) {
+        let [ret, inst] = this.consume(scope);
+        if (!prefix) {
+            const temp = new StoreValue(scope);
+            const [tempValue, tempInst] = temp["="](scope, ret);
+            ret = tempValue;
+            inst.push(...tempInst);
+        }
+        const kind = key === "++" ? "+=" : "-=";
+        return [
+            ret,
+            [...inst, ...this[kind](scope, new LiteralValue(scope, 1))[1]],
+        ];
+    };
+}
+
+const literalMethods = {
+    length: function (scope) {
+        if (typeof this.data !== "string")
+            throw new CompilerError("Length method only works on string literal values.");
+        return new LiteralValue(scope, this.data.length);
+    },
+};
+class LiteralValue extends BaseValue {
+    constructor(scope, data) {
+        super(scope);
+        this.mutability = EMutability.constant;
+        this.data = data;
+    }
+    eval(_scope) {
+        return [this, []];
+    }
+    consume(_scope) {
+        return [this, []];
+    }
+    toString() {
+        return JSON.stringify(this.data);
+    }
+    get(scope, name) {
+        if (!(name instanceof LiteralValue && typeof name.data === "string"))
+            return super.get(scope, name);
+        const method = literalMethods[name.data];
+        if (!method)
+            throw new CompilerError(`Method ${name.data} does not exist on literal values.`);
+        return [method.apply(this, [scope]), []];
+    }
+    get num() {
+        if (this.data === null)
+            return 0;
+        if (typeof this.data === "string")
+            return 1;
+        return this.data;
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "literal"), []];
+    }
+}
+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 key in operatorMap) {
+    const fn = operatorMap[key];
+    LiteralValue.prototype[key] = function (scope, value) {
+        if (!(value instanceof LiteralValue)) {
+            return BaseValue.prototype[key].apply(this, [scope, value]);
+        }
+        return [new LiteralValue(scope, fn(this.num, value.num)), []];
+    };
+}
+const unaryOperatorMap = {
+    "!": v => +!v,
+    "~": v => ~v,
+    "u-": v => -v,
+};
+for (const key in unaryOperatorMap) {
+    LiteralValue.prototype[key] = function (scope) {
+        const fn = unaryOperatorMap[key];
+        return [new LiteralValue(scope, fn(this.num)), []];
+    };
+}
+
+/**
+ * The prefix for internal variables inside the compiler output
+ */
+const internalPrefix = "&";
+const discardedName = `${internalPrefix}_`;
+/**
+ * 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()}`);
+}
+const itemNames = [
+    "copper",
+    "lead",
+    "metaglass",
+    "graphite",
+    "sand",
+    "coal",
+    "titanium",
+    "thorium",
+    "scrap",
+    "silicon",
+    "plastanium",
+    "phaseFabric",
+    "surgeAlloy",
+    "sporePod",
+    "blastCompound",
+    "pyratite",
+];
+/**
+ * A more type safe version of `Object.assign`
+ */
+function assign(obj, props) {
+    return Object.assign(obj, props);
+}
+
+/**
+ * `StoreValue` represents values unknown at compile time,
+ * mostly used with mutable variables and temporary values
+ */
+class StoreValue extends BaseValue {
+    constructor(scope) {
+        super(scope);
+        this.mutability = EMutability.mutable;
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "store"), []];
+    }
+    "="(scope, value) {
+        if (this.mutability !== EMutability.mutable)
+            throw new CompilerError(`Cannot assign to immutable store '${this}'.`);
+        if (this.owner) {
+            if (this.owner === value.owner && value instanceof StoreValue)
+                return [this, []];
+            if (!value.owner?.persistent) {
+                if (!value.owner)
+                    this.owner.own(value);
+                else
+                    value.owner.moveInto(this.owner);
+                if (value instanceof StoreValue)
+                    return [this, []];
+            }
+        }
+        const [evalValue, evalInst] = value.consume(scope);
+        return [this, [...evalInst, new SetInstruction(this, evalValue)]];
+    }
+    eval(_scope) {
+        return [this, []];
+    }
+    consume(_scope) {
+        this.ensureOwned();
+        return [this, []];
+    }
+    toString() {
+        return this.owner?.name ?? discardedName;
+    }
+}
+
+class ObjectValue extends VoidValue {
+    constructor(scope, data = {}) {
+        super(scope);
+        this.mutability = EMutability.constant;
+        this.macro = true;
+        this.data = data;
+    }
+    static fromArray(scope, items) {
+        const data = {
+            length: new LiteralValue(scope, items.length),
+        };
+        items.forEach((item, i) => {
+            if (item)
+                data[i] = item;
+        });
+        return new ObjectValue(scope, data);
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "object"), []];
+    }
+    get(scope, key) {
+        // 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
+            const member = this.data[key.data];
+            return [member, []];
+        }
+        const { $get } = this.data;
+        if (!$get)
+            throw new CompilerError("Cannot get undefined member.");
+        return $get.call(scope, [key]);
+    }
+    eval(scope) {
+        const { $eval } = this.data;
+        if (!$eval)
+            return [this, []];
+        return $eval.call(scope, []);
+    }
+    consume(scope) {
+        const { $consume } = this.data;
+        if ($consume)
+            return $consume.call(scope, []);
+        const result = this.eval(scope);
+        // required by typescript
+        const res = result[0];
+        res.ensureOwned();
+        return result;
+    }
+    call(scope, args) {
+        const { $call } = this.data;
+        if (!$call)
+            return super.call(scope, args);
+        return $call.call(scope, args);
+    }
+    ensureOwned() {
+        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
+    }
+}
+for (const op of operators) {
+    ObjectValue.prototype[op] = function (...args) {
+        const $ = this.data[`$${op}`];
+        // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return
+        if (!$)
+            return VoidValue.prototype[op].apply(this, args);
+        const [scope, ...fnArgs] = args;
+        return $.call(scope, fnArgs);
+    };
+}
+
+/**
+ * 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 `false` if you want them to be assignable. Example:
+ * ```
+ * const value = assign(new SenseableValue(scope), {
+ *   mutability: EMutability.mutable
+ * })
+ * ```
+ */
+class SenseableValue extends StoreValue {
+    constructor(scope) {
+        super(scope);
+        this.mutability = EMutability.constant;
+    }
+    get(scope, prop) {
+        if (prop instanceof LiteralValue && typeof prop.data === "string") {
+            const name = itemNames.includes(prop.data)
+                ? camelToDashCase(prop.data)
+                : prop.data;
+            const result = senseableProps.includes(prop.data)
+                ? new SenseableValue(scope)
+                : new StoreValue(scope);
+            return [
+                result,
+                [new InstructionBase("sensor", result, this, `@${name}`)],
+            ];
+        }
+        if (prop instanceof StoreValue) {
+            const temp = new StoreValue(scope);
+            return [temp, [new InstructionBase("sensor", temp, this, prop)]];
+        }
+        throw new CompilerError(`Cannot sense "${prop}" property`);
+    }
+}
+
+/**
+ * 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(scope, members) {
+        super(scope);
+        this.members = members;
+        this.macro = true;
+    }
+    "="(scope, right) {
+        const inst = [];
+        for (const [key, value] of this.members) {
+            const [item, itemInst] = right.get(scope, key);
+            inst.push(...itemInst);
+            inst.push(...value["="](scope, item)[1]);
+        }
+        return [right, inst];
+    }
+    eval(_scope) {
+        return [this, []];
+    }
+    consume(_scope) {
+        return [this, []];
+    }
+}
+
+class Scope {
+    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = []) {
+        this.parent = parent;
+        this.stacked = stacked;
+        this.ntemp = ntemp;
+        this.name = name;
+        this.inst = inst;
+        this.data = values;
+    }
+    copy() {
+        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst);
+        scope.break = this.break;
+        scope.continue = this.continue;
+        scope.function = this.function;
+        return scope;
+    }
+    createScope() {
+        const scope = this.copy();
+        scope.data = {};
+        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 owner = this.data[identifier];
+        if (owner)
+            return owner.value;
+        if (this.parent)
+            return this.parent.get(identifier);
+        throw new CompilerError(`${identifier} is not declared.`);
+    }
+    set(...args) {
+        const name = args.length === 1 ? args[0].identifier : args[0];
+        if (!name)
+            throw new CompilerError("Values in a scope must have an identifier");
+        if (name in this.data)
+            throw new CompilerError(`${name} is already declared.`);
+        return this.hardSet(...args);
+    }
+    hardSet(...args) {
+        const owner = args.length === 1
+            ? args[0]
+            : new ValueOwner({
+                scope: this,
+                identifier: args[0],
+                name: args[0],
+                value: args[1],
+            });
+        const { identifier } = owner;
+        if (!identifier)
+            throw new CompilerError("Values in a scope must have an identifier");
+        this.data[identifier] = owner;
+        return owner.value;
+    }
+    make(identifier, name) {
+        const owner = new ValueOwner({
+            scope: this,
+            value: assign(new SenseableValue(this), {
+                mutability: EMutability.mutable,
+            }),
+            identifier,
+            name,
+        });
+        return this.set(owner);
+    }
+    makeTempName() {
+        let result = `${internalPrefix}t${this.ntemp}`;
+        if (this.name)
+            result += `:${this.name}`;
+        this.ntemp++;
+        return result;
+    }
+}
+
+const Program = (c, scope, node) => {
+    return c.handleMany(scope ?? new Scope({}), node.body);
+};
+
+const VariableDeclaration = (c, scope, node) => {
+    return c.handleMany(scope, node.declarations, (scope, child) => VariableDeclarator(c, scope, child, node.kind));
+};
+const VariableDeclarator = (c, scope, node, kind = "let") => {
+    const [init, inst] = node.init
+        ? c.handleEval(scope, node.init)
+        : [null, []];
+    inst.push(...Declare(c, scope, node.id, kind, init)[1]);
+    return [null, inst];
+};
+const Declare = (c, scope, node, kind, init) => {
+    switch (node.type) {
+        case "Identifier":
+            return DeclareIdentifier(c, scope, node, kind, init);
+        case "ArrayPattern":
+            return DeclareArrayPattern(c, scope, node, kind, init);
+        case "ObjectPattern":
+            return DeclareObjectPattern(c, scope, node, kind, init);
+        default:
+            throw new CompilerError(`Unsupported declaration type: ${node.type}`, [
+                node,
+            ]);
+    }
+};
+const DeclareIdentifier = (c, scope, node, kind, init) => {
+    const { name: identifier } = node;
+    const name = nodeName(node, !c.compactNames && identifier);
+    if (kind === "const" && !init)
+        throw new CompilerError("Constants must be initialized.", [node]);
+    if (kind === "const" && init?.mutability === EMutability.constant) {
+        const owner = new ValueOwner({
+            scope,
+            identifier,
+            name,
+            value: init,
+            constant: true,
+        });
+        scope.set(owner);
+        return [null, []];
+    }
+    else {
+        const value = scope.make(identifier, name);
+        const inst = [];
+        if (init) {
+            if (init.macro)
+                throw new CompilerError("Macro values must be held by constants", [
+                    node,
+                ]);
+            inst.push(...value["="](scope, init)[1]);
+        }
+        if (kind === "const")
+            value.mutability = EMutability.constant;
+        return [null, inst];
+    }
+};
+const DeclareArrayPattern = (c, scope, node, kind, init) => {
+    const { elements } = node;
+    if (!(init instanceof ObjectValue))
+        throw new CompilerError("The value being destructured must be an object value");
+    const inst = [];
+    for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        if (!element)
+            continue;
+        const val = init.data[i];
+        if (!val)
+            throw new CompilerError(`The target object does not have a value at index ${i}`, [element]);
+        inst.push(...Declare(c, scope, element, kind, val)[1]);
+    }
+    return [null, inst];
+};
+const DeclareObjectPattern = (c, scope, node, kind, base) => {
+    if (!base)
+        throw new CompilerError("Cannot use object destructuring without an initializer", [node]);
+    const { properties } = node;
+    const [init, inst] = base.consume(scope);
+    for (const prop of properties) {
+        if (prop.type === "RestElement")
+            throw new CompilerError("The rest operator is not supported", [prop]);
+        const { key, value } = prop;
+        const child = key.type === "Identifier" && !prop.computed
+            ? [new LiteralValue(scope, key.name), []]
+            : c.handleConsume(scope, prop.key);
+        inst.push(...child[1]);
+        const propInit = init.get(scope, child[0]);
+        inst.push(...propInit[1]);
+        inst.push(...Declare(c, scope, value, kind, propInit[0])[1]);
+    }
+    return [null, inst];
+};
+
+const Literal = (_c, scope, node) => [new LiteralValue(scope, node.value), []];
+const NumericLiteral = Literal;
+const StringLiteral = Literal;
+const NullLiteral = (_c, scope) => [
+    new LiteralValue(scope, null),
+    [],
+];
+const BooleanLiteral = (_c, scope, node) => [new LiteralValue(scope, +node.value), []];
+
+const LRExpression = (c, scope, node) => {
+    const [left, leftInst] = c.handleConsume(scope, node.left);
+    const [right, rightInst] = c.handleConsume(scope, node.right);
+    const [op, opInst] = left[node.operator](scope, right);
+    return [op, [...leftInst, ...rightInst, ...opInst]];
+};
+const BinaryExpression = LRExpression;
+const LogicalExpression = LRExpression;
+const AssignmentExpression = (c, scope, node) => {
+    const [left, leftInst] = c.handle(scope, node.left);
+    // doesn't need to consume because the operators already do that
+    const [right, rightInst] = c.handleEval(scope, node.right);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [op, opInst] = left[node.operator](scope, right);
+    return [op, [...leftInst, ...rightInst, ...opInst]];
+};
+const UnaryExpression = (c, scope, { argument, operator }) => {
+    const [arg, argInst] = c.handleConsume(scope, argument);
+    const operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
+    if (operatorId === "throw")
+        throw new CompilerError("throw operator is not supported");
+    const [op, opInst] = arg[operatorId](scope);
+    return [op, [...argInst, ...opInst]];
+};
+const UpdateExpression = (c, scope, { argument, operator, prefix }) => {
+    const [arg, argInst] = c.handle(scope, argument);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [op, opInst] = arg[operator](scope, prefix);
+    return [op, [...argInst, ...opInst]];
+};
+const ConditionalExpression = (c, scope, node) => {
+    const [test, testInst] = c.handleConsume(scope, node.test);
+    if (test instanceof LiteralValue) {
+        if (test.data)
+            return c.handleEval(scope, node.consequent);
+        return c.handleEval(scope, node.alternate);
+    }
+    // TODO: this creates those annoying jumps on the
+    // temp counter, specially if you nest ternary operators
+    const result = new StoreValue(scope);
+    result.ensureOwned();
+    const consequent = c.handleEval(scope, node.consequent);
+    const alternate = c.handleEval(scope, node.alternate);
+    const alternateStartAdress = new LiteralValue(scope, null);
+    const endExpressionAdress = new LiteralValue(scope, null);
+    return [
+        result,
+        [
+            ...testInst,
+            new JumpInstruction(alternateStartAdress, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
+            ...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 Identifier = (c, scope, node) => {
+    return [scope.get(node.name), []];
+};
+
+const ExpressionStatement = (c, scope, node) => {
+    return c.handle(scope, node.expression);
+};
+const BreakStatement = (_, scope) => {
+    const addr = new LiteralValue(scope, null);
+    scope.break.bind(addr);
+    return [null, [new BreakInstruction(addr)]];
+};
+const ContinueStatement = (_, scope) => {
+    const addr = new LiteralValue(scope, null);
+    scope.continue.bind(addr);
+    return [null, [new ContinueInstruction(addr)]];
+};
+const ReturnStatement = (c, scope, node) => {
+    const [arg, argInst] = node.argument
+        ? c.handle(scope, node.argument)
+        : [null, []];
+    const [ret, retInst] = scope.function.return(scope, arg);
+    return [ret, [...argInst, ...retInst]];
+};
+
+const IfStatement = (c, scope, node) => {
+    const inst = [];
+    const [test, testInst] = c.handleConsume(scope, node.test);
+    if (test instanceof LiteralValue) {
+        if (test.data)
+            inst.push(...c.handle(scope, node.consequent)[1]);
+        else if (node.alternate)
+            inst.push(...c.handle(scope, node.alternate)[1]);
+        return [null, inst];
+    }
+    const endIfAddr = new LiteralValue(scope, null);
+    inst.push(...testInst, new JumpInstruction(endIfAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...c.handle(scope, node.consequent)[1], new AddressResolver(endIfAddr));
+    const endElseAddr = new LiteralValue(scope, null);
+    if (node.alternate)
+        inst.push(new JumpInstruction(endElseAddr, EJumpKind.Always), new AddressResolver(endIfAddr), ...c.handle(scope, node.alternate)[1], new AddressResolver(endElseAddr));
+    return [null, inst];
+};
+
+const WhileStatement = (c, scope, node) => {
+    const lines = [];
+    const [test, testLines] = c.handleConsume(scope, node.test);
+    const startLoopAddr = new LiteralValue(scope, null);
+    const endLoopAddr = new LiteralValue(scope, null);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
+    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    if (test instanceof LiteralValue) {
+        if (test.data) {
+            lines.push(startLoopLine, ...c.handle(scope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+        }
+        return [null, lines];
+    }
+    lines.push(startLoopLine, ...testLines, new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)), ...c.handle(scope, node.body)[1], new JumpInstruction(startLoopAddr, EJumpKind.Always), endLoopLine);
+    return [null, lines];
+};
+const DoWhileStatement = (c, scope, node) => {
+    const lines = [];
+    const [test, testLines] = c.handleConsume(scope, node.test);
+    const startLoopAddr = new LiteralValue(scope, null);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
+    const [, bodyLines] = c.handle(scope, node.body);
+    if (test instanceof LiteralValue) {
+        if (!test.data)
+            return [null, [...lines, ...bodyLines]];
+        return [
+            null,
+            [
+                ...lines,
+                startLoopLine,
+                ...bodyLines,
+                new JumpInstruction(startLoopAddr, EJumpKind.Always),
+            ],
+        ];
+    }
+    lines.push(startLoopLine, ...bodyLines, ...testLines, new JumpInstruction(startLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 1)));
+    return [null, lines];
+};
+
+const ForStatement = (c, scope, node) => {
+    scope = scope.createScope();
+    const initInst = node.init ? c.handle(scope, node.init)[1] : [];
+    const [test, testLines] = node.test
+        ? c.handleConsume(scope, node.test)
+        : [new LiteralValue(scope, 1), []];
+    const updateLines = node.update ? c.handle(scope, node.update)[1] : [];
+    const startLoopAddr = new LiteralValue(scope, null);
+    const endLoopAddr = new LiteralValue(scope, null);
+    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
+    const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    return [
+        null,
+        [
+            ...initInst,
+            startLoopLine,
+            ...testLines,
+            new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(scope, 0)),
+            ...c.handle(scope, node.body)[1],
+            ...updateLines,
+            new JumpInstruction(startLoopAddr, EJumpKind.Always),
+            endLoopLine,
+        ],
+    ];
+};
+
+class FunctionValue extends VoidValue {
+    constructor({ scope, params, body, c, node, }) {
+        super(scope);
+        this.mutability = EMutability.constant;
+        this.macro = true;
+        this.paramOwners = [];
+        this.bundled = false;
+        this.initialized = false;
+        this.body = body;
+        this.c = c;
+        this.node = node;
+        this.params = params;
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "function"), []];
+    }
+    initScope(name) {
+        this.childScope = this.scope.createFunction(name);
+        this.childScope.function = this;
+        for (const id of this.params) {
+            const name = nodeName(id, !this.c.compactNames && id.name);
+            const owner = new ValueOwner({
+                scope: this.childScope,
+                value: new StoreValue(this.childScope),
+                identifier: id.name,
+                name,
+            });
+            this.childScope.set(owner);
+            this.paramOwners.push(owner);
+        }
+        this.callSize = this.paramOwners.length + 2;
+    }
+    ensureInit() {
+        if (!this.owner)
+            throw new CompilerError(`Functions must be owned by a variable`);
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const { name } = this.owner;
+        this.initScope(name);
+        this.addr = new LiteralValue(this.childScope, null);
+        this.temp = new ValueOwner({
+            scope: this.childScope,
+            name: `${internalPrefix}f${name}`,
+            value: assign(new SenseableValue(this.childScope), {
+                mutability: EMutability.mutable,
+            }),
+        });
+        this.ret = new ValueOwner({
+            scope: this.childScope,
+            name: `${internalPrefix}r${name}`,
+            value: new StoreValue(this.childScope),
+        });
+        this.inst = [
+            new AddressResolver(this.addr),
+            ...this.c.handle(this.childScope, this.body)[1],
+        ];
+        if (!endsWithReturn(this.inst)) {
+            this.inst.push(new SetCounterInstruction(this.ret.value));
+        }
+    }
+    normalReturn(scope, arg) {
+        const argInst = arg ? this.temp.value["="](scope, arg)[1] : [];
+        return [null, [...argInst, new SetCounterInstruction(this.ret.value)]];
+    }
+    normalCall(scope, args) {
+        if (!this.bundled)
+            this.childScope.inst.push(...this.inst);
+        this.bundled = true;
+        const callAddressLiteral = new LiteralValue(scope, null);
+        const inst = this.paramOwners
+            .map(({ value: param }, i) => param["="](scope, args[i])[1])
+            .reduce((s, c) => s.concat(c), [])
+            .concat(...this.ret.value["="](scope, callAddressLiteral)[1], new JumpInstruction(this.addr, EJumpKind.Always), new AddressResolver(callAddressLiteral));
+        return [this.temp.value, inst];
+    }
+    inlineReturn(scope, arg) {
+        const argInst = arg ? this.inlineTemp.value["="](scope, arg)[1] : [];
+        return [null, argInst];
+    }
+    inlineCall(scope, args) {
+        // create return value
+        this.inlineTemp = new ValueOwner({
+            scope: this.childScope,
+            value: assign(new SenseableValue(scope), {
+                mutability: EMutability.mutable,
+            }),
+        });
+        this.inlineEnd = new LiteralValue(scope, null);
+        // make a copy of the function scope
+        const fnScope = this.childScope.copy();
+        // hard set variables within the function scope
+        this.paramOwners.forEach((owner, i) => {
+            const value = args[i];
+            if (!value.owner?.persistent)
+                owner.own(value);
+            fnScope.hardSet(new ValueOwner({
+                scope: fnScope,
+                value,
+                identifier: owner.identifier,
+                name: owner.name,
+            }));
+        });
+        this.tryingInline = true;
+        const inst = this.c.handle(fnScope, this.body)[1];
+        this.tryingInline = false;
+        // removing useless instruction
+        // get the last instructions
+        // const [jump] = inst.slice(-1);
+        // if (jump instanceof JumpInstruction) {
+        // 	// remove useless jump
+        // 	if (jump.args[1] === this.inlineEnd) inst.pop();
+        // }
+        inst.push(new AddressResolver(this.inlineEnd));
+        // return the function value
+        return [this.inlineTemp.value, inst];
+    }
+    call(scope, args) {
+        this.ensureInit();
+        if (args.length !== this.paramOwners.length)
+            throw new CompilerError("Cannot call: argument count not matching.");
+        const inlineCall = this.inlineCall(scope, args);
+        const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
+        if (this.inline || inlineSize <= this.callSize)
+            return inlineCall;
+        return this.normalCall(scope, args);
+    }
+    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, []];
+    }
+    consume(_scope) {
+        return [this, []];
+    }
+}
+function endsWithReturn(inst) {
+    for (let i = inst.length - 1; i >= 0; i--) {
+        const instruction = inst[i];
+        if (instruction.hidden)
+            continue;
+        return instruction instanceof SetCounterInstruction;
+    }
+    return false;
+}
+
+function handleFunctionNode(c, scope, node) {
+    let { params, body } = node;
+    if (es.isExpression(body)) {
+        body = es.blockStatement([es.returnStatement(body)]);
+    }
+    return [
+        new FunctionValue({
+            node,
+            scope,
+            params: params,
+            body,
+            c,
+        }),
+        [],
+    ];
+}
+const ArrowFunctionExpression = (c, scope, node) => {
+    return handleFunctionNode(c, scope, node);
+};
+const FunctionDeclaration = (c, scope, node) => {
+    const identifier = node.id.name;
+    const name = nodeName(node, !c.compactNames && identifier);
+    const functionIns = handleFunctionNode(c, scope, node);
+    const owner = new ValueOwner({
+        scope,
+        value: functionIns[0],
+        identifier,
+        name,
+    });
+    return [scope.set(owner), []];
+};
+const FunctionExpression = ArrowFunctionExpression;
+const ObjectMethod = ArrowFunctionExpression;
+
+const CallExpression = (c, scope, node) => {
+    const inst = [];
+    const args = node.arguments.map(node => {
+        // TODO: this might be why t0 did not increment
+        // TODO: figure out if the previous todo is still relevant
+        const [v, i] = c.handleConsume(scope, node);
+        inst.push(...i);
+        return v;
+    });
+    const [callee, calleeInst] = c.handleConsume(scope, node.callee);
+    inst.push(...calleeInst);
+    const [callValue, callInst] = callee.call(scope, args);
+    inst.push(...callInst);
+    return [callValue, inst];
+};
+const NewExpression = CallExpression;
+
+const ObjectExpression = (c, scope, node) => {
+    const data = {};
+    const inst = [];
+    for (const prop of node.properties) {
+        if (prop.type === "SpreadElement")
+            throw new CompilerError("Cannot handle spread element", [prop]);
+        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 [member, memberInst] = c.handleEval(scope, value);
+        const owner = new ValueOwner({
+            scope,
+            constant: true,
+            value: member,
+        });
+        data[index] = owner.value;
+        inst.push(...memberInst);
+    }
+    return [new ObjectValue(scope, data), inst];
+};
+const ArrayExpression = (c, scope, node) => {
+    const items = [];
+    const inst = [];
+    node.elements.forEach(element => {
+        const [value, valueInst] = element
+            ? c.handleEval(scope, element)
+            : [undefined, []];
+        items.push(value);
+        inst.push(...valueInst);
+    });
+    return [ObjectValue.fromArray(scope, items), inst];
+};
+const MemberExpression = (c, scope, node) => {
+    const [obj, objInst] = c.handleConsume(scope, node.object);
+    const [prop, propInst] = node.computed
+        ? c.handleConsume(scope, node.property)
+        : [new LiteralValue(scope, node.property.name), []];
+    const [got, gotInst] = obj.get(scope, prop);
+    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 valueInst = c.handle(scope, element);
+        if (!valueInst[0])
+            throw new CompilerError("Destructuring element must resolve to a value", [
+                element,
+            ]);
+        inst.push(...valueInst[1]);
+        members.set(new LiteralValue(scope, i), valueInst[0]);
+    }
+    return [new DestructuringValue(scope, 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 { key } = prop;
+        const keyInst = !prop.computed && key.type === "Identifier"
+            ? [new LiteralValue(scope, key.name), []]
+            : c.handleConsume(scope, prop.key);
+        inst.push(...keyInst[1]);
+        const valueInst = c.handle(scope, prop.value);
+        if (!valueInst[0])
+            throw new CompilerError("Destructuring member must resolve to a value", [
+                prop.value,
+            ]);
+        inst.push(...valueInst[1]);
+        members.set(keyInst[0], valueInst[0]);
+    }
+    return [new DestructuringValue(scope, members), inst];
+};
+
+const TemplateLiteral = (c, scope, node) => {
+    const args = [];
+    const inst = [];
+    node.expressions.forEach((expression, i) => {
+        const [v, vi] = c.handleConsume(scope, expression);
+        inst.push(...vi);
+        args.push(node.quasis[i].value.raw, v);
+    });
+    args.push(node.quasis.slice(-1)[0].value.raw);
+    inst.push(new ZeroSpaceInstruction(...args));
+    return [null, inst];
+};
+
+const BlockStatement = (c, scope, node) => {
+    const [value, insts] = c.handleMany(scope.createScope(), node.body);
+    // const cleanInst = []
+    // for (const inst of insts) {
+    //     if (inst instanceof BreakInstruction || inst instanceof ContinueInstruction || inst instanceof ReturnInstruction || inst instanceof SetCounterInstruction) break
+    //     cleanInst.push(inst)
+    // }
+    return [value, insts];
+};
+
+const File = (c, scope, node) => {
+    return c.handle(scope ?? new Scope({}), node.program);
+};
+
+const TypeCastExpression = (c, scope, node) => {
+    return c.handle(scope, node.expression);
+};
+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(scope, counter)];
+        if (!(value instanceof LiteralValue))
+            throw new CompilerError("Enum members must contain literal values", [
+                member,
+            ]);
+        if (typeof value.data === "number") {
+            lastType = "number";
+            counter = value.data + 1;
+        }
+        else {
+            lastType = "string";
+        }
+        const name = member.id.type === "Identifier" ? member.id.name : member.id.value;
+        data[name] = value;
+    }
+    scope.set(new ValueOwner({
+        scope,
+        value: new ObjectValue(scope, data),
+        constant: true,
+        identifier: node.id.name,
+        name: nodeName(node, !c.compactNames && node.id.name),
+    }));
+    return [null, []];
+};
+const TSNonNullExpression = (c, scope, node) => {
+    return c.handle(scope, node.expression);
+};
+
+var handlers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Program: Program,
+    VariableDeclaration: VariableDeclaration,
+    VariableDeclarator: VariableDeclarator,
+    NumericLiteral: NumericLiteral,
+    StringLiteral: StringLiteral,
+    NullLiteral: NullLiteral,
+    BooleanLiteral: BooleanLiteral,
+    LRExpression: LRExpression,
+    BinaryExpression: BinaryExpression,
+    LogicalExpression: LogicalExpression,
+    AssignmentExpression: AssignmentExpression,
+    UnaryExpression: UnaryExpression,
+    UpdateExpression: UpdateExpression,
+    ConditionalExpression: ConditionalExpression,
+    Identifier: Identifier,
+    ExpressionStatement: ExpressionStatement,
+    BreakStatement: BreakStatement,
+    ContinueStatement: ContinueStatement,
+    ReturnStatement: ReturnStatement,
+    IfStatement: IfStatement,
+    WhileStatement: WhileStatement,
+    DoWhileStatement: DoWhileStatement,
+    ForStatement: ForStatement,
+    ArrowFunctionExpression: ArrowFunctionExpression,
+    FunctionDeclaration: FunctionDeclaration,
+    FunctionExpression: FunctionExpression,
+    ObjectMethod: ObjectMethod,
+    CallExpression: CallExpression,
+    NewExpression: NewExpression,
+    ObjectExpression: ObjectExpression,
+    ArrayExpression: ArrayExpression,
+    MemberExpression: MemberExpression,
+    ArrayPattern: ArrayPattern,
+    ObjectPattern: ObjectPattern,
+    TemplateLiteral: TemplateLiteral,
+    BlockStatement: BlockStatement,
+    File: File,
+    TSAsExpression: TSAsExpression,
+    TSTypeAssertion: TSTypeAssertion,
+    TSInterfaceDeclaration: TSInterfaceDeclaration,
+    TSTypeAliasDeclaration: TSTypeAliasDeclaration,
+    TSEnumDeclaration: TSEnumDeclaration,
+    TSNonNullExpression: TSNonNullExpression
+});
+
+class MacroFunction extends VoidValue {
+    constructor(scope, fn) {
+        super(scope);
+        this.macro = true;
+        this.constant = true;
+        this.fn = fn;
+    }
+    call(scope, args) {
+        return this.fn.apply(this, args);
+    }
+    eval(_scope) {
+        return [this, []];
+    }
+    consume(_scope) {
+        return [this, []];
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const mathOperations = {
+    max: (a, b) => Math.max(a, b),
+    min: (a, b) => Math.min(a, b),
+    angle: (x, y) => {
+        const angle = (Math.atan2(y, x) * 180) / Math.PI;
+        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(a),
+    cos: a => Math.cos(a),
+    tan: a => Math.tan(a),
+    floor: a => Math.floor(a),
+    ceil: a => Math.ceil(a),
+    sqrt: a => Math.sqrt(a),
+    rand: null,
+};
+function createMacroMathOperations(scope) {
+    const macroMathOperations = {};
+    for (const key in mathOperations) {
+        const fn = mathOperations[key];
+        macroMathOperations[key] = new MacroFunction(scope, (a, b) => {
+            if (b) {
+                if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
+                    if (typeof a.data !== "number" || typeof b.data !== "number")
+                        throw new CompilerError("Cannot do math operation with non-numerical literals.");
+                    return [new LiteralValue(scope, fn(a.num, b.num)), []];
+                }
+                const temp = new StoreValue(scope);
+                return [temp, [new OperationInstruction(key, temp, a, b)]];
+            }
+            if (fn && a instanceof LiteralValue) {
+                if (typeof a.data !== "number")
+                    throw new CompilerError("Cannot do math operation with non-numerical literal.");
+                return [new LiteralValue(scope, fn(a.num)), []];
+            }
+            const temp = new StoreValue(scope);
+            return [temp, [new OperationInstruction(key, temp, a, b)]];
+        });
+    }
+    return macroMathOperations;
+}
+class MlogMath extends ObjectValue {
+    constructor(scope) {
+        super(scope, createMacroMathOperations(scope));
+    }
+}
+// op angle result a b
+// op len result a b
+
+class Concat extends MacroFunction {
+    constructor(scope) {
+        super(scope, (...values) => {
+            for (const value of values)
+                if (!(value instanceof LiteralValue))
+                    throw new CompilerError("Concat arguments must all be literal values.");
+            return [
+                new LiteralValue(scope, values.map(v => v.data).join("")),
+                [],
+            ];
+        });
+    }
+}
+
+class Draw extends MacroFunction {
+    constructor(scope) {
+        super(scope, (kind, ...args) => {
+            if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
+                throw new CompilerError("Draw kind must be a string literal.");
+            if ([
+                "clear",
+                "color",
+                "stroke",
+                "line",
+                "rect",
+                "lineRect",
+                "poly",
+                "linePoly",
+                "triangle",
+                "image",
+            ].indexOf(kind.data) === -1)
+                throw new CompilerError("Invalid draw kind");
+            return [
+                null,
+                [
+                    new InstructionBase("draw", kind.data, ...args.map(v => {
+                        if (v instanceof LiteralValue && typeof v.data === "string")
+                            return v.data;
+                        return v;
+                    })),
+                ],
+            ];
+        });
+    }
+}
+
+class Print extends MacroFunction {
+    constructor(scope) {
+        super(scope, (...values) => {
+            const inst = [];
+            for (const value of values) {
+                inst.push(new InstructionBase("print", value));
+            }
+            return [null, inst];
+        });
+    }
+}
+
+class PrintFlush extends MacroFunction {
+    constructor(scope) {
+        super(scope, (target) => {
+            if (!(target instanceof SenseableValue))
+                throw new CompilerError("The printflush target must be a senseable value");
+            return [null, [new InstructionBase("printflush", target)]];
+        });
+    }
+}
+
+class DrawFlush extends MacroFunction {
+    constructor(scope) {
+        super(scope, (target) => {
+            if (!(target instanceof SenseableValue))
+                throw new CompilerError("The drawflush target must be a senseable value");
+            return [null, [new InstructionBase("drawflush", target)]];
+        });
+    }
+}
+
+class GetLink extends MacroFunction {
+    constructor(scope) {
+        super(scope, (index) => {
+            if (!(index instanceof StoreValue) &&
+                (!(index instanceof LiteralValue) || typeof index.data !== "number"))
+                throw new CompilerError("The getlink index must be a number literal or a store");
+            const outBuild = new SenseableValue(scope);
+            return [outBuild, [new InstructionBase("getlink", outBuild, index)]];
+        });
+    }
+}
+
+const validKinds$1 = ["enabled", "shoot", "shootp", "config", "color"];
+class Control extends MacroFunction {
+    constructor(scope) {
+        super(scope, (kind, building, ...args) => {
+            if (!(kind instanceof LiteralValue) || typeof kind.data !== "string")
+                throw new CompilerError("The control kind must be a string literal");
+            if (!validKinds$1.includes(kind.data))
+                throw new CompilerError("Invalid control kind");
+            if (!(building instanceof SenseableValue))
+                throw new CompilerError("The building must be a senseable value");
+            return [
+                null,
+                [new InstructionBase("control", kind.data, building, ...args)],
+            ];
+        });
+    }
+}
+
+const validRadarFilters = [
+    "any",
+    "enemy",
+    "ally",
+    "player",
+    "attacker",
+    "flying",
+    "boss",
+    "ground",
+];
+const validRadarSorts = [
+    "distance",
+    "health",
+    "shield",
+    "armor",
+    "maxHealth",
+];
+class Radar extends MacroFunction {
+    constructor(scope) {
+        super(scope, (building, filter1, filter2, filter3, order, sort) => {
+            if (!(building instanceof SenseableValue))
+                throw new CompilerError("The building must a senseable value");
+            if (!(filter1 instanceof LiteralValue) ||
+                typeof filter1.data !== "string" ||
+                !(filter2 instanceof LiteralValue) ||
+                typeof filter2.data !== "string" ||
+                !(filter3 instanceof LiteralValue) ||
+                typeof filter3.data !== "string")
+                throw new CompilerError("The filters must be string literals");
+            if (!validRadarFilters.includes(filter1.data))
+                throw new CompilerError("Invalid value for filter1");
+            if (!validRadarFilters.includes(filter2.data))
+                throw new CompilerError("Invalid value for filter2");
+            if (!validRadarFilters.includes(filter3.data))
+                throw new CompilerError("Invalid value for filter3");
+            if (!(order instanceof LiteralValue || order instanceof StoreValue))
+                throw new CompilerError("The radar order must be a literal or a store");
+            if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
+                throw new CompilerError("The radar sort must be a string literal");
+            if (!validRadarSorts.includes(sort.data))
+                throw new CompilerError("Invalid sort value");
+            const outUnit = new SenseableValue(scope);
+            return [
+                outUnit,
+                [
+                    new InstructionBase("radar", filter1.data, filter2.data, filter3.data, sort.data, building, order, outUnit),
+                ],
+            ];
+        });
+    }
+}
+
+class Sensor extends MacroFunction {
+    constructor(scope) {
+        super(scope, (property, target) => {
+            if (!(property instanceof StoreValue))
+                throw new CompilerError("The sensor property must be a store");
+            if (!(target instanceof SenseableValue))
+                throw new CompilerError("The sensor target must be a senseable value");
+            const temp = new StoreValue(scope);
+            return [temp, [new InstructionBase("sensor", temp, target, property)]];
+        });
+    }
+}
+
+class Wait extends MacroFunction {
+    constructor(scope) {
+        super(scope, seconds => {
+            if (!(seconds instanceof StoreValue) &&
+                !(seconds instanceof LiteralValue && typeof seconds.data === "number"))
+                throw new CompilerError("The wait seconds must be either a number literal or a store");
+            return [null, [new InstructionBase("wait", seconds)]];
+        });
+    }
+}
+
+const validKinds = ["block", "unit", "item", "liquid"];
+class Lookup extends MacroFunction {
+    constructor(scope) {
+        super(scope, (kind, index) => {
+            if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
+                throw new CompilerError("The lookup kind must be a string literal");
+            if (!validKinds.includes(kind.data))
+                throw new CompilerError("Invalid lookup kind");
+            if (!(index instanceof LiteralValue && typeof index.data === "number") &&
+                !(index instanceof StoreValue))
+                throw new CompilerError("The lookup index must be a number literal or a store");
+            const temp = new StoreValue(scope);
+            return [temp, [new InstructionBase("lookup", kind.data, temp, index)]];
+        });
+    }
+}
+
+class End extends MacroFunction {
+    constructor(scope) {
+        super(scope, () => [null, [new EndInstruction()]]);
+    }
+}
+
+class UnitBind extends MacroFunction {
+    constructor(scope) {
+        super(scope, type => {
+            if (!(type instanceof StoreValue))
+                throw new CompilerError("The unitBind type must be a store");
+            return [null, [new InstructionBase("ubind", type)]];
+        });
+    }
+}
+
+const validModes = [
+    "idle",
+    "stop",
+    "move",
+    "approach",
+    "boost",
+    "pathfind",
+    "target",
+    "targetp",
+    "itemDrop",
+    "itemTake",
+    "payDrop",
+    "payTake",
+    "payEnter",
+    "mine",
+    "flag",
+    "build",
+    "getBlock",
+    "within",
+];
+class UnitControl extends MacroFunction {
+    constructor(scope) {
+        super(scope, (mode, ...args) => {
+            if (!(mode instanceof LiteralValue) || typeof mode.data !== "string")
+                throw new CompilerError("The unitControl mode must be a string literal");
+            if (!validModes.includes(mode.data))
+                throw new CompilerError("Invalid unitControl mode");
+            if (args.some(value => !(value instanceof StoreValue || value instanceof LiteralValue)))
+                throw new CompilerError("The others arguments of unitControl must be literals or stores");
+            let result = null;
+            let extraArgs = [];
+            switch (mode.data) {
+                case "getBlock": {
+                    const outType = new StoreValue(scope);
+                    const outBuilding = new SenseableValue(scope);
+                    result = ObjectValue.fromArray(scope, [outType, outBuilding]);
+                    extraArgs = [outType, outBuilding, new LiteralValue(scope, 0)];
+                    break;
+                }
+                case "within": {
+                    const temp = new StoreValue(scope);
+                    result = temp;
+                    extraArgs = [temp, new LiteralValue(scope, 0)];
+                    break;
+                }
+            }
+            return [
+                result,
+                [new InstructionBase("ucontrol", mode.data, ...args, ...extraArgs)],
+            ];
+        });
+    }
+}
+
+class UnitRadar extends MacroFunction {
+    constructor(scope) {
+        super(scope, (filter1, filter2, filter3, order, sort) => {
+            if (!(filter1 instanceof LiteralValue) ||
+                typeof filter1.data !== "string" ||
+                !(filter2 instanceof LiteralValue) ||
+                typeof filter2.data !== "string" ||
+                !(filter3 instanceof LiteralValue) ||
+                typeof filter3.data !== "string")
+                throw new CompilerError("The filters must be string literals");
+            if (!validRadarFilters.includes(filter1.data))
+                throw new CompilerError("Invalid value for filter1");
+            if (!validRadarFilters.includes(filter2.data))
+                throw new CompilerError("Invalid value for filter2");
+            if (!validRadarFilters.includes(filter3.data))
+                throw new CompilerError("Invalid value for filter3");
+            if (!(order instanceof LiteralValue || order instanceof StoreValue))
+                throw new CompilerError("The radar order must be a literal or a store");
+            if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
+                throw new CompilerError("The radar sort must be a string literal");
+            if (!validRadarSorts.includes(sort.data))
+                throw new CompilerError("Invalid sort value");
+            const outUnit = new SenseableValue(scope);
+            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 validFinds = ["ore", "building", "spawn", "damaged"];
+const validBuildingGroups = [
+    "core",
+    "storage",
+    "generator",
+    "turret",
+    "factory",
+    "repair",
+    "rally",
+    "battery",
+    "reactor",
+];
+class UnitLocate extends MacroFunction {
+    constructor(scope) {
+        super(scope, (find, ...args) => {
+            if (!(find instanceof LiteralValue && typeof find.data === "string"))
+                throw new CompilerError("The unitLocate find must be a string literal");
+            if (!validFinds.includes(find.data))
+                throw new CompilerError("Invalid find value");
+            if (args.some(value => !(value instanceof StoreValue || value instanceof LiteralValue)))
+                throw new CompilerError("The others arguments of unitLocate must be literals or stores");
+            const outFound = new StoreValue(scope);
+            const outX = new StoreValue(scope);
+            const outY = new StoreValue(scope);
+            const outBuilding = new SenseableValue(scope);
+            const outArgs = [outX, outY, outFound, outBuilding];
+            let inputArgs = [];
+            switch (find.data) {
+                case "ore": {
+                    const [ore] = args;
+                    inputArgs = [find.data, "core", "true", ore];
+                    break;
+                }
+                case "building": {
+                    const [group, enemy] = args;
+                    if (!(group instanceof LiteralValue && typeof group.data === "string")) {
+                        throw new CompilerError("The building group must be a string literal");
+                    }
+                    if (!validBuildingGroups.includes(group.data))
+                        throw new CompilerError("Invalid building group");
+                    inputArgs = [find.data, group.data, enemy, "@copper"];
+                    break;
+                }
+                case "spawn":
+                case "damaged": {
+                    inputArgs = [find.data, "core", "true", "@copper"];
+                    break;
+                }
+            }
+            return [
+                ObjectValue.fromArray(scope, [
+                    outFound,
+                    outX,
+                    outY,
+                    ...(find.data !== "ore" ? [outBuilding] : []),
+                ]),
+                [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
+            ];
+        });
+    }
+}
+
+class MemoryEntry extends ObjectValue {
+    constructor(scope, mem, prop) {
+        super(scope, {
+            $eval: new MacroFunction(scope, () => {
+                if (this.store)
+                    return [this.store, []];
+                const temp = new StoreValue(scope);
+                return [temp, [new InstructionBase("read", temp, mem.cell, prop)]];
+            }),
+            $consume: new MacroFunction(scope, () => {
+                if (this.store)
+                    return [this.store, []];
+                this.ensureOwned();
+                this.store = new StoreValue(scope);
+                this.owner.own(this.store);
+                return [
+                    this.store,
+                    [new InstructionBase("read", this.store, mem.cell, prop)],
+                ];
+            }),
+            "$=": new MacroFunction(scope, value => {
+                const [data, dataInst] = value.consume(scope);
+                return [
+                    data,
+                    [...dataInst, new InstructionBase("write", data, mem.cell, prop)],
+                ];
+            }),
+        });
+        this.store = null;
+    }
+}
+for (const operator of operators) {
+    if (operator === "=")
+        continue;
+    MemoryEntry.prototype[operator] = function (...args) {
+        // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return
+        return BaseValue.prototype[operator].apply(this, args);
+    };
+}
+class MemoryMacro extends ObjectValue {
+    constructor(scope, cell, size) {
+        super(scope, {
+            $get: new MacroFunction(scope, (prop) => {
+                if (prop instanceof LiteralValue && typeof prop.data !== "number")
+                    throw new CompilerError(`Invalid memory object property: "${prop.data}"`);
+                const obj = new MemoryEntry(scope, this, prop);
+                return [obj, []];
+            }),
+            length: size,
+            size,
+        });
+        this.cell = cell;
+        this.name = cell.toString();
+    }
+    toString() {
+        return this.name;
+    }
+}
+class MemoryBuilder extends ObjectValue {
+    constructor(scope) {
+        super(scope, {
+            $call: new MacroFunction(scope, (cell, size = new LiteralValue(scope, 64)) => {
+                if (!(cell instanceof SenseableValue))
+                    throw new CompilerError("Memory cell must be a senseable value.");
+                if (!(size instanceof LiteralValue && typeof size.data === "number"))
+                    throw new CompilerError("The memory size must be a number literal.");
+                return [new MemoryMacro(scope, cell, size), []];
+            }),
+        });
+    }
+}
+
+const dynamicVars = ["time", "tick"];
+class NamespaceMacro extends ObjectValue {
+    constructor(scope, { changeCasing = false } = {}) {
+        super(scope, {
+            $get: new MacroFunction(scope, prop => {
+                if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
+                    throw new CompilerError("Cannot use dynamic properties on namespace macros");
+                const symbolName = this.changeCasing
+                    ? camelToDashCase(prop.data)
+                    : prop.data;
+                const mutability = dynamicVars.includes(symbolName)
+                    ? EMutability.readonly
+                    : EMutability.constant;
+                const owner = new ValueOwner({
+                    scope,
+                    value: assign(new StoreValue(scope), {
+                        mutability,
+                    }),
+                    name: `@${symbolName}`,
+                });
+                return [owner.value, []];
+            }),
+        });
+        this.changeCasing = changeCasing;
+    }
+}
+class VarsNamespace extends NamespaceMacro {
+    constructor(scope) {
+        super(scope);
+        Object.assign(this.data, {
+            unit: new ValueOwner({
+                scope,
+                name: "@unit",
+                value: new SenseableValue(scope),
+            }).value,
+            this: new ValueOwner({
+                scope,
+                name: "@this",
+                value: new SenseableValue(scope),
+            }).value,
+        });
+    }
+}
+class UCommandsNamespace extends NamespaceMacro {
+    constructor(scope) {
+        super(scope);
+        this.data.$get = new MacroFunction(scope, prop => {
+            if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
+                throw new CompilerError("Cannot use dynamic properties on namespace macros");
+            const symbolName = prop.data[0].toUpperCase() + prop.data.slice(1);
+            const owner = new ValueOwner({
+                scope,
+                name: `@command${symbolName}`,
+                value: assign(new StoreValue(scope), {
+                    mutability: EMutability.constant,
+                }),
+            });
+            return [owner.value, []];
+        });
+    }
+}
+
+class GetGlobal extends MacroFunction {
+    constructor(scope, mutability) {
+        super(scope, (name) => {
+            if (!(name instanceof LiteralValue) || typeof name.data !== "string")
+                throw new CompilerError("The name parameter must be a string literal.");
+            const owner = new ValueOwner({
+                scope,
+                name: name.data,
+                value: assign(new SenseableValue(scope), {
+                    mutability,
+                }),
+            });
+            return [owner.value, []];
+        });
+    }
+}
+
+/**
+ * Adds all the compiler globals to `scope`
+ */
+function initScope(scope) {
+    // namespaces
+    scope.hardSet("ControlKind", new NamespaceMacro(scope));
+    scope.hardSet("Vars", new VarsNamespace(scope));
+    scope.hardSet("Items", new NamespaceMacro(scope, { changeCasing: true }));
+    scope.hardSet("Liquids", new NamespaceMacro(scope));
+    scope.hardSet("Units", new NamespaceMacro(scope));
+    scope.hardSet("LAccess", new NamespaceMacro(scope));
+    scope.hardSet("UnitCommands", new UCommandsNamespace(scope));
+    scope.hardSet("Blocks", new NamespaceMacro(scope, { changeCasing: true }));
+    // helper methods
+    scope.hardSet("getBuilding", new GetGlobal(scope, EMutability.constant));
+    scope.hardSet("getVar", new GetGlobal(scope, EMutability.mutable));
+    scope.hardSet("concat", new Concat(scope));
+    scope.hardSet("Math", new MlogMath(scope));
+    scope.hardSet("Memory", new MemoryBuilder(scope));
+    // commands
+    scope.hardSet("draw", new Draw(scope));
+    scope.hardSet("print", new Print(scope));
+    scope.hardSet("printFlush", new PrintFlush(scope));
+    scope.hardSet("drawFlush", new DrawFlush(scope));
+    scope.hardSet("getLink", new GetLink(scope));
+    scope.hardSet("control", new Control(scope));
+    scope.hardSet("radar", new Radar(scope));
+    scope.hardSet("sensor", new Sensor(scope));
+    scope.hardSet("wait", new Wait(scope));
+    scope.hardSet("lookup", new Lookup(scope));
+    scope.hardSet("endScript", new End(scope));
+    scope.hardSet("unitBind", new UnitBind(scope));
+    scope.hardSet("unitControl", new UnitControl(scope));
+    scope.hardSet("unitRadar", new UnitRadar(scope));
+    scope.hardSet("unitLocate", new UnitLocate(scope));
+}
+
+class Compiler {
+    constructor({ stackName, compactNames = false } = {}) {
+        this.handlers = handlers;
+        this.usingStack = !!stackName;
+        this.stackName = stackName;
+        this.compactNames = compactNames;
+    }
+    compile(script) {
+        let output;
+        try {
+            const program = this.parse(script);
+            const scope = new Scope({});
+            initScope(scope);
+            const valueInst = this.handle(scope, program);
+            valueInst[1].push(new EndInstruction(), ...scope.inst);
+            this.resolve(valueInst);
+            output = this.serialize(valueInst) + "\n";
+        }
+        catch (error) {
+            const nodeStack = error instanceof CompilerError ? error.nodeStack : [];
+            return [null, error, nodeStack];
+        }
+        return [output, null, []];
+    }
+    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"],
+        });
+    }
+    handle(scope, node) {
+        try {
+            const handler = this.handlers[node.type];
+            if (!handler)
+                throw new CompilerError("Missing handler for " + node.type);
+            return handler(this, scope, node, null);
+        }
+        catch (error) {
+            if (error instanceof CompilerError) {
+                error.nodeStack.push(node);
+            }
+            throw error;
+        }
+    }
+    handleEval(scope, node) {
+        const [res, inst] = this.handle(scope, node);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const [evaluated, evaluatedInst] = res.eval(scope);
+        return [evaluated, [...inst, ...evaluatedInst]];
+    }
+    handleConsume(scope, node) {
+        const [res, inst] = this.handle(scope, node);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const [evaluated, evaluatedInst] = res.consume(scope);
+        return [evaluated, [...inst, ...evaluatedInst]];
+    }
+    handleMany(scope, nodes, handler = this.handle.bind(this)) {
+        const lines = [];
+        for (const node of nodes) {
+            const [, nodeLines] = handler(scope, node);
+            lines.push(...nodeLines);
+        }
+        return [null, lines];
+    }
+}
+
+export { Compiler, CompilerError };