mlogjs 0.2.1 → 0.2.2

package/dist/types/Compiler.d.ts

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

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

@@ -1,26 +1,23 @@
-import { AddressResolver } from "./instructions";
-import { IFunctionValue, IInstruction, IScope, IValue } from "./types";
-export declare class Scope implements IScope {
-    parent: IScope;
-    name: string;
-    data: {
-        [k: string]: IValue;
-    };
-    stacked: boolean;
-    ntemp: number;
-    inst: IInstruction[];
-    break: AddressResolver;
-    continue: AddressResolver;
-    function: IFunctionValue;
-    constructor(values: {
-        [k: string]: IValue;
-    }, parent?: IScope, stacked?: boolean, ntemp?: number, name?: string, inst?: any[]);
-    copy(): IScope;
-    createScope(): IScope;
-    createFunction(name: string, stacked?: boolean): IScope;
-    has(name: string): boolean;
-    get(name: string): IValue;
-    set(name: string, value: IValue): IValue;
-    hardSet(name: string, value: IValue): IValue;
-    make(name: string, storeName: string): IValue;
-}
+import { StoreValue } from "./values";
+import { AddressResolver } from "./instructions";
+import { IFunctionValue, IInstruction, IScope, IValue } from "./types";
+export declare class Scope implements IScope {
+    parent: IScope | null;
+    stacked: boolean;
+    ntemp: number;
+    name: string;
+    inst: IInstruction[];
+    data: Record<string, IValue | null>;
+    break: AddressResolver;
+    continue: AddressResolver;
+    function: IFunctionValue;
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[]);
+    copy(): IScope;
+    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;
+}

package/dist/types/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/handlers/BlockStatement.d.ts

@@ -0,0 +1,2 @@
+import { IValue, THandler } from "../types";
+export declare const BlockStatement: THandler<IValue | null>;

package/dist/types/handlers/CallExpression.d.ts

@@ -0,0 +1,3 @@
+import { IValue, THandler } from "../types";
+export declare const CallExpression: THandler<IValue | null>;
+export declare const NewExpression: THandler<IValue | null>;

package/dist/types/handlers/ForStatement.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const ForStatement: THandler<null>;

package/{build → dist/types}/handlers/Function.d.ts

@@ -1,4 +1,4 @@
-import { THandler } from "../types";
-export declare const ArrowFunctionExpression: THandler;
-export declare const FunctionDeclaration: THandler;
-export declare const FunctionExpression: THandler;
+import { THandler } from "../types";
+export declare const ArrowFunctionExpression: THandler;
+export declare const FunctionDeclaration: THandler;
+export declare const FunctionExpression: THandler;

package/{build → dist/types}/handlers/Identifier.d.ts

@@ -1,2 +1,2 @@
-import { THandler } from "../types";
-export declare const Identifier: THandler;
+import { THandler } from "../types";
+export declare const Identifier: THandler;

package/dist/types/handlers/IfStatement.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const IfStatement: THandler<null>;

package/{build → dist/types}/handlers/Literal.d.ts

@@ -1,2 +1,2 @@
-import { THandler } from "../types";
-export declare const Literal: THandler;
+import { THandler } from "../types";
+export declare const Literal: THandler;

package/{build → dist/types}/handlers/Object.d.ts

@@ -1,4 +1,4 @@
-import { THandler } from "../types";
-export declare const ObjectExpression: THandler;
-export declare const ArrayExpression: THandler;
-export declare const MemberExpression: THandler;
+import { THandler } from "../types";
+export declare const ObjectExpression: THandler;
+export declare const ArrayExpression: THandler;
+export declare const MemberExpression: THandler;

package/{build → dist/types}/handlers/OperationExpressions.d.ts

@@ -1,7 +1,7 @@
-import { THandler } from "../types";
-export declare const LRExpression: THandler;
-export declare const BinaryExpression: THandler;
-export declare const LogicalExpression: THandler;
-export declare const AssignmentExpression: THandler;
-export declare const UnaryExpression: THandler;
-export declare const UpdateExpression: THandler;
+import { THandler } from "../types";
+export declare const LRExpression: THandler;
+export declare const BinaryExpression: THandler;
+export declare const LogicalExpression: THandler;
+export declare const AssignmentExpression: THandler;
+export declare const UnaryExpression: THandler;
+export declare const UpdateExpression: THandler;

package/dist/types/handlers/Program.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const Program: THandler<null>;

package/dist/types/handlers/Statements.d.ts

@@ -0,0 +1,5 @@
+import { IValue, THandler } from "../types";
+export declare const ExpressionStatement: THandler<IValue | null>;
+export declare const BreakStatement: THandler<null>;
+export declare const ContinueStatement: THandler<null>;
+export declare const ReturnStatement: THandler<IValue | null>;

package/dist/types/handlers/TemplateExpression.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const TemplateLiteral: THandler<null>;

package/dist/types/handlers/VariableDeclaration.d.ts

@@ -0,0 +1,3 @@
+import { THandler, IValue } from "../types";
+export declare const VariableDeclaration: THandler<null>;
+export declare const VariableDeclarator: THandler<IValue | null>;

package/dist/types/handlers/WhileStatement.d.ts

@@ -0,0 +1,2 @@
+import { THandler } from "../types";
+export declare const WhileStatement: THandler<null>;

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

@@ -1,14 +1,14 @@
-export * from "./Program";
-export * from "./VariableDeclaration";
-export * from "./Literal";
-export * from "./OperationExpressions";
-export * from "./Identifier";
-export * from "./Statements";
-export * from "./IfStatement";
-export * from "./WhileStatement";
-export * from "./ForStatement";
-export * from "./Function";
-export * from "./CallExpression";
-export * from "./Object";
-export * from "./TemplateExpression";
-export * from "./BlockStatement";
+export * from "./Program";
+export * from "./VariableDeclaration";
+export * from "./Literal";
+export * from "./OperationExpressions";
+export * from "./Identifier";
+export * from "./Statements";
+export * from "./IfStatement";
+export * from "./WhileStatement";
+export * from "./ForStatement";
+export * from "./Function";
+export * from "./CallExpression";
+export * from "./Object";
+export * from "./TemplateExpression";
+export * from "./BlockStatement";

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export declare const compile: (script: string) => [string, null, import("estree").Node[]] | [null, Error, import("estree").Node[]];

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

@@ -1,2 +1,2 @@
-import { Scope } from "./Scope";
-export declare function initScope(scope: Scope): void;
+import { Scope } from "./Scope";
+export declare function initScope(scope: Scope): void;

package/{build → dist/types}/instructions/AddressResolver.d.ts

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

package/{build → dist/types}/instructions/ControlInstructions.d.ts

@@ -1,11 +1,11 @@
-import { IBindableValue } from "../types";
-import { JumpInstruction } from "./JumpInstruction";
-export declare class BreakInstruction extends JumpInstruction {
-    constructor(address: IBindableValue);
-}
-export declare class ContinueInstruction extends JumpInstruction {
-    constructor(address: IBindableValue);
-}
-export declare class ReturnInstruction extends JumpInstruction {
-    constructor(address: IBindableValue);
-}
+import { IBindableValue } from "../types";
+import { JumpInstruction } from "./JumpInstruction";
+export declare class BreakInstruction extends JumpInstruction {
+    constructor(address: IBindableValue);
+}
+export declare class ContinueInstruction extends JumpInstruction {
+    constructor(address: IBindableValue);
+}
+export declare class ReturnInstruction extends JumpInstruction {
+    constructor(address: IBindableValue);
+}

package/{build → dist/types}/instructions/EndInstruction.d.ts

@@ -1,4 +1,4 @@
-import { InstructionBase } from "./InstructionBase";
-export declare class EndInstruction extends InstructionBase {
-    constructor();
-}
+import { InstructionBase } from "./InstructionBase";
+export declare class EndInstruction extends InstructionBase {
+    constructor();
+}

package/{build → dist/types}/instructions/InstructionBase.d.ts

@@ -1,10 +1,10 @@
-import { IInstruction, IValue } from "../types";
-export declare class InstructionBase implements IInstruction {
-    private _hidden;
-    get hidden(): boolean;
-    set hidden(value: boolean);
-    args: (string | IValue)[];
-    constructor(...args: (string | IValue)[]);
-    resolve(i: number): void;
-    toString(): string;
-}
+import { IInstruction, IValue } from "../types";
+export declare class InstructionBase implements IInstruction {
+    private _hidden;
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    args: (string | IValue | null)[];
+    constructor(...args: (string | IValue | null)[]);
+    resolve(i: number): void;
+    toString(): string;
+}

package/{build → dist/types}/instructions/JumpInstruction.d.ts

@@ -1,15 +1,15 @@
-import { IBindableValue, IValue } from "../types";
-import { InstructionBase } from "./InstructionBase";
-export declare enum EJumpKind {
-    Equal = "equal",
-    NotEqual = "notEqual",
-    LessThan = "lessThan",
-    LessThanEq = "lessThanEq",
-    GreaterThan = "greaterThan",
-    GreaterThanEq = "greaterThanEq",
-    StrictEqual = "strictEqual",
-    Always = "always"
-}
-export declare class JumpInstruction extends InstructionBase {
-    constructor(address: IBindableValue, kind: EJumpKind, left?: IValue, right?: IValue);
-}
+import { IBindableValue, IValue } from "../types";
+import { InstructionBase } from "./InstructionBase";
+export declare enum EJumpKind {
+    Equal = "equal",
+    NotEqual = "notEqual",
+    LessThan = "lessThan",
+    LessThanEq = "lessThanEq",
+    GreaterThan = "greaterThan",
+    GreaterThanEq = "greaterThanEq",
+    StrictEqual = "strictEqual",
+    Always = "always"
+}
+export declare class JumpInstruction extends InstructionBase {
+    constructor(address: IBindableValue, kind: EJumpKind, left?: IValue | null, right?: IValue | null);
+}

package/{build → dist/types}/instructions/OperationInstruction.d.ts

@@ -1,5 +1,5 @@
-import { InstructionBase } from ".";
-import { IValue } from "../types";
-export declare class OperationInstruction extends InstructionBase {
-    constructor(kind: string, temp: IValue, left: IValue, right?: IValue);
-}
+import { InstructionBase } from ".";
+import { IValue } from "../types";
+export declare class OperationInstruction extends InstructionBase {
+    constructor(kind: string, temp: IValue, left: IValue, right: IValue | null);
+}

package/{build → dist/types}/instructions/SetCounterInstruction.d.ts

@@ -1,5 +1,5 @@
-import { InstructionBase } from ".";
-import { IValue } from "../types";
-export declare class SetCounterInstruction extends InstructionBase {
-    constructor(value: IValue);
-}
+import { InstructionBase } from ".";
+import { IValue } from "../types";
+export declare class SetCounterInstruction extends InstructionBase {
+    constructor(value: IValue);
+}

package/{build → dist/types}/instructions/SetInstruction.d.ts

@@ -1,5 +1,5 @@
-import { InstructionBase } from ".";
-import { IValue } from "../types";
-export declare class SetInstruction extends InstructionBase {
-    constructor(store: IValue, value: IValue);
-}
+import { InstructionBase } from ".";
+import { IValue } from "../types";
+export declare class SetInstruction extends InstructionBase {
+    constructor(store: IValue, value: IValue);
+}

package/{build → dist/types}/instructions/ZeroSpaceInstruction.d.ts

@@ -1,4 +1,4 @@
-import { InstructionBase } from "./InstructionBase";
-export declare class ZeroSpaceInstruction extends InstructionBase {
-    toString(): string;
-}
+import { InstructionBase } from "./InstructionBase";
+export declare class ZeroSpaceInstruction extends InstructionBase {
+    toString(): string;
+}

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

@@ -1,9 +1,9 @@
-export * from "./InstructionBase";
-export * from "./OperationInstruction";
-export * from "./SetInstruction";
-export * from "./EndInstruction";
-export * from "./AddressResolver";
-export * from "./JumpInstruction";
-export * from "./SetCounterInstruction";
-export * from "./ZeroSpaceInstruction";
-export * from "./ControlInstructions";
+export * from "./InstructionBase";
+export * from "./OperationInstruction";
+export * from "./SetInstruction";
+export * from "./EndInstruction";
+export * from "./AddressResolver";
+export * from "./JumpInstruction";
+export * from "./SetCounterInstruction";
+export * from "./ZeroSpaceInstruction";
+export * from "./ControlInstructions";

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

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

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

@@ -0,0 +1,12 @@
+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;
+}
+export {};

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,21 @@
-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 declare class Unit extends ObjectValue {
+    name: string;
+    constructor(scope: IScope, name: string);
+    toString(): string;
+}
+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/{build → dist/types}/macros/commands/Draw.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 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 → 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);
+}