mlogjs 0.2.1 → 0.2.2

package/dist/index.mjs

@@ -0,0 +1,1813 @@
+import { parse } from 'acorn';
+
+const arithmeticBinaryOperators = [
+    "*",
+    "**",
+    "+",
+    "-",
+    "/",
+    "%",
+];
+const comparisonBinaryOperators = [
+    "!=",
+    "!==",
+    "<",
+    "<=",
+    "==",
+    "===",
+    ">",
+    ">=",
+];
+const bitwiseBinaryOperators = [
+    "&",
+    "<<",
+    ">>",
+    ">>>",
+    "^",
+    "|",
+];
+const binaryOperators = [
+    ...arithmeticBinaryOperators,
+    ...comparisonBinaryOperators,
+    ...bitwiseBinaryOperators,
+    "instanceof",
+    "in",
+];
+const logicalOperators = ["&&", "??", "||"];
+const arithmeticAssignmentOperators = [
+    "%=",
+    "&=",
+    "*=",
+    "**=",
+    "+=",
+    "-=",
+    "/=",
+];
+const logicalAssignmentOperators = ["&&=", "||="];
+const bitwiseAssignmentOperators = [
+    "<<=",
+    ">>=",
+    ">>>=",
+    "^=",
+    "|=",
+];
+const assignmentOperators = [
+    ...arithmeticAssignmentOperators,
+    ...logicalAssignmentOperators,
+    ...bitwiseAssignmentOperators,
+    "=",
+];
+const leftRightOperators = [
+    ...binaryOperators,
+    ...logicalOperators,
+    ...assignmentOperators,
+];
+const unaryOperators = [
+    "!",
+    "u+",
+    "u-",
+    "delete",
+    "typeof",
+    "void",
+    "~",
+];
+const updateOperators = ["++", "--"];
+const singleOperators = [...unaryOperators, ...updateOperators];
+const operators = [...leftRightOperators, ...singleOperators];
+const operatorMap$2 = {
+    "==": "equal",
+    "===": "strictEqual",
+    "!=": "notEqual",
+    "!==": "notEqual",
+    "<": "lessThan",
+    ">": "greaterThan",
+    "<=": "lessThanEq",
+    ">=": "greaterThanEq",
+    "+": "add",
+    "-": "sub",
+    "*": "mul",
+    "/": "div",
+    "%": "mod",
+    "**": "pow",
+    "|": "or",
+    "&": "and",
+    "^": "xor",
+    ">>": "shr",
+    ">>>": "shr",
+    "<<": "shl",
+    "&&": "land",
+    "||": "or",
+};
+
+class VoidValue {
+    constructor(scope) {
+        this.constant = false;
+        this.macro = false;
+        this.scope = scope;
+    }
+    eval(scope) {
+        throw new Error(`${this} cannot eval.`);
+    }
+    call(scope, args) {
+        throw new Error(`${this} cannot call.`);
+    }
+    get(scope, name) {
+        throw new Error(`${this} cannot get.`);
+    }
+    toString() {
+        return "void";
+    }
+}
+for (const key of operators) {
+    VoidValue.prototype[key] = function () {
+        console.log(this);
+        throw new Error(`${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);
+    }
+}
+
+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 ReturnInstruction extends JumpInstruction {
+    constructor(address) {
+        super(address, EJumpKind.Always);
+    }
+}
+
+class BaseValue extends VoidValue {
+    "u-"(scope) {
+        const [that, inst] = this.eval(scope);
+        const temp = new TempValue(scope);
+        return [
+            temp,
+            [
+                ...inst,
+                new OperationInstruction("sub", temp, new LiteralValue(scope, 0), that),
+            ],
+        ];
+    }
+}
+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.eval(scope);
+        const [right, rightInst] = value.eval(scope);
+        const temp = new TempValue(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.eval(scope);
+        const temp = new TempValue(scope);
+        return [temp, [...inst, new OperationInstruction(name, temp, that, null)]];
+    };
+}
+const assignmentToBinary = {
+    "+=": "+",
+    "-=": "-",
+    "*=": "*",
+    "/=": "/",
+    "%=": "%",
+    "**=": "**",
+    "|=": "|",
+    "&=": "&",
+    "^=": "^",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "<<=": "<<",
+    "&&=": "&&",
+    "||=": "||",
+};
+for (const op in assignmentToBinary) {
+    BaseValue.prototype[op] = function (scope, value) {
+        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.eval(scope);
+        if (!prefix) {
+            const temp = new TempValue(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 Error("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.constant = true;
+        this.data = data;
+    }
+    eval(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 Error(`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)), []];
+    };
+}
+
+class StoreValue extends BaseValue {
+    constructor(scope, name) {
+        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);
+        return [this, [...evalInst, new SetInstruction(this, evalValue)]];
+    }
+    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);
+    }
+    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];
+        }
+    }
+}
+
+class ObjectValue extends VoidValue {
+    constructor(scope, data = {}) {
+        super(scope);
+        this.constant = true;
+        this.macro = true;
+        this.data = 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)) {
+            const member = this.data[key.data];
+            return [member, []];
+        }
+        const { $get } = this.data;
+        if (!$get)
+            throw new Error("Cannot get undefined member.");
+        return $get.call(scope, [key]);
+    }
+    eval(scope) {
+        const { $eval } = this.data;
+        if (!$eval)
+            return [this, []];
+        return $eval.call(scope, []);
+    }
+    call(scope, args) {
+        const { $call } = this.data;
+        if (!$call)
+            return super.call(scope, args);
+        return $call.call(scope, args);
+    }
+}
+for (const op of operators) {
+    ObjectValue.prototype[op] = function (...args) {
+        const $ = this.data[`$${op}`];
+        if (!$)
+            return VoidValue.prototype[op].apply(this, args);
+        let [scope, ...fnArgs] = args;
+        return $.call(scope, fnArgs);
+    };
+}
+
+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) {
+        return new Scope({}, this, stacked ?? this.stacked, 0, name, this.inst);
+    }
+    has(name) {
+        if (name in this.data)
+            return true;
+        if (this.parent)
+            return this.parent.has(name);
+        return false;
+    }
+    get(name) {
+        const value = this.data[name];
+        if (value)
+            return value;
+        if (this.parent)
+            return this.parent.get(name);
+        throw Error(`${name} is not declared.`);
+    }
+    set(name, value) {
+        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;
+    }
+    make(name, storeName) {
+        return this.set(name, this.stacked ? null : new StoreValue(this, storeName));
+    }
+}
+
+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
+        ? 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;
+        }
+        default:
+            throw new Error("");
+    }
+};
+
+const Literal = (c, scope, node) => {
+    const { value } = node;
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number") {
+        return [new LiteralValue(scope, value), []];
+    }
+    if (typeof value === "boolean") {
+        return [new LiteralValue(scope, +value), []];
+    }
+    throw Error("Cannot create literal " + typeof value);
+};
+
+const LRExpression = (c, scope, node) => {
+    const [left, leftInst] = c.handleEval(scope, node.left);
+    const [right, rightInst] = c.handleEval(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);
+    const [right, rightInst] = c.handleEval(scope, node.right);
+    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 operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
+    const [op, opInst] = arg[operatorId](scope);
+    return [op, [...argInst, ...opInst]];
+};
+const UpdateExpression = (c, scope, { argument, operator, prefix }) => {
+    const [arg, argInst] = c.handle(scope, argument);
+    const [op, opInst] = arg[operator](scope, prefix);
+    return [op, [...argInst, ...opInst]];
+};
+
+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.handleEval(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.handleEval(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 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)
+        : [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, name, paramNames, paramStores, body, c) {
+        super(scope);
+        this.constant = true;
+        this.macro = true;
+        this.bundled = false;
+        this.name = name;
+        this.paramNames = paramNames;
+        this.paramStores = paramStores;
+        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);
+    }
+    typeof(scope) {
+        return [new LiteralValue(scope, "function"), []];
+    }
+    createInst() {
+        this.inst = [
+            new AddressResolver(this.addr),
+            ...this.c.handle(this.scope, this.body)[1],
+        ];
+        this.inst.push(new SetCounterInstruction(this.ret));
+    }
+    normalReturn(scope, arg) {
+        const argInst = arg ? this.temp["="](scope, arg)[1] : [];
+        return [null, [...argInst, new SetCounterInstruction(this.ret)]];
+    }
+    normalCall(scope, args) {
+        if (!this.bundled)
+            this.scope.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])
+            .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];
+    }
+    inlineReturn(scope, arg) {
+        const argInst = arg ? this.inlineTemp["="](scope, arg)[1] : [];
+        return [null, [...argInst, new ReturnInstruction(this.inlineEnd)]];
+    }
+    inlineCall(scope, args) {
+        // create return value
+        this.inlineTemp = new TempValue(scope);
+        this.inlineEnd = new LiteralValue(scope, null);
+        // make a copy of the function scope
+        const fnScope = this.scope.copy();
+        // hard set variables within the function scope
+        this.paramNames.forEach((name, i) => fnScope.hardSet(name, args[i]));
+        this.tryingInline = true;
+        let inst = this.c.handle(fnScope, this.body)[1];
+        this.tryingInline = false;
+        // removing useless instruction
+        // get the last instructions
+        // const [jump] = inst.slice(-1);
+        // if (jump instanceof JumpInstruction) {
+        // 	// remove useless jump
+        // 	if (jump.args[1] === this.inlineEnd) inst.pop();
+        // }
+        inst.push(new AddressResolver(this.inlineEnd));
+        // return the function value
+        return [this.inlineTemp, inst];
+    }
+    call(scope, args) {
+        if (args.length !== this.paramStores.length)
+            throw new Error("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) {
+        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, []];
+    }
+}
+
+const ArrowFunctionExpression = (c, scope, node) => {
+    const name = nodeName(node);
+    scope = scope.createFunction(name);
+    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)));
+    }
+    return [
+        new FunctionValue(scope, name, paramNames, paramStores, body, c),
+        [],
+    ];
+};
+const FunctionDeclaration = (c, scope, node) => {
+    return [
+        scope.set(node.id.name, ArrowFunctionExpression(c, scope, node, null)[0]),
+        [],
+    ];
+};
+const FunctionExpression = 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);
+        inst.push(...i);
+        return v;
+    });
+    const [callee, calleeInst] = c.handleEval(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.computed)
+            throw new Error("Cannot handle computed property.");
+        const { key, value } = prop;
+        let index;
+        if (key.type === "Identifier")
+            index = key.name;
+        else if (key.type === "Literal")
+            index = "" + key.value;
+        else {
+            throw new Error(`Unsupported object key type: ${key.type}`);
+        }
+        const [member, memberInst] = c.handleEval(scope, value);
+        data[index] = member;
+        inst.push(...memberInst);
+    }
+    return [new ObjectValue(scope, data), inst];
+};
+const ArrayExpression = (c, scope, node) => {
+    const data = {};
+    const inst = [];
+    node.elements.forEach((element, i) => {
+        if (!element)
+            return;
+        const [value, valueInst] = c.handleEval(scope, element);
+        data[i] = value;
+        inst.push(...valueInst);
+    });
+    return [new ObjectValue(scope, data), inst];
+};
+const MemberExpression = (c, scope, node) => {
+    const [obj, objInst] = c.handleEval(scope, node.object);
+    const [prop, propInst] = node.computed
+        ? c.handleEval(scope, node.property)
+        : [new LiteralValue(scope, node.property.name), []];
+    const [got, gotInst] = obj.get(scope, prop);
+    return [got, [...objInst, ...propInst, ...gotInst]];
+};
+
+const TemplateLiteral = (c, scope, node) => {
+    const args = [];
+    const inst = [];
+    node.expressions.forEach((expression, i) => {
+        const [v, vi] = c.handleEval(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];
+};
+
+var handlers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Program: Program,
+    VariableDeclaration: VariableDeclaration,
+    VariableDeclarator: VariableDeclarator,
+    Literal: Literal,
+    LRExpression: LRExpression,
+    BinaryExpression: BinaryExpression,
+    LogicalExpression: LogicalExpression,
+    AssignmentExpression: AssignmentExpression,
+    UnaryExpression: UnaryExpression,
+    UpdateExpression: UpdateExpression,
+    Identifier: Identifier,
+    ExpressionStatement: ExpressionStatement,
+    BreakStatement: BreakStatement,
+    ContinueStatement: ContinueStatement,
+    ReturnStatement: ReturnStatement,
+    IfStatement: IfStatement,
+    WhileStatement: WhileStatement,
+    ForStatement: ForStatement,
+    ArrowFunctionExpression: ArrowFunctionExpression,
+    FunctionDeclaration: FunctionDeclaration,
+    FunctionExpression: FunctionExpression,
+    CallExpression: CallExpression,
+    NewExpression: NewExpression,
+    ObjectExpression: ObjectExpression,
+    ArrayExpression: ArrayExpression,
+    MemberExpression: MemberExpression,
+    TemplateLiteral: TemplateLiteral,
+    BlockStatement: BlockStatement
+});
+
+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, []];
+    }
+}
+
+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 Error("Cannot do math operation with non-numerical literals.");
+                    return [new LiteralValue(scope, fn(a.num, b.num)), []];
+                }
+                const temp = new TempValue(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.");
+                return [new LiteralValue(scope, fn(a.num)), []];
+            }
+            const temp = new TempValue(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 Error("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 Error("Draw kind must be literal.");
+            if ([
+                "clear",
+                "color",
+                "stroke",
+                "line",
+                "rect",
+                "lineRect",
+                "poly",
+                "linePoly",
+                "triangle",
+                "image",
+            ].indexOf(kind.data) === -1)
+                throw new Error("Draw kind must be valid");
+            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 ObjectValue))
+                throw new Error("The printflush target must be a building");
+            return [null, [new InstructionBase("printflush", target)]];
+        });
+    }
+}
+
+class DrawFlush extends MacroFunction {
+    constructor(scope) {
+        super(scope, (target) => {
+            if (!(target instanceof ObjectValue))
+                throw new Error("The drawflush target must be a building");
+            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)]];
+        });
+    }
+}
+
+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 Error("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");
+            return [
+                null,
+                [new InstructionBase("control", kind.data, building, ...args)],
+            ];
+        });
+    }
+}
+
+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",
+    "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 ObjectValue))
+                throw new Error("The building must a store");
+            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");
+            if (!validRadarFilters.includes(filter1.data))
+                throw new Error("Invalid value for filter1");
+            if (!validRadarFilters.includes(filter2.data))
+                throw new Error("Invalid value for filter2");
+            if (!validRadarFilters.includes(filter3.data))
+                throw new Error("Invalid value for filter3");
+            if (!(order instanceof LiteralValue || order instanceof StoreValue))
+                throw new Error("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");
+            if (!validRadarSorts.includes(sort.data))
+                throw new Error("Invalid sort value");
+            const temp = new TempValue(scope);
+            const resultUnit = new Unit(scope, temp.name);
+            return [
+                resultUnit,
+                [
+                    new InstructionBase("radar", filter1.data, filter2.data, filter3.data, sort.data, building, order, temp),
+                ],
+            ];
+        });
+    }
+}
+
+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)]];
+        });
+    }
+}
+
+class Wait extends MacroFunction {
+    constructor(scope) {
+        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");
+            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 Error("The lookup kind must be a string literal");
+            if (!validKinds.includes(kind.data))
+                throw new Error("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);
+            return [temp, [new InstructionBase("lookup", kind.data, temp, index)]];
+        });
+    }
+}
+
+class UnitBind extends MacroFunction {
+    constructor(scope) {
+        super(scope, type => {
+            if (!(type instanceof StoreValue))
+                throw new Error("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 Error("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");
+            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),
+                    });
+                    extraArgs = [outType, outBuilding, new LiteralValue(scope, 0)];
+                    break;
+                }
+                case "within": {
+                    const temp = new TempValue(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 Error("The filters must be string literals");
+            if (!validRadarFilters.includes(filter1.data))
+                throw new Error("Invalid value for filter1");
+            if (!validRadarFilters.includes(filter2.data))
+                throw new Error("Invalid value for filter2");
+            if (!validRadarFilters.includes(filter3.data))
+                throw new Error("Invalid value for filter3");
+            if (!(order instanceof LiteralValue || order instanceof StoreValue))
+                throw new Error("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");
+            if (!validRadarSorts.includes(sort.data))
+                throw new Error("Invalid sort value");
+            const temp = new TempValue(scope);
+            return [
+                temp,
+                [
+                    new InstructionBase("uradar", filter1.data, filter2.data, filter3.data, order, sort.data, temp),
+                ],
+            ];
+        });
+    }
+}
+
+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 Error("The unitLocate find must be a string literal");
+            if (!validFinds.includes(find.data))
+                throw new Error("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);
+            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 Error("The building group must be a string literal");
+                    }
+                    if (!validBuildingGroups.includes(group.data))
+                        throw new Error("Invalid building group");
+                    inputArgs = [find.data, group.data, enemy, "@copper"];
+                    break;
+                }
+                case "spawn":
+                case "damaged": {
+                    inputArgs = [find.data, "core", "true", "@copper"];
+                    break;
+                }
+            }
+            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),
+                }),
+                [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);
+                return [temp, [new InstructionBase("read", temp, mem.cell, prop)]];
+            }),
+            "$=": new MacroFunction(scope, value => {
+                return [value, [new InstructionBase("write", value, mem.cell, prop)]];
+            }),
+        });
+    }
+}
+for (const operator of operators) {
+    if (operator === "=")
+        continue;
+    MemoryEntry.prototype[operator] = function (...args) {
+        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 Error(`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 ObjectValue))
+                    throw new Error("Memory cell must be a building object.");
+                if (!(size instanceof LiteralValue && typeof size.data === "number"))
+                    throw new Error("The memory size must be a number literal.");
+                return [new MemoryMacro(scope, cell, size), []];
+            }),
+        });
+    }
+}
+
+class RawValueMacro 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), []];
+        });
+    }
+}
+
+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 BuildingBuilder(scope));
+    scope.hardSet("getVar", new RawValueMacro(scope));
+    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("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) {
+        this.handlers = handlers;
+        this.usingStack = !!stackName;
+        this.stackName = stackName;
+    }
+    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) {
+            return [null, error, 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, {
+            locations: true,
+            ecmaVersion: "latest",
+        });
+    }
+    handle(scope, node) {
+        try {
+            const handler = this.handlers[node.type];
+            if (!handler)
+                throw Error("Missing handler for " + node.type);
+            return handler(this, scope, node, null);
+        }
+        catch (error) {
+            error.nodeStack ??= [];
+            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]];
+    }
+    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];
+    }
+}
+
+const compiler = new Compiler();
+const compile = (script) => compiler.compile(script);
+
+export { compile };