mlogjs 0.2.2 → 0.3.0-beta.0

package/dist/index.mjs

@@ -1,4 +1,12 @@
-import { parse } from 'acorn';
+import { parse } from '@babel/parser';
+import * as es from '@babel/types';
+
+class CompilerError extends Error {
+    constructor(message, nodeStack = []) {
+        super(message);
+        this.nodeStack = nodeStack;
+    }
+}
 
 const arithmeticBinaryOperators = [
     "*",
@@ -73,46 +81,29 @@ const unaryOperators = [
 ];
 const updateOperators = ["++", "--"];
 const singleOperators = [...unaryOperators, ...updateOperators];
-const operators = [...leftRightOperators, ...singleOperators];
-const operatorMap$2 = {
-    "==": "equal",
-    "===": "strictEqual",
-    "!=": "notEqual",
-    "!==": "notEqual",
-    "<": "lessThan",
-    ">": "greaterThan",
-    "<=": "lessThanEq",
-    ">=": "greaterThanEq",
-    "+": "add",
-    "-": "sub",
-    "*": "mul",
-    "/": "div",
-    "%": "mod",
-    "**": "pow",
-    "|": "or",
-    "&": "and",
-    "^": "xor",
-    ">>": "shr",
-    ">>>": "shr",
-    "<<": "shl",
-    "&&": "land",
-    "||": "or",
-};
+const operators = [...leftRightOperators, ...singleOperators];
 
 class VoidValue {
     constructor(scope) {
+        this.owner = null;
         this.constant = false;
         this.macro = false;
         this.scope = scope;
     }
-    eval(scope) {
-        throw new Error(`${this} cannot eval.`);
+    eval(_scope) {
+        throw new CompilerError(`${this} cannot eval.`);
     }
-    call(scope, args) {
-        throw new Error(`${this} cannot call.`);
+    consume(_scope) {
+        throw new CompilerError(`${this} cannot be consumed.`);
     }
-    get(scope, name) {
-        throw new Error(`${this} cannot get.`);
+    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";
@@ -121,7 +112,7 @@ class VoidValue {
 for (const key of operators) {
     VoidValue.prototype[key] = function () {
         console.log(this);
-        throw new Error(`${this} cannot '${key}' operation.`);
+        throw new CompilerError(`${this} cannot '${key}' operation.`);
     };
 }
 
@@ -136,7 +127,7 @@ class InstructionBase {
     set hidden(value) {
         this._hidden = value;
     }
-    resolve(i) { }
+    resolve(_i) { }
     toString() {
         return this.args.filter(arg => arg).join(" ");
     }
@@ -152,6 +143,9 @@ class SetInstruction extends InstructionBase {
     constructor(store, value) {
         super("set", store, value);
     }
+    get hidden() {
+        return this._hidden || !this.args[1].owner;
+    }
 }
 
 class EndInstruction extends InstructionBase {
@@ -224,17 +218,44 @@ class ContinueInstruction extends JumpInstruction {
     constructor(address) {
         super(address, EJumpKind.Always);
     }
-}
-class ReturnInstruction 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.eval(scope);
-        const temp = new TempValue(scope);
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
         return [
             temp,
             [
@@ -243,6 +264,13 @@ class BaseValue extends VoidValue {
             ],
         ];
     }
+    "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",
@@ -271,9 +299,9 @@ const operatorMap$1 = {
 for (const key in operatorMap$1) {
     const kind = operatorMap$1[key];
     BaseValue.prototype[key] = function (scope, value) {
-        const [left, leftInst] = this.eval(scope);
-        const [right, rightInst] = value.eval(scope);
-        const temp = new TempValue(scope);
+        const [left, leftInst] = this.consume(scope);
+        const [right, rightInst] = value.consume(scope);
+        const temp = new StoreValue(scope);
         return [
             temp,
             [
@@ -291,8 +319,8 @@ const unaryOperatorMap$1 = {
 for (const key in unaryOperatorMap$1) {
     const name = unaryOperatorMap$1[key];
     BaseValue.prototype[key] = function (scope) {
-        const [that, inst] = this.eval(scope);
-        const temp = new TempValue(scope);
+        const [that, inst] = this.consume(scope);
+        const temp = new StoreValue(scope);
         return [temp, [...inst, new OperationInstruction(name, temp, that, null)]];
     };
 }
@@ -314,6 +342,7 @@ 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]];
@@ -321,9 +350,9 @@ for (const op in assignmentToBinary) {
 }
 for (const key of updateOperators) {
     BaseValue.prototype[key] = function (scope, prefix) {
-        let [ret, inst] = this.eval(scope);
+        let [ret, inst] = this.consume(scope);
         if (!prefix) {
-            const temp = new TempValue(scope);
+            const temp = new StoreValue(scope);
             const [tempValue, tempInst] = temp["="](scope, ret);
             ret = tempValue;
             inst.push(...tempInst);
@@ -339,7 +368,7 @@ for (const key of updateOperators) {
 const literalMethods = {
     length: function (scope) {
         if (typeof this.data !== "string")
-            throw new Error("Length method only works on string literal values.");
+            throw new CompilerError("Length method only works on string literal values.");
         return new LiteralValue(scope, this.data.length);
     },
 };
@@ -349,7 +378,10 @@ class LiteralValue extends BaseValue {
         this.constant = true;
         this.data = data;
     }
-    eval(scope) {
+    eval(_scope) {
+        return [this, []];
+    }
+    consume(_scope) {
         return [this, []];
     }
     toString() {
@@ -360,7 +392,7 @@ class LiteralValue extends BaseValue {
             return super.get(scope, name);
         const method = literalMethods[name.data];
         if (!method)
-            throw new Error(`Method ${name.data} does not exist on literal values.`);
+            throw new CompilerError(`Method ${name.data} does not exist on literal values.`);
         return [method.apply(this, [scope]), []];
     }
     get num() {
@@ -419,87 +451,94 @@ for (const key in unaryOperatorMap) {
     };
 }
 
+/**
+ * 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",
+];
+
+/**
+ * `StoreValue` represents values unknown at compile time,
+ * mostly used with mutable variables and temporary values
+ */
 class StoreValue extends BaseValue {
-    constructor(scope, name) {
+    constructor(scope) {
         super(scope);
         this.constant = false;
-        this.name = name;
     }
     typeof(scope) {
         return [new LiteralValue(scope, "store"), []];
     }
     "="(scope, value) {
         if (this.constant)
-            throw new Error(`Cannot assign to unmutable store '${this.name}'.`);
-        if (value instanceof TempValue && value.canProxy)
-            return value.proxy(this);
-        const [evalValue, evalInst] = value.eval(scope);
+            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) {
+    eval(_scope) {
         return [this, []];
     }
-    toString() {
-        return this.name;
-    }
-}
-
-class TempValue extends StoreValue {
-    constructor(scope, name) {
-        super(scope, name ?? "t" + scope.ntemp + (scope.name ? ":" + scope.name : ""));
-        this.canProxy = true;
-        if (!name)
-            scope.ntemp++;
-    }
-    eval(scope) {
-        return super.eval(scope);
-    }
-    "="(scope, value) {
-        if (this.proxied) {
-            this.noProxy();
-            return [this, [new SetInstruction(this, value)]];
-        }
-        if (value instanceof LiteralValue && this.canProxy) {
-            return this.proxy(value);
-        }
-        return super["="](scope, value);
+    consume(_scope) {
+        this.ensureOwned();
+        return [this, []];
     }
-    proxy(value) {
-        if (!this.canProxy) {
-            console.log(this.proxied);
-            throw new Error("Cannot proxy (canProxy = false).");
-        }
-        if (this.proxied)
-            throw new Error("Cannot proxy multiple times.");
-        this.proxied = value;
-        this.canProxy = false;
-        for (const key of [
-            ...operators,
-            "eval",
-            "get",
-            "call",
-            "toString",
-            "proxy",
-        ]) {
-            if (key !== "=" && key in value)
-                this[key] = (...args) => value[key].apply(value, args);
-        }
-        this.setInst = new SetInstruction(this, value);
-        this.setInst.hidden = true;
-        return [this, [this.setInst]];
-    }
-    noProxy() {
-        this.setInst.hidden = false;
-        for (const key of [
-            ...operators,
-            "eval",
-            "get",
-            "call",
-            "toString",
-            "proxy",
-        ]) {
-            this[key] = TempValue.prototype[key];
-        }
+    toString() {
+        return this.owner?.name ?? discardedName;
     }
 }
 
@@ -510,19 +549,30 @@ class ObjectValue extends VoidValue {
         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 (this.data.hasOwnProperty(key.data)) {
+        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 Error("Cannot get undefined member.");
+            throw new CompilerError("Cannot get undefined member.");
         return $get.call(scope, [key]);
     }
     eval(scope) {
@@ -531,23 +581,115 @@ class ObjectValue extends VoidValue {
             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);
-        let [scope, ...fnArgs] = 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 = new SenseableValue(scope)
+ * value.constant = false
+ * ```
+ */
+class SenseableValue extends StoreValue {
+    constructor(scope) {
+        super(scope);
+        this.constant = true;
+    }
+    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`);
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "senseable"), []];
+    }
+}
+
+/**
+ * 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;
@@ -570,35 +712,64 @@ class Scope {
         scope.parent = this;
         return scope;
     }
-    createFunction(name, stacked) {
-        return new Scope({}, this, stacked ?? this.stacked, 0, name, this.inst);
+    createFunction(name, stacked = this.stacked) {
+        return new Scope({}, this, stacked, 0, name, this.inst);
     }
-    has(name) {
-        if (name in this.data)
+    has(identifier) {
+        if (identifier in this.data)
             return true;
         if (this.parent)
-            return this.parent.has(name);
+            return this.parent.has(identifier);
         return false;
     }
-    get(name) {
-        const value = this.data[name];
-        if (value)
-            return value;
+    get(identifier) {
+        const owner = this.data[identifier];
+        if (owner)
+            return owner.value;
         if (this.parent)
-            return this.parent.get(name);
-        throw Error(`${name} is not declared.`);
+            return this.parent.get(identifier);
+        throw new CompilerError(`${identifier} is not declared.`);
     }
-    set(name, value) {
+    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 Error(`${name} is already declared.`);
-        return this.hardSet(name, value);
-    }
-    hardSet(name, value) {
-        this.data[name] = value;
-        return value;
+            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 value = new SenseableValue(this);
+        value.constant = false;
+        const owner = new ValueOwner({
+            scope: this,
+            value,
+            identifier,
+            name,
+        });
+        return this.set(owner);
     }
-    make(name, storeName) {
-        return this.set(name, this.stacked ? null : new StoreValue(this, storeName));
+    makeTempName() {
+        let result = `${internalPrefix}t${this.ntemp}`;
+        if (this.name)
+            result += `:${this.name}`;
+        this.ntemp++;
+        return result;
     }
 }
 
@@ -606,86 +777,109 @@ const Program = (c, scope, node) => {
     return c.handleMany(scope ?? new Scope({}), node.body);
 };
 
-function nodeName(node) {
-    const { line, column } = node.loc.start;
-    return line + ":" + column;
-}
-function camelToDashCase(name) {
-    return name.replace(/[A-Z]/g, str => `-${str.toLowerCase()}`);
-}
-
 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") => {
-    let valinst = node.init
+    const [init, inst] = node.init
         ? c.handleEval(scope, node.init)
         : [null, []];
-    switch (node.id.type) {
-        case "Identifier": {
-            const { name } = node.id;
-            const [init] = valinst;
-            if (kind === "const" && !init)
-                throw Error("Cannot create constant with void value.");
-            if (kind === "const" && init?.constant) {
-                scope.set(name, init);
-                return valinst;
-            }
-            else {
-                const value = scope.make(name, nodeName(node));
-                if (init) {
-                    if (init.macro)
-                        throw new Error("Macro value must be constant.");
-                    valinst[1].push(...value["="](scope, init)[1]);
-                }
-                if (kind === "const")
-                    value.constant = true;
-                return valinst;
-            }
-        }
-        case "ArrayPattern": {
-            const { elements } = node.id;
-            const [init] = valinst;
-            if (!init)
-                throw new Error("Cannot use array destructuring with constant with void value.");
-            if (!init.macro)
-                throw new Error("Cannot use array destructuring on non macro values");
-            if (!(init instanceof ObjectValue)) {
-                throw new Error("Array destructuring target must be an object value");
-            }
-            for (let i = 0; i < elements.length; i++) {
-                const element = elements[i];
-                if (!element)
-                    continue;
-                if (element.type !== "Identifier") {
-                    throw new Error("Array destructuring expression can only have empty items or identifiers");
-                }
-                const val = init.data[i];
-                scope.set(element.name, val);
-            }
-            return valinst;
-        }
+    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 Error("");
+            throw new CompilerError(`Unsupported declaration type: ${node.type}`, [
+                node,
+            ]);
     }
-};
-
-const Literal = (c, scope, node) => {
-    const { value } = node;
-    if (value === null ||
-        typeof value === "string" ||
-        typeof value === "number") {
-        return [new LiteralValue(scope, value), []];
+};
+const DeclareIdentifier = (c, scope, node, kind, init) => {
+    const { name: identifier } = node;
+    const name = nodeName(node, !c.compactNames && identifier);
+    if (kind === "const" && !init)
+        throw new CompilerError("Constants must be initialized.", [node]);
+    if (kind === "const" && init?.constant) {
+        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.constant = true;
+        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]);
     }
-    if (typeof value === "boolean") {
-        return [new LiteralValue(scope, +value), []];
+    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]);
     }
-    throw Error("Cannot create literal " + typeof value);
+    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.handleEval(scope, node.left);
-    const [right, rightInst] = c.handleEval(scope, node.right);
+    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]];
 };
@@ -693,20 +887,55 @@ 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.handleEval(scope, argument);
+    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) => {
@@ -736,7 +965,7 @@ const ReturnStatement = (c, scope, node) => {
 
 const IfStatement = (c, scope, node) => {
     const inst = [];
-    const [test, testInst] = c.handleEval(scope, node.test);
+    const [test, testInst] = c.handleConsume(scope, node.test);
     if (test instanceof LiteralValue) {
         if (test.data)
             inst.push(...c.handle(scope, node.consequent)[1]);
@@ -754,7 +983,7 @@ const IfStatement = (c, scope, node) => {
 
 const WhileStatement = (c, scope, node) => {
     const lines = [];
-    const [test, testLines] = c.handleEval(scope, node.test);
+    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);
@@ -767,13 +996,35 @@ const WhileStatement = (c, scope, node) => {
     }
     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.handleEval(scope, 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);
@@ -796,65 +1047,108 @@ const ForStatement = (c, scope, node) => {
 };
 
 class FunctionValue extends VoidValue {
-    constructor(scope, name, paramNames, paramStores, body, c) {
+    constructor({ scope, params, body, c, node, }) {
         super(scope);
         this.constant = true;
         this.macro = true;
+        this.paramOwners = [];
         this.bundled = false;
-        this.name = name;
-        this.paramNames = paramNames;
-        this.paramStores = paramStores;
+        this.initialized = false;
         this.body = body;
         this.c = c;
-        this.callSize = paramStores.length + 2;
-        scope.function = this;
-        this.createValues();
-        this.createInst();
-    }
-    createValues() {
-        this.addr = new LiteralValue(this.scope, null);
-        this.temp = new StoreValue(this.scope, "f" + this.name);
-        this.ret = new StoreValue(this.scope, "r" + this.name);
+        this.node = node;
+        this.params = params;
     }
     typeof(scope) {
         return [new LiteralValue(scope, "function"), []];
     }
-    createInst() {
+    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 = nodeName(this.node, !this.c.compactNames && this.owner.name);
+        this.initScope(name);
+        this.addr = new LiteralValue(this.childScope, null);
+        this.temp = new ValueOwner({
+            scope: this.childScope,
+            name: `${internalPrefix}f${name}`,
+            value: new SenseableValue(this.childScope),
+        });
+        this.temp.value.constant = false;
+        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.scope, this.body)[1],
+            ...this.c.handle(this.childScope, this.body)[1],
         ];
-        this.inst.push(new SetCounterInstruction(this.ret));
+        if (!endsWithReturn(this.inst)) {
+            this.inst.push(new SetCounterInstruction(this.ret.value));
+        }
     }
     normalReturn(scope, arg) {
-        const argInst = arg ? this.temp["="](scope, arg)[1] : [];
-        return [null, [...argInst, new SetCounterInstruction(this.ret)]];
+        const argInst = arg ? this.temp.value["="](scope, arg)[1] : [];
+        return [null, [...argInst, new SetCounterInstruction(this.ret.value)]];
     }
     normalCall(scope, args) {
         if (!this.bundled)
-            this.scope.inst.push(...this.inst);
+            this.childScope.inst.push(...this.inst);
         this.bundled = true;
         const callAddressLiteral = new LiteralValue(scope, null);
-        const inst = this.paramStores
-            .map((param, i) => param["="](scope, args[i])[1])
+        const inst = this.paramOwners
+            .map(({ value: param }, i) => param["="](scope, args[i])[1])
             .reduce((s, c) => s.concat(c), [])
-            .concat(...this.ret["="](scope, callAddressLiteral)[1], new JumpInstruction(this.addr, EJumpKind.Always), new AddressResolver(callAddressLiteral));
-        return [this.temp, inst];
+            .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["="](scope, arg)[1] : [];
-        return [null, [...argInst, new ReturnInstruction(this.inlineEnd)]];
+        const argInst = arg ? this.inlineTemp.value["="](scope, arg)[1] : [];
+        return [null, argInst];
     }
     inlineCall(scope, args) {
         // create return value
-        this.inlineTemp = new TempValue(scope);
+        this.inlineTemp = new ValueOwner({
+            scope: this.childScope,
+            value: new SenseableValue(scope),
+        });
+        this.inlineTemp.value.constant = false;
         this.inlineEnd = new LiteralValue(scope, null);
         // make a copy of the function scope
-        const fnScope = this.scope.copy();
+        const fnScope = this.childScope.copy();
         // hard set variables within the function scope
-        this.paramNames.forEach((name, i) => fnScope.hardSet(name, args[i]));
+        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;
-        let inst = this.c.handle(fnScope, this.body)[1];
+        const inst = this.c.handle(fnScope, this.body)[1];
         this.tryingInline = false;
         // removing useless instruction
         // get the last instructions
@@ -865,11 +1159,12 @@ class FunctionValue extends VoidValue {
         // }
         inst.push(new AddressResolver(this.inlineEnd));
         // return the function value
-        return [this.inlineTemp, inst];
+        return [this.inlineTemp.value, inst];
     }
     call(scope, args) {
-        if (args.length !== this.paramStores.length)
-            throw new Error("Cannot call: argument count not matching.");
+        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)
@@ -877,6 +1172,7 @@ class FunctionValue extends VoidValue {
         return this.normalCall(scope, args);
     }
     return(scope, arg) {
+        this.ensureInit();
         if (arg && arg.macro) {
             this.inline = true;
             return [null, []];
@@ -885,49 +1181,67 @@ class FunctionValue extends VoidValue {
             return this.inlineReturn(scope, arg);
         return this.normalReturn(scope, arg);
     }
-    eval(scope) {
+    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;
 }
 
-const ArrowFunctionExpression = (c, scope, node) => {
-    const name = nodeName(node);
-    scope = scope.createFunction(name);
+function handleFunctionNode(c, scope, node) {
     let { params, body } = node;
-    if (node.expression) {
-        body = {
-            type: "BlockStatement",
-            body: [{ type: "ReturnStatement", argument: body }],
-        };
-    }
-    const paramNames = [];
-    const paramStores = [];
-    for (const id of params) {
-        paramNames.push(id.name);
-        paramStores.push(scope.make(id.name, nodeName(id)));
+    if (es.isExpression(body)) {
+        body = es.blockStatement([es.returnStatement(body)]);
     }
     return [
-        new FunctionValue(scope, name, paramNames, paramStores, body, c),
+        new FunctionValue({
+            node,
+            scope,
+            params: params,
+            body,
+            c,
+        }),
         [],
     ];
+}
+const ArrowFunctionExpression = (c, scope, node) => {
+    return handleFunctionNode(c, scope, node);
 };
 const FunctionDeclaration = (c, scope, node) => {
-    return [
-        scope.set(node.id.name, ArrowFunctionExpression(c, scope, node, null)[0]),
-        [],
-    ];
+    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 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
-        const [v, i] = c.handleEval(scope, node);
+        // 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.handleEval(scope, node.callee);
+    const [callee, calleeInst] = c.handleConsume(scope, node.callee);
     inst.push(...calleeInst);
     const [callValue, callInst] = callee.call(scope, args);
     inst.push(...callInst);
@@ -939,49 +1253,101 @@ 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 Error("Cannot handle computed property.");
-        const { key, value } = prop;
+            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")
+        if (key.type === "Identifier") {
             index = key.name;
-        else if (key.type === "Literal")
-            index = "" + key.value;
+        }
+        else if (key.type === "StringLiteral" || key.type === "NumericLiteral") {
+            index = `${key.value}`;
+        }
         else {
-            throw new Error(`Unsupported object key type: ${key.type}`);
+            throw new CompilerError(`Unsupported object key type: ${key.type}`, [
+                key,
+            ]);
         }
         const [member, memberInst] = c.handleEval(scope, value);
-        data[index] = member;
+        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 data = {};
+    const items = [];
     const inst = [];
-    node.elements.forEach((element, i) => {
-        if (!element)
-            return;
-        const [value, valueInst] = c.handleEval(scope, element);
-        data[i] = value;
+    node.elements.forEach(element => {
+        const [value, valueInst] = element
+            ? c.handleEval(scope, element)
+            : [undefined, []];
+        items.push(value);
         inst.push(...valueInst);
     });
-    return [new ObjectValue(scope, data), inst];
+    return [ObjectValue.fromArray(scope, items), inst];
 };
 const MemberExpression = (c, scope, node) => {
-    const [obj, objInst] = c.handleEval(scope, node.object);
+    const [obj, objInst] = c.handleConsume(scope, node.object);
     const [prop, propInst] = node.computed
-        ? c.handleEval(scope, node.property)
+        ? 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.handleEval(scope, expression);
+        const [v, vi] = c.handleConsume(scope, expression);
         inst.push(...vi);
         args.push(node.quasis[i].value.raw, v);
     });
@@ -1000,18 +1366,73 @@ const BlockStatement = (c, scope, node) => {
     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,
-    Literal: Literal,
+    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,
@@ -1019,17 +1440,28 @@ var handlers = /*#__PURE__*/Object.freeze({
     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
+    BlockStatement: BlockStatement,
+    File: File,
+    TSAsExpression: TSAsExpression,
+    TSTypeAssertion: TSTypeAssertion,
+    TSInterfaceDeclaration: TSInterfaceDeclaration,
+    TSTypeAliasDeclaration: TSTypeAliasDeclaration,
+    TSEnumDeclaration: TSEnumDeclaration,
+    TSNonNullExpression: TSNonNullExpression
 });
 
 class MacroFunction extends VoidValue {
@@ -1042,11 +1474,15 @@ class MacroFunction extends VoidValue {
     call(scope, args) {
         return this.fn.apply(this, args);
     }
-    eval(scope) {
+    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),
@@ -1075,18 +1511,18 @@ function createMacroMathOperations(scope) {
             if (b) {
                 if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
                     if (typeof a.data !== "number" || typeof b.data !== "number")
-                        throw new Error("Cannot do math operation with non-numerical literals.");
+                        throw new CompilerError("Cannot do math operation with non-numerical literals.");
                     return [new LiteralValue(scope, fn(a.num, b.num)), []];
                 }
-                const temp = new TempValue(scope);
+                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 Error("Cannot do math operation with non-numerical literal.");
+                    throw new CompilerError("Cannot do math operation with non-numerical literal.");
                 return [new LiteralValue(scope, fn(a.num)), []];
             }
-            const temp = new TempValue(scope);
+            const temp = new StoreValue(scope);
             return [temp, [new OperationInstruction(key, temp, a, b)]];
         });
     }
@@ -1105,7 +1541,7 @@ class Concat extends MacroFunction {
         super(scope, (...values) => {
             for (const value of values)
                 if (!(value instanceof LiteralValue))
-                    throw new Error("Concat arguments must all be literal values.");
+                    throw new CompilerError("Concat arguments must all be literal values.");
             return [
                 new LiteralValue(scope, values.map(v => v.data).join("")),
                 [],
@@ -1118,7 +1554,7 @@ class Draw extends MacroFunction {
     constructor(scope) {
         super(scope, (kind, ...args) => {
             if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
-                throw new Error("Draw kind must be literal.");
+                throw new CompilerError("Draw kind must be a string literal.");
             if ([
                 "clear",
                 "color",
@@ -1131,7 +1567,7 @@ class Draw extends MacroFunction {
                 "triangle",
                 "image",
             ].indexOf(kind.data) === -1)
-                throw new Error("Draw kind must be valid");
+                throw new CompilerError("Invalid draw kind");
             return [
                 null,
                 [
@@ -1161,8 +1597,8 @@ class Print extends MacroFunction {
 class PrintFlush extends MacroFunction {
     constructor(scope) {
         super(scope, (target) => {
-            if (!(target instanceof ObjectValue))
-                throw new Error("The printflush target must be a building");
+            if (!(target instanceof SenseableValue))
+                throw new CompilerError("The printflush target must be a senseable value");
             return [null, [new InstructionBase("printflush", target)]];
         });
     }
@@ -1171,93 +1607,21 @@ class PrintFlush extends MacroFunction {
 class DrawFlush extends MacroFunction {
     constructor(scope) {
         super(scope, (target) => {
-            if (!(target instanceof ObjectValue))
-                throw new Error("The drawflush target must be a building");
+            if (!(target instanceof SenseableValue))
+                throw new CompilerError("The drawflush target must be a senseable value");
             return [null, [new InstructionBase("drawflush", target)]];
         });
     }
 }
 
-const itemNames = [
-    "copper",
-    "lead",
-    "metaglass",
-    "graphite",
-    "sand",
-    "coal",
-    "titanium",
-    "thorium",
-    "scrap",
-    "silicon",
-    "plastanium",
-    "phaseFabric",
-    "surgeAlloy",
-    "sporePod",
-    "blastCompound",
-    "pyratite",
-];
-class Building extends ObjectValue {
-    constructor(scope, name) {
-        super(scope, {
-            $get: new MacroFunction(scope, (prop) => {
-                if (prop instanceof LiteralValue && typeof prop.data === "string") {
-                    const name = itemNames.includes(prop.data)
-                        ? camelToDashCase(prop.data)
-                        : prop.data;
-                    const temp = new TempValue(scope);
-                    return [
-                        temp,
-                        [new InstructionBase("sensor", temp, this, `@${name}`)],
-                    ];
-                }
-                if (prop instanceof StoreValue) {
-                    const temp = new TempValue(scope);
-                    return [temp, [new InstructionBase("sensor", temp, this, prop)]];
-                }
-                throw new Error("Building property acessors must be string literals or stores");
-            }),
-        });
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
-}
-class BuildingBuilder extends ObjectValue {
-    constructor(scope) {
-        super(scope, {
-            $call: new MacroFunction(scope, (nameLit) => {
-                if (!(nameLit instanceof LiteralValue))
-                    throw new Error("Block name must be a literal.");
-                if (typeof nameLit.data !== "string")
-                    throw new Error("Block name must be a string.");
-                return [new Building(scope, nameLit.data), []];
-            }),
-        });
-    }
-}
-for (const key in operatorMap$2) {
-    const kind = operatorMap$2[key];
-    Building.prototype[key] = function (scope, value) {
-        const left = new StoreValue(scope, this.name);
-        const [right, rightInst] = value.eval(scope);
-        const temp = new TempValue(scope);
-        return [
-            temp,
-            [...rightInst, new OperationInstruction(kind, temp, left, right)],
-        ];
-    };
-}
-
 class GetLink extends MacroFunction {
     constructor(scope) {
         super(scope, (index) => {
             if (!(index instanceof StoreValue) &&
                 (!(index instanceof LiteralValue) || typeof index.data !== "number"))
-                throw new Error("The getlink index must be a number literal or a store");
-            const temp = new TempValue(scope);
-            const outBuild = new Building(scope, temp.name);
-            return [outBuild, [new InstructionBase("getlink", temp, index)]];
+                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)]];
         });
     }
 }
@@ -1267,11 +1631,11 @@ class Control extends MacroFunction {
     constructor(scope) {
         super(scope, (kind, building, ...args) => {
             if (!(kind instanceof LiteralValue) || typeof kind.data !== "string")
-                throw new Error("The control kind must be a string literal");
+                throw new CompilerError("The control kind must be a string literal");
             if (!validKinds$1.includes(kind.data))
-                throw new Error("Invalid control kind");
-            if (!(building instanceof ObjectValue))
-                throw new Error("The building must be an object value");
+                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)],
@@ -1280,91 +1644,6 @@ class Control extends MacroFunction {
     }
 }
 
-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 Error("Cannot use dynamic properties on object macros");
-                const symbolName = this.changeCasing
-                    ? camelToDashCase(prop.data)
-                    : prop.data;
-                return [new StoreValue(scope, `@${symbolName}`), []];
-            }),
-        });
-        this.changeCasing = changeCasing;
-    }
-}
-class VarsNamespace extends NamespaceMacro {
-    constructor(scope) {
-        super(scope);
-        const $get = this.data.$get;
-        this.data.$get = new MacroFunction(scope, prop => {
-            if (prop instanceof LiteralValue) {
-                if (prop.data === "unit")
-                    return [new Unit(scope, "@unit"), []];
-                if (prop.data === "this")
-                    return [new Building(scope, "@this"), []];
-            }
-            return $get.call(scope, [prop]);
-        });
-    }
-}
-class UCommandsNamespace extends NamespaceMacro {
-    constructor(scope) {
-        super(scope);
-        const $get = this.data.$get;
-        this.data.$get = new MacroFunction(scope, prop => {
-            if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
-                throw new Error("Cannot use dynamic properties on object macros");
-            const symbolName = prop.data[0].toUpperCase() + prop.data.slice(1);
-            return [new StoreValue(scope, `@command${symbolName}`), []];
-        });
-    }
-}
-// TODO: repeated logic between UnitMacro and Building
-class Unit extends ObjectValue {
-    constructor(scope, name) {
-        super(scope, {
-            $get: new MacroFunction(scope, prop => {
-                if (prop instanceof LiteralValue && typeof prop.data === "string") {
-                    const name = itemNames.includes(prop.data)
-                        ? camelToDashCase(prop.data)
-                        : prop.data;
-                    const temp = new TempValue(scope);
-                    // special case, should return another unit or building
-                    const result = prop.data === "controller" ? new Unit(scope, temp.name) : temp;
-                    return [
-                        result,
-                        [new InstructionBase("sensor", result, this, `@${name}`)],
-                    ];
-                }
-                if (prop instanceof StoreValue) {
-                    const temp = new TempValue(scope);
-                    return [temp, [new InstructionBase("sensor", temp, this, prop)]];
-                }
-                throw new Error("Building property acessors must be string literals or stores");
-            }),
-        });
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
-}
-for (const key in operatorMap$2) {
-    const kind = operatorMap$2[key];
-    Unit.prototype[key] = function (scope, value) {
-        const left = new StoreValue(scope, this.name);
-        const [right, rightInst] = value.eval(scope);
-        const temp = new TempValue(scope);
-        return [
-            temp,
-            [...rightInst, new OperationInstruction(kind, temp, left, right)],
-        ];
-    };
-}
-
 const validRadarFilters = [
     "any",
     "enemy",
@@ -1385,33 +1664,32 @@ const validRadarSorts = [
 class Radar extends MacroFunction {
     constructor(scope) {
         super(scope, (building, filter1, filter2, filter3, order, sort) => {
-            if (!(building instanceof ObjectValue))
-                throw new Error("The building must a store");
+            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 Error("The filters must be string literals");
+                throw new CompilerError("The filters must be string literals");
             if (!validRadarFilters.includes(filter1.data))
-                throw new Error("Invalid value for filter1");
+                throw new CompilerError("Invalid value for filter1");
             if (!validRadarFilters.includes(filter2.data))
-                throw new Error("Invalid value for filter2");
+                throw new CompilerError("Invalid value for filter2");
             if (!validRadarFilters.includes(filter3.data))
-                throw new Error("Invalid value for filter3");
+                throw new CompilerError("Invalid value for filter3");
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
-                throw new Error("The radar order must be a literal or a store");
+                throw new CompilerError("The radar order must be a literal or a store");
             if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
-                throw new Error("The radar sort must be a string literal");
+                throw new CompilerError("The radar sort must be a string literal");
             if (!validRadarSorts.includes(sort.data))
-                throw new Error("Invalid sort value");
-            const temp = new TempValue(scope);
-            const resultUnit = new Unit(scope, temp.name);
+                throw new CompilerError("Invalid sort value");
+            const outUnit = new SenseableValue(scope);
             return [
-                resultUnit,
+                outUnit,
                 [
-                    new InstructionBase("radar", filter1.data, filter2.data, filter3.data, sort.data, building, order, temp),
+                    new InstructionBase("radar", filter1.data, filter2.data, filter3.data, sort.data, building, order, outUnit),
                 ],
             ];
         });
@@ -1422,11 +1700,11 @@ class Sensor extends MacroFunction {
     constructor(scope) {
         super(scope, (property, target) => {
             if (!(property instanceof StoreValue))
-                throw new Error("The sensor property must be a store");
-            if (!(target instanceof ObjectValue))
-                throw new Error("The sensor target must be a store");
-            const temp = new TempValue(scope);
-            return [temp, [new InstructionBase("sensor", temp, property, target)]];
+                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)]];
         });
     }
 }
@@ -1436,7 +1714,7 @@ class Wait extends MacroFunction {
         super(scope, seconds => {
             if (!(seconds instanceof StoreValue) &&
                 !(seconds instanceof LiteralValue && typeof seconds.data === "number"))
-                throw new Error("The wait seconds must be either a number literal or a store");
+                throw new CompilerError("The wait seconds must be either a number literal or a store");
             return [null, [new InstructionBase("wait", seconds)]];
         });
     }
@@ -1447,23 +1725,29 @@ class Lookup extends MacroFunction {
     constructor(scope) {
         super(scope, (kind, index) => {
             if (!(kind instanceof LiteralValue && typeof kind.data === "string"))
-                throw new Error("The lookup kind must be a string literal");
+                throw new CompilerError("The lookup kind must be a string literal");
             if (!validKinds.includes(kind.data))
-                throw new Error("Invalid lookup kind");
+                throw new CompilerError("Invalid lookup kind");
             if (!(index instanceof LiteralValue && typeof index.data === "number") &&
                 !(index instanceof StoreValue))
-                throw new Error("The lookup index must be a number literal or a store");
-            const temp = new TempValue(scope);
+                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 Error("The unitBind type must be a store");
+                throw new CompilerError("The unitBind type must be a store");
             return [null, [new InstructionBase("ubind", type)]];
         });
     }
@@ -1493,29 +1777,23 @@ class UnitControl extends MacroFunction {
     constructor(scope) {
         super(scope, (mode, ...args) => {
             if (!(mode instanceof LiteralValue) || typeof mode.data !== "string")
-                throw new Error("The unitControl mode must be a string literal");
+                throw new CompilerError("The unitControl mode must be a string literal");
             if (!validModes.includes(mode.data))
-                throw new Error("Invalid unitControl mode");
-            if (args.some(value => !(value instanceof StoreValue ||
-                value instanceof LiteralValue ||
-                value instanceof ObjectValue)))
-                throw new Error("The others arguments of unitControl must be literals or stores");
+                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 TempValue(scope);
-                    const outBuilding = new TempValue(scope);
-                    result = new ObjectValue(scope, {
-                        0: outType,
-                        1: new Building(scope, outBuilding.name),
-                        length: new LiteralValue(scope, 2),
-                    });
+                    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 TempValue(scope);
+                    const temp = new StoreValue(scope);
                     result = temp;
                     extraArgs = [temp, new LiteralValue(scope, 0)];
                     break;
@@ -1538,24 +1816,25 @@ class UnitRadar extends MacroFunction {
                 typeof filter2.data !== "string" ||
                 !(filter3 instanceof LiteralValue) ||
                 typeof filter3.data !== "string")
-                throw new Error("The filters must be string literals");
+                throw new CompilerError("The filters must be string literals");
             if (!validRadarFilters.includes(filter1.data))
-                throw new Error("Invalid value for filter1");
+                throw new CompilerError("Invalid value for filter1");
             if (!validRadarFilters.includes(filter2.data))
-                throw new Error("Invalid value for filter2");
+                throw new CompilerError("Invalid value for filter2");
             if (!validRadarFilters.includes(filter3.data))
-                throw new Error("Invalid value for filter3");
+                throw new CompilerError("Invalid value for filter3");
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
-                throw new Error("The radar order must be a literal or a store");
+                throw new CompilerError("The radar order must be a literal or a store");
             if (!(sort instanceof LiteralValue) || typeof sort.data !== "string")
-                throw new Error("The radar sort must be a string literal");
+                throw new CompilerError("The radar sort must be a string literal");
             if (!validRadarSorts.includes(sort.data))
-                throw new Error("Invalid sort value");
-            const temp = new TempValue(scope);
+                throw new CompilerError("Invalid sort value");
+            const outUnit = new SenseableValue(scope);
             return [
-                temp,
+                outUnit,
                 [
-                    new InstructionBase("uradar", filter1.data, filter2.data, filter3.data, order, sort.data, temp),
+                    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),
                 ],
             ];
         });
@@ -1578,15 +1857,15 @@ class UnitLocate extends MacroFunction {
     constructor(scope) {
         super(scope, (find, ...args) => {
             if (!(find instanceof LiteralValue && typeof find.data === "string"))
-                throw new Error("The unitLocate find must be a string literal");
+                throw new CompilerError("The unitLocate find must be a string literal");
             if (!validFinds.includes(find.data))
-                throw new Error("Invalid find value");
+                throw new CompilerError("Invalid find value");
             if (args.some(value => !(value instanceof StoreValue || value instanceof LiteralValue)))
-                throw new Error("The others arguments of unitLocate must be literals or stores");
-            const outFound = new TempValue(scope);
-            const outX = new TempValue(scope);
-            const outY = new TempValue(scope);
-            const outBuilding = new TempValue(scope);
+                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) {
@@ -1598,10 +1877,10 @@ class UnitLocate extends MacroFunction {
                 case "building": {
                     const [group, enemy] = args;
                     if (!(group instanceof LiteralValue && typeof group.data === "string")) {
-                        throw new Error("The building group must be a string literal");
+                        throw new CompilerError("The building group must be a string literal");
                     }
                     if (!validBuildingGroups.includes(group.data))
-                        throw new Error("Invalid building group");
+                        throw new CompilerError("Invalid building group");
                     inputArgs = [find.data, group.data, enemy, "@copper"];
                     break;
                 }
@@ -1612,54 +1891,54 @@ class UnitLocate extends MacroFunction {
                 }
             }
             return [
-                new ObjectValue(scope, {
-                    0: outFound,
-                    1: outX,
-                    2: outY,
-                    3: new Building(scope, outBuilding.name),
-                    length: new LiteralValue(scope, find.data === "ore" ? 3 : 4),
-                }),
+                ObjectValue.fromArray(scope, [
+                    outFound,
+                    outX,
+                    outY,
+                    ...(find.data !== "ore" ? [outBuilding] : []),
+                ]),
                 [new InstructionBase("ulocate", ...inputArgs, ...outArgs)],
             ];
         });
     }
 }
 
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Radar: Radar,
-    Draw: Draw,
-    Print: Print,
-    PrintFlush: PrintFlush,
-    DrawFlush: DrawFlush,
-    GetLink: GetLink,
-    Control: Control,
-    Sensor: Sensor,
-    Wait: Wait,
-    Lookup: Lookup,
-    UnitBind: UnitBind,
-    UnitControl: UnitControl,
-    UnitRadar: UnitRadar,
-    UnitLocate: UnitLocate
-});
-
 class MemoryEntry extends ObjectValue {
     constructor(scope, mem, prop) {
         super(scope, {
             $eval: new MacroFunction(scope, () => {
-                const temp = new TempValue(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 => {
-                return [value, [new InstructionBase("write", value, mem.cell, prop)]];
+                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);
     };
 }
@@ -1668,7 +1947,7 @@ class MemoryMacro extends ObjectValue {
         super(scope, {
             $get: new MacroFunction(scope, (prop) => {
                 if (prop instanceof LiteralValue && typeof prop.data !== "number")
-                    throw new Error(`Invalid memory object property: "${prop.data}"`);
+                    throw new CompilerError(`Invalid memory object property: "${prop.data}"`);
                 const obj = new MemoryEntry(scope, this, prop);
                 return [obj, []];
             }),
@@ -1686,26 +1965,88 @@ class MemoryBuilder extends ObjectValue {
     constructor(scope) {
         super(scope, {
             $call: new MacroFunction(scope, (cell, size = new LiteralValue(scope, 64)) => {
-                if (!(cell instanceof ObjectValue))
-                    throw new Error("Memory cell must be a building object.");
+                if (!(cell instanceof SenseableValue))
+                    throw new CompilerError("Memory cell must be a senseable value.");
                 if (!(size instanceof LiteralValue && typeof size.data === "number"))
-                    throw new Error("The memory size must be a number literal.");
+                    throw new CompilerError("The memory size must be a number literal.");
                 return [new MemoryMacro(scope, cell, size), []];
             }),
         });
     }
 }
 
-class RawValueMacro extends MacroFunction {
+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 owner = new ValueOwner({
+                    scope,
+                    value: new StoreValue(scope),
+                    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: new StoreValue(scope),
+            });
+            return [owner.value, []];
+        });
+    }
+}
+
+class GetGlobal extends MacroFunction {
     constructor(scope) {
         super(scope, (name) => {
             if (!(name instanceof LiteralValue) || typeof name.data !== "string")
-                throw new Error("The name of the building must be a string literal.");
-            return [new StoreValue(scope, name.data), []];
+                throw new CompilerError("The name parameter must be a string literal.");
+            const owner = new ValueOwner({
+                scope,
+                name: name.data,
+                value: new SenseableValue(scope),
+            });
+            return [owner.value, []];
         });
     }
 }
 
+/**
+ * Adds all the compiler globals to `scope`
+ */
 function initScope(scope) {
     // namespaces
     scope.hardSet("ControlKind", new NamespaceMacro(scope));
@@ -1717,8 +2058,8 @@ function initScope(scope) {
     scope.hardSet("UnitCommands", new UCommandsNamespace(scope));
     scope.hardSet("Blocks", new NamespaceMacro(scope, { changeCasing: true }));
     // helper methods
-    scope.hardSet("getBuilding", new BuildingBuilder(scope));
-    scope.hardSet("getVar", new RawValueMacro(scope));
+    scope.hardSet("getBuilding", new GetGlobal(scope));
+    scope.hardSet("getVar", new GetGlobal(scope));
     scope.hardSet("concat", new Concat(scope));
     scope.hardSet("Math", new MlogMath(scope));
     scope.hardSet("Memory", new MemoryBuilder(scope));
@@ -1733,6 +2074,7 @@ function initScope(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));
@@ -1740,10 +2082,11 @@ function initScope(scope) {
 }
 
 class Compiler {
-    constructor(stackName) {
+    constructor({ stackName, compactNames = false } = {}) {
         this.handlers = handlers;
         this.usingStack = !!stackName;
         this.stackName = stackName;
+        this.compactNames = compactNames;
     }
     compile(script) {
         let output;
@@ -1757,7 +2100,8 @@ class Compiler {
             output = this.serialize(valueInst) + "\n";
         }
         catch (error) {
-            return [null, error, error?.nodeStack ?? []];
+            const nodeStack = error instanceof CompilerError ? error.nodeStack : [];
+            return [null, error, nodeStack];
         }
         return [output, null, []];
     }
@@ -1770,44 +2114,49 @@ class Compiler {
         }
     }
     serialize(resLines) {
-        const [_, inst] = resLines;
+        const [, inst] = resLines;
         return inst.filter(l => !l.hidden).join("\n");
     }
     parse(script) {
         return parse(script, {
-            locations: true,
-            ecmaVersion: "latest",
+            ranges: true,
+            plugins: ["typescript"],
         });
     }
     handle(scope, node) {
         try {
             const handler = this.handlers[node.type];
             if (!handler)
-                throw Error("Missing handler for " + node.type);
+                throw new CompilerError("Missing handler for " + node.type);
             return handler(this, scope, node, null);
         }
         catch (error) {
-            error.nodeStack ??= [];
-            error.nodeStack.push(node);
+            if (error instanceof CompilerError) {
+                error.nodeStack.push(node);
+            }
             throw error;
         }
     }
     handleEval(scope, node) {
         const [res, inst] = this.handle(scope, node);
-        const [evaluated, evaluatedLines] = res.eval(scope);
-        return [evaluated, [...inst, ...evaluatedLines]];
+        // 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);
+            const [, nodeLines] = handler(scope, node);
             lines.push(...nodeLines);
         }
         return [null, lines];
     }
 }
 
-const compiler = new Compiler();
-const compile = (script) => compiler.compile(script);
-
-export { compile };
+export { Compiler, CompilerError };