@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/host-defined/inspect.mts

@@ -0,0 +1,246 @@
+import {
+  JSStringValue, ObjectValue, Value, wellKnownSymbols, BooleanValue, NumberValue, BigIntValue, SymbolValue, UndefinedValue,
+} from '../value.mts';
+import {
+  Call, IsArray, Get, LengthOfArrayLike,
+  EscapeRegExpPattern, R, Realm, type BuiltinFunctionObject,
+} from '../abstract-ops/all.mts';
+import { Completion, X } from '../completion.mts';
+import { isRegExpObject } from '../intrinsics/RegExp.mts';
+import type { DateObject } from '../intrinsics/Date.mts';
+import type { BooleanObject } from '../intrinsics/Boolean.mts';
+import type { NumberObject } from '../intrinsics/Number.mts';
+import type { BigIntObject } from '../intrinsics/BigInt.mts';
+import type { StringObject } from '../intrinsics/String.mts';
+import type { SymbolObject } from '../intrinsics/Symbol.mts';
+import { isTypedArrayObject } from '../intrinsics/TypedArray.mts';
+import { surroundingAgent } from './engine.mts';
+import {
+  type Descriptor, type ValueCompletion, type PromiseObject, CyclicModuleRecord,
+} from '#self';
+
+const bareKeyRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+
+function getObjectTag(value: ObjectValue, wrap = false): string {
+  let s = '';
+  try {
+    s = (X(Get(value, wellKnownSymbols.toStringTag)) as JSStringValue).stringValue();
+  } catch { }
+  try {
+    const c = X(Get(value, Value('constructor')));
+    s = (X(Get(c as ObjectValue, Value('name'))) as JSStringValue).stringValue();
+  } catch { }
+  if (s) {
+    if (wrap) {
+      return `[${s}] `;
+    }
+    return s;
+  }
+  return '';
+}
+
+const compactObject = (realm: Realm, value: ObjectValue) => {
+  try {
+    const toString = X(Get(value, Value('toString'))) as BuiltinFunctionObject;
+    const objectToString = realm.Intrinsics['%Object.prototype.toString%'];
+    if (toString.nativeFunction === objectToString.nativeFunction) {
+      return (X(Call(toString, value)) as JSStringValue).stringValue();
+    } else {
+      const tag = getObjectTag(value, false) || 'Unknown';
+      const ctor = X(Get(value, Value('constructor')));
+      if (ctor instanceof ObjectValue) {
+        const ctorName = (X(Get(ctor, Value('name'))) as JSStringValue).stringValue();
+        if (ctorName !== '') {
+          return `#<${ctorName}>`;
+        }
+        return `[object ${tag}]`;
+      }
+      return `[object ${tag}]`;
+    }
+  } catch (e) {
+    return '[object Unknown]';
+  }
+};
+
+interface InspectContext {
+  realm: Realm;
+  indent: number;
+  inspected: Value[];
+  compact: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Inspector = (value: any, context: InspectContext, inner: (v: Value) => string) => string;
+
+const INSPECTORS = {
+  Null: () => 'null',
+  Undefined: () => 'undefined',
+  Boolean: (v: BooleanValue) => v.booleanValue().toString(),
+  Number: (v: NumberValue) => {
+    const n = R(v);
+    if (n === 0 && Object.is(n, -0)) {
+      return '-0';
+    }
+    return n.toString();
+  },
+  BigInt: (v: BigIntValue) => `${R(v)}n`,
+  String: (v: JSStringValue) => {
+    const s = JSON.stringify(v.stringValue()).slice(1, -1);
+    return `'${s}'`;
+  },
+  Symbol: (v: SymbolValue) => `Symbol(${v.Description instanceof UndefinedValue ? '' : v.Description.stringValue()})`,
+  Object: (v: ObjectValue, ctx, i) => {
+    if (ctx.inspected.includes(v)) {
+      return '[Circular]';
+    }
+    if ('PromiseState' in v) {
+      ctx.indent += 1;
+      const result = v.PromiseState === 'pending' ? 'undefined' : i((v as PromiseObject).PromiseResult!);
+      ctx.indent -= 1;
+      return `Promise {
+  [[PromiseState]]: ${v.PromiseState}
+  [[PromiseResult]]: ${result}
+}`;
+    }
+    if (
+      'Module' in v
+      && v.Module instanceof CyclicModuleRecord
+      && v.Module.Status === 'linked'
+      && v.Module.DeferredNamespace === v
+    ) {
+      // Do not read the namespace to avoid triggering the module evaluation.
+      return 'Deferred Module { ... }';
+    }
+
+    if ('Call' in v) {
+      const name = v.properties.get('name');
+      if (name && (name.Value! as JSStringValue).stringValue() !== '') {
+        return `[Function: ${(name.Value as JSStringValue).stringValue()}]`;
+      }
+      return '[Function]';
+    }
+
+    if ('ErrorData' in v) {
+      let e = X(Get(v, Value('stack')));
+      if (!(e as JSStringValue).stringValue) {
+        const toString = X(Get(v, Value('toString')));
+        e = X(Call(toString, v));
+      }
+      return (e as JSStringValue).stringValue();
+    }
+
+    if (isRegExpObject(v)) {
+      const P = EscapeRegExpPattern(v.OriginalSource, v.OriginalFlags).stringValue();
+      const F = v.OriginalFlags.stringValue();
+      return `/${P}/${F}`;
+    }
+
+    if ('DateValue' in v) {
+      const d = new Date(R((v as DateObject).DateValue));
+      if (Number.isNaN(d.getTime())) {
+        return '[Date Invalid]';
+      }
+      return `[Date ${d.toISOString()}]`;
+    }
+
+    if ('BooleanData' in v) {
+      return `[Boolean ${i((v as BooleanObject).BooleanData)}]`;
+    }
+    if ('NumberData' in v) {
+      return `[Number ${i((v as NumberObject).NumberData)}]`;
+    }
+    if ('BigIntData' in v) {
+      return `[BigInt ${i((v as BigIntObject).BigIntData)}]`;
+    }
+    if ('StringData' in v) {
+      return `[String ${i((v as StringObject).StringData)}]`;
+    }
+    if ('SymbolData' in v) {
+      return `[Symbol ${i((v as SymbolObject).SymbolData)}]`;
+    }
+
+    ctx.indent += 1;
+    ctx.inspected.push(v);
+
+    try {
+      const isArray = IsArray(v) === Value.true;
+      const isTypedArray = isTypedArrayObject(v);
+      if (isArray || isTypedArray) {
+        const length = X(LengthOfArrayLike(v));
+        let holes = 0;
+        const flushHoles = () => {
+          if (holes > 0) {
+            out.push(`<${holes} empty items>`);
+            holes = 0;
+          }
+        };
+        const out = [];
+        for (let j = 0; j < length; j += 1) {
+          const elem = X(v.GetOwnProperty(Value(j.toString())));
+          if (elem instanceof UndefinedValue) {
+            holes += 1;
+          } else {
+            flushHoles();
+            if (elem.Value) {
+              out.push(i(elem.Value));
+            } else {
+              out.push('<accessor>');
+            }
+          }
+        }
+        flushHoles();
+        return `${isTypedArray ? `${v.TypedArrayName.stringValue()} ` : ''}[${out.join(', ')}]`;
+      }
+
+      const keys = X(v.OwnPropertyKeys());
+      const cache = [];
+      for (const key of keys) {
+        const C = X(v.GetOwnProperty(key)) as Descriptor;
+        if (C.Enumerable === Value.true) {
+          cache.push([
+            key instanceof JSStringValue && bareKeyRe.test(key.stringValue()) ? key.stringValue() : i(key),
+            C.Value ? i(C.Value) : '<accessor>',
+          ]);
+        }
+      }
+
+      const tag = getObjectTag(v);
+      let out = tag && tag !== 'Object' ? `${tag} {` : '{';
+      if (cache.length > 5) {
+        cache.forEach((c) => {
+          out = `${out}\n${'  '.repeat(ctx.indent)}${c[0]}: ${c[1]},`;
+        });
+        return `${out}\n${'  '.repeat(ctx.indent - 1)}}`;
+      } else {
+        const oc = ctx.compact;
+        ctx.compact = true;
+        cache.forEach((c, index) => {
+          out = `${out}${index === 0 ? '' : ','} ${c[0]}: ${c[1]}`;
+        });
+        ctx.compact = oc;
+        return `${out} }`;
+      }
+    } catch {
+      return compactObject(ctx.realm, v);
+    } finally {
+      ctx.indent -= 1;
+      ctx.inspected.pop();
+    }
+  },
+} satisfies Partial<Record<Value['type'], Inspector>>;
+
+// TODO: add an option to inspect so it can return string with color.
+export function inspect(value: Value | ValueCompletion): string {
+  const context: InspectContext = {
+    realm: surroundingAgent.currentRealmRecord,
+    indent: 0,
+    inspected: [],
+    compact: false,
+  };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const inner = (v: Value) => (INSPECTORS[v.type] as any)(v, context, inner);
+  if (value instanceof Completion) {
+    value = value.Value;
+  }
+  return inner(value);
+}

package/src/host-defined/test262-intrinsics.mts

@@ -0,0 +1,164 @@
+// defined intrinsics that used in test262
+import { isArray } from '../helpers.mts';
+import {
+  CreateBuiltinFunction, DetachArrayBuffer, EnsureCompletion, inspect, isArrayBufferObject, isBuiltinFunctionObject, JSStringValue, ManagedRealm, NormalCompletion, OrdinaryObjectCreate, Q, skipDebugger, surroundingAgent, ToString, Value, type Arguments, type ValueCompletion, gc,
+  ParseScript,
+  ThrowCompletion,
+  ScriptEvaluation,
+  CreateNonEnumerableDataPropertyOrThrow,
+  type ValueEvaluator,
+  X,
+  type NativeSteps,
+  Call,
+  Assert,
+  HasProperty,
+  Set,
+} from '#self';
+
+/** https://github.com/tc39/test262/blob/main/INTERPRETING.md */
+export function createTest262Intrinsics(realm: ManagedRealm, printCompatMode: boolean) {
+  return realm.scope(() => {
+    let test262PrintHandle: ((str: string) => void) | undefined;
+    const setPrintHandle = (f: typeof test262PrintHandle | undefined) => {
+      test262PrintHandle = f;
+    };
+    const print = CreateBuiltinFunction((args: Arguments): ValueCompletion => {
+      if (surroundingAgent.debugger_isPreviewing) {
+        return NormalCompletion(Value.undefined);
+      }
+      /* node:coverage ignore next */
+      if (test262PrintHandle) {
+        if (args[0] instanceof JSStringValue) {
+          test262PrintHandle(args[0].stringValue());
+          return Value.undefined;
+        }
+      } else {
+        if (printCompatMode) {
+          const str: string[] = [];
+          for (let i = 0; i < args.length; i += 1) {
+            const arg = args[i];
+            const s = EnsureCompletion(skipDebugger(ToString(arg)));
+            if (s.Type === 'throw') {
+              return s;
+            }
+            str.push(s.Value.stringValue());
+          }
+          // eslint-disable-next-line no-console
+          console.log(...str);
+          return Value.undefined;
+        } else {
+          const formatted = args.map((a: Value, i: number) => {
+            if (i === 0 && a instanceof JSStringValue) {
+              return a.stringValue();
+            }
+            return inspect(a);
+          }).join(' ');
+          console.log(formatted); // eslint-disable-line no-console
+        }
+      }
+      return Value.undefined;
+    }, 0, Value('print'), []);
+    CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('print'), print);
+
+    const $262 = OrdinaryObjectCreate.from({
+      // TODO: AbstractModuleSource
+      createRealm: function* createRealm(): ValueEvaluator {
+        Q(surroundingAgent.debugger_cannotPreview);
+        const realm = new ManagedRealm();
+        const { $262 } = createTest262Intrinsics(realm, printCompatMode);
+        return $262;
+      },
+      detachArrayBuffer: function* detachArrayBuffer(arrayBuffer) {
+        if (!isArrayBufferObject(arrayBuffer)) {
+          return surroundingAgent.Throw('TypeError', 'Raw', 'Argument must be an ArrayBuffer');
+        }
+        Q(DetachArrayBuffer(arrayBuffer));
+        return Value.undefined;
+      },
+      evalScript: function* evalScript(sourceText) {
+        if (!(sourceText instanceof JSStringValue)) {
+          return surroundingAgent.Throw('TypeError', 'Raw', 'Argument must be a string');
+        }
+        const s = ParseScript(sourceText.stringValue(), surroundingAgent.currentRealmRecord);
+        if (isArray(s)) {
+          return ThrowCompletion(s[0]);
+        }
+        const status = yield* ScriptEvaluation(s);
+        return status;
+      },
+      gc,
+      global: realm.GlobalObject,
+      // TODO: agent only if we have multi-threading.
+
+      // engine262 only
+      spec: function* spec(value) {
+        if (isBuiltinFunctionObject(value) && value.nativeFunction.section) {
+          return Value(value.nativeFunction.section);
+        }
+        return Value.undefined;
+      },
+      debugger: function* hostDebugger(value = Value.undefined, callValue = Value.false): ValueEvaluator {
+        if (surroundingAgent.debugger_isPreviewing) {
+          return Value.undefined;
+        }
+        // eslint-disable-next-line no-debugger
+        debugger;
+        if (callValue !== Value.false) {
+          Q(skipDebugger(Call(value, Value.undefined, [])));
+        }
+        return Value.undefined;
+      },
+    });
+    // engine262 only
+    CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('$262'), $262);
+    CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('$'), $262);
+
+    return {
+      setPrintHandle,
+      $262,
+    };
+  });
+}
+
+export function boostTest262Harness(realm: ManagedRealm) {
+  // test262/harness/regExpUtils.js
+  const key = Value('buildString');
+  realm.scope(() => {
+    if (X(HasProperty(realm.GlobalObject, key)) === Value.true) {
+      X(Set(realm.GlobalObject, key, CreateBuiltinFunction(boostHarness.buildString, 1, key, []), Value.true));
+    }
+  });
+}
+
+const boostHarness = {
+  * buildString(argumentsList): ValueEvaluator {
+    const json = Q(yield* Call(surroundingAgent.intrinsic('%JSON.stringify%'), Value.null, [argumentsList[0]]));
+    Assert(json instanceof JSStringValue);
+    const jsonString = json.stringValue();
+
+    const { loneCodePoints, ranges } = JSON.parse(jsonString);
+
+    // #region test262/harness/regExpUtils.js
+    const CHUNK_SIZE = 10000;
+    let result = String.fromCodePoint.apply(null, loneCodePoints);
+    for (let i = 0; i < ranges.length; i += 1) {
+      const range = ranges[i];
+      const start = range[0];
+      const end = range[1];
+      const codePoints: number[] = [];
+      for (let length = 0, codePoint = start; codePoint <= end; codePoint += 1) {
+        codePoints[length] = codePoint;
+        length += 1;
+        if (length === CHUNK_SIZE) {
+          result += String.fromCodePoint.apply(null, codePoints);
+          length = 0;
+          codePoints.length = 0;
+        }
+      }
+      result += String.fromCodePoint.apply(null, codePoints);
+    }
+    // #endregion
+
+    return Value(result);
+  },
+} satisfies Record<string, NativeSteps>;

package/src/index.mts

@@ -0,0 +1,37 @@
+export * from './abstract-ops/all.mts';
+export * from './static-semantics/all.mts';
+export * from './runtime-semantics/all.mts';
+export * from './value.mts';
+export * from './host-defined/engine.mts';
+export * from './completion.mts';
+export * from './environment.mts';
+export * from './parse.mts';
+export * from './modules.mts';
+export * from './host-defined/inspect.mts';
+export * from './evaluator.mts';
+
+export { captureStack } from './helpers.mts';
+export {
+  Throw, type ErrorType, gc, runJobQueue, type ManagedRealmHostDefined, ManagedRealm,
+} from './api.mts';
+export type { ParseNode } from './parser/ParseNode.mts';
+export { createTest262Intrinsics, boostTest262Harness } from './host-defined/test262-intrinsics.mts';
+export { performDevtoolsEval } from './host-defined/debugger-eval.mts';
+export {
+  getHostDefinedErrorStack, skipDebugger, getCurrentStack, JSStringMap, JSStringSet, CallSite, type Mutable, PropertyKeyMap, kInternal,
+} from './helpers.mts';
+
+export { isMapObject, type MapObject } from './intrinsics/Map.mts';
+export { isSetObject, type SetObject } from './intrinsics/Set.mts';
+export { isRegExpObject, type RegExpObject } from './intrinsics/RegExp.mts';
+export { isWeakMapObject, type WeakMapObject } from './intrinsics/WeakMap.mts';
+export { isWeakSetObject, type WeakSetObject } from './intrinsics/WeakSet.mts';
+export { isDataViewObject, type DataViewObject } from './intrinsics/DataView.mts';
+export { isDateObject, type DateObject } from './intrinsics/Date.mts';
+export { DateProto_toISOString } from './intrinsics/DatePrototype.mts';
+export { isPromiseObject, type PromiseObject } from './intrinsics/Promise.mts';
+export { isTypedArrayObject, type TypedArrayObject } from './intrinsics/TypedArray.mts';
+export { isProxyExoticObject, type ProxyObject } from './intrinsics/Proxy.mts';
+export { isWeakRef, type WeakRefObject } from './intrinsics/WeakRef.mts';
+export { type FinalizationRegistryObject } from './intrinsics/FinalizationRegistry.mts';
+export { isErrorObject } from './intrinsics/Error.mts';

package/src/intrinsics/AggregateError.mts

@@ -0,0 +1,68 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Value, Descriptor, type Arguments, type FunctionCallContext,
+  UndefinedValue,
+} from '../value.mts';
+import {
+  ToString,
+  IteratorToList,
+  OrdinaryCreateFromConstructor,
+  DefinePropertyOrThrow,
+  InstallErrorCause,
+  CreateArrayFromList,
+  Realm,
+  type FunctionObject,
+  CreateNonEnumerableDataPropertyOrThrow,
+  GetIterator,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { captureStack, errorStackToString } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import type { ErrorObject } from './Error.mts';
+
+/** https://tc39.es/ecma262/#sec-aggregate-error-constructor */
+function* AggregateErrorConstructor([errors = Value.undefined, message = Value.undefined, options = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 1. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
+  let newTarget;
+  if (NewTarget instanceof UndefinedValue) {
+    newTarget = surroundingAgent.activeFunctionObject as FunctionObject;
+  } else {
+    newTarget = NewTarget;
+  }
+  // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%AggregateError.prototype%", « [[ErrorData]] »).
+  const O = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%AggregateError.prototype%', [
+    'ErrorData',
+    'HostDefinedErrorStack',
+  ])) as ErrorObject;
+  // 3. If message is not undefined, then
+  if (message !== Value.undefined) {
+    // a. Let msg be ? ToString(message).
+    const msg = Q(yield* ToString(message));
+    // b. Perform ! CreateMethodProperty(O, "message", msg).
+    X(CreateNonEnumerableDataPropertyOrThrow(O, Value('message'), msg));
+  }
+  Q(yield* InstallErrorCause(O, options));
+  // 4. Let errorsList be ? IterableToList(errors).
+  const errorsList = Q(yield* IteratorToList(Q(yield* GetIterator(errors, 'sync'))));
+  // 5. Perform ! DefinePropertyOrThrow(O, "errors", Property Descriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: ! CreateArrayFromList(errorsList) }).
+  X(DefinePropertyOrThrow(O, Value('errors'), Descriptor({
+    Configurable: Value.true,
+    Enumerable: Value.false,
+    Writable: Value.true,
+    Value: CreateArrayFromList(errorsList),
+  })));
+
+  // NON-SPEC
+  const S = captureStack();
+  O.HostDefinedErrorStack = S.stack;
+  O.ErrorData = X(errorStackToString(O, S.stack, S.nativeStack));
+
+  // 7. Return O.
+  return O;
+}
+
+export function bootstrapAggregateError(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, AggregateErrorConstructor, 'AggregateError', 2, realmRec.Intrinsics['%AggregateError.prototype%'], []);
+  c.Prototype = realmRec.Intrinsics['%Error%'];
+  realmRec.Intrinsics['%AggregateError%'] = c;
+}

package/src/intrinsics/AggregateErrorPrototype.mts

@@ -0,0 +1,12 @@
+import { Value } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Realm } from '#self';
+
+export function bootstrapAggregateErrorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['name', Value('AggregateError')],
+    ['message', Value('')],
+  ], realmRec.Intrinsics['%Error.prototype%'], 'AggregateError');
+
+  realmRec.Intrinsics['%AggregateError.prototype%'] = proto;
+}