mlogjs 0.4.9 → 0.5.0

package/README.md

@@ -1,12 +1,14 @@
 <div markdown="1" align="center">
 
-[![mlogjs](https://mlogjs.github.io/mlogjs/logo.png)][docs]
+[![mlogjs](https://mlogjs.netlify.app/logo.png)][docs]
 
 # **JavaScript [MLog](https://mindustrygame.github.io/wiki/logic/0-introduction/) Compiler**
 
 [![ci](https://github.com/weisrc/mlogjs/actions/workflows/ci.yml/badge.svg)][ci]
 [![npm](https://img.shields.io/npm/v/mlogjs?color=cb3837&logo=npm)][npm]
-[![docs](https://img.shields.io/badge/docs-mlogjs-41B883?logo=readthedocs)][docs]
+[![docs](https://img.shields.io/badge/docs-stable-41B883?logo=readthedocs)][docs]
+[![unreleased docs](https://img.shields.io/badge/docs-unreleased-41B883?logo=readthedocs)][unreleased docs]
+[![chat](https://img.shields.io/badge/chat-discord-blue?logo=discord)][discord]
 
 </div>
 
@@ -17,7 +19,7 @@
 - Fully Typed API
 - Macros
 - All Instructions and Variables
-- An [online editor]
+- An online editor integrated to the docs
 
 ## Installation
 
@@ -42,16 +44,17 @@ printFlush();
 mlogjs hello.js
 ```
 
-## Resources
+## Examples
 
-- [Discord](https://discord.gg/SvgjCtZnR5)
-- [Documentation][docs]
-- [NPM package][npm]
-- [GitHub Action CI][ci]
+You can find other usage examples [here](https://github.com/mlogjs/mlogjs/tree/main/compiler/test/examples).
+
+## Changelog
+
+Changes for each release are documented in the [CHANGELOG](https://github.com/mlogjs/mlogjs/blob/main/compiler/CHANGELOG.md).
 
 ## Contribute
 
-Having trouble? [Ask for help on discord](https://discord.gg/DxXkqsWx)
+Having trouble? [Ask for help on discord](https://discord.gg/2VudfNUp)
 or [open an issue](https://github.com/mlogjs/mlogjs/issues/new)
 
 Help and suggestions are welcomed!
@@ -64,5 +67,6 @@ MIT
 
 [npm]: https://www.npmjs.com/package/mlogjs
 [ci]: https://github.com/mlogjs/mlogjs/actions/workflows/ci.yml
-[docs]: https://mlogjs.github.io/mlogjs
-[online editor]: https://mlogjs.github.io/mlogjs/editor.html
+[docs]: https://mlogjs.github.io/mlogjs/
+[unreleased docs]: https://mlogjs.netlify.app
+[discord]: https://discord.gg/SvgjCtZnR5

package/dist/Compiler.d.ts

@@ -1,38 +1,38 @@
-import { CompilerError } from "./CompilerError";
-import { es, IScope, IValue, TEOutput, THandler, TValueInstructions } from "./types";
-declare type THandlerMap = {
-    [k in es.Node["type"]]?: THandler<IValue | null>;
-};
-export interface CompilerOptions {
-    stackName?: string;
-    /** Wether the compiler should preserve or compact variable and function names*/
-    compactNames?: boolean;
-    sourcemap?: boolean;
-}
-export declare class Compiler {
-    protected stackName?: string;
-    protected usingStack: boolean;
-    protected handlers: THandlerMap;
-    readonly compactNames: boolean;
-    readonly sourcemap: boolean;
-    constructor({ stackName, compactNames, sourcemap, }?: CompilerOptions);
-    compile(script: string): [string, null, es.SourceLocation[] | undefined] | [null, CompilerError];
-    protected resolve(valueInst: TValueInstructions<IValue | null>): void;
-    protected serialize(resLines: TValueInstructions<IValue | null>): string;
-    protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
-    protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
-    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions<IValue | null>;
-    handleEval(scope: IScope, node: es.Node, out?: TEOutput): TValueInstructions;
-    /**
-     * Handles many nodes in order.
-     *
-     * The usage of this method over a regular loop over an array of nodes
-     * is only required if the code inside the loop generates
-     * instructions that are not tracked by the compiler
-     * handler methods ({@link handle}, {@link handleEval}
-     * and {@link handleMany})
-     *
-     */
-    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
-}
-export {};
+import { CompilerError } from "./CompilerError";
+import { es, IScope, IValue, TEOutput, THandler, TValueInstructions } from "./types";
+type THandlerMap = {
+    [k in es.Node["type"]]?: THandler<IValue | null>;
+};
+export interface CompilerOptions {
+    stackName?: string;
+    /** Wether the compiler should preserve or compact variable and function names*/
+    compactNames?: boolean;
+    sourcemap?: boolean;
+}
+export declare class Compiler {
+    protected stackName?: string;
+    protected usingStack: boolean;
+    protected handlers: THandlerMap;
+    readonly compactNames: boolean;
+    readonly sourcemap: boolean;
+    constructor({ stackName, compactNames, sourcemap, }?: CompilerOptions);
+    compile(script: string): [string, null, es.SourceLocation[] | undefined] | [null, CompilerError];
+    protected resolve(valueInst: TValueInstructions<IValue | null>): void;
+    protected serialize(resLines: TValueInstructions<IValue | null>): string;
+    protected parse(script: string): import("@babel/parser").ParseResult<es.File>;
+    protected mapSources(valueInst: TValueInstructions<IValue | null>): es.SourceLocation[];
+    handle(scope: IScope, node: es.Node, handler?: THandler<IValue | null> | undefined, out?: TEOutput): TValueInstructions<IValue | null>;
+    handleEval(scope: IScope, node: es.Node, out?: TEOutput): TValueInstructions;
+    /**
+     * Handles many nodes in order.
+     *
+     * The usage of this method over a regular loop over an array of nodes
+     * is only required if the code inside the loop generates
+     * instructions that are not tracked by the compiler
+     * handler methods ({@link handle}, {@link handleEval}
+     * and {@link handleMany})
+     *
+     */
+    handleMany<T extends es.Node>(scope: IScope, nodes: T[], handler?: (node: T) => TValueInstructions<IValue | null>): TValueInstructions<null>;
+}
+export {};

package/dist/CompilerError.d.ts

@@ -1,33 +1,33 @@
-import { es } from "./types";
-/**
- * Error thrown by the babel parser.
- *
- * It doesn't export the type so we are writing it ourselves
- */
-export interface ParsingError extends Error {
-    code: string;
-    reasonCode: string;
-    loc: {
-        line: number;
-        column: number;
-    };
-}
-declare type CompilerErrorSource = es.Node | es.SourceLocation | {
-    line: number;
-    column: number;
-};
-export declare class CompilerError extends Error {
-    protected _loc?: es.SourceLocation;
-    /**
-     * The error that preceded this `CompilerError`.
-     *
-     * If it's not `undefined` it means that `this` is just wrapping the error to
-     * append extra data like the node stack
-     * */
-    inner?: unknown;
-    constructor(message: string, source?: CompilerErrorSource);
-    get loc(): es.SourceLocation | undefined;
-    set loc(value: CompilerErrorSource | undefined);
-    static from(error: unknown, source?: CompilerErrorSource): CompilerError;
-}
-export {};
+import { es } from "./types";
+/**
+ * Error thrown by the babel parser.
+ *
+ * It doesn't export the type so we are writing it ourselves
+ */
+export interface ParsingError extends Error {
+    code: string;
+    reasonCode: string;
+    loc: {
+        line: number;
+        column: number;
+    };
+}
+type CompilerErrorSource = es.Node | es.SourceLocation | {
+    line: number;
+    column: number;
+};
+export declare class CompilerError extends Error {
+    protected _loc?: es.SourceLocation;
+    /**
+     * The error that preceded this `CompilerError`.
+     *
+     * If it's not `undefined` it means that `this` is just wrapping the error to
+     * append extra data like the node stack
+     * */
+    inner?: unknown;
+    constructor(message: string, source?: CompilerErrorSource);
+    get loc(): es.SourceLocation | undefined;
+    set loc(value: CompilerErrorSource | undefined);
+    static from(error: unknown, source?: CompilerErrorSource): CompilerError;
+}
+export {};

package/dist/Scope.d.ts

@@ -1,25 +1,31 @@
-import { SenseableValue } from "./values";
-import { AddressResolver } from "./instructions";
-import { IFunctionValue, IInstruction, INamedValue, 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;
-    label?: string;
-    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(identifier: string): boolean;
-    get(identifier: string): INamedValue;
-    set<T extends IValue>(name: string, value: T): T;
-    hardSet<T extends IValue>(name: string, value: T): T;
-    make(identifier: string, name: string): SenseableValue;
-    makeTempName(): string;
-}
+import { SenseableValue } from "./values";
+import { AddressResolver } from "./instructions";
+import { IFunctionValue, IInstruction, INamedValue, IScope, IValue } from "./types";
+export declare class Scope implements IScope {
+    parent: IScope | null;
+    stacked: boolean;
+    ntemp: number;
+    name: string;
+    inst: IInstruction[];
+    operationCache: Record<string, IValue>;
+    cacheDependencies: Record<string, string[]>;
+    data: Record<string, IValue | null>;
+    break: AddressResolver;
+    continue: AddressResolver;
+    function: IFunctionValue;
+    label?: string;
+    checkIndexes: boolean;
+    constructor(values: Record<string, IValue | null>, parent?: IScope | null, stacked?: boolean, ntemp?: number, name?: string, inst?: IInstruction[], operationCache?: Record<string, IValue>, cacheDependencies?: Record<string, string[]>);
+    copy(): IScope;
+    createScope(): IScope;
+    createFunction(name: string, stacked?: boolean): IScope;
+    has(identifier: string): boolean;
+    get(identifier: string): INamedValue;
+    set<T extends IValue>(name: string, value: T): T;
+    hardSet<T extends IValue>(name: string, value: T): T;
+    make(identifier: string, name: string): SenseableValue;
+    makeTempName(): string;
+    addCachedOperation(op: string, result: IValue, left: IValue, right?: IValue | undefined): void;
+    getCachedOperation(op: string, left: IValue, right?: IValue | undefined): IValue | undefined;
+    clearDependentCache(value: IValue): void;
+}

package/dist/bin.cjs

@@ -9,62 +9,103 @@ var yargs = require('yargs');
 var chalk = require('chalk');
 var path = require('path');
 
-yargs(helpers.hideBin(process.argv))
-    .command("$0 [path] [out]", "compiles your Javascript file to MLog", yargs => {
-    return yargs
-        .positional("path", {
-        describe: "path of the file to compile",
-        type: "string",
-    })
-        .positional("out", {
-        describe: "path of the output file",
-        type: "string",
-    })
-        .option("compact-names", {
-        type: "boolean",
-        default: false,
-        describe: "Wether the compiler should preserve or compact variable and function names",
-    });
-}, argv => {
-    const path$1 = argv.path;
-    if (!path$1)
-        return console.log("missing required path argument");
-    if (!fs.existsSync(path$1))
-        return console.log(`file at ${path$1} does not exist`);
-    const out = argv.out ?? defaultOutPath(path$1);
-    if (path$1 == out)
-        return console.log("The out path cannot be the same as the input path");
-    const compiler = new index_cjs.Compiler({
-        compactNames: argv["compact-names"],
-    });
-    const code = fs.readFileSync(path$1, "utf8");
-    const [output, error] = compiler.compile(code);
-    if (error) {
-        if (!error.loc) {
-            console.log(error.inner ?? error);
-            return;
-        }
-        const { start, end } = error.loc;
-        const lines = code.split("\n");
-        console.log(chalk.cyanBright([path.resolve(path$1), start.line, start.column].join(":")));
-        for (let i = Math.max(start.line - 3, 0); i < Math.min(end.line + 2, lines.length); i++) {
-            const n = i + 1;
-            if (n !== start.line)
-                continue;
-            const head = chalk.gray(`${n} | `.padStart(6, " "));
-            console.log(head + cliHighlight.highlight(lines[i], { language: "js" }));
-            console.log(chalk.red(" ".repeat(6 + start.column) + "^ " + error.message));
-        }
-        return;
-    }
-    fs.writeFileSync(out, output);
-    console.log(`Success: Compiled ${path$1}. Your compiled code is at ${out}.`);
-})
-    .help()
-    .scriptName("mlogjs")
-    .demandCommand()
-    .parse();
-function defaultOutPath(path$1) {
-    const parsed = path.parse(path$1);
-    return path.join(parsed.dir, `${parsed.name}.mlog`);
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+yargs(helpers.hideBin(process.argv))
+    .command("setup [dir]", "Copies the compiler type definitions in the current folder", yargs => {
+    return yargs
+        .positional("dir", {
+        default: ".",
+        type: "string",
+        describe: "The directory where the type definitions folder will be copied",
+    })
+        .option("tsconfig", {
+        type: "boolean",
+        default: false,
+        describe: "Wether a tsconfig.json file should be created in the current directory",
+    });
+}, argv => {
+    // this approach depends on the fact that the
+    // output bin.cjs file is one folder bellow the package folder
+    const currentPath = __dirname.replace(/\\/g, "/");
+    const parent = currentPath.split("/").slice(0, -1).join("/");
+    const libPath = path.join(parent, "lib");
+    const dir = path.resolve(process.cwd(), argv.dir);
+    const target = path.join(dir, "lib");
+    fs.cpSync(libPath, target, {
+        recursive: true,
+    });
+    if (!argv.tsconfig)
+        return;
+    const tsconfigPath = path.join(dir, "tsconfig.json");
+    const json = {
+        compilerOptions: {
+            allowJs: true,
+            checkJs: true,
+            moduleDetection: "force",
+            noEmit: true,
+            noLib: true,
+            target: "ESNext",
+        },
+        include: ["./lib", "*.js", "*.ts"],
+        exclude: ["node_modules"],
+    };
+    fs.writeFileSync(tsconfigPath, JSON.stringify(json, null, "\t"));
+})
+    .command("$0 [path] [out]", "compiles your Javascript file to MLog", yargs => {
+    return yargs
+        .positional("path", {
+        describe: "path of the file to compile",
+        type: "string",
+    })
+        .positional("out", {
+        describe: "path of the output file",
+        type: "string",
+    })
+        .option("compact-names", {
+        type: "boolean",
+        default: false,
+        describe: "Wether the compiler should preserve or compact variable and function names",
+    });
+}, argv => {
+    const path$1 = argv.path;
+    if (!path$1)
+        return console.log("missing required path argument");
+    if (!fs.existsSync(path$1))
+        return console.log(`file at ${path$1} does not exist`);
+    const out = argv.out ?? defaultOutPath(path$1);
+    if (path$1 == out)
+        return console.log("The out path cannot be the same as the input path");
+    const compiler = new index_cjs.Compiler({
+        compactNames: argv["compact-names"],
+    });
+    const code = fs.readFileSync(path$1, "utf8");
+    const [output, error] = compiler.compile(code);
+    if (error) {
+        if (!error.loc) {
+            console.log(error.inner ?? error);
+            return;
+        }
+        const { start, end } = error.loc;
+        const lines = code.split("\n");
+        console.log(chalk.cyanBright([path.resolve(path$1), start.line, start.column].join(":")));
+        for (let i = Math.max(start.line - 3, 0); i < Math.min(end.line + 2, lines.length); i++) {
+            const n = i + 1;
+            if (n !== start.line)
+                continue;
+            const head = chalk.gray(`${n} | `.padStart(6, " "));
+            console.log(head + cliHighlight.highlight(lines[i], { language: "js" }));
+            console.log(chalk.red(" ".repeat(6 + start.column) + "^ " + error.message));
+        }
+        return;
+    }
+    fs.writeFileSync(out, output);
+    console.log(`Success: Compiled ${path$1}. Your compiled code is at ${out}.`);
+})
+    .help()
+    .scriptName("mlogjs")
+    .demandCommand()
+    .parse();
+function defaultOutPath(path$1) {
+    const parsed = path.parse(path$1);
+    return path.join(parsed.dir, `${parsed.name}.mlog`);
 }

package/dist/bin.d.ts

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

package/dist/handlers/BlockStatement.d.ts

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

package/dist/handlers/CallExpression.d.ts

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

package/dist/handlers/File.d.ts

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

package/dist/handlers/ForStatement.d.ts

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

package/dist/handlers/Function.d.ts

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

package/dist/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/handlers/IfStatement.d.ts

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

package/dist/handlers/Literal.d.ts

@@ -1,5 +1,5 @@
-import { THandler } from "../types";
-export declare const NumericLiteral: THandler<import("../types").IValue>;
-export declare const StringLiteral: THandler<import("../types").IValue>;
-export declare const NullLiteral: THandler;
-export declare const BooleanLiteral: THandler;
+import { THandler } from "../types";
+export declare const NumericLiteral: THandler<import("../types").IValue>;
+export declare const StringLiteral: THandler<import("../types").IValue>;
+export declare const NullLiteral: THandler;
+export declare const BooleanLiteral: THandler;

package/dist/handlers/Object.d.ts

@@ -1,7 +1,8 @@
-import { IValue, THandler } from "../types";
-export declare const ObjectExpression: THandler;
-export declare const ArrayExpression: THandler;
-export declare const MemberExpression: THandler;
-export declare const ArrayPattern: THandler;
-export declare const ObjectPattern: THandler;
-export declare const OptionalMemberExpression: THandler<IValue>;
+import { IValue, THandler } from "../types";
+export declare const ObjectExpression: THandler;
+export declare const ArrayExpression: THandler;
+export declare const MemberExpression: THandler;
+export declare const ArrayPattern: THandler;
+export declare const ObjectPattern: THandler;
+export declare const OptionalMemberExpression: THandler;
+export declare const AssignmentPattern: THandler<IValue>;

package/dist/handlers/OperationExpressions.d.ts

@@ -1,9 +1,9 @@
-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;
-export declare const ConditionalExpression: THandler;
-export declare const SequenceExpression: 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;
+export declare const ConditionalExpression: THandler;
+export declare const SequenceExpression: THandler;

package/dist/handlers/Program.d.ts

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

package/dist/handlers/Statements.d.ts

@@ -1,7 +1,7 @@
-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>;
-export declare const EmptyStatement: THandler<null>;
-export declare const LabeledStatement: THandler<null>;
+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>;
+export declare const EmptyStatement: THandler<null>;
+export declare const LabeledStatement: THandler<null>;

package/dist/handlers/SwitchStatement.d.ts

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

package/dist/handlers/TemplateExpression.d.ts

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

package/dist/handlers/Typescript.d.ts

@@ -1,7 +1,8 @@
-import { THandler } from "../types";
-export declare const TSAsExpression: THandler<import("../types").IValue>;
-export declare const TSTypeAssertion: THandler<import("../types").IValue>;
-export declare const TSInterfaceDeclaration: THandler<null>;
-export declare const TSTypeAliasDeclaration: THandler<null>;
-export declare const TSEnumDeclaration: THandler<null>;
-export declare const TSNonNullExpression: THandler;
+import { IValue, THandler } from "../types";
+export declare const TSAsExpression: THandler<IValue>;
+export declare const TSTypeAssertion: THandler<IValue>;
+export declare const TSInterfaceDeclaration: THandler<null>;
+export declare const TSTypeAliasDeclaration: THandler<null>;
+export declare const TSEnumDeclaration: THandler<null>;
+export declare const TSNonNullExpression: THandler;
+export declare const TSSatisfiesExpression: THandler<IValue | null>;

package/dist/handlers/VariableDeclaration.d.ts

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

package/dist/handlers/WhileStatement.d.ts

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

package/dist/handlers/index.d.ts

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