@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/abstract-ops/iterator-operations.mts

@@ -0,0 +1,311 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  BooleanValue,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+} from '../value.mts';
+import {
+  Completion,
+  EnsureCompletion,
+  IfAbruptRejectPromise,
+  Q, X,
+  Await,
+  NormalCompletion,
+  type ValueEvaluator,
+  ThrowCompletion,
+  AbruptCompletion,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../helpers.mts';
+import type { AsyncFromSyncIteratorObject } from '../intrinsics/AsyncFromSyncIteratorPrototype.mts';
+import type {
+  Evaluator, PlainEvaluator, YieldEvaluator,
+} from '../evaluator.mts';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  Get,
+  GetMethod,
+  PromiseResolve,
+  OrdinaryObjectCreate,
+  PerformPromiseThen,
+  ToBoolean,
+  CreateIteratorFromClosure,
+  type FunctionObject,
+  PromiseCapabilityRecord,
+  CreateDataPropertyOrThrow,
+  GeneratorYield,
+} from './all.mts';
+import type { ValueCompletion, PromiseObject, OrdinaryObject } from '#self';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-operations-on-iterator-objects */
+// and
+/** https://tc39.es/ecma262/#sec-iteration */
+
+export interface IteratorRecord {
+  readonly Iterator: ObjectValue;
+  readonly NextMethod: Value;
+  Done: BooleanValue;
+}
+
+export interface IteratorObject extends OrdinaryObject {
+  Iterated: IteratorRecord;
+}
+
+/** https://tc39.es/ecma262/#sec-getiteratordirect */
+export function* GetIteratorDirect(obj: ObjectValue): PlainEvaluator<IteratorRecord> {
+  const nextMethod = Q(yield* Get(obj, Value('next')));
+  const iteratorRecord: IteratorRecord = {
+    Iterator: obj,
+    NextMethod: nextMethod,
+    Done: Value.false,
+  };
+  return iteratorRecord;
+}
+
+/** https://tc39.es/ecma262/#sec-getiteratorfrommethod */
+export function* GetIteratorFromMethod(obj: Value, method: FunctionObject): PlainEvaluator<IteratorRecord> {
+  const iterator = Q(yield* Call(method, obj));
+  if (!(iterator instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', iterator);
+  }
+  return yield* GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-getiterator */
+export function* GetIterator(obj: Value, kind: 'sync' | 'async'): PlainEvaluator<IteratorRecord> {
+  let method;
+  if (kind === 'async') {
+    method = Q(yield* GetMethod(obj, wellKnownSymbols.asyncIterator));
+    if (method === Value.undefined) {
+      const syncMethod = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+      if (syncMethod instanceof UndefinedValue) {
+        return surroundingAgent.Throw('TypeError', 'NotIterable', obj);
+      }
+      const syncIteratorRecord = Q(yield* GetIteratorFromMethod(obj, syncMethod));
+      return CreateAsyncFromSyncIterator(syncIteratorRecord);
+    }
+  } else {
+    method = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+  }
+  if (method instanceof UndefinedValue) {
+    return surroundingAgent.Throw('TypeError', 'NotIterable', obj);
+  }
+  return yield* GetIteratorFromMethod(obj, method);
+}
+
+export type PrimitiveHanding = 'iterate-string-primitives' | 'reject-primitives'
+export function* GetIteratorFlattenable(obj: Value, primitiveHandling: PrimitiveHanding): PlainEvaluator<IteratorRecord> {
+  if (!(obj instanceof ObjectValue)) {
+    if (primitiveHandling === 'reject-primitives') {
+      return surroundingAgent.Throw('TypeError', 'NotAnObject', obj);
+    }
+    Assert(primitiveHandling === 'iterate-string-primitives');
+    if (!(obj instanceof JSStringValue)) {
+      return surroundingAgent.Throw('TypeError', 'NotAString', obj);
+    }
+  }
+  const method = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+  let iterator;
+  if (method instanceof UndefinedValue) {
+    iterator = obj;
+  } else {
+    iterator = Q(yield* Call(method, obj));
+  }
+  if (!(iterator instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', iterator);
+  }
+  return yield* GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-iteratornext */
+export function* IteratorNext(iteratorRecord: IteratorRecord, value?: Value): ValueEvaluator<ObjectValue> {
+  let result;
+  if (!value) {
+    result = EnsureCompletion(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator));
+  } else {
+    result = EnsureCompletion(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator, [value]));
+  }
+  if (result instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+    return Q(result);
+  }
+  result = X(result);
+  if (!(result instanceof ObjectValue)) {
+    iteratorRecord.Done = Value.true;
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', result);
+  }
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorcomplete */
+export function* IteratorComplete(iteratorResult: ObjectValue): ValueEvaluator<BooleanValue> {
+  return ToBoolean(Q(yield* Get(iteratorResult, Value('done'))));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorvalue */
+export function IteratorValue(iterResult: ObjectValue): ValueEvaluator {
+  return Get(iterResult, Value('value'));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorstep */
+export function* IteratorStep(iteratorRecord: IteratorRecord): PlainEvaluator<ObjectValue | 'done'> {
+  const result = Q(yield* IteratorNext(iteratorRecord));
+  let done: ValueCompletion = EnsureCompletion(yield* IteratorComplete(result));
+  if (done instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+    return done;
+  }
+  done = X(done);
+  if (done === Value.true) {
+    iteratorRecord.Done = Value.true;
+    return 'done';
+  }
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorstepvalue */
+export function* IteratorStepValue(iteratorRecord: IteratorRecord): PlainEvaluator<Value | 'done'> {
+  const result = Q(yield* IteratorStep(iteratorRecord));
+  if (result === 'done') {
+    return 'done';
+  }
+  const value = EnsureCompletion(yield* IteratorValue(result));
+  if (value instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+  }
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorclose */
+export function* IteratorClose<T, C extends Completion<T>>(iteratorRecord: IteratorRecord, completion: C): Evaluator<C | ThrowCompletion> {
+  Assert(iteratorRecord.Iterator instanceof ObjectValue);
+  const iterator = iteratorRecord.Iterator;
+  let innerResult: ValueCompletion = EnsureCompletion(yield* GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret === Value.undefined) {
+      return completion;
+    }
+    innerResult = EnsureCompletion(yield* Call(ret, iterator));
+  }
+  if (completion instanceof ThrowCompletion) {
+    return completion;
+  }
+  if (innerResult instanceof ThrowCompletion) {
+    return innerResult;
+  }
+  if (!(innerResult.Value instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', innerResult.Value);
+  }
+  return completion;
+}
+
+/** https://tc39.es/ecma262/#sec-asynciteratorclose */
+export function* AsyncIteratorClose<T, C extends Completion<T>>(iteratorRecord: IteratorRecord, completion: C | T) {
+  Assert(iteratorRecord.Iterator instanceof ObjectValue);
+  const iterator = iteratorRecord.Iterator;
+  let innerResult: NormalCompletion<Value> | ThrowCompletion = EnsureCompletion(yield* GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret instanceof UndefinedValue) {
+      return completion;
+    }
+    innerResult = EnsureCompletion(yield* Call(ret, iterator));
+    if (innerResult instanceof NormalCompletion) {
+      innerResult = EnsureCompletion(yield* Await(innerResult.Value));
+    }
+  }
+  if (completion instanceof ThrowCompletion) {
+    return completion;
+  }
+  if (innerResult instanceof ThrowCompletion) {
+    return innerResult;
+  }
+  if (!(innerResult.Value instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', innerResult.Value);
+  }
+  return completion;
+}
+
+/** https://tc39.es/ecma262/#sec-createiterresultobject */
+export function CreateIteratorResultObject(value: Value, done: BooleanValue) {
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  X(CreateDataPropertyOrThrow(obj, Value('value'), value));
+  X(CreateDataPropertyOrThrow(obj, Value('done'), done));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-createlistiteratorRecord */
+export function CreateListIteratorRecord(list: Iterable<Value>): IteratorRecord {
+  const closure = function* closure(): YieldEvaluator {
+    for (const E of list) {
+      Q(yield* GeneratorYield(CreateIteratorResultObject(E, Value.false)));
+    }
+    return NormalCompletion(Value.undefined);
+  };
+  const iterator = CreateIteratorFromClosure(closure, undefined, surroundingAgent.intrinsic('%Iterator.prototype%'));
+  return {
+    Iterator: iterator,
+    NextMethod: surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype.next%'),
+    Done: Value.false,
+  };
+}
+
+/** https://tc39.es/ecma262/#sec-iteratortolist */
+export function* IteratorToList(iteratorRecord: IteratorRecord): PlainEvaluator<Value[]> {
+  const list: Value[] = [];
+  while (true) {
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    if (next === 'done') {
+      return list;
+    }
+    list.push(next);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-createasyncfromsynciterator */
+export function CreateAsyncFromSyncIterator(syncIteratorRecord: IteratorRecord): IteratorRecord {
+  const asyncIterator = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncFromSyncIteratorPrototype%'), [
+    'SyncIteratorRecord',
+  ]) as Mutable<AsyncFromSyncIteratorObject>;
+  asyncIterator.SyncIteratorRecord = syncIteratorRecord;
+  const nextMethod = X(Get(asyncIterator, Value('next')));
+  return {
+    Iterator: asyncIterator,
+    NextMethod: nextMethod,
+    Done: Value.false,
+  };
+}
+
+/** https://tc39.es/ecma262/#sec-asyncfromsynciteratorcontinuation */
+export function* AsyncFromSyncIteratorContinuation(result: ObjectValue, promiseCapability: PromiseCapabilityRecord, syncIteratorRecord: IteratorRecord, closeOnRejection: BooleanValue): ValueEvaluator<PromiseObject> {
+  const done = yield* IteratorComplete(result);
+  IfAbruptRejectPromise(done, promiseCapability);
+  __ts_cast__<BooleanValue>(done);
+  const value = yield* IteratorValue(result);
+  IfAbruptRejectPromise(value, promiseCapability);
+  __ts_cast__<Value>(value);
+  let valueWrapper = yield* PromiseResolve(surroundingAgent.intrinsic('%Promise%'), value);
+  if (valueWrapper instanceof AbruptCompletion && done === Value.false && closeOnRejection === Value.true) {
+    valueWrapper = yield* IteratorClose(syncIteratorRecord, valueWrapper);
+  }
+  IfAbruptRejectPromise(valueWrapper, promiseCapability);
+  __ts_cast__<PromiseObject>(valueWrapper);
+  const unwrap = ([v]: Arguments) => CreateIteratorResultObject(v, done);
+  const onFullfilled = CreateBuiltinFunction(unwrap, 1, Value(''), []);
+  let onRejected;
+  if (done === Value.true || closeOnRejection === Value.false) {
+    onRejected = Value.undefined;
+  } else {
+    const closeIterator = ([error]: Arguments) => IteratorClose(syncIteratorRecord, ThrowCompletion(error));
+    onRejected = CreateBuiltinFunction(closeIterator, 1, Value(''), []);
+  }
+  PerformPromiseThen(valueWrapper, onFullfilled, onRejected, promiseCapability);
+  return promiseCapability.Promise;
+}

package/src/abstract-ops/keyed-collections.mts

@@ -0,0 +1,19 @@
+import {
+  F, R,
+} from './all.mts';
+import {
+  NumberValue, Value,
+} from '#self';
+
+// This file covers abstract operations defined in
+// https://tc39.es/ecma262/#sec-abstract-operations-for-keyed-collections
+
+/** https://tc39.es/ecma262/#sec-canonicalizekeyedcollectionkey */
+export function CanonicalizeKeyedCollectionKey(key : Value) : Value {
+  // 1. If key is -0𝔽, return +0𝔽.
+  if (key instanceof NumberValue && Object.is(R(key), -0)) {
+    key = F(+0);
+  }
+  // 2. Return key.
+  return key;
+}

package/src/abstract-ops/module-namespace-exotic-objects.mts

@@ -0,0 +1,351 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Q, X } from '../completion.mts';
+import { AbstractModuleRecord, CyclicModuleRecord, ResolvedBindingRecord } from '../modules.mts';
+import {
+  SymbolValue,
+  Value,
+  Descriptor,
+  wellKnownSymbols,
+  JSStringValue,
+  type ObjectInternalMethods,
+  UndefinedValue,
+  type PropertyKeyValue,
+  ObjectValue,
+  BooleanValue,
+} from '../value.mts';
+import {
+  JSStringSet, type Mutable,
+} from '../helpers.mts';
+import {
+  Assert,
+  CompareArrayElements,
+  SameValue,
+  MakeBasicObject,
+  IsPropertyKey,
+  IsAccessorDescriptor,
+  SetImmutablePrototype,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  OrdinaryHasProperty,
+  OrdinaryGet,
+  OrdinaryDelete,
+  OrdinaryOwnPropertyKeys,
+  GetModuleNamespace, R,
+  type ExoticObject,
+  EvaluateModuleSync,
+  GetImportedModule,
+} from './all.mts';
+import type { ModuleRecord, PlainEvaluator } from '#self';
+
+export interface ModuleNamespaceObject extends ExoticObject {
+  readonly Module: AbstractModuleRecord;
+  readonly Exports: JSStringSet;
+  /* [import-defer] */ readonly Deferred: boolean;
+}
+
+export function isModuleNamespaceObject(V: Value): V is ModuleNamespaceObject {
+  return V instanceof ObjectValue && 'Module' in V;
+}
+
+const InternalMethods = {
+  * GetPrototypeOf() {
+    return Value.null;
+  },
+  * SetPrototypeOf(V) {
+    return Q(yield* SetImmutablePrototype(this, V));
+  },
+  * IsExtensible() {
+    return Value.false;
+  },
+  * PreventExtensions() {
+    return Value.true;
+  },
+  * GetOwnProperty(P) {
+    const O = this;
+
+    if (surroundingAgent.feature('import-defer') ? IsSymbolLikeNamespaceKey(P, O) : P instanceof SymbolValue) {
+      return OrdinaryGetOwnProperty(O, P);
+    }
+    let exports;
+    if (surroundingAgent.feature('import-defer')) {
+      exports = Q(yield* GetModuleExportsList(O));
+    } else {
+      exports = O.Exports;
+    }
+    if (!exports.has(P as JSStringValue)) {
+      return Value.undefined;
+    }
+    const value = Q(yield* O.Get(P, O));
+    return Descriptor({
+      Value: value,
+      Writable: Value.true,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    });
+  },
+  * DefineOwnProperty(P, Desc) {
+    const O = this;
+
+    if (surroundingAgent.feature('import-defer') ? IsSymbolLikeNamespaceKey(P, O) : P instanceof SymbolValue) {
+      return yield* OrdinaryDefineOwnProperty(O, P, Desc);
+    }
+
+    const current = Q(yield* O.GetOwnProperty(P));
+    if (current instanceof UndefinedValue) {
+      return Value.false;
+    }
+    if (IsAccessorDescriptor(Desc)) {
+      return Value.false;
+    }
+    if (Desc.Writable !== undefined && Desc.Writable === Value.false) {
+      return Value.false;
+    }
+    if (Desc.Enumerable !== undefined && Desc.Enumerable === Value.false) {
+      return Value.false;
+    }
+    if (Desc.Configurable !== undefined && Desc.Configurable === Value.true) {
+      return Value.false;
+    }
+    if (Desc.Value !== undefined) {
+      return SameValue(Desc.Value, current.Value!);
+    }
+    return Value.true;
+  },
+  * HasProperty(P) {
+    const O = this;
+
+    if (surroundingAgent.feature('import-defer') ? IsSymbolLikeNamespaceKey(P, O) : P instanceof SymbolValue) {
+      return yield* OrdinaryHasProperty(O, P);
+    }
+    let exports;
+    if (surroundingAgent.feature('import-defer')) {
+      exports = Q(yield* GetModuleExportsList(O));
+    } else {
+      exports = O.Exports;
+    }
+    if (exports.has(P as JSStringValue)) {
+      return Value.true;
+    }
+    return Value.false;
+  },
+  /** https://tc39.es/ecma262/#sec-module-namespace-exotic-objects-get-p-receiver */
+  * Get(P, Receiver) {
+    const O = this;
+
+    // 1. Assert: IsPropertyKey(P) is true.
+    Assert(IsPropertyKey(P));
+    // 2. If Type(P) is Symbol, then
+    if (surroundingAgent.feature('import-defer') ? IsSymbolLikeNamespaceKey(P, O) : P instanceof SymbolValue) {
+      // a. Return ? OrdinaryGet(O, P, Receiver).
+      return yield* OrdinaryGet(O, P, Receiver);
+    }
+    let exports;
+    if (surroundingAgent.feature('import-defer')) {
+      exports = Q(yield* GetModuleExportsList(O));
+    } else {
+      // 3. Let exports be O.[[Exports]].
+      exports = O.Exports;
+    }
+    // 4. If P is not an element of exports, return undefined.
+    if (!exports.has(P as JSStringValue)) {
+      return Value.undefined;
+    }
+    // 5. Let m be O.[[Module]].
+    const m = O.Module;
+    // 6. Let binding be ! m.ResolveExport(P).
+    const binding = m.ResolveExport(P as JSStringValue);
+    // 7. Assert: binding is a ResolvedBinding Record.
+    Assert(binding instanceof ResolvedBindingRecord);
+    // 8. Let targetModule be binding.[[Module]].
+    const targetModule = binding.Module;
+    // 9. Assert: targetModule is not undefined.
+    Assert(!(targetModule instanceof UndefinedValue));
+    // 10. If binding.[[BindingName]] is ~namespace~, then
+    if (binding.BindingName === 'namespace') {
+      // a. Return ? GetModuleNamespace(targetModule).
+      return Q(GetModuleNamespace(targetModule, /* [import-defer] */ 'evaluation'));
+    }
+    // 11. Let targetEnv be targetModule.[[Environment]].
+    const targetEnv = targetModule.Environment;
+    // 12. If targetEnv is undefined, throw a ReferenceError exception.
+    if (!targetEnv) {
+      return surroundingAgent.Throw('ReferenceError', 'NotDefined', P);
+    }
+    // 13. Return ? targetEnv.GetBindingValue(binding.[[BindingName]], true).
+    return Q(yield* targetEnv.GetBindingValue(binding.BindingName, Value.true));
+  },
+  * Set() {
+    return Value.false;
+  },
+  * Delete(P) {
+    const O = this;
+
+    Assert(IsPropertyKey(P));
+    if (surroundingAgent.feature('import-defer') ? IsSymbolLikeNamespaceKey(P, O) : P instanceof SymbolValue) {
+      return Q(yield* OrdinaryDelete(O, P));
+    }
+    let exports;
+    if (surroundingAgent.feature('import-defer')) {
+      exports = Q(yield* GetModuleExportsList(O));
+    } else {
+      exports = O.Exports;
+    }
+    if (exports.has(P as JSStringValue)) {
+      return Value.false;
+    }
+    return Value.true;
+  },
+  * OwnPropertyKeys() {
+    const O = this;
+
+    let exports;
+    if (surroundingAgent.feature('import-defer')) {
+      exports = Q(yield* GetModuleExportsList(O));
+      if (O.Deferred && exports.has('then')) {
+        exports = [...exports].filter((x) => x.stringValue() !== 'then');
+      }
+    } else {
+      exports = O.Exports;
+    }
+
+    const symbolKeys = X(OrdinaryOwnPropertyKeys(O));
+    return [...exports, ...symbolKeys];
+  },
+} satisfies Partial<ObjectInternalMethods<ModuleNamespaceObject>>;
+
+/** https://tc39.es/ecma262/#sec-modulenamespacecreate */
+export function ModuleNamespaceCreate(
+  module: AbstractModuleRecord,
+  exports: readonly JSStringValue[],
+  /* [import-defer] */ phase: 'defer' | 'evaluation',
+): ModuleNamespaceObject {
+  if (!surroundingAgent.feature('import-defer')) {
+    // 1. Assert: module.[[Namespace]] is EMPTY.
+    Assert(module.Namespace === undefined);
+  }
+  // 2. Let internalSlotsList be the internal slots listed in Table 31.
+  const internalSlotsList = ['Module', 'Exports'];
+  // 3. Let M be MakeBasicObject(internalSlotsList).
+  const M = MakeBasicObject(internalSlotsList) as Mutable<ModuleNamespaceObject>;
+  // 4. Set M's essential internal methods to the definitions specified in 10.4.6.
+  /** https://tc39.es/ecma262/#sec-module-namespace-exotic-objects */
+  M.GetPrototypeOf = InternalMethods.GetPrototypeOf;
+  M.SetPrototypeOf = InternalMethods.SetPrototypeOf;
+  M.IsExtensible = InternalMethods.IsExtensible;
+  M.PreventExtensions = InternalMethods.PreventExtensions;
+  M.GetOwnProperty = InternalMethods.GetOwnProperty;
+  M.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+  M.HasProperty = InternalMethods.HasProperty;
+  M.Get = InternalMethods.Get;
+  M.Set = InternalMethods.Set;
+  M.Delete = InternalMethods.Delete;
+  M.OwnPropertyKeys = InternalMethods.OwnPropertyKeys;
+  // 5. Set M.[[Module]] to module.
+  M.Module = module;
+  // 6. Let sortedExports be a List whose elements are the elements of exports, sorted according to lexicographic code unit order.
+  const sortedExports = [...exports].sort((x, y) => {
+    const result = X(CompareArrayElements(x, y, Value.undefined));
+    return R(result);
+  });
+  // 7. Set M.[[Exports]] to sortedExports.
+  M.Exports = new JSStringSet(sortedExports);
+  if (!surroundingAgent.feature('import-defer')) {
+    // 8. Create own properties of M corresponding to the definitions in 26.3.
+    M.properties.set(wellKnownSymbols.toStringTag, Descriptor({
+      Writable: Value.false,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+      Value: Value('Module'),
+    }));
+    // 9. Set module.[[Namespace]] to M.
+    (module as Mutable<AbstractModuleRecord>).Namespace = M;
+  } else {
+    /** https://tc39.es/proposal-defer-import-eval/#sec-modulenamespacecreate */
+
+    let toStringTag: JSStringValue;
+    // 9. If phase is defer, then
+    if (phase === 'defer') {
+      // a. Assert: module.[[DeferredNamespace]] is empty.
+      Assert(module.DeferredNamespace === undefined);
+      // b. Set module.[[DeferredNamespace]] to M.
+      (module as Mutable<AbstractModuleRecord>).DeferredNamespace = M;
+      // c. Set M.[[Deferred]] to true.
+      M.Deferred = true;
+      // d. Let toStringTag be "Deferred Module".
+      toStringTag = Value('Deferred Module');
+    } else { // 10. Else,
+      // a. Assert: module.[[Namespace]] is empty.
+      Assert(module.Namespace === undefined);
+      // b. Set module.[[Namespace]] to M.
+      (module as Mutable<AbstractModuleRecord>).Namespace = M;
+      // c. Set M.[[Deferred]] to false.
+      M.Deferred = false;
+      // d. Let toStringTag be "Module".
+      toStringTag = Value('Module');
+    }
+    // 11. Create an own data property of M named %Symbol.toStringTag% whose [[Value]] is toStringTag whose [[Writable]], [[Enumerable]], and [[Configurable]] attributes are false.
+    M.properties.set(wellKnownSymbols.toStringTag, Descriptor({
+      Writable: Value.false,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+      Value: toStringTag,
+    }));
+  }
+  // 10. Return M.
+  return M;
+}
+
+/* [import-defer] */
+/** https://tc39.es/proposal-defer-import-eval/#sec-IsSymbolLikeNamespaceKey */
+function IsSymbolLikeNamespaceKey(P: PropertyKeyValue, ns: ModuleNamespaceObject): P is SymbolValue {
+  if (P instanceof SymbolValue) {
+    return true;
+  }
+  if (ns.Deferred && P.stringValue() === 'then') {
+    return true;
+  }
+  return false;
+}
+
+/* [import-defer] */
+/** https://tc39.es/proposal-defer-import-eval/#sec-GetModuleExportsList */
+function* GetModuleExportsList(O: ModuleNamespaceObject): PlainEvaluator<JSStringSet> {
+  if (O.Deferred) {
+    const m = O.Module;
+    if (ReadyForSyncExecution(m) === Value.false) {
+      return surroundingAgent.Throw('TypeError', 'DeferredModuleNotReady', m);
+    }
+    Q(yield* EvaluateModuleSync(m));
+  }
+  return O.Exports;
+}
+
+/* [import-defer] */
+/** https://tc39.es/proposal-defer-import-eval/#sec-ReadyForSyncExecution */
+export function ReadyForSyncExecution(module: ModuleRecord, seen?: Set<CyclicModuleRecord>): BooleanValue {
+  if (!(module instanceof CyclicModuleRecord)) {
+    return Value.true;
+  }
+  seen ??= new Set();
+  if (seen.has(module)) {
+    return Value.true;
+  }
+  seen.add(module);
+  if (module.Status === 'evaluated') {
+    return Value.true;
+  }
+  if (module.Status === 'evaluating' || module.Status === 'evaluating-async') {
+    return Value.false;
+  }
+  Assert(module.Status === 'linked');
+  if (module.HasTLA === Value.true) {
+    return Value.false;
+  }
+  for (const request of module.RequestedModules) {
+    const requiredModule = GetImportedModule(module, request);
+    if (ReadyForSyncExecution(requiredModule, seen) === Value.false) {
+      return Value.false;
+    }
+  }
+  return Value.true;
+}