@lewin671/python-vm 0.1.0 → 0.1.1

package/src/vm/statements.ts

@@ -1,358 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { ASTNodeType } from '../types';
-import { BreakSignal, ContinueSignal, PyClass, PyException, PyFunction, PyInstance, ReturnSignal, Scope } from './runtime-types';
-import { PyDict } from './runtime-types';
-
-export function executeStatement(this: VirtualMachine, node: any, scope: Scope): any {
-  switch (node.type) {
-    case ASTNodeType.EXPRESSION_STATEMENT:
-      return this.evaluateExpression(node.expression, scope);
-    case ASTNodeType.IMPORT_STATEMENT: {
-      for (const entry of node.names) {
-        const module = this.importModule(entry.name, scope);
-        const bindingName = entry.alias || entry.name.split('.')[0];
-        scope.set(bindingName, module);
-      }
-      return null;
-    }
-    case ASTNodeType.ASSIGNMENT: {
-      const value = this.evaluateExpression(node.value, scope);
-      for (const target of node.targets) {
-        this.assignTarget(target, value, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.AUG_ASSIGNMENT: {
-      const current = this.evaluateExpression(node.target, scope);
-      const value = this.evaluateExpression(node.value, scope);
-      const result = this.applyBinary(node.operator.slice(0, -1), current, value);
-      this.assignTarget(node.target, result, scope);
-      return null;
-    }
-    case ASTNodeType.IF_STATEMENT: {
-      if (this.isTruthy(this.evaluateExpression(node.test, scope), scope)) {
-        return this.executeBlock(node.body, scope);
-      }
-      for (const branch of node.elifs) {
-        if (this.isTruthy(this.evaluateExpression(branch.test, scope), scope)) {
-          return this.executeBlock(branch.body, scope);
-        }
-      }
-      if (node.orelse?.length) {
-        return this.executeBlock(node.orelse, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.WHILE_STATEMENT: {
-      while (this.isTruthy(this.evaluateExpression(node.test, scope), scope)) {
-        try {
-          this.executeBlock(node.body, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal) break;
-          if (err instanceof ContinueSignal) continue;
-          throw err;
-        }
-      }
-      return null;
-    }
-    case ASTNodeType.FOR_STATEMENT: {
-      const iterable = this.evaluateExpression(node.iter, scope);
-      const items = this.iterableToArray(iterable);
-      for (const item of items) {
-        this.assignTarget(node.target, item, scope);
-        try {
-          this.executeBlock(node.body, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal) break;
-          if (err instanceof ContinueSignal) continue;
-          throw err;
-        }
-      }
-      return null;
-    }
-    case ASTNodeType.MATCH_STATEMENT: {
-      const subject = this.evaluateExpression(node.subject, scope);
-      for (const matchCase of node.cases) {
-        const result = this.matchPattern(matchCase.pattern, subject, scope);
-        if (!result.matched) continue;
-        if (matchCase.guard) {
-          const guardScope = new Scope(scope);
-          this.applyBindings(result.bindings, guardScope);
-          if (!this.isTruthy(this.evaluateExpression(matchCase.guard, guardScope), guardScope)) continue;
-        }
-        this.applyBindings(result.bindings, scope);
-        return this.executeBlock(matchCase.body, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.FUNCTION_DEF: {
-      const params = (node.params || []).map((param: any) => {
-        if (param.type === 'Param' && param.defaultValue) {
-          return { ...param, defaultEvaluated: this.evaluateExpression(param.defaultValue, scope) };
-        }
-        return param;
-      });
-      const fn = new PyFunction(node.name, params, node.body, scope, this.containsYield(node.body));
-      scope.set(node.name, fn);
-      if (node.decorators && node.decorators.length > 0) {
-        let decorated: any = fn;
-        for (const decorator of node.decorators.reverse()) {
-          const decFn = this.evaluateExpression(decorator, scope);
-          decorated = this.callFunction(decFn, [decorated], scope);
-        }
-        scope.set(node.name, decorated);
-      }
-      return null;
-    }
-    case ASTNodeType.CLASS_DEF: {
-      const bases = node.bases?.map((b: any) => this.evaluateExpression(b, scope)) || [];
-      const classScope = new Scope(scope);
-      this.executeBlock(node.body, classScope);
-      const attributes = new Map(classScope.values.entries());
-      const isException = bases.some((b: any) => b instanceof PyClass && b.isException);
-      const klass = new PyClass(node.name, bases, attributes, isException);
-      scope.set(node.name, klass);
-      if (node.decorators && node.decorators.length > 0) {
-        let decorated: any = klass;
-        for (const decorator of node.decorators.reverse()) {
-          const decFn = this.evaluateExpression(decorator, scope);
-          decorated = this.callFunction(decFn, [decorated], scope);
-        }
-        scope.set(node.name, decorated);
-      }
-      return null;
-    }
-    case ASTNodeType.RETURN_STATEMENT:
-      throw new ReturnSignal(node.value ? this.evaluateExpression(node.value, scope) : null);
-    case ASTNodeType.BREAK_STATEMENT:
-      throw new BreakSignal();
-    case ASTNodeType.CONTINUE_STATEMENT:
-      throw new ContinueSignal();
-    case ASTNodeType.PASS_STATEMENT:
-      return null;
-    case ASTNodeType.ASSERT_STATEMENT: {
-      const test = this.evaluateExpression(node.test, scope);
-      if (!this.isTruthy(test, scope)) {
-        const message = node.message ? this.evaluateExpression(node.message, scope) : 'Assertion failed';
-        throw new PyException('AssertionError', String(message));
-      }
-      return null;
-    }
-    case ASTNodeType.RAISE_STATEMENT: {
-      const exc = node.exception ? this.evaluateExpression(node.exception, scope) : null;
-      if (exc instanceof PyException) throw exc;
-      if (exc instanceof PyInstance && exc.klass.isException) {
-        const message = exc.attributes.get('message');
-        throw new PyException(exc.klass.name, message ? String(message) : exc.klass.name, exc);
-      }
-      if (exc instanceof PyClass && exc.isException) {
-        throw new PyException(exc.name, exc.name);
-      }
-      throw new PyException('Exception', exc ? String(exc) : 'Exception');
-    }
-    case ASTNodeType.TRY_STATEMENT: {
-      try {
-        this.executeBlock(node.body, scope);
-      } catch (err) {
-        let handled = false;
-        for (const handler of node.handlers) {
-          if (!handler.exceptionType) {
-            handled = true;
-          } else if (err instanceof PyException) {
-            const expected = this.evaluateExpression(handler.exceptionType, scope);
-            if (expected instanceof PyClass && expected.isException && err.pyType === expected.name) {
-              handled = true;
-            } else if (expected instanceof PyInstance && expected.klass.isException && err.pyType === expected.klass.name) {
-              handled = true;
-            }
-          }
-          if (handled) {
-            if (handler.name) {
-              scope.set(handler.name, err instanceof PyException ? err : new PyException('Exception', String(err)));
-            }
-            this.executeBlock(handler.body, scope);
-            break;
-          }
-        }
-        if (!handled) throw err;
-      } finally {
-        if (node.finalbody?.length) {
-          this.executeBlock(node.finalbody, scope);
-        }
-      }
-      if (node.orelse?.length) {
-        this.executeBlock(node.orelse, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.WITH_STATEMENT: {
-      for (const item of node.items) {
-        const ctx = this.evaluateExpression(item.context, scope);
-        const enter = this.getAttribute(ctx, '__enter__', scope);
-        const exit = this.getAttribute(ctx, '__exit__', scope);
-        const value = this.callFunction(enter, [], scope);
-        if (item.target) {
-          this.assignTarget(item.target, value, scope);
-        }
-        try {
-          this.executeBlock(node.body, scope);
-        } catch (err) {
-          this.callFunction(exit, [err], scope);
-          throw err;
-        }
-        this.callFunction(exit, [null, null, null], scope);
-      }
-      return null;
-    }
-    case ASTNodeType.GLOBAL_STATEMENT:
-      for (const name of node.names) scope.globals.add(name);
-      return null;
-    case ASTNodeType.NONLOCAL_STATEMENT:
-      for (const name of node.names) scope.nonlocals.add(name);
-      return null;
-    case ASTNodeType.DELETE_STATEMENT:
-      this.deleteTarget(node.target, scope);
-      return null;
-    default:
-      throw new Error(`Unsupported statement type: ${node.type}`);
-  }
-}
-
-export function assignTarget(this: VirtualMachine, target: any, value: any, scope: Scope) {
-  if (target.type === ASTNodeType.IDENTIFIER) {
-    scope.set(target.name, value);
-    return;
-  }
-  if (target.type === ASTNodeType.ATTRIBUTE) {
-    const obj = this.evaluateExpression(target.object, scope);
-    this.setAttribute(obj, target.name, value);
-    return;
-  }
-  if (target.type === ASTNodeType.SUBSCRIPT) {
-    const obj = this.evaluateExpression(target.object, scope);
-    let index: any;
-    if (target.index && target.index.type === ASTNodeType.SLICE) {
-      index = {
-        type: ASTNodeType.SLICE,
-        start: target.index.start ? this.evaluateExpression(target.index.start, scope) : null,
-        end: target.index.end ? this.evaluateExpression(target.index.end, scope) : null,
-        step: target.index.step ? this.evaluateExpression(target.index.step, scope) : null
-      };
-    } else {
-      index = this.evaluateExpression(target.index, scope);
-    }
-    if (Array.isArray(obj)) {
-      if (index && index.type === ASTNodeType.SLICE) {
-        const start = index.start !== null ? index.start : null;
-        const end = index.end !== null ? index.end : null;
-        const step = index.step !== null ? index.step : null;
-        const stepValue = step !== null && step !== undefined ? step : 1;
-        const values = this.toIterableArray(value);
-        if (stepValue === 1) {
-          const bounds = this.computeSliceBounds(obj.length, start, end, stepValue);
-          obj.splice(bounds.start, bounds.end - bounds.start, ...values);
-        } else {
-          const indices = this.computeSliceIndices(obj.length, start, end, stepValue);
-          if (values.length !== indices.length) {
-            throw new PyException(
-              'ValueError',
-              `attempt to assign sequence of size ${values.length} to extended slice of size ${indices.length}`
-            );
-          }
-          for (let i = 0; i < indices.length; i++) {
-            obj[indices[i]] = values[i];
-          }
-        }
-      } else {
-        obj[index] = value;
-      }
-      return;
-    }
-    if (obj instanceof PyDict) {
-      obj.set(index, value);
-      return;
-    }
-    throw new PyException('TypeError', 'unsupported subscript assignment');
-  }
-  if (target.type === ASTNodeType.TUPLE_LITERAL || target.type === ASTNodeType.LIST_LITERAL) {
-    const elements = target.elements;
-    const unpackValue = this.toIterableArray(value);
-    const starIndex = elements.findIndex((el: any) => el.type === ASTNodeType.STARRED);
-    if (starIndex === -1) {
-      for (let i = 0; i < elements.length; i++) {
-        this.assignTarget(elements[i], unpackValue[i], scope);
-      }
-      return;
-    }
-    const prefixCount = starIndex;
-    const suffixCount = elements.length - starIndex - 1;
-    if (unpackValue.length < prefixCount + suffixCount) {
-      throw new PyException('ValueError', 'not enough values to unpack');
-    }
-    for (let i = 0; i < prefixCount; i++) {
-      this.assignTarget(elements[i], unpackValue[i], scope);
-    }
-    const starTarget = elements[starIndex];
-    const middle = unpackValue.slice(prefixCount, unpackValue.length - suffixCount);
-    this.assignTarget(starTarget.target, middle, scope);
-    for (let i = 0; i < suffixCount; i++) {
-      const valueIndex = unpackValue.length - suffixCount + i;
-      const elementIndex = starIndex + 1 + i;
-      this.assignTarget(elements[elementIndex], unpackValue[valueIndex], scope);
-    }
-    return;
-  }
-  throw new PyException('TypeError', 'invalid assignment target');
-}
-
-export function toIterableArray(this: VirtualMachine, value: any): any[] {
-  if (Array.isArray(value)) return value;
-  if (value && typeof value[Symbol.iterator] === 'function') {
-    return Array.from(value);
-  }
-  throw new PyException('TypeError', 'cannot unpack non-iterable');
-}
-
-export function deleteTarget(this: VirtualMachine, target: any, scope: Scope) {
-  if (target.type === ASTNodeType.SUBSCRIPT) {
-    const obj = this.evaluateExpression(target.object, scope);
-    let index: any;
-    if (target.index && target.index.type === ASTNodeType.SLICE) {
-      index = {
-        type: ASTNodeType.SLICE,
-        start: target.index.start ? this.evaluateExpression(target.index.start, scope) : null,
-        end: target.index.end ? this.evaluateExpression(target.index.end, scope) : null,
-        step: target.index.step ? this.evaluateExpression(target.index.step, scope) : null
-      };
-    } else {
-      index = this.evaluateExpression(target.index, scope);
-    }
-    if (Array.isArray(obj)) {
-      if (index && index.type === ASTNodeType.SLICE) {
-        const start = index.start !== null ? index.start : null;
-        const end = index.end !== null ? index.end : null;
-        const step = index.step !== null ? index.step : null;
-        const stepValue = step !== null && step !== undefined ? step : 1;
-        if (stepValue === 1) {
-          const bounds = this.computeSliceBounds(obj.length, start, end, stepValue);
-          obj.splice(bounds.start, bounds.end - bounds.start);
-        } else {
-          const indices = this.computeSliceIndices(obj.length, start, end, stepValue);
-          indices.sort((a, b) => b - a);
-          for (const idx of indices) {
-            obj.splice(idx, 1);
-          }
-        }
-      } else {
-        obj.splice(index, 1);
-      }
-      return;
-    }
-    if (obj instanceof PyDict) {
-      obj.delete(index);
-      return;
-    }
-    throw new PyException('TypeError', 'unsupported delete target');
-  }
-  throw new PyException('TypeError', 'unsupported delete target');
-}

package/src/vm/truthy.ts

@@ -1,36 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { PyDict, PyException, PyInstance, Scope } from './runtime-types';
-import { isNumericLike, toNumber } from './value-utils';
-
-export function isTruthy(this: VirtualMachine, value: any, scope: Scope): boolean {
-  if (value === null || value === undefined) return false;
-  if (value instanceof Number) return value.valueOf() !== 0;
-  if (typeof value === 'boolean') return value;
-  if (typeof value === 'number') return value !== 0;
-  if (typeof value === 'bigint') return value !== 0n;
-  if (typeof value === 'string') return value.length > 0;
-  if (Array.isArray(value)) return value.length > 0;
-  if (value instanceof PyDict) return value.size > 0;
-  if (value instanceof Set) return value.size > 0;
-  if (value instanceof PyInstance) {
-    const boolAttr = this.findClassAttribute(value.klass, '__bool__');
-    if (boolAttr !== undefined) {
-      const bound = this.getAttribute(value, '__bool__', scope);
-      const result = typeof bound === 'function' ? bound() : bound;
-      if (typeof result !== 'boolean') {
-        throw new PyException('TypeError', '__bool__ should return bool');
-      }
-      return result;
-    }
-    const lenAttr = this.findClassAttribute(value.klass, '__len__');
-    if (lenAttr !== undefined) {
-      const bound = this.getAttribute(value, '__len__', scope);
-      const result = typeof bound === 'function' ? bound() : bound;
-      if (!isNumericLike(result)) {
-        throw new PyException('TypeError', '__len__ should return int');
-      }
-      return toNumber(result) !== 0;
-    }
-  }
-  return true;
-}

package/src/vm/value-utils.ts

@@ -1,173 +0,0 @@
-import { PyClass, PyDict, PyException, PyFunction, PyInstance } from './runtime-types';
-
-export const isPyNone = (value: any) => value === null;
-
-export const isBigInt = (value: any): value is bigint => typeof value === 'bigint';
-export const isIntObject = (value: any): boolean => value instanceof Number && (value as any).__int__ === true;
-export const isFloatObject = (value: any): boolean => value instanceof Number && !isIntObject(value);
-export const isFloatLike = (value: any): boolean => isFloatObject(value) || (typeof value === 'number' && !Number.isInteger(value));
-export const isIntLike = (value: any): boolean =>
-  isBigInt(value) ||
-  value === true ||
-  value === false ||
-  (typeof value === 'number' && Number.isInteger(value)) ||
-  isIntObject(value);
-export const isNumericLike = (value: any): boolean =>
-  isBigInt(value) || typeof value === 'number' || value instanceof Number || typeof value === 'boolean';
-export const toNumber = (value: any): number => {
-  if (value instanceof Number) return value.valueOf();
-  if (typeof value === 'boolean') return value ? 1 : 0;
-  if (typeof value === 'bigint') return Number(value);
-  return value;
-};
-export const toBigIntValue = (value: any): bigint => {
-  if (typeof value === 'bigint') return value;
-  if (value instanceof Number) return BigInt(Math.trunc(value.valueOf()));
-  if (typeof value === 'number') return BigInt(value);
-  return BigInt(value);
-};
-export const shouldUseBigInt = (left: any, right: any): boolean =>
-  (isBigInt(left) || isBigInt(right)) && !isFloatLike(left) && !isFloatLike(right);
-export const numericEquals = (left: any, right: any): boolean => {
-  if (isNumericLike(left) && isNumericLike(right)) {
-    if (isFloatLike(left) || isFloatLike(right)) {
-      const leftNum = toNumber(left);
-      const rightNum = toNumber(right);
-      return !Number.isNaN(leftNum) && !Number.isNaN(rightNum) && leftNum === rightNum;
-    }
-    return toBigIntValue(left) === toBigIntValue(right);
-  }
-  return left === right;
-};
-export const numericCompare = (
-  left: any,
-  right: any
-): { kind: 'float' | 'int'; left: number | bigint; right: number | bigint } | null => {
-  if (!isNumericLike(left) || !isNumericLike(right)) return null;
-  if (isFloatLike(left) || isFloatLike(right)) {
-    return { kind: 'float', left: toNumber(left), right: toNumber(right) };
-  }
-  return { kind: 'int', left: toBigIntValue(left), right: toBigIntValue(right) };
-};
-
-export const bigIntFloorDiv = (left: bigint, right: bigint): bigint => {
-  const quotient = left / right;
-  if (left % right === 0n) return quotient;
-  if ((left < 0n) !== (right < 0n)) return quotient - 1n;
-  return quotient;
-};
-
-export const pyTypeName = (value: any): string => {
-  if (value === null) return 'NoneType';
-  if (isBigInt(value)) return 'int';
-  if (isIntObject(value)) return 'int';
-  if (value instanceof Number) return 'float';
-  if (typeof value === 'boolean') return 'bool';
-  if (typeof value === 'number') return Number.isInteger(value) ? 'int' : 'float';
-  if (typeof value === 'string') return 'str';
-  if (Array.isArray(value)) return (value as any).__tuple__ ? 'tuple' : 'list';
-  if (value instanceof Set) return 'set';
-  if (value instanceof PyDict) return 'dict';
-  if (value instanceof PyFunction) return 'function';
-  if (value instanceof PyClass) return 'type';
-  if (value instanceof PyInstance) return value.klass.name;
-  return typeof value;
-};
-
-export const pyRepr = (value: any): string => {
-  if (value === null) return 'None';
-  if (value instanceof Number) {
-    const num = value.valueOf();
-    if (Number.isNaN(num)) return 'nan';
-    if (num === Infinity) return 'inf';
-    if (num === -Infinity) return '-inf';
-    if (isIntObject(value)) return String(num);
-    if (Object.is(num, -0)) return '-0.0';
-    return Number.isInteger(num) ? `${num}.0` : String(num);
-  }
-  if (typeof value === 'boolean') return value ? 'True' : 'False';
-  if (typeof value === 'number') return Number.isNaN(value) ? 'nan' : String(value);
-  if (typeof value === 'bigint') return value.toString();
-  if (value && value.__complex__) {
-    const sign = value.im >= 0 ? '+' : '-';
-    const imag = Math.abs(value.im);
-    return `(${value.re}${sign}${imag}j)`;
-  }
-  if (typeof value === 'string') return `'${value.replace(/'/g, "\\'")}'`;
-  if (Array.isArray(value)) {
-    const items = value.map((v: any) => pyRepr(v)).join(', ');
-    if ((value as any).__tuple__) {
-      if (value.length === 1) return `(${items},)`;
-      return `(${items})`;
-    }
-    return `[${items}]`;
-  }
-  if (value instanceof Set) {
-    const items = Array.from(value.values()).map((v) => pyRepr(v)).join(', ');
-    return `{${items}}`;
-  }
-  if (value instanceof PyDict) {
-    const items = Array.from(value.entries()).map(([k, v]) => `${pyRepr(k)}: ${pyRepr(v)}`).join(', ');
-    return `{${items}}`;
-  }
-  if (value instanceof PyFunction) return `<function ${value.name}>`;
-  if (value instanceof PyClass) return `<class '${value.name}'>`;
-  if (value instanceof PyInstance) return `<${value.klass.name} object>`;
-  return String(value);
-};
-
-export const pyStr = (value: any): string => {
-  if (typeof value === 'string') return value;
-  if (value && value.__complex__) return pyRepr(value);
-  if (value && value.__typeName__) return `<class '${value.__typeName__}'>`;
-  if (value instanceof PyException) return value.message;
-  return pyRepr(value);
-};
-
-export const isComplex = (value: any) => value && value.__complex__;
-
-export const toComplex = (value: any) => {
-  if (isComplex(value)) return value;
-  if (isNumericLike(value)) return { __complex__: true, re: toNumber(value), im: 0 };
-  return { __complex__: true, re: 0, im: 0 };
-};
-
-export const pythonModulo = (left: any, right: any) => {
-  if (shouldUseBigInt(left, right)) {
-    const leftNum = toBigIntValue(left);
-    const rightNum = toBigIntValue(right);
-    if (rightNum === 0n) throw new PyException('ZeroDivisionError', 'division by zero');
-    const remainder = leftNum % rightNum;
-    const adjust = remainder !== 0n && (leftNum < 0n) !== (rightNum < 0n);
-    const quotient = leftNum / rightNum - (adjust ? 1n : 0n);
-    return leftNum - quotient * rightNum;
-  }
-  const leftNum = toNumber(left);
-  const rightNum = toNumber(right);
-  if (rightNum === 0) throw new PyException('ZeroDivisionError', 'division by zero');
-  const quotient = Math.floor(leftNum / rightNum);
-  const result = leftNum - quotient * rightNum;
-  if (isFloatObject(left) || isFloatObject(right)) {
-    return new Number(result);
-  }
-  return result;
-};
-
-export const parseStringToken = (tokenValue: string): { value: string; isFString: boolean } => {
-  let raw = tokenValue;
-  let isFString = false;
-  if (raw.startsWith('f') || raw.startsWith('F')) {
-    isFString = true;
-    raw = raw.slice(1);
-  }
-  const quote = raw[0];
-  if (raw.startsWith(quote.repeat(3))) {
-    const inner = raw.slice(3, -3);
-    return { value: inner, isFString };
-  }
-  const inner = raw.slice(1, -1);
-  return {
-    value: inner.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"').replace(/\\'/g, "'"),
-    isFString,
-  };
-};

package/src/vm/vm.ts

@@ -1,80 +0,0 @@
-import { installBuiltins } from './builtins';
-import { callFunction, containsYield, evaluateComprehension, expressionHasYield, generateComprehension } from './callable';
-import { execute, executeBlock, executeBlockGenerator, executeStatementGenerator, iterableToArray, matchPattern, matchValueEquals, applyBindings } from './execution';
-import { evaluateExpressionGenerator } from './expression-generator';
-import { createAsyncioModule, importModule, loadModuleFromFile, resolveModulePath } from './imports';
-import {
-  applyFormatSpec,
-  applyWidth,
-  contains,
-  evaluateExpression,
-  evaluateExpressionString,
-  executeExpressionInline,
-  splitFormatSpec,
-} from './expressions';
-import { assignTarget, deleteTarget, executeStatement, toIterableArray } from './statements';
-import {
-  applyBinary,
-  computeSliceBounds,
-  computeSliceIndices,
-  findClassAttribute,
-  formatPercent,
-  getAttribute,
-  getSubscript,
-  normalizeSliceStep,
-  setAttribute,
-} from './operations';
-import { isTruthy } from './truthy';
-import { Scope } from './runtime-types';
-
-export class VirtualMachine {
-  public moduleCache: Map<string, any> = new Map();
-  public moduleSearchPaths: string[];
-
-  constructor(moduleSearchPaths: string[] = [process.cwd()]) {
-    this.moduleSearchPaths = moduleSearchPaths;
-  }
-
-  execute = execute;
-  installBuiltins = installBuiltins;
-  importModule = importModule;
-  createAsyncioModule = createAsyncioModule;
-  loadModuleFromFile = loadModuleFromFile;
-  resolveModulePath = resolveModulePath;
-  executeBlock = executeBlock;
-  iterableToArray = iterableToArray;
-  matchValueEquals = matchValueEquals;
-  matchPattern = matchPattern;
-  applyBindings = applyBindings;
-  executeBlockGenerator = executeBlockGenerator;
-  executeStatementGenerator = executeStatementGenerator;
-  evaluateExpressionGenerator = evaluateExpressionGenerator;
-  executeStatement = executeStatement;
-  assignTarget = assignTarget;
-  toIterableArray = toIterableArray;
-  deleteTarget = deleteTarget;
-  evaluateExpression = evaluateExpression;
-  evaluateExpressionString = evaluateExpressionString;
-  executeExpressionInline = executeExpressionInline;
-  applyFormatSpec = applyFormatSpec;
-  splitFormatSpec = splitFormatSpec;
-  applyWidth = applyWidth;
-  contains = contains;
-  isTruthy = isTruthy;
-  applyBinary = applyBinary;
-  formatPercent = formatPercent;
-  getSubscript = getSubscript;
-  computeSliceBounds = computeSliceBounds;
-  computeSliceIndices = computeSliceIndices;
-  normalizeSliceStep = normalizeSliceStep;
-  getAttribute = getAttribute;
-  setAttribute = setAttribute;
-  findClassAttribute = findClassAttribute;
-  callFunction = callFunction;
-  containsYield = containsYield;
-  evaluateComprehension = evaluateComprehension;
-  generateComprehension = generateComprehension;
-  expressionHasYield = expressionHasYield;
-}
-
-export * from './runtime-types';