mlogjs 0.5.2 → 0.6.0

package/dist/instructions/AddressResolver.d.ts

@@ -1,12 +1,12 @@
 import { InstructionBase } from ".";
-import { IBindableValue, IScope } from "../types";
+import { IScope, TLineRef } from "../types";
 export declare class AddressResolver extends InstructionBase {
     get hidden(): boolean;
     set hidden(value: boolean);
-    bonds: IBindableValue<number | null>[];
-    constructor(...bonds: IBindableValue<number | null>[]);
+    bonds: TLineRef[];
+    constructor(...bonds: TLineRef[]);
     resolve(i: number): void;
-    bind(bond: IBindableValue<number | null>): void;
+    bind(bond: TLineRef): void;
     bindBreak(scope: IScope): this;
     bindContinue(scope: IScope): this;
 }

package/dist/instructions/ControlInstructions.d.ts

@@ -1,10 +1,10 @@
-import { EInstIntent, IBindableValue } from "../types";
+import { EInstIntent, TLineRef } from "../types";
 import { JumpInstruction } from "./JumpInstruction";
 export declare class BreakInstruction extends JumpInstruction {
     intent: EInstIntent;
-    constructor(address: IBindableValue<number | null>);
+    constructor(address: TLineRef);
 }
 export declare class ContinueInstruction extends JumpInstruction {
     intent: EInstIntent;
-    constructor(address: IBindableValue<number | null>);
+    constructor(address: TLineRef);
 }

package/dist/instructions/InstructionBase.d.ts

@@ -7,6 +7,7 @@ export declare class InstructionBase implements IInstruction {
     protected _hidden: boolean;
     get hidden(): boolean;
     set hidden(value: boolean);
+    ignoredByParser: boolean;
     args: (string | IValue | null)[];
     source?: SourceLocation;
     constructor(...args: (string | IValue | null)[]);

package/dist/instructions/JumpInstruction.d.ts

@@ -1,4 +1,4 @@
-import { IBindableValue, IValue } from "../types";
+import { IValue, TLineRef } from "../types";
 import { JumpOutValue } from "../values/JumpOutValue";
 import { InstructionBase } from "./InstructionBase";
 export declare enum EJumpKind {
@@ -12,11 +12,11 @@ export declare enum EJumpKind {
     Always = "always"
 }
 export declare class JumpInstruction extends InstructionBase {
-    address: IBindableValue<number | null>;
-    constructor(address: IBindableValue<number | null>, kind: EJumpKind, left?: IValue | null, right?: IValue | null);
+    address: TLineRef;
+    constructor(address: TLineRef, kind: EJumpKind, left?: IValue | null, right?: IValue | null);
     /**
-     * Works with the `JumpOutValue` class to determine
-     * wether a jump should be added if the expression wasn't jump compressed.
+     * Works with the `JumpOutValue` class to determine whether a jump should be
+     * added if the expression wasn't jump compressed.
      */
     static or(test: IValue, out: JumpOutValue): JumpInstruction[];
 }

package/dist/instructions/index.d.ts

@@ -5,5 +5,4 @@ export * from "./EndInstruction";
 export * from "./AddressResolver";
 export * from "./JumpInstruction";
 export * from "./SetCounterInstruction";
-export * from "./ZeroSpaceInstruction";
 export * from "./ControlInstructions";

package/dist/macros/DynamicArray.d.ts

@@ -1,13 +1,13 @@
 import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
-import { LiteralValue, ObjectValue, SenseableValue, StoreValue } from "../values";
+import { LiteralValue, ObjectValue, StoreValue } from "../values";
 import { MacroFunction } from "./Function";
 export declare class DynamicArray extends ObjectValue {
     scope: IScope;
     name: string;
     values: IValue[];
     dynamic: boolean;
-    getterTemp: SenseableValue;
-    setterTemp: SenseableValue;
+    getterTemp: StoreValue;
+    setterTemp: StoreValue;
     returnTemp: StoreValue;
     getterAddr: LiteralValue<number | null>;
     setterAddr: LiteralValue<number | null>;
@@ -26,7 +26,7 @@ export declare class DynamicArray extends ObjectValue {
     initRemoveAt(): void;
     initFill(): void;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }
 export declare class DynamicArrayConstructor extends MacroFunction {
     constructor(dynamic: boolean);

package/dist/macros/Function.d.ts

@@ -9,8 +9,8 @@ export declare class MacroFunction<RT extends IValue | null = IValue> extends Vo
     constructor(fn: TFunction<RT>, paramOuts?: TEOutput[] | undefined);
     call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<RT>;
     eval(_scope: IScope): TValueInstructions;
-    preCall(_scope: IScope, _out?: TEOutput | undefined): readonly TEOutput[] | undefined;
+    preCall(_scope: IScope, _out?: TEOutput): readonly TEOutput[] | undefined;
     debugString(): string;
-    toString(): string;
+    toMlogString(): string;
 }
 export {};

package/dist/macros/GetBuildings.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "./Function";
+export declare class GetBuildings extends MacroFunction {
+    constructor();
+}

package/dist/macros/GetColor.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "./Function";
+export declare class GetColor extends MacroFunction {
+    constructor();
+}

package/dist/macros/Marker.d.ts

@@ -0,0 +1,4 @@
+import { ObjectValue } from "../values";
+export declare class MarkerConstructor extends ObjectValue {
+    constructor();
+}

package/dist/macros/Namespace.d.ts

@@ -12,4 +12,20 @@ export declare class NamespaceMacro extends ObjectValue {
 export declare class VarsNamespace extends NamespaceMacro {
     constructor();
 }
+export declare class ColorsNamespace extends NamespaceMacro {
+    constructor();
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions<IValue>;
+}
+export declare class SoundsNamespace extends NamespaceMacro {
+    constructor();
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions<IValue>;
+}
+export declare class StatusEffectsNamespace extends NamespaceMacro {
+    constructor();
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions<IValue>;
+}
+export declare class PVarsNamespace extends NamespaceMacro {
+    constructor();
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions<IValue>;
+}
 export {};

package/dist/macros/Queries.d.ts

@@ -0,0 +1,10 @@
+import { IScope, IValue, TEOutput, TValueInstructions } from "../types";
+import { ObjectValue, StoreValue } from "../values";
+export declare class QueriesMacro extends ObjectValue {
+    queriesStore: StoreValue;
+    constructor();
+    get(scope: IScope, key: IValue, out?: TEOutput): TValueInstructions<IValue>;
+    hasProperty(scope: IScope, prop: IValue): boolean;
+    debugString(): string;
+    toMlogString(): string;
+}

package/dist/macros/StringView.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "./Function";
+export declare class StringViewBuilder extends MacroFunction {
+    constructor();
+}

package/dist/macros/commands/Effect.d.ts

@@ -0,0 +1,4 @@
+import { ObjectValue } from "../../values";
+export declare class Effect extends ObjectValue {
+    constructor();
+}

package/dist/macros/commands/Format.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class Format extends MacroFunction<null> {
+    constructor();
+}

package/dist/macros/commands/LocalePrint.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class LocalePrint extends MacroFunction<null> {
+    constructor();
+}

package/dist/macros/commands/PlayMusic.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class PlayMusic extends MacroFunction<null> {
+    constructor();
+}

package/dist/macros/commands/PlaySound.d.ts

@@ -0,0 +1,4 @@
+import { ObjectValue } from "../../values";
+export declare class PlaySound extends ObjectValue {
+    constructor();
+}

package/dist/macros/commands/PrintChar.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "..";
+export declare class PrintChar extends MacroFunction<null> {
+    constructor();
+}

package/dist/macros/commands/Query.d.ts

@@ -0,0 +1,4 @@
+import { ObjectValue } from "../../values";
+export declare class Query extends ObjectValue {
+    constructor();
+}

package/dist/macros/commands/SetProp.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class SetProp extends MacroFunction {
+    constructor();
+}

package/dist/macros/commands/SpawnBullet.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class SpawnBullet extends MacroFunction {
+    constructor();
+}

package/dist/macros/commands/Sync.d.ts

@@ -0,0 +1,6 @@
+import { IScope, TEOutput } from "../../types";
+import { MacroFunction } from "../Function";
+export declare class SyncLockConstructor extends MacroFunction {
+    constructor();
+    preCall(scope: IScope, out?: TEOutput): readonly TEOutput[] | undefined;
+}

package/dist/macros/commands/UnpackColor.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class UnpackColor extends MacroFunction {
+    constructor();
+}

package/dist/macros/commands/WeatherSense.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class WeatherSense extends MacroFunction {
+    constructor();
+}

package/dist/macros/commands/WeatherSet.d.ts

@@ -0,0 +1,4 @@
+import { MacroFunction } from "../Function";
+export declare class WeatherSet extends MacroFunction<null> {
+    constructor();
+}

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

@@ -28,3 +28,16 @@ export * from "./SetRate";
 export * from "./Fetch";
 export * from "./GetFlag";
 export * from "./SetFlag";
+export * from "./SetProp";
+export * from "./Sync";
+export * from "./Effect";
+export * from "./LocalePrint";
+export * from "./WeatherSense";
+export * from "./WeatherSet";
+export * from "./PlaySound";
+export * from "./PrintChar";
+export * from "./UnpackColor";
+export * from "./Format";
+export * from "./Query";
+export * from "./SpawnBullet";
+export * from "./PlayMusic";

package/dist/macros/index.d.ts

@@ -3,6 +3,12 @@ export * from "./Math";
 export * from "./Other";
 export * as commands from "./commands";
 export * from "./Memory";
-export { NamespaceMacro, VarsNamespace } from "./Namespace";
+export { NamespaceMacro, VarsNamespace, StatusEffectsNamespace, PVarsNamespace, } from "./Namespace";
+export * from "./Queries";
 export * from "./DynamicArray";
 export * from "./Unchecked";
+export * from "./GetBuildings";
+export * from "./GetGlobal";
+export * from "./GetColor";
+export * from "./Marker";
+export * from "./StringView";

package/dist/macros/util.d.ts

@@ -10,8 +10,11 @@ interface IOverloadNamespaceOptions<K extends string> {
         named?: string;
         args: (IParameterDescriptor | string)[];
     }>;
-    handler(scope: IScope, overload: K, out: TEOutput | undefined, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
+    handler(this: void, scope: IScope, overload: K, out: TEOutput | undefined, ...args: (IValue | string)[]): TValueInstructions<IValue | null>;
 }
-/** Used to create namespaces that contain multiple methods that map into instructions */
+/**
+ * Used to create namespaces that contain multiple methods that map into
+ * instructions
+ */
 export declare function createOverloadNamespace<K extends string>({ overloads, handler, }: IOverloadNamespaceOptions<K>): Record<string, MacroFunction<IValue | null>>;
 export {};

package/dist/modules.d.ts

@@ -0,0 +1,8 @@
+import { IScope } from "./types";
+import { ObjectValue } from "./values";
+/**
+ * Creates the global scope of the user's script, contains all built-ins that
+ * are not privileged
+ */
+export declare function createGlobalScope(): IScope;
+export declare function createWordModule(): ObjectValue;

package/dist/operators.d.ts

@@ -38,7 +38,7 @@ export declare const operatorMap: {
     readonly "&": "and";
     readonly "^": "xor";
     readonly ">>": "shr";
-    readonly ">>>": "shr";
+    readonly ">>>": "ushr";
     readonly "<<": "shl";
     readonly "&&": "land";
     readonly "||": "or";

package/dist/types.d.ts

@@ -2,32 +2,35 @@ 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,
     /**
-     * This is used by the `end` and `stop` instructions.
-     * Means that the processor will restart or shutdown.
+     * This is used by the `end` and `stop` instructions. Means that the processor
+     * will restart or shutdown.
      */
     exit = 4
 }
 export interface IInstruction {
     intent: EInstIntent;
     /**
-     * Used by function values to check if a return instruction
-     * originates from them or other function.
+     * Used by function values to check if a return instruction originates from
+     * them or other function.
      */
     intentSource?: IValue;
     hidden: boolean;
+    /**
+     * Used to identify pseudo instructions like single line comments and label
+     * declarations created in asm calls.
+     */
+    ignoredByParser: boolean;
     resolve(i: number): void;
     source?: es.SourceLocation;
     /**
-     * Helps analyzing control flow, handlers should
-     * indicate which instructions returned are guaranteed to run
+     * Helps analyzing control flow, handlers should indicate which instructions
+     * returned are guaranteed to run
      */
     alwaysRuns: boolean;
 }
@@ -38,14 +41,14 @@ export interface IInstruction {
  *
  * A string means that the handler should create a value with the given name.
  *
- * An IValue means that the handler should try to use `this` as the output value.
+ * An IValue means that the handler should try to use `this` as the output
+ * value.
  */
 export type TEOutput = IValue | string;
 export type THandler<T extends IValue | null = IValue> = (compiler: Compiler, scope: IScope, node: any, out: TEOutput | undefined, 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.
+ * 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 */
@@ -54,8 +57,8 @@ export interface IScope {
     data: Record<string, IValue | null>;
     name: string;
     /**
-     * Additional instructions required by this scope, such as
-     * the instructions that make the body of a function
+     * Additional instructions required by this scope, such as the instructions
+     * that make the body of a function
      */
     inst: IInstruction[];
     /** The label applied to this scope */
@@ -64,31 +67,44 @@ export interface IScope {
     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. */
+    /**
+     * 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;
     /**
-     * A record of the cached value operations, maps the id
-     * of an operation to a previously computed value.
+     * A record of the cached value operations, maps the id of an operation to a
+     * previously computed value.
      */
     operationCache: Record<string, IValue>;
     /** Tracks the dependency relation beteween values and cached operations */
     cacheDependencies: Record<string, string[]>;
     /**
-     * Tells array macros whether to check index access performed.
-     * This field is mutable.
+     * Tells array macros whether to check index access performed. This field is
+     * mutable.
      */
     checkIndexes: boolean;
     /**
-     * Creates a new scope that has `this` as it's parent.
+     * Maps mlogjs' built-in modules, such as `"mlogjs:world"`.
+     *
+     * This was put here because only the compiler object and scope are accessible
+     * to the ast node handlers, and it is more appropriate to put this in the
+     * scope rather than the compiler object.
      */
+    builtInModules: Record<string, IValue>;
+    /** 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
+     * 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
      */
@@ -98,21 +114,25 @@ export interface IScope {
     /** Gets a value by their owner's identifier */
     get(identifier: string): INamedValue;
     /**
-     * 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.
+     * 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 `value` with an owner that uses `name` as both it's name and identifier,
-     * overriding any preexisting variables with the same identifier.
+     * 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;
     /**
      * 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
      */
@@ -120,8 +140,9 @@ export interface IScope {
     /**
      * 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.
+     * 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 */
@@ -141,9 +162,9 @@ export interface IValueOperators {
     "!"(scope: IScope, out?: TEOutput): TValueInstructions;
     "u+"(scope: IScope, out?: TEOutput): TValueInstructions;
     "u-"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "delete"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "typeof"(scope: IScope, out?: TEOutput): TValueInstructions;
-    "void"(scope: IScope, out?: TEOutput): TValueInstructions;
+    delete(scope: IScope, out?: TEOutput): TValueInstructions;
+    typeof(scope: IScope, out?: TEOutput): TValueInstructions;
+    void(scope: IScope, out?: TEOutput): TValueInstructions;
     "~"(scope: IScope, out?: TEOutput): TValueInstructions;
     "++"(scope: IScope, prefix: boolean, out?: TEOutput): TValueInstructions;
     "--"(scope: IScope, prefix: boolean, out?: TEOutput): TValueInstructions;
@@ -169,9 +190,9 @@ export interface IValueOperators {
     "|"(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     instanceof(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     in(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "&&"(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "??"(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
-    "||"(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
+    "&&"(scope: IScope, value: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
+    "??"(scope: IScope, value: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
+    "||"(scope: IScope, value: IValue, out?: TEOutput, endAddress?: TLineRef): TValueInstructions;
     "%="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     "&="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
     "*="(scope: IScope, value: IValue, out?: TEOutput): TValueInstructions;
@@ -191,54 +212,56 @@ export interface IValueOperators {
 }
 /** 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
-     */
+    /** 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.
+     * 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 */
+    /** Compile-time constants. */
     constant = 2,
     /** An immutable value that hasn't been initialized yet */
-    init = 3
+    init = 3,
+    /** A value unknown at compile-time that will not change after initialization */
+    immutable = 4
 }
 export interface IValue extends IValueOperators {
     /** The name is used by values that exist on some form in the runtime */
     name?: string;
     mutability: EMutability;
     macro: boolean;
+    /** Used by the operation cache to know if an operation can be safely cached. */
+    volatile: boolean;
     /**
-     * Evaluates `this`, returning it's representation in a more basic
-     * value like `StoreValue` with the instructions required to compute that value
+     * Evaluates `this`, returning it's representation in a more basic value like
+     * `StoreValue` with the instructions required to compute that value
      */
     eval(scope: IScope, out?: TEOutput): TValueInstructions;
     call(scope: IScope, args: IValue[], out?: TEOutput): TValueInstructions<IValue | null>;
     get(scope: IScope, name: IValue, out?: TEOutput): TValueInstructions;
     /**
-     * Wether `this` has a given property.
-     * This method is used to know if it's safe to get a
-     * field of an object without errors.
+     * Wether `this` has a given property. This method is used to know if it's
+     * safe to get a field of an object without errors.
      */
     hasProperty(scope: IScope, prop: IValue): boolean;
     /**
-     * A hook that the CallExpression and related handlers call
-     * before evaluating the function parameters.
+     * A hook that the CallExpression and related handlers call before evaluating
+     * the function parameters.
      */
     preCall(scope: IScope, out?: TEOutput): readonly TEOutput[] | undefined;
     /**
-     * A hook that the CallExpression and related handlers call
-     * after the call has been evaluated.
+     * A hook that the CallExpression and related handlers call after the call has
+     * been evaluated.
      */
     postCall(scope: IScope): void;
     /** The string representation of `this` in error messages. */
     debugString(): string;
+    /** The string representation of `this` in the generated mlog code. */
+    toMlogString(): string;
     /**
-     * Allows some values to choose alternative representations
-     * when they are used as operation outputs.
+     * Allows some values to choose alternative representations when they are used
+     * as operation outputs.
      */
     toOut(): IValue;
 }
@@ -250,6 +273,12 @@ export type TLiteral = string | number;
 export interface IBindableValue<T extends TLiteral | null = TLiteral> extends IValue {
     data: T;
 }
+export type TLineRef = IBindableValue<number | null>;
+export declare enum EInlineType {
+    auto = 0,
+    always = 1,
+    never = 2
+}
 export interface IFunctionValue extends IValue {
     return(scope: IScope, argument: IValue | null, out?: TEOutput): TValueInstructions<IValue | null>;
 }
@@ -258,7 +287,3 @@ export type TValueInstructions<Content extends IValue | null = IValue> = [
     Content,
     IInstruction[]
 ];
-/** Map of overridable operators in object macros */
-export type TOperatorMacroMap = {
-    [K in UnaryOperator | UpdateOperator | LeftRightOperator as `$${K}`]?: MacroFunction;
-};

package/dist/utils/constants.d.ts

@@ -1,8 +1,13 @@
-/**
- * The prefix for internal variables inside the compiler output
- */
+/** The prefix for internal variables inside the compiler output */
 export declare const internalPrefix = "&";
-export declare const discardedName: string;
+export declare const discardedName = "&_";
 export declare const itemNames: string[];
 /** The name of a special processor variable, controls the instruction pointer */
 export declare const counterName = "@counter";
+export declare const worldModuleName = "mlogjs:world";
+export declare const mathConstants: {
+    E: number;
+    PI: number;
+    radToDeg: number;
+    degToRad: number;
+};