@lewin671/python-vm 0.1.0

package/dist/types/bytecode.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpCode = void 0;
+var OpCode;
+(function (OpCode) {
+    // Loading and storing
+    OpCode[OpCode["LOAD_CONST"] = 0] = "LOAD_CONST";
+    OpCode[OpCode["LOAD_NAME"] = 1] = "LOAD_NAME";
+    OpCode[OpCode["STORE_NAME"] = 2] = "STORE_NAME";
+    // Binary operations
+    OpCode[OpCode["BINARY_ADD"] = 3] = "BINARY_ADD";
+    OpCode[OpCode["BINARY_SUBTRACT"] = 4] = "BINARY_SUBTRACT";
+    OpCode[OpCode["BINARY_MULTIPLY"] = 5] = "BINARY_MULTIPLY";
+    OpCode[OpCode["BINARY_DIVIDE"] = 6] = "BINARY_DIVIDE";
+    OpCode[OpCode["BINARY_MODULO"] = 7] = "BINARY_MODULO";
+    OpCode[OpCode["BINARY_POWER"] = 8] = "BINARY_POWER";
+    // Comparison operations
+    OpCode[OpCode["COMPARE_EQ"] = 9] = "COMPARE_EQ";
+    OpCode[OpCode["COMPARE_NE"] = 10] = "COMPARE_NE";
+    OpCode[OpCode["COMPARE_LT"] = 11] = "COMPARE_LT";
+    OpCode[OpCode["COMPARE_GT"] = 12] = "COMPARE_GT";
+    OpCode[OpCode["COMPARE_LE"] = 13] = "COMPARE_LE";
+    OpCode[OpCode["COMPARE_GE"] = 14] = "COMPARE_GE";
+    // Logical operations
+    OpCode[OpCode["LOGICAL_AND"] = 15] = "LOGICAL_AND";
+    OpCode[OpCode["LOGICAL_OR"] = 16] = "LOGICAL_OR";
+    OpCode[OpCode["LOGICAL_NOT"] = 17] = "LOGICAL_NOT";
+    // Function calls
+    OpCode[OpCode["CALL_FUNCTION"] = 18] = "CALL_FUNCTION";
+    OpCode[OpCode["RETURN_VALUE"] = 19] = "RETURN_VALUE";
+    // Print
+    OpCode[OpCode["PRINT_ITEM"] = 20] = "PRINT_ITEM";
+    OpCode[OpCode["PRINT_NEWLINE"] = 21] = "PRINT_NEWLINE";
+})(OpCode || (exports.OpCode = OpCode = {}));
+//# sourceMappingURL=bytecode.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './token';
+export * from './ast';
+export * from './bytecode';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./token"), exports);
+__exportStar(require("./ast"), exports);
+__exportStar(require("./bytecode"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/token.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Token 类型定义
+ */
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare enum TokenType {
+    KEYWORD = 0,
+    IDENTIFIER = 1,
+    NUMBER = 2,
+    STRING = 3,
+    BOOLEAN = 4,
+    NONE = 5,
+    OPERATOR = 6,
+    LPAREN = 7,
+    RPAREN = 8,
+    LBRACKET = 9,
+    RBRACKET = 10,
+    LBRACE = 11,
+    RBRACE = 12,
+    ASSIGN = 13,
+    COLON = 14,
+    COMMA = 15,
+    DOT = 16,
+    AT = 17,
+    EOF = 18,
+    INDENT = 19,
+    DEDENT = 20,
+    NEWLINE = 21
+}
+//# sourceMappingURL=token.d.ts.map

package/dist/types/token.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    // Keywords
+    TokenType[TokenType["KEYWORD"] = 0] = "KEYWORD";
+    // Identifiers
+    TokenType[TokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
+    // Literals
+    TokenType[TokenType["NUMBER"] = 2] = "NUMBER";
+    TokenType[TokenType["STRING"] = 3] = "STRING";
+    TokenType[TokenType["BOOLEAN"] = 4] = "BOOLEAN";
+    TokenType[TokenType["NONE"] = 5] = "NONE";
+    // Operators
+    TokenType[TokenType["OPERATOR"] = 6] = "OPERATOR";
+    // Parentheses
+    TokenType[TokenType["LPAREN"] = 7] = "LPAREN";
+    TokenType[TokenType["RPAREN"] = 8] = "RPAREN";
+    TokenType[TokenType["LBRACKET"] = 9] = "LBRACKET";
+    TokenType[TokenType["RBRACKET"] = 10] = "RBRACKET";
+    TokenType[TokenType["LBRACE"] = 11] = "LBRACE";
+    TokenType[TokenType["RBRACE"] = 12] = "RBRACE";
+    // Assignment
+    TokenType[TokenType["ASSIGN"] = 13] = "ASSIGN";
+    // Colon
+    TokenType[TokenType["COLON"] = 14] = "COLON";
+    // Comma
+    TokenType[TokenType["COMMA"] = 15] = "COMMA";
+    TokenType[TokenType["DOT"] = 16] = "DOT";
+    TokenType[TokenType["AT"] = 17] = "AT";
+    // End of file
+    TokenType[TokenType["EOF"] = 18] = "EOF";
+    // Indentation
+    TokenType[TokenType["INDENT"] = 19] = "INDENT";
+    TokenType[TokenType["DEDENT"] = 20] = "DEDENT";
+    TokenType[TokenType["NEWLINE"] = 21] = "NEWLINE";
+})(TokenType || (exports.TokenType = TokenType = {}));
+//# sourceMappingURL=token.js.map

package/dist/vm/builtins.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function installBuiltins(this: VirtualMachine, scope: Scope): void;
+//# sourceMappingURL=builtins.d.ts.map

package/dist/vm/builtins.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installBuiltins = installBuiltins;
+const runtime_types_1 = require("./runtime-types");
+const value_utils_1 = require("./value-utils");
+function installBuiltins(scope) {
+    const builtins = new Map();
+    builtins.set('print', (...args) => {
+        let sep = ' ';
+        let end = '\n';
+        if (args.length > 0) {
+            const last = args[args.length - 1];
+            if (last && last.__kwargs__) {
+                const kwargs = last.__kwargs__;
+                sep = kwargs.sep !== undefined ? kwargs.sep : sep;
+                end = kwargs.end !== undefined ? kwargs.end : end;
+                args = args.slice(0, -1);
+            }
+        }
+        const output = args.map((a) => (0, value_utils_1.pyStr)(a)).join(sep) + end;
+        process.stdout.write(output);
+        return null;
+    });
+    builtins.set('len', (value) => {
+        if (typeof value === 'string' || Array.isArray(value))
+            return value.length;
+        if (value instanceof runtime_types_1.PyDict || value instanceof Set)
+            return value.size;
+        throw new runtime_types_1.PyException('TypeError', 'object has no len()');
+    });
+    builtins.set('range', (...args) => {
+        let start = 0;
+        let end = 0;
+        let step = 1;
+        if (args.length === 1) {
+            end = (0, value_utils_1.toNumber)(args[0]);
+        }
+        else if (args.length === 2) {
+            start = (0, value_utils_1.toNumber)(args[0]);
+            end = (0, value_utils_1.toNumber)(args[1]);
+        }
+        else if (args.length >= 3) {
+            start = (0, value_utils_1.toNumber)(args[0]);
+            end = (0, value_utils_1.toNumber)(args[1]);
+            step = (0, value_utils_1.toNumber)(args[2]);
+        }
+        const result = [];
+        if (step === 0)
+            throw new runtime_types_1.PyException('ValueError', 'range() arg 3 must not be zero');
+        if (step > 0) {
+            for (let i = start; i < end; i += step)
+                result.push(i);
+        }
+        else {
+            for (let i = start; i > end; i += step)
+                result.push(i);
+        }
+        return result;
+    });
+    const listFn = (value) => {
+        if (Array.isArray(value))
+            return [...value];
+        if (value instanceof Set)
+            return Array.from(value.values());
+        if (value && typeof value[Symbol.iterator] === 'function')
+            return Array.from(value);
+        return [];
+    };
+    listFn.__typeName__ = 'list';
+    builtins.set('list', listFn);
+    const tupleFn = (value) => {
+        const arr = Array.isArray(value) ? [...value] : value && typeof value[Symbol.iterator] === 'function' ? Array.from(value) : [];
+        arr.__tuple__ = true;
+        return arr;
+    };
+    tupleFn.__typeName__ = 'tuple';
+    builtins.set('tuple', tupleFn);
+    const setFn = (value) => {
+        if (value instanceof Set)
+            return new Set(value);
+        if (Array.isArray(value))
+            return new Set(value);
+        if (value && typeof value[Symbol.iterator] === 'function')
+            return new Set(Array.from(value));
+        return new Set();
+    };
+    setFn.__typeName__ = 'set';
+    builtins.set('set', setFn);
+    builtins.set('sum', (value) => {
+        if (value.some((v) => typeof v === 'bigint')) {
+            return value.reduce((acc, v) => acc + (0, value_utils_1.toBigIntValue)(v), 0n);
+        }
+        return value.reduce((acc, v) => acc + v, 0);
+    });
+    builtins.set('max', (...args) => {
+        const values = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        if (values.every((v) => (0, value_utils_1.isNumericLike)(v) && !(0, value_utils_1.isFloatLike)(v))) {
+            return values.reduce((acc, v) => ((0, value_utils_1.toBigIntValue)(v) > (0, value_utils_1.toBigIntValue)(acc) ? v : acc));
+        }
+        return Math.max(...values.map((v) => (0, value_utils_1.toNumber)(v)));
+    });
+    builtins.set('min', (...args) => {
+        const values = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        if (values.every((v) => (0, value_utils_1.isNumericLike)(v) && !(0, value_utils_1.isFloatLike)(v))) {
+            return values.reduce((acc, v) => ((0, value_utils_1.toBigIntValue)(v) < (0, value_utils_1.toBigIntValue)(acc) ? v : acc));
+        }
+        return Math.min(...values.map((v) => (0, value_utils_1.toNumber)(v)));
+    });
+    builtins.set('abs', (value) => {
+        if (typeof value === 'bigint')
+            return value < 0n ? -value : value;
+        return Math.abs((0, value_utils_1.toNumber)(value));
+    });
+    const roundHalfToEven = (input) => {
+        const floored = Math.floor(input);
+        const diff = input - floored;
+        const epsilon = 1e-12;
+        if (diff > 0.5 + epsilon)
+            return floored + 1;
+        if (diff < 0.5 - epsilon)
+            return floored;
+        return floored % 2 === 0 ? floored : floored + 1;
+    };
+    builtins.set('round', (value, digits) => {
+        if (digits === undefined)
+            return roundHalfToEven(value);
+        const factor = Math.pow(10, digits);
+        return roundHalfToEven(value * factor) / factor;
+    });
+    const intFn = (value) => {
+        if (typeof value === 'bigint')
+            return value;
+        const text = typeof value === 'string' ? value.trim() : null;
+        if (text && /^[-+]?\\d+$/.test(text)) {
+            const big = BigInt(text);
+            const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+            const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
+            if (big > maxSafe || big < minSafe) {
+                return big;
+            }
+        }
+        const result = parseInt(value, 10);
+        if (Number.isNaN(result))
+            throw new runtime_types_1.PyException('ValueError', 'Invalid integer');
+        const boxed = new Number(result);
+        boxed.__int__ = true;
+        return boxed;
+    };
+    intFn.__typeName__ = 'int';
+    builtins.set('int', intFn);
+    const floatFn = (value) => {
+        if (value === undefined)
+            return new Number(0);
+        if (value instanceof Number)
+            return new Number(value.valueOf());
+        if (typeof value === 'number')
+            return new Number(value);
+        if (typeof value === 'boolean')
+            return new Number(value ? 1 : 0);
+        if (typeof value === 'string') {
+            const text = value.trim();
+            if (text.length === 0)
+                throw new runtime_types_1.PyException('ValueError', 'Invalid float');
+            const lower = text.toLowerCase();
+            if (lower === 'nan' || lower === '+nan' || lower === '-nan')
+                return new Number(NaN);
+            if (lower === 'inf' || lower === '+inf' || lower === 'infinity' || lower === '+infinity')
+                return new Number(Infinity);
+            if (lower === '-inf' || lower === '-infinity')
+                return new Number(-Infinity);
+            const result = parseFloat(text);
+            if (Number.isNaN(result))
+                throw new runtime_types_1.PyException('ValueError', 'Invalid float');
+            return new Number(result);
+        }
+        const result = parseFloat(value);
+        if (Number.isNaN(result))
+            throw new runtime_types_1.PyException('ValueError', 'Invalid float');
+        return new Number(result);
+    };
+    floatFn.__typeName__ = 'float';
+    builtins.set('float', floatFn);
+    const strFn = (value) => (0, value_utils_1.pyStr)(value);
+    strFn.__typeName__ = 'str';
+    builtins.set('str', strFn);
+    const boolFn = (value) => this.isTruthy(value, scope);
+    boolFn.__typeName__ = 'bool';
+    builtins.set('bool', boolFn);
+    builtins.set('type', (value) => ({ __typeName__: (0, value_utils_1.pyTypeName)(value) }));
+    builtins.set('isinstance', (value, typeObj) => {
+        if (typeObj && typeObj.__typeName__) {
+            return (0, value_utils_1.pyTypeName)(value) === typeObj.__typeName__;
+        }
+        return false;
+    });
+    builtins.set('enumerate', (iterable) => {
+        const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
+        return arr.map((v, i) => {
+            const tup = [i, v];
+            tup.__tuple__ = true;
+            return tup;
+        });
+    });
+    builtins.set('zip', (...iterables) => {
+        const arrays = iterables.map((it) => (Array.isArray(it) ? it : Array.from(it)));
+        const length = Math.min(...arrays.map((a) => a.length));
+        const result = [];
+        for (let i = 0; i < length; i++) {
+            const tup = arrays.map((a) => a[i]);
+            tup.__tuple__ = true;
+            result.push(tup);
+        }
+        return result;
+    });
+    builtins.set('sorted', (iterable) => {
+        const arr = Array.isArray(iterable) ? [...iterable] : Array.from(iterable);
+        if (arr.every((v) => (0, value_utils_1.isNumericLike)(v))) {
+            return arr.sort((a, b) => (0, value_utils_1.toNumber)(a) - (0, value_utils_1.toNumber)(b));
+        }
+        return arr.sort();
+    });
+    builtins.set('reversed', (iterable) => {
+        const arr = Array.isArray(iterable) ? [...iterable] : Array.from(iterable);
+        return arr.reverse();
+    });
+    builtins.set('map', (fn, iterable) => {
+        const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
+        return arr.map((value) => this.callFunction(fn, [value], scope));
+    });
+    builtins.set('filter', (fn, iterable) => {
+        const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
+        return arr.filter((value) => this.isTruthy(this.callFunction(fn, [value], scope), scope));
+    });
+    builtins.set('next', (iterable) => {
+        if (iterable instanceof runtime_types_1.PyGenerator) {
+            return iterable.next();
+        }
+        if (iterable && typeof iterable.next === 'function') {
+            const result = iterable.next();
+            if (result.done)
+                throw new runtime_types_1.PyException('StopIteration', 'StopIteration');
+            return result.value;
+        }
+        throw new runtime_types_1.PyException('TypeError', 'object is not an iterator');
+    });
+    builtins.set('open', (path, mode = 'r') => {
+        const file = new runtime_types_1.PyFile(String(path), String(mode));
+        try {
+            file.open();
+        }
+        catch (err) {
+            throw new runtime_types_1.PyException('FileNotFoundError', 'File not found');
+        }
+        return file;
+    });
+    const exceptionClass = (name, base) => {
+        const klass = new runtime_types_1.PyClass(name, base ? [base] : [], new Map(), true);
+        return klass;
+    };
+    const ExceptionBase = exceptionClass('Exception');
+    builtins.set('Exception', ExceptionBase);
+    builtins.set('AssertionError', exceptionClass('AssertionError', ExceptionBase));
+    builtins.set('ZeroDivisionError', exceptionClass('ZeroDivisionError', ExceptionBase));
+    builtins.set('ValueError', exceptionClass('ValueError', ExceptionBase));
+    builtins.set('TypeError', exceptionClass('TypeError', ExceptionBase));
+    builtins.set('FileNotFoundError', exceptionClass('FileNotFoundError', ExceptionBase));
+    scope.values = new Map([...builtins.entries()]);
+}
+//# sourceMappingURL=builtins.js.map

package/dist/vm/callable.d.ts

@@ -0,0 +1,8 @@
+import type { VirtualMachine } from './vm';
+import { Scope } from './runtime-types';
+export declare function callFunction(this: VirtualMachine, func: any, args: any[], scope: Scope, kwargs?: Record<string, any>): any;
+export declare function containsYield(this: VirtualMachine, body: any[]): boolean;
+export declare function evaluateComprehension(this: VirtualMachine, node: any, scope: Scope, emit: () => void): void;
+export declare function generateComprehension(this: VirtualMachine, node: any, scope: Scope, valueFactory: () => any): Generator<any, any, any>;
+export declare function expressionHasYield(this: VirtualMachine, node: any): boolean;
+//# sourceMappingURL=callable.d.ts.map

package/dist/vm/callable.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFunction = callFunction;
+exports.containsYield = containsYield;
+exports.evaluateComprehension = evaluateComprehension;
+exports.generateComprehension = generateComprehension;
+exports.expressionHasYield = expressionHasYield;
+const types_1 = require("../types");
+const runtime_types_1 = require("./runtime-types");
+function callFunction(func, args, scope, kwargs = {}) {
+    if (!kwargs) {
+        kwargs = {};
+    }
+    if (func instanceof runtime_types_1.PyFunction) {
+        const callScope = new runtime_types_1.Scope(func.closure);
+        for (const param of func.params) {
+            if (param.type === 'Param') {
+                let argValue;
+                if (args.length > 0) {
+                    argValue = args.shift();
+                }
+                else if (param.name in kwargs) {
+                    argValue = kwargs[param.name];
+                    delete kwargs[param.name];
+                }
+                else if (param.defaultEvaluated !== undefined) {
+                    argValue = param.defaultEvaluated;
+                }
+                else if (param.defaultValue) {
+                    argValue = this.evaluateExpression(param.defaultValue, scope);
+                }
+                else {
+                    argValue = null;
+                }
+                callScope.set(param.name, argValue);
+            }
+            else if (param.type === 'VarArg') {
+                const varArgs = [...args];
+                varArgs.__tuple__ = true;
+                callScope.set(param.name, varArgs);
+                args = [];
+            }
+            else if (param.type === 'KwArg') {
+                const kwDict = new runtime_types_1.PyDict();
+                for (const [key, value] of Object.entries(kwargs)) {
+                    kwDict.set(key, value);
+                }
+                callScope.set(param.name, kwDict);
+                kwargs = {};
+            }
+        }
+        try {
+            if (func.isGenerator) {
+                const iterator = this.executeBlockGenerator(func.body, callScope);
+                return new runtime_types_1.PyGenerator(iterator);
+            }
+            const result = this.executeBlock(func.body, callScope);
+            return result;
+        }
+        catch (err) {
+            if (err instanceof runtime_types_1.ReturnSignal)
+                return err.value;
+            throw err;
+        }
+    }
+    if (func instanceof runtime_types_1.PyClass) {
+        const instance = new runtime_types_1.PyInstance(func);
+        if (func.isException && args.length > 0) {
+            instance.attributes.set('message', args[0]);
+        }
+        const init = this.findClassAttribute(func, '__init__');
+        if (init instanceof runtime_types_1.PyFunction) {
+            this.callFunction(init, [instance, ...args], scope, kwargs);
+        }
+        return instance;
+    }
+    if (typeof func === 'function') {
+        if (Object.keys(kwargs).length > 0) {
+            return func(...args, { __kwargs__: kwargs });
+        }
+        return func(...args);
+    }
+    throw new runtime_types_1.PyException('TypeError', 'object is not callable');
+}
+function containsYield(body) {
+    for (const stmt of body) {
+        if (stmt.type === types_1.ASTNodeType.YIELD)
+            return true;
+        if (stmt.expression && this.expressionHasYield(stmt.expression))
+            return true;
+        if (stmt.value && this.expressionHasYield(stmt.value))
+            return true;
+        if (stmt.body && Array.isArray(stmt.body) && this.containsYield(stmt.body))
+            return true;
+    }
+    return false;
+}
+function evaluateComprehension(node, scope, emit) {
+    const clauses = node.clauses || [];
+    const walk = (index) => {
+        if (index >= clauses.length) {
+            emit();
+            return;
+        }
+        const clause = clauses[index];
+        const iterable = this.evaluateExpression(clause.iter, scope);
+        const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+        for (const item of items) {
+            this.assignTarget(clause.target, item, scope);
+            const passes = clause.ifs.every((cond) => this.isTruthy(this.evaluateExpression(cond, scope), scope));
+            if (passes) {
+                walk(index + 1);
+            }
+        }
+    };
+    walk(0);
+}
+function* generateComprehension(node, scope, valueFactory) {
+    const clauses = node.clauses || [];
+    const walk = (index) => {
+        const self = this;
+        return (function* () {
+            if (index >= clauses.length) {
+                yield valueFactory();
+                return;
+            }
+            const clause = clauses[index];
+            const iterable = self.evaluateExpression(clause.iter, scope);
+            const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+            for (const item of items) {
+                self.assignTarget(clause.target, item, scope);
+                const passes = clause.ifs.every((cond) => self.isTruthy(self.evaluateExpression(cond, scope), scope));
+                if (passes) {
+                    yield* walk(index + 1);
+                }
+            }
+        })();
+    };
+    yield* walk(0);
+    return null;
+}
+function expressionHasYield(node) {
+    if (!node)
+        return false;
+    if (node.type === types_1.ASTNodeType.YIELD)
+        return true;
+    for (const key of Object.keys(node)) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+            if (value.some((item) => item && typeof item === 'object' && this.expressionHasYield(item))) {
+                return true;
+            }
+        }
+        else if (value && typeof value === 'object') {
+            if (this.expressionHasYield(value))
+                return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=callable.js.map

package/dist/vm/execution.d.ts

@@ -0,0 +1,15 @@
+import type { VirtualMachine } from './vm';
+import { ByteCode } from '../types';
+import { Scope } from './runtime-types';
+export declare function execute(this: VirtualMachine, bytecode: ByteCode): any;
+export declare function executeBlock(this: VirtualMachine, body: any[], scope: Scope): any;
+export declare function iterableToArray(this: VirtualMachine, iterable: any): any[];
+export declare function matchValueEquals(left: any, right: any): boolean;
+export declare function matchPattern(this: VirtualMachine, node: any, value: any, scope: Scope): {
+    matched: boolean;
+    bindings: Map<string, any>;
+};
+export declare function applyBindings(bindings: Map<string, any>, scope: Scope): void;
+export declare function executeBlockGenerator(this: VirtualMachine, body: any[], scope: Scope): Generator<any, any, any>;
+export declare function executeStatementGenerator(this: VirtualMachine, node: any, scope: Scope): Generator<any, any, any>;
+//# sourceMappingURL=execution.d.ts.map