@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/abstract-ops/immutable-prototype-objects.mts

@@ -0,0 +1,20 @@
+import {
+  BooleanValue, NullValue, ObjectValue, Value,
+} from '../value.mts';
+import { Q, type ExpressionCompletion } from '../completion.mts';
+import { Assert, SameValue, type ExoticObject } from './all.mts';
+
+export type ImmutablePrototypeObject = ExoticObject;
+/** https://tc39.es/ecma262/#sec-set-immutable-prototype */
+export function SetImmutablePrototype(O: ObjectValue, V: Value): ExpressionCompletion<BooleanValue> {
+  // 1. Assert: Either Type(V) is Object or Type(V) is Null.
+  Assert(V instanceof ObjectValue || V instanceof NullValue);
+  // 2. Let current be ? O.[[GetPrototypeOf]]().
+  const current = Q(O.GetPrototypeOf());
+  // 3. If SameValue(V, current) is true, return true.
+  if (SameValue(V, current) === Value.true) {
+    return Value.true;
+  }
+  // 4. Return false.
+  return Value.false;
+}

package/src/abstract-ops/import-calls.mts

@@ -0,0 +1,73 @@
+// This file covers abstract operations defined in
+// https://tc39.es/ecma262/#sec-import-calls
+
+import {
+  AbstractModuleRecord,
+  Call, CreateBuiltinFunction, GetModuleNamespace, PerformPromiseThen, PromiseCapabilityRecord, Value,
+  type Arguments,
+} from '../api.mts';
+import {
+  AbruptCompletion, ValueOfNormalCompletion, X, type PlainCompletion,
+} from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-ContinueDynamicImport */
+export function ContinueDynamicImport(promiseCapability: PromiseCapabilityRecord, moduleCompletion: PlainCompletion<AbstractModuleRecord>) {
+  // 1. If moduleCompletion is an abrupt completion, then
+  if (moduleCompletion instanceof AbruptCompletion) {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « moduleCompletion.[[Value]] »).
+    X(Call(promiseCapability.Reject, Value.undefined, [moduleCompletion.Value]));
+    // b. Return unused.
+    return;
+  }
+  // 2. Let module be moduleCompletion.[[Value]].
+  const module = ValueOfNormalCompletion(moduleCompletion);
+
+  // 3. Let loadPromise be module.LoadRequestedModules().
+  const loadPromise = module.LoadRequestedModules();
+
+  // 4. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures promiseCapability and performs the following steps when called:
+  const rejectedClosure = ([reason = Value.undefined]: Arguments): void => {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « reason »).
+    X(Call(promiseCapability.Reject, Value.undefined, [reason]));
+    // b. Return unused.
+  };
+  // 5. Let onRejected be CreateBuiltinFunction(rejectedClosure, 1, "", « »).
+  const onRejected = CreateBuiltinFunction(rejectedClosure, 1, Value(''), []);
+
+  // 6. Let linkAndEvaluateClosure be a new Abstract Closure with no parameters that captures module, promiseCapability, and onRejected and performs the following steps when called:
+  const linkAndEvaluateClosure = () => {
+    // a. Let link be Completion(module.Link()).
+    const link = module.Link();
+    // b. If link is an abrupt completion, then
+    if (link instanceof AbruptCompletion) {
+      // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « link.[[Value]] »).
+      X(Call(promiseCapability.Reject, Value.undefined, [link.Value as Value]));
+      // ii. Return unused.
+      return;
+    }
+
+    // c. Let evaluatePromise be module.Evaluate().
+    const evaluatePromise = module.Evaluate();
+
+    // d. Let fulfilledClosure be a new Abstract Closure with no parameters that captures module and promiseCapability and performs the following steps when called:
+    const fulfilledClosure = () => {
+      // i. Let namespace be GetModuleNamespace(module).
+      const namespace = GetModuleNamespace(module);
+      // ii. Perform ! Call(promiseCapability.[[Resolve]], undefined, « namespace »).
+      X(Call(promiseCapability.Resolve, Value.undefined, [namespace]));
+      // iii. Return unused.
+    };
+    // e. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 0, "", « »).
+    const onFulfilled = CreateBuiltinFunction(fulfilledClosure, 0, Value(''), []);
+
+    // f. Perform PerformPromiseThen(evaluatePromise, onFulfilled, onRejected).
+    PerformPromiseThen(evaluatePromise, onFulfilled, onRejected);
+    // g. Return unused.
+  };
+  // 7. Let linkAndEvaluate be CreateBuiltinFunction(linkAndEvaluateClosure, 0, "", « »).
+  const linkAndEvaluate = CreateBuiltinFunction(linkAndEvaluateClosure, 0, Value(''), []);
+
+  // 8. Perform PerformPromiseThen(loadPromise, linkAndEvaluate, onRejected).
+  PerformPromiseThen(loadPromise, linkAndEvaluate, onRejected);
+  // 9. Return unused.
+}

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

@@ -0,0 +1,306 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  BooleanValue,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+} from '../value.mts';
+import {
+  Completion,
+  EnsureCompletion,
+  IfAbruptRejectPromise,
+  Q, X,
+  Await,
+  NormalCompletion,
+  type ExpressionCompletion,
+  type PlainCompletion,
+  ThrowCompletion,
+  AbruptCompletion,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../helpers.mts';
+import type { AsyncFromSyncIteratorObject } from '../intrinsics/AsyncFromSyncIteratorPrototype.mts';
+import type { 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 { PromiseObject } 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;
+}
+
+/** https://tc39.es/ecma262/#sec-getiteratordirect */
+export function GetIteratorDirect(obj: ObjectValue): PlainCompletion<IteratorRecord> {
+  const nextMethod = Q(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): PlainCompletion<IteratorRecord> {
+  const iterator = Q(Call(method, obj));
+  if (!(iterator instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', iterator);
+  }
+  return GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-getiterator */
+export function GetIterator(obj: Value, kind: 'sync' | 'async'): PlainCompletion<IteratorRecord> {
+  let method;
+  if (kind === 'async') {
+    method = Q(GetMethod(obj, wellKnownSymbols.asyncIterator));
+    if (method === Value.undefined) {
+      const syncMethod = Q(GetMethod(obj, wellKnownSymbols.iterator));
+      if (syncMethod instanceof UndefinedValue) {
+        return surroundingAgent.Throw('TypeError', 'NotIterable', obj);
+      }
+      const syncIteratorRecord = Q(GetIteratorFromMethod(obj, syncMethod));
+      return CreateAsyncFromSyncIterator(syncIteratorRecord);
+    }
+  } else {
+    method = Q(GetMethod(obj, wellKnownSymbols.iterator));
+  }
+  if (method instanceof UndefinedValue) {
+    return surroundingAgent.Throw('TypeError', 'NotIterable', obj);
+  }
+  return GetIteratorFromMethod(obj, method);
+}
+
+export type PrimitiveHanding = 'iterate-string-primitives' | 'reject-primitives'
+export function GetIteratorFlattenable(obj: Value, primitiveHandling: PrimitiveHanding): PlainCompletion<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(GetMethod(obj, wellKnownSymbols.iterator));
+  let iterator;
+  if (method instanceof UndefinedValue) {
+    iterator = obj;
+  } else {
+    iterator = Q(Call(method, obj));
+  }
+  if (!(iterator instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', iterator);
+  }
+  return GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-iteratornext */
+export function IteratorNext(iteratorRecord: IteratorRecord, value?: Value): ExpressionCompletion<ObjectValue> {
+  let result;
+  if (!value) {
+    result = EnsureCompletion(Call(iteratorRecord.NextMethod, iteratorRecord.Iterator));
+  } else {
+    result = EnsureCompletion(Call(iteratorRecord.NextMethod, iteratorRecord.Iterator, [value]));
+  }
+  if (result instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+    return 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): ExpressionCompletion<BooleanValue> {
+  return ToBoolean(Q(Get(iteratorResult, Value('done'))));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorvalue */
+export function IteratorValue(iterResult: ObjectValue): ExpressionCompletion {
+  return Get(iterResult, Value('value'));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorstep */
+export function IteratorStep(iteratorRecord: IteratorRecord): PlainCompletion<ObjectValue | 'done'> {
+  const result = Q(IteratorNext(iteratorRecord));
+  let done: ExpressionCompletion = EnsureCompletion(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): PlainCompletion<Value | 'done'> {
+  const result = Q(IteratorStep(iteratorRecord));
+  if (result === 'done') {
+    return 'done';
+  }
+  const value = EnsureCompletion(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): C | ThrowCompletion {
+  Assert(iteratorRecord.Iterator instanceof ObjectValue);
+  const iterator = iteratorRecord.Iterator;
+  let innerResult: ExpressionCompletion = EnsureCompletion(GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret === Value.undefined) {
+      return completion;
+    }
+    innerResult = EnsureCompletion(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: ExpressionCompletion = EnsureCompletion(GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret instanceof UndefinedValue) {
+      return completion;
+    }
+    innerResult = 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('%IteratorPrototype%'));
+  return {
+    Iterator: iterator,
+    NextMethod: surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype.next%'),
+    Done: Value.false,
+  };
+}
+
+/** https://tc39.es/ecma262/#sec-iteratortolist */
+export function IteratorToList(iteratorRecord: IteratorRecord): PlainCompletion<Value[]> {
+  const list: Value[] = [];
+  while (true) {
+    const next = Q(IteratorStepValue(iteratorRecord));
+    if (next === 'done') {
+      return list;
+    }
+    list.push(next);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-createasyncfromsynciterator */
+export function CreateAsyncFromSyncIterator(syncIteratorRecord: 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): PromiseObject {
+  const done = IteratorComplete(result);
+  IfAbruptRejectPromise(done, promiseCapability);
+  __ts_cast__<BooleanValue>(done);
+  const value = IteratorValue(result);
+  IfAbruptRejectPromise(value, promiseCapability);
+  __ts_cast__<Value>(value);
+  let valueWrapper = PromiseResolve(surroundingAgent.intrinsic('%Promise%'), value);
+  if (valueWrapper instanceof AbruptCompletion && done === Value.false && closeOnRejection === Value.true) {
+    valueWrapper = 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/module-namespace-exotic-objects.mts

@@ -0,0 +1,223 @@
+import { surroundingAgent } from '../engine.mts';
+import { Q, X } from '../completion.mts';
+import { AbstractModuleRecord, ResolvedBindingRecord } from '../modules.mts';
+import {
+  SymbolValue,
+  Value,
+  Descriptor,
+  wellKnownSymbols,
+  JSStringValue,
+  type ObjectInternalMethods,
+  UndefinedValue,
+  type PropertyKeyValue,
+  NullValue,
+  BooleanValue,
+} from '../value.mts';
+import { isArray, JSStringSet, type Mutable } from '../helpers.mts';
+import {
+  Assert,
+  CompareArrayElements,
+  SameValue,
+  MakeBasicObject,
+  IsPropertyKey,
+  IsAccessorDescriptor,
+  SetImmutablePrototype,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  OrdinaryHasProperty,
+  OrdinaryGet,
+  OrdinaryDelete,
+  OrdinaryOwnPropertyKeys,
+  GetModuleNamespace, R,
+  type ExoticObject,
+} from './all.mts';
+
+export interface ModuleNamespaceObject extends ExoticObject {
+  readonly Module: AbstractModuleRecord;
+  readonly Exports: JSStringSet;
+  readonly Prototype: NullValue;
+  // never used
+  readonly Extensible: BooleanValue;
+}
+
+const InternalMethods = {
+  SetPrototypeOf(V) {
+    return Q(SetImmutablePrototype(this, V));
+  },
+  IsExtensible() {
+    return Value.false;
+  },
+  PreventExtensions() {
+    return Value.true;
+  },
+  GetOwnProperty(P) {
+    const O = this;
+
+    if (P instanceof SymbolValue) {
+      return OrdinaryGetOwnProperty(O, P);
+    }
+    const exports = O.Exports;
+    if (!exports.has(P)) {
+      return Value.undefined;
+    }
+    const value = Q(O.Get(P, O));
+    return Descriptor({
+      Value: value,
+      Writable: Value.true,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    });
+  },
+  DefineOwnProperty(P, Desc) {
+    const O = this;
+
+    if (P instanceof SymbolValue) {
+      return OrdinaryDefineOwnProperty(O, P, Desc);
+    }
+
+    const current = Q(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 (P instanceof SymbolValue) {
+      return OrdinaryHasProperty(O, P);
+    }
+    const exports = O.Exports;
+    if (exports.has(P)) {
+      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 (P instanceof SymbolValue) {
+      // a. Return ? OrdinaryGet(O, P, Receiver).
+      return OrdinaryGet(O, P, Receiver);
+    }
+    // 3. Let exports be O.[[Exports]].
+    const exports = O.Exports;
+    // 4. If P is not an element of exports, return undefined.
+    if (!exports.has(P)) {
+      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);
+    // 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));
+    }
+    // 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(targetEnv.GetBindingValue(binding.BindingName, Value.true));
+  },
+  Set() {
+    return Value.false;
+  },
+  Delete(P) {
+    const O = this;
+
+    Assert(IsPropertyKey(P));
+    if (P instanceof SymbolValue) {
+      return Q(OrdinaryDelete(O, P));
+    }
+    const exports = O.Exports;
+    if (exports.has(P)) {
+      return Value.false;
+    }
+    return Value.true;
+  },
+  OwnPropertyKeys() {
+    const O = this;
+
+    const exports: PropertyKeyValue[] = [...O.Exports];
+    const symbolKeys = X(OrdinaryOwnPropertyKeys(O));
+    exports.push(...symbolKeys);
+    return exports;
+  },
+} satisfies Partial<ObjectInternalMethods<ModuleNamespaceObject>>;
+
+/** https://tc39.es/ecma262/#sec-modulenamespacecreate */
+export function ModuleNamespaceCreate(module: AbstractModuleRecord, exports: readonly JSStringValue[]) {
+  // 1. Assert: module is a Module Record.
+  Assert(module instanceof AbstractModuleRecord);
+  // 2. Assert: module.[[Namespace]] is undefined.
+  Assert(module.Namespace instanceof UndefinedValue);
+  // 3. Assert: exports is a List of String values.
+  Assert(isArray(exports));
+  // 4. Let internalSlotsList be the internal slots listed in Table 31.
+  const internalSlotsList = ['Module', 'Exports', 'Prototype'];
+  // 5. Let M be ! MakeBasicObject(internalSlotsList).
+  const M = X(MakeBasicObject(internalSlotsList)) as Mutable<ModuleNamespaceObject>;
+  /** https://tc39.es/ecma262/#sec-module-namespace-exotic-objects */
+  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;
+  // 7. Set M.[[Prototype]] to null.
+  M.Prototype = Value.null;
+  // 8. Set M.[[Module]] to module.
+  M.Module = module;
+  // 9. Let sortedExports be a new List containing the same values as the list exports where the values are ordered as if an Array of the same values had been sorted using Array.prototype.sort using undefined as comparefn.
+  const sortedExports = [...exports].sort((x, y) => {
+    const result = X(CompareArrayElements(x, y, Value.undefined));
+    return R(result);
+  });
+  // 10. Set M.[[Exports]] to sortedExports.
+  M.Exports = new JSStringSet(sortedExports);
+  // 11. 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'),
+  }));
+  // 12. Set module.[[Namespace]] to M.
+  (module as Mutable<AbstractModuleRecord>).Namespace = M;
+  // 13. Return M;
+  return M;
+}