mlogjs 0.2.1 → 0.2.2

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,14 @@
-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 "./UnitBind";
+export * from "./UnitControl";
+export * from "./UnitRadar";
+export * from "./UnitLocate";

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

@@ -1,7 +1,7 @@
-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 { BuildingBuilder } from "./Building";
+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"> | Extract<LogicalOperator, "&&" | "||">]: string;
+};

package/dist/types/types.d.ts

@@ -0,0 +1,100 @@
+export * as es from "estree";
+import { Compiler } from "./Compiler";
+import { AddressResolver } from "./instructions";
+import { MacroFunction } from "./macros";
+import { LeftRightOperator, UnaryOperator, UpdateOperator } from "./operators";
+import { StoreValue } from "./values";
+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>;
+export interface IScope {
+    parent: IScope | null;
+    data: {};
+    name: string;
+    inst: IInstruction[];
+    break: AddressResolver;
+    continue: AddressResolver;
+    function: IFunctionValue;
+    ntemp: number;
+    createScope(): IScope;
+    createFunction(name: string, stacked?: boolean): IScope;
+    has(name: string): boolean;
+    get(name: string): IValue;
+    set<T extends IValue>(name: string, value: T): T;
+    hardSet<T extends IValue>(name: string, value: T): T;
+    make(name: string, storeName: string): StoreValue;
+    copy(): IScope;
+}
+export interface IValue {
+    scope: IScope;
+    constant: boolean;
+    macro: boolean;
+    eval(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    "!"(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;
+}
+export declare type TLiteral = string | number;
+export interface IBindableValue extends IValue {
+    data: TLiteral;
+}
+export interface IFunctionValue extends IValue {
+    return(scope: IScope, argument: IValue): TValueInstructions<IValue | null>;
+}
+export declare type TValueInstructions<Content extends IValue | null = IValue> = [
+    Content,
+    IInstruction[]
+];
+export declare type TOperatorMacroMap = {
+    [K in UnaryOperator | UpdateOperator | LeftRightOperator as `$${K}`]?: MacroFunction;
+};

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

@@ -1,3 +1,3 @@
-import { es } from "./types";
-export declare function nodeName(node: es.Node): string;
-export declare function camelToDashCase(name: string): string;
+import { es } from "./types";
+export declare function nodeName(node: es.Node): string;
+export declare function camelToDashCase(name: string): string;

package/{build → dist/types}/values/BaseValue.d.ts

@@ -1,5 +1,5 @@
-import { IScope, IValue, TValueInstructions } from "../types";
-import { VoidValue } from ".";
-export declare class BaseValue extends VoidValue implements IValue {
-    "u-"(scope: IScope): TValueInstructions;
-}
+import { IScope, IValue, TValueInstructions } from "../types";
+import { VoidValue } from ".";
+export declare class BaseValue extends VoidValue implements IValue {
+    "u-"(scope: IScope): TValueInstructions;
+}

package/{build → dist/types}/values/FunctionValue.d.ts

@@ -1,34 +1,34 @@
-import { Compiler } from "../Compiler";
-import { es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./StoreValue";
-import { VoidValue } from "./VoidValue";
-export declare class FunctionValue extends VoidValue implements IFunctionValue {
-    constant: boolean;
-    macro: boolean;
-    private paramStores;
-    private paramNames;
-    private inst;
-    private addr;
-    private temp;
-    private ret;
-    private inline;
-    private tryingInline;
-    private body;
-    private name;
-    private c;
-    private callSize;
-    private inlineTemp;
-    private inlineEnd;
-    private bundled;
-    private createValues;
-    typeof(scope: IScope): TValueInstructions;
-    private createInst;
-    constructor(scope: IScope, name: string, paramNames: string[], paramStores: StoreValue[], body: es.BlockStatement, c: Compiler);
-    private normalReturn;
-    private normalCall;
-    private inlineReturn;
-    private inlineCall;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
-    return(scope: IScope, arg: IValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
-}
+import { Compiler } from "../Compiler";
+import { es, IFunctionValue, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./StoreValue";
+import { VoidValue } from "./VoidValue";
+export declare class FunctionValue extends VoidValue implements IFunctionValue {
+    constant: boolean;
+    macro: boolean;
+    private paramStores;
+    private paramNames;
+    private inst;
+    private addr;
+    private temp;
+    private ret;
+    private inline;
+    private tryingInline;
+    private body;
+    private name;
+    private c;
+    private callSize;
+    private inlineTemp;
+    private inlineEnd;
+    private bundled;
+    private createValues;
+    typeof(scope: IScope): TValueInstructions;
+    private createInst;
+    constructor(scope: IScope, name: string, paramNames: string[], paramStores: StoreValue[], body: es.BlockStatement, c: Compiler);
+    private normalReturn;
+    private normalCall;
+    private inlineReturn;
+    private inlineCall;
+    call(scope: IScope, args: IValue[]): TValueInstructions;
+    return(scope: IScope, arg: IValue): TValueInstructions<IValue | null>;
+    eval(scope: IScope): TValueInstructions;
+}

package/{build → dist/types}/values/LiteralValue.d.ts

@@ -1,12 +1,12 @@
-import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue } from "../types";
-import { BaseValue } from ".";
-export declare class LiteralValue extends BaseValue implements IBindableValue {
-    data: TLiteral;
-    constant: boolean;
-    constructor(scope: IScope, data: TLiteral);
-    eval(scope: IScope): TValueInstructions;
-    toString(): string;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    get num(): number;
-    typeof(scope: IScope): TValueInstructions;
-}
+import { IScope, IBindableValue, TLiteral, TValueInstructions, IValue } from "../types";
+import { BaseValue } from ".";
+export declare class LiteralValue extends BaseValue implements IBindableValue {
+    data: TLiteral;
+    constant: boolean;
+    constructor(scope: IScope, data: TLiteral);
+    eval(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

@@ -0,0 +1,19 @@
+import { MacroFunction } from "../macros";
+import { 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>;
+}
+export declare class ObjectValue extends VoidValue {
+    constant: boolean;
+    macro: boolean;
+    data: IObjectValueData;
+    constructor(scope: IScope, data?: IObjectValueData);
+    typeof(scope: IScope): TValueInstructions;
+    get(scope: IScope, key: LiteralValue): TValueInstructions;
+    eval(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+}

package/{build → dist/types}/values/StoreValue.d.ts

@@ -1,11 +1,11 @@
-import { BaseValue } from ".";
-import { IScope, IValue, TValueInstructions } from "../types";
-export declare class StoreValue extends BaseValue implements IValue {
-    name: string;
-    constant: boolean;
-    constructor(scope: IScope, name: string);
-    typeof(scope: IScope): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
-    eval(scope: IScope): TValueInstructions;
-    toString(): string;
-}
+import { BaseValue } from ".";
+import { IScope, IValue, TValueInstructions } from "../types";
+export declare class StoreValue extends BaseValue implements IValue {
+    name: string;
+    constant: boolean;
+    constructor(scope: IScope, name: string);
+    typeof(scope: IScope): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+    eval(scope: IScope): TValueInstructions;
+    toString(): string;
+}

package/{build → dist/types}/values/TempValue.d.ts

@@ -1,12 +1,12 @@
-import { IInstruction, IScope, IValue, TValueInstructions } from "../types";
-import { StoreValue } from "./";
-export declare class TempValue extends StoreValue {
-    proxied: IValue;
-    canProxy: boolean;
-    setInst: IInstruction;
-    constructor(scope: IScope, name?: string);
-    eval(scope: IScope): TValueInstructions;
-    "="(scope: IScope, value: IValue): TValueInstructions;
-    proxy(value: IValue): TValueInstructions;
-    noProxy(): void;
-}
+import { IInstruction, IScope, IValue, TValueInstructions } from "../types";
+import { StoreValue } from "./";
+export declare class TempValue extends StoreValue {
+    proxied: IValue;
+    canProxy: boolean;
+    setInst: IInstruction;
+    constructor(scope: IScope, name?: string);
+    eval(scope: IScope): TValueInstructions;
+    "="(scope: IScope, value: IValue): TValueInstructions;
+    proxy(value: IValue): TValueInstructions;
+    noProxy(): void;
+}

package/{build → dist/types}/values/VoidValue.d.ts

@@ -1,11 +1,13 @@
-import { IScope, IValue, TValueInstructions } from "../types";
-export declare class VoidValue implements IValue {
-    scope: IScope;
-    constant: boolean;
-    macro: boolean;
-    constructor(scope: IScope);
-    eval(scope: IScope): TValueInstructions;
-    call(scope: IScope, args: IValue[]): TValueInstructions;
-    get(scope: IScope, name: IValue): TValueInstructions;
-    toString(): string;
-}
+import { IScope, IValue, TValueInstructions } from "../types";
+export declare class VoidValue implements IValue {
+    scope: IScope;
+    constant: boolean;
+    macro: boolean;
+    constructor(scope: IScope);
+    eval(scope: IScope): TValueInstructions;
+    call(scope: IScope, args: IValue[]): TValueInstructions<IValue | null>;
+    get(scope: IScope, name: IValue): TValueInstructions;
+    toString(): string;
+}
+export interface VoidValue extends IValue {
+}

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

@@ -1,6 +1,6 @@
-export * from "./VoidValue";
-export * from "./BaseValue";
-export * from "./LiteralValue";
-export * from "./StoreValue";
-export * from "./TempValue";
-export * from "./ObjectValue";
+export * from "./VoidValue";
+export * from "./BaseValue";
+export * from "./LiteralValue";
+export * from "./StoreValue";
+export * from "./TempValue";
+export * from "./ObjectValue";

package/doc/README.md

@@ -0,0 +1,9 @@
+# MlogJS
+
+MlogJS is a compiler that allows users to compile complex JavaScript programs into Mindustry Logic Code.
+
+## Discord
+
+You can join the Discord server for more information and for help.
+
+<iframe src="https://discord.com/widget?id=841105039211888710&theme=dark" width="350" height="300" allowtransparency="true" frameborder="0" sandbox="allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts"></iframe>

package/lib/eslib/lib.es5.d.ts

@@ -120,7 +120,7 @@ interface Math {
   sqrt(x: number): number;
 
   /**
-   * Returns a random floating point number from 0 to `range` (excluding `range` istself)
+   * Returns a random floating point number from 0 to `range` (excluding `range` itself)
    * @param range
    */
   rand(range: number): number;

package/lib/traits.d.ts

@@ -1,5 +1,4 @@
 import "./globals";
-import "./custom-lib";
 
 type LogicSymbols = typeof Items & typeof Liquids & typeof LAccess;
 

package/package.json

@@ -1,28 +1,24 @@
 {
   "name": "mlogjs",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Compiler that compiles Javascript to Mindustry Logic Code.",
-  "main": "build/index.js",
-  "bin": "./build/bin.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "bin": "./dist/index.cjs",
+  "types": "./dist/types",
   "scripts": {
-    "clean": "rm -rf docs dist build",
-    "build": "tsc && vite build",
-    "build:editor": "cd editor && vite build",
+    "clean": "rm -rf ../docs dist build",
+    "build": "rollup -c",
     "dev": "ts-node src/bin",
-    "dev:editor": "cd editor && vite",
     "test": "jest",
     "coverage": "jest --coverage",
-    "docs:doc": "mkdir -p docs && cp -r doc/. docs",
-    "docs:lib": "typedoc --out docs/lib lib/*",
-    "docs:src": "typedoc --out docs/src src/index.ts",
+    "docs:doc": "mkdir -p ../docs && cp -r doc/. ../docs",
+    "docs:lib": "typedoc --out ../docs/lib lib/*",
+    "docs:src": "typedoc --out ../docs/src src/index.ts",
     "docs": "run-p docs:lib docs:src docs:doc",
     "start": "npm run build && npm i -g . && mlogjs",
     "prepublishOnly": "npm run build"
   },
-  "exports": {
-    "require": "./build/index.js",
-    "import": "./dist/index.js"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/weisrc/mlogjs.git"
@@ -41,27 +37,21 @@
     "yargs": "^17.0.1"
   },
   "devDependencies": {
-    "@monaco-editor/react": "^4.3.1",
+    "@rollup/plugin-alias": "^3.1.9",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@rollup/plugin-typescript": "^8.3.1",
     "@types/estree": "^0.0.51",
     "@types/jest": "^27.4.1",
     "@types/node": "^15.3.0",
-    "@types/react": "^17.0.39",
-    "@types/react-dom": "^17.0.13",
-    "@types/react-split-pane": "^0.1.67",
     "@types/yargs": "^16.0.1",
-    "@vitejs/plugin-react": "^1.2.0",
     "jest": "^27.5.1",
-    "monaco-editor": "^0.32.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.5.1",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "react-split-pane": "^0.1.92",
+    "rollup": "^2.70.1",
     "ts-jest": "^27.1.3",
     "ts-node": "^10.6.0",
+    "tslib": "^2.3.1",
     "typedoc": "^0.22.12",
-    "typescript": "^4.6.2",
-    "vite": "^2.8.6"
+    "typescript": "*"
   },
   "files": [
     "build",
@@ -70,4 +60,4 @@
     "LICENSE",
     "README.md"
   ]
-}
+}

package/build/Compiler.d.ts

@@ -1,18 +0,0 @@
-import { es, IScope, THandler, TValueInstructions } from "./types";
-declare type THandlerMap = {
-    [k in es.Node["type"]]?: THandler;
-};
-export declare class Compiler {
-    protected stackName?: string;
-    protected usingStack: boolean;
-    protected handlers: THandlerMap;
-    constructor(stackName?: string);
-    compile(script: string): [string, Error, es.Node[]];
-    protected resolve(valueInst: TValueInstructions): void;
-    protected serialize(resLines: TValueInstructions): string;
-    protected parse(script: string): es.Node;
-    handle(scope: IScope, node: es.Node): TValueInstructions;
-    handleEval(scope: IScope, node: es.Node): TValueInstructions;
-    handleMany(scope: IScope, nodes: es.Node[], handler?: typeof Compiler.prototype.handle): TValueInstructions;
-}
-export {};