greybel-interpreter 1.7.1 → 1.7.3

package/dist/context.d.ts

@@ -1,12 +1,12 @@
 import { ASTBase } from 'greyscript-core';
-import CPS from './cps';
-import HandlerContainer from './handler-container';
-import Operation from './operations/operation';
-import CustomValue from './types/base';
-import CustomMap from './types/map';
-import CustomNil from './types/nil';
-import ObjectValue from './utils/object-value';
-import Path from './utils/path';
+import { CPS } from './cps';
+import { HandlerContainer } from './handler-container';
+import { Operation } from './operations/operation';
+import { CustomValue } from './types/base';
+import { CustomMap } from './types/map';
+import { CustomNil } from './types/nil';
+import { ObjectValue } from './utils/object-value';
+import { Path } from './utils/path';
 export declare enum ContextType {
     Api = 0,
     Global = 1,
@@ -71,7 +71,7 @@ export interface ContextForkOptions {
     target?: string;
     injected?: boolean;
 }
-export default class OperationContext {
+export declare class OperationContext {
     target: string;
     stackItem: ASTBase;
     debugger: Debugger;

package/dist/context.js

@@ -1,14 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionState = exports.LoopState = exports.ProcessState = exports.Debugger = exports.Scope = exports.ContextState = exports.ContextType = void 0;
-const handler_container_1 = __importDefault(require("./handler-container"));
-const base_1 = __importDefault(require("./types/base"));
-const default_1 = __importDefault(require("./types/default"));
-const map_1 = __importDefault(require("./types/map"));
-const path_1 = __importDefault(require("./utils/path"));
+exports.OperationContext = exports.FunctionState = exports.LoopState = exports.ProcessState = exports.Debugger = exports.Scope = exports.ContextState = exports.ContextType = void 0;
+const handler_container_1 = require("./handler-container");
+const base_1 = require("./types/base");
+const default_1 = require("./types/default");
+const map_1 = require("./types/map");
+const path_1 = require("./utils/path");
 var ContextType;
 (function (ContextType) {
     ContextType[ContextType["Api"] = 0] = "Api";
@@ -24,14 +21,14 @@ var ContextState;
     ContextState[ContextState["Temporary"] = 0] = "Temporary";
     ContextState[ContextState["Default"] = 1] = "Default";
 })(ContextState = exports.ContextState || (exports.ContextState = {}));
-class Scope extends map_1.default {
+class Scope extends map_1.CustomMap {
     constructor(context) {
         super();
         this.context = context;
     }
     get(path) {
-        if (path instanceof base_1.default) {
-            return this.get(new path_1.default([path]));
+        if (path instanceof base_1.CustomValue) {
+            return this.get(new path_1.Path([path]));
         }
         if (path.count() === 0) {
             return this;
@@ -44,8 +41,8 @@ class Scope extends map_1.default {
         else if (this.context.api.scope.has(path)) {
             return this.context.api.scope.get(path);
         }
-        else if (path.count() === 1 && map_1.default.getIntrinsics().has(current)) {
-            return map_1.default.getIntrinsics().get(current);
+        else if (path.count() === 1 && map_1.CustomMap.getIntrinsics().has(current)) {
+            return map_1.CustomMap.getIntrinsics().get(current);
         }
         else if (this.context.previous !== null) {
             return this.context.previous.get(path);
@@ -66,7 +63,7 @@ class Debugger {
     }
     debug(...segments) {
         console.debug(...segments);
-        return default_1.default.Void;
+        return default_1.DefaultType.Void;
     }
     setBreakpoint(breakpoint) {
         this.breakpoint = breakpoint;
@@ -125,7 +122,7 @@ class LoopState {
 exports.LoopState = LoopState;
 class FunctionState {
     constructor() {
-        this.value = default_1.default.Void;
+        this.value = default_1.DefaultType.Void;
         this.isReturn = false;
         this.context = null;
         this.super = null;
@@ -143,7 +140,7 @@ class OperationContext {
         this.isProtected = options.isProtected || false;
         this.injected = options.injected || false;
         this.debugger = options.debugger || new Debugger();
-        this.handler = options.handler || new handler_container_1.default();
+        this.handler = options.handler || new handler_container_1.HandlerContainer();
         this.cps = options.cps || null;
         this.processState = options.processState || new ProcessState();
         this.environmentVariables = options.environmentVariables || new Map();
@@ -252,8 +249,8 @@ class OperationContext {
     }
     set(path, value) {
         var _a;
-        if (path instanceof base_1.default) {
-            this.set(new path_1.default([path]), value);
+        if (path instanceof base_1.CustomValue) {
+            this.set(new path_1.Path([path]), value);
             return;
         }
         if (this.state === ContextState.Temporary) {
@@ -265,8 +262,8 @@ class OperationContext {
     }
     get(path) {
         var _a;
-        if (path instanceof base_1.default) {
-            return this.get(new path_1.default([path]));
+        if (path instanceof base_1.CustomValue) {
+            return this.get(new path_1.Path([path]));
         }
         if (path.count() === 0) {
             return this.scope;
@@ -299,7 +296,6 @@ class OperationContext {
         return newContext;
     }
 }
-exports.default = OperationContext;
 OperationContext.lookupApiType = [ContextType.Api];
 OperationContext.lookupGlobalsType = [
     ContextType.Global
@@ -308,3 +304,4 @@ OperationContext.lookupLocalsType = [
     ContextType.Global,
     ContextType.Function
 ];
+exports.OperationContext = OperationContext;

package/dist/cps.d.ts

@@ -1,12 +1,12 @@
 import { ASTBase } from 'greyscript-core';
-import HandlerContainer from './handler-container';
-import Operation from './operations/operation';
+import { HandlerContainer } from './handler-container';
+import { Operation } from './operations/operation';
 export declare class CPSContext {
     readonly target: string;
     readonly handler: HandlerContainer;
     constructor(target: string, handler: HandlerContainer);
 }
-export default class CPS {
+export declare class CPS {
     private readonly context;
     private __visit;
     constructor(context: CPSContext);

package/dist/cps.js

@@ -8,37 +8,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CPSContext = void 0;
+exports.CPS = exports.CPSContext = void 0;
 const greybel_core_1 = require("greybel-core");
 const greyscript_core_1 = require("greyscript-core");
-const assign_1 = __importDefault(require("./operations/assign"));
-const break_1 = __importDefault(require("./operations/break"));
-const call_1 = __importDefault(require("./operations/call"));
-const chunk_1 = __importDefault(require("./operations/chunk"));
-const continue_1 = __importDefault(require("./operations/continue"));
-const debugger_statement_1 = __importDefault(require("./operations/debugger-statement"));
-const envar_1 = __importDefault(require("./operations/envar"));
-const evaluate_1 = __importDefault(require("./operations/evaluate"));
-const for_1 = __importDefault(require("./operations/for"));
-const function_1 = __importDefault(require("./operations/function"));
-const function_reference_1 = __importDefault(require("./operations/function-reference"));
-const if_statement_1 = __importDefault(require("./operations/if-statement"));
-const import_1 = __importDefault(require("./operations/import"));
-const include_1 = __importDefault(require("./operations/include"));
-const list_1 = __importDefault(require("./operations/list"));
-const literal_1 = __importDefault(require("./operations/literal"));
-const map_1 = __importDefault(require("./operations/map"));
-const negated_binary_1 = __importDefault(require("./operations/negated-binary"));
-const new_instance_1 = __importDefault(require("./operations/new-instance"));
-const noop_1 = __importDefault(require("./operations/noop"));
-const not_1 = __importDefault(require("./operations/not"));
-const resolve_1 = __importDefault(require("./operations/resolve"));
-const return_1 = __importDefault(require("./operations/return"));
-const while_1 = __importDefault(require("./operations/while"));
+const assign_1 = require("./operations/assign");
+const break_1 = require("./operations/break");
+const call_1 = require("./operations/call");
+const chunk_1 = require("./operations/chunk");
+const continue_1 = require("./operations/continue");
+const debugger_statement_1 = require("./operations/debugger-statement");
+const envar_1 = require("./operations/envar");
+const evaluate_1 = require("./operations/evaluate");
+const for_1 = require("./operations/for");
+const function_1 = require("./operations/function");
+const function_reference_1 = require("./operations/function-reference");
+const if_statement_1 = require("./operations/if-statement");
+const import_1 = require("./operations/import");
+const include_1 = require("./operations/include");
+const list_1 = require("./operations/list");
+const literal_1 = require("./operations/literal");
+const map_1 = require("./operations/map");
+const negated_binary_1 = require("./operations/negated-binary");
+const new_instance_1 = require("./operations/new-instance");
+const noop_1 = require("./operations/noop");
+const not_1 = require("./operations/not");
+const resolve_1 = require("./operations/resolve");
+const return_1 = require("./operations/return");
+const while_1 = require("./operations/while");
+const error_1 = require("./utils/error");
 class CPSContext {
     constructor(target, handler) {
         this.target = target;
@@ -51,34 +49,34 @@ const visit = (context, stack, item) => __awaiter(void 0, void 0, void 0, functi
     const defaultVisit = visit.bind(null, context, stack);
     switch (item.type) {
         case greyscript_core_1.ASTType.MapConstructorExpression:
-            return new map_1.default(item, currentTarget).build(defaultVisit);
+            return new map_1.MapOperation(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.ListConstructorExpression:
-            return new list_1.default(item, currentTarget).build(defaultVisit);
+            return new list_1.List(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.AssignmentStatement:
-            return new assign_1.default(item, currentTarget).build(defaultVisit);
+            return new assign_1.Assign(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.MemberExpression:
         case greyscript_core_1.ASTType.Identifier:
         case greyscript_core_1.ASTType.IndexExpression:
-            return new resolve_1.default(item, currentTarget).build(defaultVisit);
+            return new resolve_1.Resolve(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.FunctionDeclaration:
-            return new function_1.default(item, currentTarget).build(defaultVisit);
+            return new function_1.FunctionOperation(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.InvalidCodeExpression:
-            return new noop_1.default(item, currentTarget).build(defaultVisit);
+            return new noop_1.Noop(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.WhileStatement:
-            return new while_1.default(item, currentTarget).build(defaultVisit);
+            return new while_1.While(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.ForGenericStatement:
-            return new for_1.default(item, currentTarget).build(defaultVisit);
+            return new for_1.For(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.IfStatement:
         case greyscript_core_1.ASTType.IfShortcutStatement:
-            return new if_statement_1.default(item, currentTarget).build(defaultVisit);
+            return new if_statement_1.IfStatement(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.ReturnStatement:
-            return new return_1.default(item, currentTarget).build(defaultVisit);
+            return new return_1.Return(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.BreakStatement:
-            return new break_1.default(item, currentTarget).build(defaultVisit);
+            return new break_1.Break(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.ContinueStatement:
-            return new continue_1.default(item, currentTarget).build(defaultVisit);
+            return new continue_1.Continue(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.CallExpression:
-            return new call_1.default(item, currentTarget).build(defaultVisit);
+            return new call_1.Call(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.CallStatement:
             return defaultVisit(item.expression);
         case greybel_core_1.ASTType.FeatureImportExpression: {
@@ -86,83 +84,124 @@ const visit = (context, stack, item) => __awaiter(void 0, void 0, void 0, functi
             const target = yield context.handler.resourceHandler.getTargetRelativeTo(currentTarget, importExpr.path);
             if (stack.includes(target)) {
                 console.warn('Found circluar dependency. Using noop operation.');
-                return new noop_1.default(item, target);
+                return new noop_1.Noop(item, target);
             }
             const code = yield context.handler.resourceHandler.get(target);
             if (code == null) {
-                throw new Error(`Cannot find import ${currentTarget}.`);
+                throw new error_1.PrepareError(`Cannot find import ${currentTarget}.`, {
+                    target: currentTarget,
+                    item
+                });
+            }
+            try {
+                const subVisit = visit.bind(null, context, [...stack, target]);
+                const importStatement = yield new import_1.Import(importExpr, target, code).build(subVisit);
+                return importStatement;
+            }
+            catch (err) {
+                throw new error_1.PrepareError(err.message, {
+                    target: currentTarget,
+                    item
+                });
             }
-            const subVisit = visit.bind(null, context, [...stack, target]);
-            const importStatement = yield new import_1.default(importExpr, target, code).build(subVisit);
-            return importStatement;
         }
         case greybel_core_1.ASTType.FeatureIncludeExpression: {
             const includeExpr = item;
             const target = yield context.handler.resourceHandler.getTargetRelativeTo(currentTarget, includeExpr.path);
             if (stack.includes(target)) {
                 console.warn('Found circluar dependency. Using noop operation.');
-                return new noop_1.default(item, target);
+                return new noop_1.Noop(item, target);
             }
             const code = yield context.handler.resourceHandler.get(target);
             if (code == null) {
-                throw new Error(`Cannot find include ${currentTarget}.`);
+                throw new error_1.PrepareError(`Cannot find include ${currentTarget}.`, {
+                    target: currentTarget,
+                    item
+                });
+            }
+            try {
+                const subVisit = visit.bind(null, context, [...stack, target]);
+                const importStatement = yield new include_1.Include(includeExpr, target, code).build(subVisit);
+                return importStatement;
+            }
+            catch (err) {
+                throw new error_1.PrepareError(err.message, {
+                    target: currentTarget,
+                    item
+                });
             }
-            const subVisit = visit.bind(null, context, [...stack, target]);
-            const importStatement = yield new include_1.default(includeExpr, target, code).build(subVisit);
-            return importStatement;
         }
         case greyscript_core_1.ASTType.ImportCodeExpression: {
             const importExpr = item;
+            if (importExpr.fileSystemDirectory === null) {
+                console.warn(`Ignoring dependency in ${currentTarget}. Using noop operation.`);
+                return new noop_1.Noop(item, currentTarget);
+            }
             const target = yield context.handler.resourceHandler.getTargetRelativeTo(currentTarget, importExpr.fileSystemDirectory);
             if (stack.includes(target)) {
-                console.warn('Found circluar dependency. Using noop operation.');
-                return new noop_1.default(item, target);
+                console.warn(`Found circluar dependency in ${currentTarget}. Using noop operation.`);
+                return new noop_1.Noop(item, target);
             }
             const code = yield context.handler.resourceHandler.get(target);
             if (code == null) {
-                throw new Error(`Cannot find native import ${currentTarget}.`);
+                throw new error_1.PrepareError(`Cannot find native import ${currentTarget}.`, {
+                    target: currentTarget,
+                    item
+                });
+            }
+            try {
+                const subVisit = visit.bind(null, context, [...stack, target]);
+                const importStatement = yield new include_1.Include(importExpr, target, code).build(subVisit);
+                return importStatement;
+            }
+            catch (err) {
+                throw new error_1.PrepareError(err.message, {
+                    target: currentTarget,
+                    item
+                });
             }
-            const subVisit = visit.bind(null, context, [...stack, target]);
-            const importStatement = yield new include_1.default(importExpr, target, code).build(subVisit);
-            return importStatement;
         }
         case greybel_core_1.ASTType.FeatureDebuggerExpression:
-            return new debugger_statement_1.default(item, currentTarget);
+            return new debugger_statement_1.DebuggerStatement(item, currentTarget);
         case greybel_core_1.ASTType.FeatureEnvarExpression:
-            return new envar_1.default(item, currentTarget);
+            return new envar_1.EnvarExpression(item, currentTarget);
         case greyscript_core_1.ASTType.BooleanLiteral:
         case greyscript_core_1.ASTType.StringLiteral:
         case greyscript_core_1.ASTType.NumericLiteral:
         case greyscript_core_1.ASTType.NilLiteral:
-            return new literal_1.default(item, currentTarget).build(defaultVisit);
+            return new literal_1.Literal(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.EmptyExpression:
-            return new noop_1.default(item, currentTarget).build(defaultVisit);
+            return new noop_1.Noop(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.IsaExpression:
         case greyscript_core_1.ASTType.BinaryExpression:
         case greyscript_core_1.ASTType.LogicalExpression:
-            return new evaluate_1.default(item, currentTarget).build(defaultVisit);
+            return new evaluate_1.Evaluate(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.NegationExpression:
-            return new not_1.default(item, currentTarget).build(defaultVisit);
+            return new not_1.Not(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.BinaryNegatedExpression:
-            return new negated_binary_1.default(item, currentTarget).build(defaultVisit);
+            return new negated_binary_1.NegatedBinary(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.UnaryExpression: {
             const unaryExpr = item;
             if (unaryExpr.operator === 'new') {
-                return new new_instance_1.default(unaryExpr).build(defaultVisit);
+                return new new_instance_1.NewInstance(unaryExpr).build(defaultVisit);
             }
             else if (unaryExpr.operator === '@') {
-                return new function_reference_1.default(unaryExpr).build(defaultVisit);
+                return new function_reference_1.FunctionReference(unaryExpr).build(defaultVisit);
             }
-            throw new Error('Unknown unary expression.');
+            throw new error_1.RuntimeError('Unknown unary expression.', {
+                target: currentTarget
+            });
         }
         case greyscript_core_1.ASTType.Chunk:
-            return new chunk_1.default(item, currentTarget).build(defaultVisit);
+            return new chunk_1.Chunk(item, currentTarget).build(defaultVisit);
         case greyscript_core_1.ASTType.Comment:
-            return new noop_1.default(item, currentTarget);
+            return new noop_1.Noop(item, currentTarget);
         case greyscript_core_1.ASTType.ParenthesisExpression:
             return defaultVisit(item.expression);
         default:
-            throw new Error(`Unexpected AST type ${item.type}.`);
+            throw new error_1.RuntimeError(`Unexpected AST type ${item.type}.`, {
+                target: currentTarget
+            });
     }
 });
 class CPS {
@@ -174,4 +213,4 @@ class CPS {
         return this.__visit(item);
     }
 }
-exports.default = CPS;
+exports.CPS = CPS;

package/dist/handler/output.d.ts

@@ -5,14 +5,14 @@ export interface KeyEvent {
 export declare abstract class OutputHandler {
     abstract print(message: string, appendNewLine?: boolean): void;
     abstract progress(timeout: number): PromiseLike<void>;
-    abstract waitForInput(isPassword: boolean): PromiseLike<string>;
-    abstract waitForKeyPress(): PromiseLike<KeyEvent>;
+    abstract waitForInput(isPassword: boolean, message?: string): PromiseLike<string>;
+    abstract waitForKeyPress(message?: string): PromiseLike<KeyEvent>;
     abstract clear(): void;
 }
 export declare class DefaultOutputHandler extends OutputHandler {
     print(message: string, appendNewLine?: boolean): void;
     progress(timeout: number): PromiseLike<void>;
-    waitForInput(_isPassword: boolean): PromiseLike<string>;
-    waitForKeyPress(): PromiseLike<KeyEvent>;
+    waitForInput(_isPassword: boolean, _message?: string): PromiseLike<string>;
+    waitForKeyPress(_message?: string): PromiseLike<KeyEvent>;
     clear(): void;
 }

package/dist/handler/output.js

@@ -18,10 +18,10 @@ class DefaultOutputHandler extends OutputHandler {
             setTimeout(resolve, timeout);
         });
     }
-    waitForInput(_isPassword) {
+    waitForInput(_isPassword, _message) {
         return Promise.resolve('test');
     }
-    waitForKeyPress() {
+    waitForKeyPress(_message) {
         return Promise.resolve({
             keyCode: 13,
             code: 'Enter'

package/dist/handler-container.d.ts

@@ -6,7 +6,7 @@ export interface HandlerContainerOptions {
     outputHandler?: OutputHandler;
     errorHandler?: ErrorHandler;
 }
-export default class HandlerContainer {
+export declare class HandlerContainer {
     readonly resourceHandler: ResourceHandler;
     readonly outputHandler: OutputHandler;
     readonly errorHandler: ErrorHandler;

package/dist/handler-container.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlerContainer = void 0;
 const error_1 = require("./handler/error");
 const output_1 = require("./handler/output");
 const resource_1 = require("./handler/resource");
@@ -11,4 +12,4 @@ class HandlerContainer {
         this.errorHandler = (options === null || options === void 0 ? void 0 : options.errorHandler) || new error_1.DefaultErrorHandler();
     }
 }
-exports.default = HandlerContainer;
+exports.HandlerContainer = HandlerContainer;

package/dist/index.d.ts

@@ -1,46 +1,47 @@
-export { ContextForkOptions, ContextOptions, ContextState, ContextType, Debugger, FunctionState, LoopState, default as OperationContext, ProcessState, Scope } from './context';
-export { default as CPS, CPSContext } from './cps';
+export { ContextForkOptions, ContextOptions, ContextState, ContextType, Debugger, FunctionState, LoopState, OperationContext, ProcessState, Scope } from './context';
+export { CPS, CPSContext } from './cps';
 export { DefaultErrorHandler, ErrorHandler } from './handler/error';
 export { DefaultOutputHandler, KeyEvent, OutputHandler } from './handler/output';
 export { DefaultResourceHandler, ResourceHandler } from './handler/resource';
-export { default as HandlerContainer } from './handler-container';
-export { default as Interpreter, InterpreterOptions } from './interpreter';
-export { default as Assign } from './operations/assign';
-export { default as Block, IsEOL } from './operations/block';
-export { default as Break } from './operations/break';
-export { default as Call } from './operations/call';
-export { default as Chunk } from './operations/chunk';
-export { default as Continue } from './operations/continue';
-export { default as DebuggerStatement } from './operations/debugger-statement';
-export { default as Evaluate, GenericProcessorHandler, handle, handleInterface, handleList, handleMap, handleNumber, handleString, ListProcessorHandler, MapProcessorHandler, NumberProcessorHandler, ProcessorHandler, ProcessorHandlerFunction, StringProcessorHandler } from './operations/evaluate';
-export { default as For } from './operations/for';
-export { default as FunctionOpertion } from './operations/function';
-export { Clause, default as IfStatement } from './operations/if-statement';
-export { default as Import } from './operations/import';
-export { default as Include } from './operations/include';
-export { default as List } from './operations/list';
-export { default as Literal } from './operations/literal';
-export { default as MapOperation } from './operations/map';
-export { default as NegatedBinary } from './operations/negated-binary';
-export { default as NewInstance } from './operations/new-instance';
-export { default as Noop } from './operations/noop';
-export { default as Not } from './operations/not';
-export { CPSVisit, default as Operation } from './operations/operation';
-export { default as Reference } from './operations/reference';
-export { IdentifierSegment, IndexSegment, OperationSegment, default as Resolve, ResolveResult, Segment } from './operations/resolve';
-export { default as Return } from './operations/return';
-export { default as While } from './operations/while';
-export { default as CustomValue } from './types/base';
-export { default as CustomBoolean } from './types/boolean';
-export { default as DefaultType } from './types/default';
-export { Argument, Callback, default as CustomFunction } from './types/function';
-export { default as CustomInterface, CustomInterfaceIterator } from './types/interface';
-export { default as CustomList, CustomListIterator } from './types/list';
-export { default as CustomMap, CustomMapIterator } from './types/map';
-export { default as CustomNil } from './types/nil';
-export { default as CustomNumber } from './types/number';
-export { default as CustomString, CustomStringIterator } from './types/string';
+export { HandlerContainer } from './handler-container';
+export { Interpreter, InterpreterOptions } from './interpreter';
+export { Assign } from './operations/assign';
+export { Block, IsEOL } from './operations/block';
+export { Break } from './operations/break';
+export { Call } from './operations/call';
+export { Chunk } from './operations/chunk';
+export { Continue } from './operations/continue';
+export { DebuggerStatement } from './operations/debugger-statement';
+export { Evaluate, GenericProcessorHandler, handle, handleInterface, handleList, handleMap, handleNumber, handleString, ListProcessorHandler, MapProcessorHandler, NumberProcessorHandler, ProcessorHandler, ProcessorHandlerFunction, StringProcessorHandler } from './operations/evaluate';
+export { For } from './operations/for';
+export { FunctionOperation } from './operations/function';
+export { Clause, IfStatement } from './operations/if-statement';
+export { Import } from './operations/import';
+export { Include } from './operations/include';
+export { List } from './operations/list';
+export { Literal } from './operations/literal';
+export { MapOperation } from './operations/map';
+export { NegatedBinary } from './operations/negated-binary';
+export { NewInstance } from './operations/new-instance';
+export { Noop } from './operations/noop';
+export { Not } from './operations/not';
+export { CPSVisit, Operation } from './operations/operation';
+export { Reference } from './operations/reference';
+export { IdentifierSegment, IndexSegment, OperationSegment, Resolve, ResolveResult, Segment } from './operations/resolve';
+export { Return } from './operations/return';
+export { While } from './operations/while';
+export { CustomValue } from './types/base';
+export { CustomBoolean } from './types/boolean';
+export { DefaultType } from './types/default';
+export { Argument, Callback, CustomFunction } from './types/function';
+export { CustomInterface, CustomInterfaceIterator } from './types/interface';
+export { CustomList, CustomListIterator } from './types/list';
+export { CustomMap, CustomMapIterator } from './types/map';
+export { CustomNil } from './types/nil';
+export { CustomNumber } from './types/number';
+export { CustomString, CustomStringIterator } from './types/string';
 export { CustomObject, CustomValueWithIntrinsics } from './types/with-intrinsics';
-export { default as deepEqual } from './utils/deep-equal';
-export { default as ObjectValue } from './utils/object-value';
-export { default as Path } from './utils/path';
+export { deepEqual } from './utils/deep-equal';
+export { PrepareError, RuntimeError } from './utils/error';
+export { ObjectValue } from './utils/object-value';
+export { Path } from './utils/path';