mlogjs 0.4.0 → 0.4.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-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

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

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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-export * from "./Draw";
-export * from "./Print";
-export * from "./PrintFlush";
-export * from "./DrawFlush";
-export * from "./GetBlock";
-export * from "./GetLink";
-export * from "./Control";
-export { Radar } from "./Radar";
-export * from "./Sensor";
-export * from "./Wait";
-export * from "./Lookup";
-export * from "./PackColor";
-export * from "./End";
-export * from "./SetBlock";
-export * from "./SpawnUnit";
-export * from "./Stop";
-export * from "./UnitBind";
-export * from "./UnitControl";
-export * from "./UnitRadar";
-export * from "./UnitLocate";
-export * from "./ApplyStatus";
-export * from "./SpawnWave";
-export * from "./SetRule";
-export * from "./FlushMessage";
-export * from "./Cutscene";
-export * from "./Explosion";
-export * from "./SetRate";
-export * from "./Fetch";
-export * from "./GetFlag";
-export * from "./SetFlag";

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

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

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

@@ -1,18 +0,0 @@
-import { IParameterDescriptor } from "../assertions";
-import { IScope, IValue, TValueInstructions } from "../types";
-import { MacroFunction } from "./Function";
-interface IOverloadNamespaceOptions<K extends string> {
-    scope: IScope;
-    overloads: Record<K, {
-        /**
-         * Pass the name of the options argument to tell if this overload uses
-         * named parameters.
-         */
-        named?: string;
-        args: (IParameterDescriptor | string)[];
-    }>;
-    handler(overload: K, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
-}
-/** Used to create namespaces that contain multiple methods that map into instructions */
-export declare function createOverloadNamespace<K extends string>({ scope, overloads, handler, }: IOverloadNamespaceOptions<K>): Record<string, MacroFunction<IValue | null>>;
-export {};

package/dist/types/operators.d.ts

@@ -1,25 +0,0 @@
-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

@@ -1,238 +0,0 @@
-export * as es from "@babel/types";
-import * as es from "@babel/types";
-import { Compiler } from "./Compiler";
-import { AddressResolver } from "./instructions";
-import { MacroFunction } from "./macros";
-import { LeftRightOperator, UnaryOperator, UpdateOperator } from "./operators";
-export declare enum EInstIntent {
-    none = 0,
-    break = 1,
-    continue = 2,
-    return = 3
-}
-export interface IInstruction {
-    intent: EInstIntent;
-    hidden: boolean;
-    resolve(i: number): void;
-    source?: es.SourceLocation;
-    /**
-     * Helps analyzing control flow, handlers should
-     * indicate which instructions returned are guaranteed to run
-     */
-    alwaysRuns: boolean;
-}
-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;
-};

package/dist/types/utils.d.ts

@@ -1,47 +0,0 @@
-import { es, IValue, TValueInstructions } from "./types";
-import { IObjectValueData, LiteralValue, ObjectValue } from "./values";
-/**
- * The prefix for internal variables inside the compiler output
- */
-export declare const internalPrefix = "&";
-export declare const discardedName: string;
-/**
- * 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].
- */
-export declare function nodeName(node: es.Node, name?: false | string): string;
-/**
- * Converts a camel case string into a dash case one.
- *
- * As an example `camelCase` becomes `camel-case`
- * @example
- * ```
- * camelToDashCase("camelCase") // returns "camel-case"
- * ```
- */
-export declare function camelToDashCase(name: string): string;
-export declare const itemNames: string[];
-/**
- * A more type safe version of `Object.assign`
- */
-export declare function assign<T extends {}>(obj: T, props: {
-    [K in keyof T as T[K] extends Function ? never : K]?: T[K];
-}): T;
-export declare function appendSourceLocations<T extends IValue | null>(valueInst: TValueInstructions<T>, node: es.Node): TValueInstructions<T>;
-export declare function withAlwaysRuns<T extends IValue | null>(valueInst: TValueInstructions<T>, value: boolean): TValueInstructions<T>;
-export declare function isTemplateObjectArray(value: IValue): value is ObjectValue & {
-    data: IObjectValueData & {
-        raw: ObjectValue & {
-            data: IObjectValueData & {
-                length: LiteralValue & {
-                    data: number;
-                };
-            };
-        };
-        length: LiteralValue & {
-            data: number;
-        };
-    };
-};

package/dist/types/values/BaseValue.d.ts

@@ -1,9 +0,0 @@
-import { IOwnedValue, IScope, IValue, TValueInstructions } from "../types";
-import { VoidValue } from ".";
-export declare class BaseValue extends VoidValue implements IValue {
-    "u-"(scope: IScope): TValueInstructions;
-    "u+"(scope: IScope): TValueInstructions;
-    "!"(scope: IScope): TValueInstructions;
-    "~"(scope: IScope): TValueInstructions;
-    ensureOwned(): asserts this is IOwnedValue;
-}

package/dist/types/values/DestructuringValue.d.ts

@@ -1,17 +0,0 @@
-import { IScope, IValue, TValueInstructions } from "../types";
-import { VoidValue } from "./VoidValue";
-/**
- * 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.
- */
-export declare class DestructuringValue extends VoidValue {
-    members: Map<IValue, IValue>;
-    macro: boolean;
-    constructor(scope: IScope, members: Map<IValue, IValue>);
-    "="(scope: IScope, right: IValue): TValueInstructions;
-    eval(_scope: IScope): TValueInstructions<IValue>;
-    consume(_scope: IScope): TValueInstructions<IValue>;
-}

package/dist/types/values/FunctionValue.d.ts

@@ -1,47 +0,0 @@
-import { Compiler } from "../Compiler";
-import { EMutability, es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-import { VoidValue } from "./VoidValue";
-export declare type TFunctionValueInitParams = (childScope: IScope) => {
-    paramStores: StoreValue[];
-    paramNames: string[];
-};
-export declare class FunctionValue extends VoidValue implements IFunctionValue {
-    mutability: EMutability;
-    macro: boolean;
-    private node;
-    private childScope;
-    private params;
-    private paramOwners;
-    private inst;
-    private addr;
-    private temp;
-    private ret;
-    private inline;
-    private tryingInline;
-    private body;
-    private c;
-    private callSize;
-    private inlineTemp;
-    private inlineEnd?;
-    private bundled;
-    private initialized;
-    constructor({ scope, params, body, c, node, }: {
-        scope: IScope;
-        body: es.BlockStatement;
-        c: Compiler;
-        node: es.Function;
-        params: es.Identifier[];
-    });
-    typeof(scope: IScope): TValueInstructions;
-    private initScope;
-    private ensureInit;
-    private normalReturn;
-    private normalCall;
-    private inlineReturn;
-    private inlineCall;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
-    return(scope: IScope, arg: IValue | null): TValueInstructions<IValue | null>;
-    eval(_scope: IScope): TValueInstructions;
-    consume(_scope: IScope): TValueInstructions;
-}

package/dist/types/values/LiteralValue.d.ts

@@ -1,13 +0,0 @@
-import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue, EMutability } from "../types";
-import { BaseValue } from ".";
-export declare class LiteralValue extends BaseValue implements IBindableValue {
-    data: TLiteral;
-    mutability: EMutability;
-    constructor(scope: IScope, data: TLiteral);
-    eval(_scope: IScope): TValueInstructions;
-    consume(_scope: IScope): TValueInstructions;
-    toString(): string;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    get num(): number;
-    typeof(scope: IScope): TValueInstructions;
-}

package/dist/types/values/ObjectValue.d.ts

@@ -1,23 +0,0 @@
-import { MacroFunction } from "../macros";
-import { EMutability, IOwnedValue, IScope, IValue, TOperatorMacroMap, TValueInstructions } from "../types";
-import { LiteralValue } from "./LiteralValue";
-import { VoidValue } from "./VoidValue";
-export interface IObjectValueData extends TOperatorMacroMap {
-    [k: string]: IValue | undefined;
-    $get?: MacroFunction<IValue>;
-    $eval?: MacroFunction<IValue>;
-    $consume?: MacroFunction<IValue>;
-}
-export declare class ObjectValue extends VoidValue {
-    mutability: EMutability;
-    macro: boolean;
-    data: IObjectValueData;
-    constructor(scope: IScope, data?: IObjectValueData);
-    static fromArray(scope: IScope, items: IObjectValueData[keyof IObjectValueData][], intialData?: IObjectValueData): ObjectValue;
-    typeof(scope: IScope): TValueInstructions;
-    get(scope: IScope, key: LiteralValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
-    consume(scope: IScope): TValueInstructions;
-    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
-    ensureOwned(): asserts this is IOwnedValue;
-}

package/dist/types/values/SenseableValue.d.ts

@@ -1,23 +0,0 @@
-import { EMutability, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-/**
- * Senseable values are "objects" in the mlog runtime that
- * have special properties that can be accessed
- * via the `sense` instruction.
- *
- * This class extends `StoreValue` to allow dynamic behavior
- * that is not possible with object macros.
- *
- * Note that these values are constant by default, so make sure
- * to set that field to `false` if you want them to be assignable. Example:
- * ```
- * const value = assign(new SenseableValue(scope), {
- *   mutability: EMutability.mutable
- * })
- * ```
- */
-export declare class SenseableValue extends StoreValue {
-    mutability: EMutability;
-    constructor(scope: IScope);
-    get(scope: IScope, prop: IValue): TValueInstructions<IValue>;
-}

package/dist/types/values/StoreValue.d.ts

@@ -1,15 +0,0 @@
-import { BaseValue } from ".";
-import { EMutability, IScope, IValue, TValueInstructions } from "../types";
-/**
- * `StoreValue` represents values unknown at compile time,
- * mostly used with mutable variables and temporary values
- */
-export declare class StoreValue extends BaseValue implements IValue {
-    mutability: EMutability;
-    constructor(scope: IScope);
-    typeof(scope: IScope): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
-    eval(_scope: IScope): TValueInstructions;
-    consume(_scope: IScope): TValueInstructions;
-    toString(): string;
-}

package/dist/types/values/ValueOwner.d.ts

@@ -1,27 +0,0 @@
-import { IScope, IValue, IValueOwner } from "../types";
-export interface IValueOwnerParams<T extends IValue> {
-    scope: IScope;
-    constant?: boolean;
-    value: T;
-    /** The identifier of the variable that `this` represents */
-    identifier?: string;
-    /** The name that the variable will have during transpilation to mlog */
-    name?: string;
-}
-export declare class ValueOwner<T extends IValue = IValue> implements IValueOwner<T> {
-    scope: IScope;
-    constant: boolean;
-    value: T;
-    owned: Set<T>;
-    identifier?: string;
-    name: string;
-    persistent: boolean;
-    /**
-     * Creates a new `ValueOwner`, if `value` is already owned,
-     * `this` will be aliased to `value`, else `this` will own `value`
-     */
-    constructor({ scope, constant, value, identifier, name, }: IValueOwnerParams<T>);
-    own(target: T): void;
-    replace(target: T): void;
-    moveInto(owner: IValueOwner<T>): void;
-}