greybel-interpreter 5.6.2 → 6.0.1

package/README.md

@@ -1,3 +1,73 @@
 # greybel-interpreter
 
-[![greybel-interpreter](https://circleci.com/gh/ayecue/greybel-interpreter.svg?style=svg)](https://circleci.com/gh/ayecue/greybel-interpreter)
+[![greybel-interpreter](https://circleci.com/gh/ayecue/greybel-interpreter.svg?style=svg)](https://circleci.com/gh/ayecue/greybel-interpreter)
+
+A bytecode interpreter for [MiniScript](https://miniscript.org) written in TypeScript. It compiles MiniScript source code to bytecode and executes it in a stack-based VM built on top of [greybel-core](../greybel-core). For GreyScript-specific interpretation, see [greyscript-interpreter](../greyscript-interpreter).
+
+## Features
+
+* Bytecode compiler that converts AST to efficient instructions
+* Stack-based virtual machine with non-blocking scheduling
+* Built-in type system: string, number, boolean, list, map, function, and nil
+* Pluggable handler system for resource loading, output, and error handling
+* Debugger support with breakpoints and step-through execution
+* Code injection at runtime via `interpreter.inject()`
+* Environment variable injection
+* Extensible API surface - supply custom intrinsics via an `ObjectValue` map
+* Runs in both Node.js and the browser (includes Rollup bundle config)
+* Written in TypeScript with type definitions included
+
+## Install
+
+```
+npm install greybel-interpreter
+```
+
+## Usage
+
+```ts
+import { Interpreter, HandlerContainer } from 'greybel-interpreter';
+
+const interpreter = new Interpreter({
+  target: '/path/to/main.src',
+  handler: new HandlerContainer(),
+  environmentVariables: new Map([['MY_VAR', '123']])
+});
+
+await interpreter.run();
+```
+
+### Custom intrinsics
+
+```ts
+import {
+  Interpreter,
+  CustomFunction,
+  CustomString,
+  DefaultType,
+  ObjectValue
+} from 'greybel-interpreter';
+
+const api = new ObjectValue();
+
+api.set(
+  new CustomString('exit'),
+  CustomFunction.createExternal('exit', (fnCtx, self, args) => {
+    interpreter.exit();
+    return Promise.resolve(DefaultType.Void);
+  })
+);
+
+const interpreter = new Interpreter({
+  target: '/path/to/main.src',
+  api
+});
+
+await interpreter.run();
+```
+
+## Testing
+
+```
+npm test
+```

package/dist/bytecode-generator/context.js

@@ -40,8 +40,8 @@ class Context {
         return {
             name: name !== null && name !== void 0 ? name : node.type,
             path: target,
-            start: node.start,
-            end: node.end
+            start: { line: node.startLine, character: node.startChar },
+            end: { line: node.endLine, character: node.endChar }
         };
     }
     getInternalLocation() {

package/dist/bytecode-generator/expression.js

@@ -91,7 +91,7 @@ class BytecodeExpressionGenerator {
                 case greybel_core_1.ASTType.FeatureLineExpression:
                     this.context.pushCode({
                         op: instruction_1.OpCode.PUSH,
-                        value: new number_1.CustomNumber(node.start.line)
+                        value: new number_1.CustomNumber(node.startLine)
                     }, node);
                     return;
                 case greybel_core_1.ASTType.FeatureFileExpression:
@@ -100,13 +100,11 @@ class BytecodeExpressionGenerator {
                         value: new string_1.CustomString((0, path_1.basename)(this.context.target.peek()))
                     }, node);
                     return;
-                case miniscript_core_1.ASTType.Comment:
-                    return;
                 case miniscript_core_1.ASTType.ComparisonGroupExpression:
                     yield this.processComparisonGroupExpression(node);
                     return;
                 default: {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    const range = new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar]);
                     throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
                         target: this.context.target.peek(),
                         range
@@ -486,7 +484,7 @@ class BytecodeExpressionGenerator {
             const importTarget = yield this.context.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
             const content = yield this.context.handler.resourceHandler.get(importTarget);
             if (content == null) {
-                const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                const range = new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar]);
                 throw new error_1.PrepareError(`Cannot find injection "${currentTarget}"`, {
                     target: currentTarget,
                     range
@@ -531,7 +529,7 @@ BytecodeExpressionGenerator.binaryExpressionToOp = {
     [miniscript_core_1.Operator.GreaterThanOrEqual]: instruction_1.OpCode.GREATER_THAN_OR_EQUAL,
     [miniscript_core_1.Operator.Plus]: instruction_1.OpCode.ADD,
     [miniscript_core_1.Operator.Minus]: instruction_1.OpCode.SUB,
-    [miniscript_core_1.Operator.Asterik]: instruction_1.OpCode.MUL,
+    [miniscript_core_1.Operator.Asterisk]: instruction_1.OpCode.MUL,
     [miniscript_core_1.Operator.Slash]: instruction_1.OpCode.DIV,
     [miniscript_core_1.Operator.Modulo]: instruction_1.OpCode.MOD,
     [miniscript_core_1.Operator.Power]: instruction_1.OpCode.POW,

package/dist/bytecode-generator/instruction.d.ts

@@ -1,4 +1,3 @@
-import { ASTPosition } from 'miniscript-core';
 import { CustomValue } from '../types/base';
 import { CustomFunctionCallback } from '../types/function';
 import { CustomString } from '../types/string';
@@ -70,8 +69,14 @@ export interface FunctionDefinitionInstructionArgument {
 export type SourceLocation = {
     name: string;
     path: string;
-    start: ASTPosition;
-    end: ASTPosition;
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
 };
 export interface BaseInstruction {
     op: OpCode;

package/dist/bytecode-generator/statement.js

@@ -109,7 +109,6 @@ class BytecodeStatementGenerator {
                     yield this.processForGenericStatement(node);
                     return;
                 case miniscript_core_1.ASTType.EmptyExpression:
-                case miniscript_core_1.ASTType.Comment:
                     return;
                 case greybel_core_1.ASTType.FeatureInjectExpression:
                     return;
@@ -125,7 +124,7 @@ class BytecodeStatementGenerator {
                     yield this.processDebuggerExpression(node);
                     return;
                 default: {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    const range = new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar]);
                     throw new error_1.PrepareError(`Unexpected AST type ${node.type}`, {
                         target: this.context.target.peek(),
                         range
@@ -633,7 +632,7 @@ class BytecodeStatementGenerator {
                 }
                 throw new error_1.PrepareError(err.message, {
                     target: path,
-                    range: new miniscript_core_1.ASTRange(node.start, node.end)
+                    range: new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar])
                 }, err);
             }
         });
@@ -643,13 +642,13 @@ class BytecodeStatementGenerator {
             const currentTarget = this.context.target.peek();
             const importTarget = yield this.context.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
             if (this.context.target.includes(importTarget)) {
-                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
+                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.startLine}. Using noop instead to prevent overflow.`);
                 return;
             }
             if (!this.context.imports.has(importTarget)) {
                 const code = yield this.context.handler.resourceHandler.get(importTarget);
                 if (code == null) {
-                    const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                    const range = new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar]);
                     throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
                         target: currentTarget,
                         range
@@ -679,15 +678,18 @@ class BytecodeStatementGenerator {
     }
     processIncludeExpression(node) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (node.typeOnly) {
+                return;
+            }
             const currentTarget = this.context.target.peek();
             const importTarget = yield this.context.handler.resourceHandler.getTargetRelativeTo(currentTarget, node.path);
             if (this.context.target.includes(importTarget)) {
-                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.start.line}. Using noop instead to prevent overflow.`);
+                console.warn(`Found circular dependency between "${currentTarget}" and "${importTarget}" at line ${node.startLine}. Using noop instead to prevent overflow.`);
                 return;
             }
             const code = yield this.context.handler.resourceHandler.get(importTarget);
             if (code == null) {
-                const range = new miniscript_core_1.ASTRange(node.start, node.end);
+                const range = new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar]);
                 throw new error_1.PrepareError(`Cannot find import "${currentTarget}"`, {
                     target: currentTarget,
                     range
@@ -705,7 +707,7 @@ class BytecodeStatementGenerator {
                 }
                 throw new error_1.PrepareError(err.message, {
                     target: importTarget,
-                    range: new miniscript_core_1.ASTRange(node.start, node.end)
+                    range: new miniscript_core_1.ASTRange([node.startLine, node.startChar], [node.endLine, node.endChar])
                 }, err);
             }
         });

package/dist/bytecode-generator.d.ts

@@ -10,9 +10,13 @@ export interface BytecodeConverterOptions {
     handler: HandlerContainer;
     debugMode?: boolean;
     context?: Context;
+    environmentVariables?: Map<string, string>;
+    strictMode?: boolean;
 }
 export declare class BytecodeGenerator {
     protected context: Context;
+    protected environmentVariables: Map<string, string>;
+    protected strictMode: boolean;
     constructor(options: BytecodeConverterOptions);
     compile(code: string): Promise<BytecodeCompileResult>;
 }

package/dist/bytecode-generator.js

@@ -17,7 +17,10 @@ const greybel_core_1 = require("greybel-core");
 const error_1 = require("./utils/error");
 const parse = function (code) {
     try {
-        const parser = new greybel_core_1.Parser(code);
+        const parser = new greybel_core_1.Parser(code, {
+            environmentVariables: this.environmentVariables,
+            strictMode: this.strictMode
+        });
         return parser.parseChunk();
     }
     catch (err) {
@@ -34,12 +37,14 @@ const parse = function (code) {
 };
 class BytecodeGenerator {
     constructor(options) {
-        var _a;
+        var _a, _b, _c;
         this.context = (_a = options.context) !== null && _a !== void 0 ? _a : new context_1.Context({
             target: options.target,
             handler: options.handler,
             debugMode: options.debugMode
         });
+        this.environmentVariables = (_b = options.environmentVariables) !== null && _b !== void 0 ? _b : new Map();
+        this.strictMode = (_c = options.strictMode) !== null && _c !== void 0 ? _c : false;
     }
     compile(code) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/interpreter.d.ts

@@ -17,6 +17,7 @@ export interface InterpreterOptions {
     debugger?: Debugger;
     debugMode?: boolean;
     environmentVariables?: Map<string, string>;
+    strictMode?: boolean;
 }
 export interface InterpreterRunOptions {
     customCode?: string;
@@ -27,6 +28,7 @@ export declare class Interpreter extends EventEmitter {
     api: ObjectValue;
     params: Array<string>;
     environmentVariables: Map<string, string>;
+    strictMode: boolean;
     handler: HandlerContainer;
     debugger: Debugger;
     debugMode: boolean;

package/dist/interpreter.js

@@ -28,7 +28,7 @@ exports.PARAMS_PROPERTY = new string_1.CustomString('params');
 exports.IS_GREYBEL_PROPERTY = new string_1.CustomString('IS_GREYBEL');
 class Interpreter extends events_1.EventEmitter {
     constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         super();
         this.handler = (_a = options.handler) !== null && _a !== void 0 ? _a : new handler_container_1.HandlerContainer();
         this.debugger = (_b = options.debugger) !== null && _b !== void 0 ? _b : new vm_1.Debugger();
@@ -36,10 +36,11 @@ class Interpreter extends events_1.EventEmitter {
         this.api = (_c = options.api) !== null && _c !== void 0 ? _c : new object_value_1.ObjectValue();
         this.params = (_d = options.params) !== null && _d !== void 0 ? _d : [];
         this.environmentVariables = (_e = options.environmentVariables) !== null && _e !== void 0 ? _e : new Map();
-        this.debugMode = (_f = options.debugMode) !== null && _f !== void 0 ? _f : false;
+        this.strictMode = (_f = options.strictMode) !== null && _f !== void 0 ? _f : false;
+        this.debugMode = (_g = options.debugMode) !== null && _g !== void 0 ? _g : false;
         this.apiContext = null;
         this.globalContext = null;
-        this.setTarget((_g = options.target) !== null && _g !== void 0 ? _g : 'unknown');
+        this.setTarget((_h = options.target) !== null && _h !== void 0 ? _h : 'unknown');
     }
     setTarget(target) {
         if (this.vm !== null && this.vm.isPending()) {
@@ -73,7 +74,9 @@ class Interpreter extends events_1.EventEmitter {
         return __awaiter(this, void 0, void 0, function* () {
             const bytecodeGenerator = new bytecode_generator_1.BytecodeGenerator({
                 target: 'injected',
-                handler: this.handler
+                handler: this.handler,
+                environmentVariables: this.environmentVariables,
+                strictMode: this.strictMode
             });
             const result = yield bytecodeGenerator.compile(code);
             const vm = new vm_1.VM({
@@ -171,7 +174,9 @@ class Interpreter extends events_1.EventEmitter {
             const bytecodeConverter = new bytecode_generator_1.BytecodeGenerator({
                 target: this.target,
                 handler: this.handler,
-                debugMode: this.debugMode
+                debugMode: this.debugMode,
+                environmentVariables: this.environmentVariables,
+                strictMode: this.strictMode
             });
             const bytecode = yield bytecodeConverter.compile(code);
             this.initVM(bytecode, vmOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greybel-interpreter",
-  "version": "5.6.2",
+  "version": "6.0.1",
   "description": "Interpreter",
   "main": "dist/index",
   "typings": "dist/index",
@@ -50,7 +50,7 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "greybel-core": "~2.6.0",
+    "greybel-core": "~3.0.1",
     "hyperid": "^3.2.0",
     "imurmurhash": "^0.1.4",
     "non-blocking-schedule": "^0.2.0"