mlogjs 0.2.1 → 0.3.0

package/dist/types/macros/Entities.d.ts

@@ -0,0 +1,11 @@
+import { IScope, IValue } from "../types";
+import { ObjectValue } from "../values";
+export declare const itemNames: string[];
+export declare class Building extends ObjectValue {
+    toString(): string;
+    constructor(scope: IScope);
+}
+export declare class Unit extends ObjectValue implements IValue {
+    constructor(scope: IScope);
+    toString(): string;
+}

package/dist/types/macros/Function.d.ts

@@ -0,0 +1,13 @@
+import { IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from "../values";
+declare type TFunction<T extends IValue | null> = (...args: IValue[]) => TValueInstructions<T>;
+export declare class MacroFunction<RT extends IValue | null = IValue> extends VoidValue {
+    macro: boolean;
+    constant: boolean;
+    fn: TFunction<RT>;
+    constructor(scope: IScope, fn: TFunction<RT>);
+    call(scope: IScope, args: IValue[]): TValueInstructions<RT>;
+    eval(_scope: IScope): TValueInstructions;
+    consume(_scope: IScope): TValueInstructions;
+}
+export {};

package/dist/types/macros/GetGlobal.d.ts

@@ -0,0 +1,5 @@
+import { EMutability, IScope } from "../types";
+import { MacroFunction } from "./Function";
+export declare class GetGlobal extends MacroFunction {
+    constructor(scope: IScope, mutability: EMutability);
+}

package/{build → dist/types}/macros/Math.d.ts

@@ -1,5 +1,5 @@
-import { IScope } from "../types";
-import { ObjectValue } from "../values";
-export declare class MlogMath extends ObjectValue {
-    constructor(scope: IScope);
-}
+import { IScope } from "../types";
+import { ObjectValue } from "../values";
+export declare class MlogMath extends ObjectValue {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/Memory.d.ts

@@ -1,5 +1,5 @@
-import { IScope } from "../types";
-import { ObjectValue } from "../values";
-export declare class MemoryBuilder extends ObjectValue {
-    constructor(scope: IScope);
-}
+import { IScope } from "../types";
+import { ObjectValue } from "../values";
+export declare class MemoryBuilder extends ObjectValue {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/Namespace.d.ts

@@ -1,21 +1,16 @@
-import { IScope } from "../types";
-import { ObjectValue } from "../values";
-interface NamespaceMacroOptions {
-    changeCasing?: boolean;
-}
-export declare class NamespaceMacro extends ObjectValue {
-    changeCasing: boolean;
-    constructor(scope: IScope, { changeCasing }?: NamespaceMacroOptions);
-}
-export declare class VarsNamespace extends NamespaceMacro {
-    constructor(scope: IScope);
-}
-export declare class UCommandsNamespace extends NamespaceMacro {
-    constructor(scope: IScope);
-}
-export declare class Unit extends ObjectValue {
-    name: string;
-    constructor(scope: IScope, name: string);
-    toString(): string;
-}
-export {};
+import { IScope } from "../types";
+import { ObjectValue } from "../values";
+interface NamespaceMacroOptions {
+    changeCasing?: boolean;
+}
+export declare class NamespaceMacro extends ObjectValue {
+    changeCasing: boolean;
+    constructor(scope: IScope, { changeCasing }?: NamespaceMacroOptions);
+}
+export declare class VarsNamespace extends NamespaceMacro {
+    constructor(scope: IScope);
+}
+export declare class UCommandsNamespace extends NamespaceMacro {
+    constructor(scope: IScope);
+}
+export {};

package/{build → dist/types}/macros/Other.d.ts

@@ -1,5 +1,5 @@
-import { IScope } from "../types";
-import { MacroFunction } from "./Function";
-export declare class Concat extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { IScope } from "../types";
+import { MacroFunction } from "./Function";
+export declare class Concat extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/RawValue.d.ts

@@ -1,5 +1,5 @@
-import { IScope } from "../types";
-import { MacroFunction } from "./Function";
-export declare class RawValueMacro extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { IScope } from "../types";
+import { MacroFunction } from "./Function";
+export declare class RawValueMacro extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Control.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class Control extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Control extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/Draw.d.ts

@@ -0,0 +1,5 @@
+import { IScope } from "../../types";
+import { MacroFunction } from "../Function";
+export declare class Draw extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/DrawFlush.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class DrawFlush extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class DrawFlush extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build/macros/commands/Draw.d.ts → dist/types/macros/commands/End.d.ts}

@@ -1,5 +1,5 @@
-import { IScope } from "../../types";
-import { MacroFunction } from "../Function";
-export declare class Draw extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { IScope } from "../../types";
+import { MacroFunction } from "../Function";
+export declare class End extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/GetLink.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class GetLink extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class GetLink extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Lookup.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class Lookup extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Lookup extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Print.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class Print extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Print extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/PrintFlush.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class PrintFlush extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class PrintFlush extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Radar.d.ts

@@ -1,7 +1,7 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare const validRadarFilters: string[];
-export declare const validRadarSorts: string[];
-export declare class Radar extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare const validRadarFilters: string[];
+export declare const validRadarSorts: string[];
+export declare class Radar extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Sensor.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class Sensor extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Sensor extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/UnitBind.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class UnitBind extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitBind extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/dist/types/macros/commands/UnitControl.d.ts

@@ -0,0 +1,5 @@
+import { MacroFunction } from "..";
+import { IScope, IValue } from "../../types";
+export declare class UnitControl extends MacroFunction<IValue | null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/UnitLocate.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class UnitLocate extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitLocate extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/UnitRadar.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class UnitRadar extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class UnitRadar extends MacroFunction {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/Wait.d.ts

@@ -1,5 +1,5 @@
-import { MacroFunction } from "..";
-import { IScope } from "../../types";
-export declare class Wait extends MacroFunction {
-    constructor(scope: IScope);
-}
+import { MacroFunction } from "..";
+import { IScope } from "../../types";
+export declare class Wait extends MacroFunction<null> {
+    constructor(scope: IScope);
+}

package/{build → dist/types}/macros/commands/index.d.ts

@@ -1,14 +1,15 @@
-export * from "./Draw";
-export * from "./Print";
-export * from "./PrintFlush";
-export * from "./DrawFlush";
-export * from "./GetLink";
-export * from "./Control";
-export { Radar } from "./Radar";
-export * from "./Sensor";
-export * from "./Wait";
-export * from "./Lookup";
-export * from "./UnitBind";
-export * from "./UnitControl";
-export * from "./UnitRadar";
-export * from "./UnitLocate";
+export * from "./Draw";
+export * from "./Print";
+export * from "./PrintFlush";
+export * from "./DrawFlush";
+export * from "./GetLink";
+export * from "./Control";
+export { Radar } from "./Radar";
+export * from "./Sensor";
+export * from "./Wait";
+export * from "./Lookup";
+export * from "./End";
+export * from "./UnitBind";
+export * from "./UnitControl";
+export * from "./UnitRadar";
+export * from "./UnitLocate";

package/{build → dist/types}/macros/index.d.ts

@@ -1,7 +1,6 @@
-export * from "./Function";
-export * from "./Math";
-export * from "./Other";
-export * as commands from "./commands";
-export * from "./Memory";
-export { BuildingBuilder } from "./Building";
-export { NamespaceMacro, VarsNamespace } from "./Namespace";
+export * from "./Function";
+export * from "./Math";
+export * from "./Other";
+export * as commands from "./commands";
+export * from "./Memory";
+export { NamespaceMacro, VarsNamespace } from "./Namespace";

package/{build → dist/types}/operators.d.ts

@@ -1,25 +1,25 @@
-export declare const arithmeticBinaryOperators: readonly ["*", "**", "+", "-", "/", "%"];
-export declare const comparisonBinaryOperators: readonly ["!=", "!==", "<", "<=", "==", "===", ">", ">="];
-export declare const bitwiseBinaryOperators: readonly ["&", "<<", ">>", ">>>", "^", "|"];
-export declare const binaryOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in"];
-export declare type BinaryOperator = typeof binaryOperators[number];
-export declare const logicalOperators: readonly ["&&", "??", "||"];
-export declare type LogicalOperator = typeof logicalOperators[number];
-export declare const arithmeticAssignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/="];
-export declare const logicalAssignmentOperators: readonly ["&&=", "||="];
-export declare const bitwiseAssignmentOperators: readonly ["<<=", ">>=", ">>>=", "^=", "|="];
-export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
-export declare type AssignementOperator = typeof assignmentOperators[number];
-export declare const leftRightOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
-export declare type LeftRightOperator = typeof leftRightOperators[number];
-export declare const unaryOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~"];
-export declare type UnaryOperator = typeof unaryOperators[number];
-export declare const updateOperators: readonly ["++", "--"];
-export declare type UpdateOperator = typeof updateOperators[number];
-export declare const singleOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
-export declare type SingleOperator = typeof singleOperators[number];
-export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
-export declare type Operator = typeof operators[number];
-export declare const operatorMap: {
-    [k in BinaryOperator | LogicalOperator]?: string;
-};
+export declare const arithmeticBinaryOperators: readonly ["*", "**", "+", "-", "/", "%"];
+export declare const comparisonBinaryOperators: readonly ["!=", "!==", "<", "<=", "==", "===", ">", ">="];
+export declare const bitwiseBinaryOperators: readonly ["&", "<<", ">>", ">>>", "^", "|"];
+export declare const binaryOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in"];
+export declare type BinaryOperator = typeof binaryOperators[number];
+export declare const logicalOperators: readonly ["&&", "??", "||"];
+export declare type LogicalOperator = typeof logicalOperators[number];
+export declare const arithmeticAssignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/="];
+export declare const logicalAssignmentOperators: readonly ["&&=", "||="];
+export declare const bitwiseAssignmentOperators: readonly ["<<=", ">>=", ">>>=", "^=", "|="];
+export declare const assignmentOperators: readonly ["%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
+export declare type AssignementOperator = typeof assignmentOperators[number];
+export declare const leftRightOperators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "="];
+export declare type LeftRightOperator = typeof leftRightOperators[number];
+export declare const unaryOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~"];
+export declare type UnaryOperator = typeof unaryOperators[number];
+export declare const updateOperators: readonly ["++", "--"];
+export declare type UpdateOperator = typeof updateOperators[number];
+export declare const singleOperators: readonly ["!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
+export declare type SingleOperator = typeof singleOperators[number];
+export declare const operators: readonly ["*", "**", "+", "-", "/", "%", "!=", "!==", "<", "<=", "==", "===", ">", ">=", "&", "<<", ">>", ">>>", "^", "|", "instanceof", "in", "&&", "??", "||", "%=", "&=", "*=", "**=", "+=", "-=", "/=", "&&=", "||=", "<<=", ">>=", ">>>=", "^=", "|=", "=", "!", "u+", "u-", "delete", "typeof", "void", "~", "++", "--"];
+export declare type Operator = typeof operators[number];
+export declare const operatorMap: {
+    [k in Exclude<BinaryOperator, "instanceof" | "in"> | Exclude<LogicalOperator, "??">]: string;
+};

package/dist/types/types.d.ts

@@ -0,0 +1,224 @@
+export * as es from "@babel/types";
+import { Compiler } from "./Compiler";
+import { AddressResolver } from "./instructions";
+import { MacroFunction } from "./macros";
+import { LeftRightOperator, UnaryOperator, UpdateOperator } from "./operators";
+export interface IInstruction {
+    hidden: boolean;
+    resolve(i: number): void;
+}
+export declare type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, arg: any) => TValueInstructions<T>;
+/**
+ * The scope manages the source code generated variables and their owners,
+ * as well as break and continue statements and they also work as function
+ * bodies.
+ */
+export interface IScope {
+    /** Every scope except the top level one has a parent */
+    parent: IScope | null;
+    /** The registry of variables contained by this scope */
+    data: Record<string, IValueOwner | null>;
+    name: string;
+    /**
+     * Additional instructions required by this scope, such as
+     * the instructions that make the body of a function
+     */
+    inst: IInstruction[];
+    /** Where to jump to on a break statement */
+    break: AddressResolver;
+    /** Where to jump to on a continue statement */
+    continue: AddressResolver;
+    /** The function linked to `this`, is `null` when the scope is not inside a function. */
+    function: IFunctionValue;
+    /** Counts the number of temp variables generated during compilaton */
+    ntemp: number;
+    /**
+     * Creates a new scope that has `this` as it's parent.
+     */
+    createScope(): IScope;
+    /**
+     * Creates a new scope to be used by a function value, the scope has the following properties:
+     * - uses `name` as it's primary name, it changes how variable names are formatted.
+     * - it has `this` as it's parent
+     * - independent variable registry
+     * @param name The name of the scope
+     * @param stacked
+     */
+    createFunction(name: string, stacked?: boolean): IScope;
+    /** Checks if there is an owner registered with the specified identifier */
+    has(identifier: string): boolean;
+    /** Gets a value by their owner's identifier */
+    get(identifier: string): IOwnedValue;
+    /**
+     * Registers `value` with an owner that uses `name` as both it's name and identifier,
+     * throws an error if there already is an owner with the same identitifer.
+     * @param name
+     * @param value
+     */
+    set<T extends IValue>(name: string, value: T): T;
+    /**
+     * Registers `owner` and it's inner value, throws an error
+     * if there already is an owner with the same identifier.
+     */
+    set<T extends IValue>(owner: IValueOwner<T>): T;
+    /**
+     * Registers `value` with an owner that uses `name` as both it's name and identifier,
+     * overriding any preexisting variables with the same identifier.
+     * @param name
+     * @param value
+     */
+    hardSet<T extends IValue>(name: string, value: T): T;
+    /**
+     * Registers `owner` and it's inner value, overriding
+     * any preexisting variables with the same identifier.
+     * @param owner
+     */
+    hardSet<T extends IValue>(owner: IValueOwner<T>): T;
+    /**
+     * Creates an owned store and registers it to this scope.
+     * @param identifier The name of the variable that will hold the store
+     * @param name The mlog name that the owner will have
+     */
+    make(identifier: string, name: string): IValue;
+    /**
+     * Creates a shallow copy of this scope.
+     *
+     * Be aware that since the copy is shallow, changes on object fields (except `data`)
+     * reflect on the original scope. Note that changes to the children of data also follow this rule.
+     */
+    copy(): IScope;
+    /** Creates a temporary mlog variable name */
+    makeTempName(): string;
+}
+/**
+ * Owners track how variables will behave when it comes to their usage.
+ *
+ * As an example, Stores use their owners to determine what to do during
+ * assignments, like making a compile time alias, moving the values or generating
+ * a `set` instruction.
+ */
+export interface IValueOwner<T extends IValue = IValue> {
+    scope: IScope;
+    constant: boolean;
+    value: T;
+    /** The name of the variable on the source code that generated this value owner */
+    identifier?: string;
+    /** The name this owner has in it's mlog representation */
+    name: string;
+    /** Whether this owner is temporary or persistent */
+    persistent: boolean;
+    /** Set of values owned by this, can be used to get the owned value count  */
+    owned: Set<T>;
+    /** Adds `target` to the {@link owned set of owned values} and sets its owner to `this` */
+    own(target: T): void;
+    /** Replaces the currently held value by `target` */
+    replace(target: T): void;
+    /** Moves all values owned by `this` into `owner` */
+    moveInto(owner: IValueOwner<T>): void;
+}
+export interface IValueOperators {
+    "!"(scope: IScope): TValueInstructions;
+    "u+"(scope: IScope): TValueInstructions;
+    "u-"(scope: IScope): TValueInstructions;
+    "delete"(scope: IScope): TValueInstructions;
+    "typeof"(scope: IScope): TValueInstructions;
+    "void"(scope: IScope): TValueInstructions;
+    "~"(scope: IScope): TValueInstructions;
+    "++"(scope: IScope, prefix: boolean): TValueInstructions;
+    "--"(scope: IScope, prefix: boolean): TValueInstructions;
+    "*"(scope: IScope, value: IValue): TValueInstructions;
+    "**"(scope: IScope, value: IValue): TValueInstructions;
+    "+"(scope: IScope, value: IValue): TValueInstructions;
+    "-"(scope: IScope, value: IValue): TValueInstructions;
+    "/"(scope: IScope, value: IValue): TValueInstructions;
+    "%"(scope: IScope, value: IValue): TValueInstructions;
+    "!="(scope: IScope, value: IValue): TValueInstructions;
+    "!=="(scope: IScope, value: IValue): TValueInstructions;
+    "<"(scope: IScope, value: IValue): TValueInstructions;
+    "<="(scope: IScope, value: IValue): TValueInstructions;
+    "=="(scope: IScope, value: IValue): TValueInstructions;
+    "==="(scope: IScope, value: IValue): TValueInstructions;
+    ">"(scope: IScope, value: IValue): TValueInstructions;
+    ">="(scope: IScope, value: IValue): TValueInstructions;
+    "&"(scope: IScope, value: IValue): TValueInstructions;
+    "<<"(scope: IScope, value: IValue): TValueInstructions;
+    ">>"(scope: IScope, value: IValue): TValueInstructions;
+    ">>>"(scope: IScope, value: IValue): TValueInstructions;
+    "^"(scope: IScope, value: IValue): TValueInstructions;
+    "|"(scope: IScope, value: IValue): TValueInstructions;
+    instanceof(scope: IScope, value: IValue): TValueInstructions;
+    in(scope: IScope, value: IValue): TValueInstructions;
+    "&&"(scope: IScope, value: IValue): TValueInstructions;
+    "??"(scope: IScope, value: IValue): TValueInstructions;
+    "||"(scope: IScope, value: IValue): TValueInstructions;
+    "%="(scope: IScope, value: IValue): TValueInstructions;
+    "&="(scope: IScope, value: IValue): TValueInstructions;
+    "*="(scope: IScope, value: IValue): TValueInstructions;
+    "**="(scope: IScope, value: IValue): TValueInstructions;
+    "+="(scope: IScope, value: IValue): TValueInstructions;
+    "-="(scope: IScope, value: IValue): TValueInstructions;
+    "/="(scope: IScope, value: IValue): TValueInstructions;
+    "&&="(scope: IScope, value: IValue): TValueInstructions;
+    "||="(scope: IScope, value: IValue): TValueInstructions;
+    "<<="(scope: IScope, value: IValue): TValueInstructions;
+    ">>="(scope: IScope, value: IValue): TValueInstructions;
+    ">>>="(scope: IScope, value: IValue): TValueInstructions;
+    "^="(scope: IScope, value: IValue): TValueInstructions;
+    "|="(scope: IScope, value: IValue): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+}
+/** Defines the possible types of mutability of a value */
+export declare enum EMutability {
+    /**
+     * The value can be changed by the user's code,
+     * by the mlog runtime, or us
+     */
+    mutable = 0,
+    /**
+     * The value cannot be directly assigned,
+     * but it's still not safe from mutations coming from the runtime.
+     */
+    readonly = 1,
+    /** Constant values, won't change during execution */
+    constant = 2
+}
+export interface IValue extends IValueOperators {
+    owner: IValueOwner | null;
+    scope: IScope;
+    mutability: EMutability;
+    macro: boolean;
+    /**
+     * Evaluates `this`, returning it's representation in a more basic
+     * value like `StoreValue` with the instructions required to compute that value
+     */
+    eval(scope: IScope): TValueInstructions;
+    /**
+     * Does the same thing as {@link IValue.eval eval}, but ensures that the resulting value has an owner.
+     *
+     * This behaviour is required when dealing with temporary values inside expressions like comparations.
+     */
+    consume(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    ensureOwned(): asserts this is IOwnedValue;
+}
+/** Helper type that is used in some typescript assertions */
+export interface IOwnedValue extends IValue {
+    owner: Exclude<IValue["owner"], null>;
+}
+export declare type TLiteral = string | number;
+export interface IBindableValue extends IValue {
+    data: TLiteral;
+}
+export interface IFunctionValue extends IValue {
+    return(scope: IScope, argument: IValue | null): TValueInstructions<IValue | null>;
+}
+/** Contains a value and the instructions required to compute it */
+export declare type TValueInstructions<Content extends IValue | null = IValue> = [
+    Content,
+    IInstruction[]
+];
+/** Map of overridable operators in object macros */
+export declare type TOperatorMacroMap = {
+    [K in UnaryOperator | UpdateOperator | LeftRightOperator as `$${K}`]?: MacroFunction;
+};