@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/lib-src/node/module.mts

@@ -0,0 +1,233 @@
+import { dirname, isAbsolute, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+import { readFile } from 'fs/promises';
+import {
+  AbstractModuleRecord,
+  Assert,
+  ManagedRealm, ModuleCache, OutOfRange, Realm,
+  surroundingAgent,
+  Throw,
+  Value,
+  type Job,
+  type ImportAttributeRecord,
+  type ModuleCacheKey,
+  type ModuleLoader,
+  type PlainCompletion,
+} from '#self';
+
+export interface FileSystemLoaderOptions {
+  getModuleCache?: (realm: ManagedRealm) => ModuleCache;
+  /** @default false */
+  sync?: boolean;
+  /**
+   * @default false
+   * If this loader accepts specifier like "/home/test/module.js".
+   * This conflicts with URL specifiers ("/root.js" relative to "http://example.com/").
+   *
+   * This will not reject Windows absolute path like "C:\path\to\module.js".
+   */
+  allowAbsoluteSpecifier?: boolean;
+  canImport?: (resolvedSpecifier: string, callback: (result: boolean) => void) => void;
+}
+
+export type ResolvedResult = { type: undefined | 'text' | 'json' | 'bytes', path: string };
+
+export function createFileSystemModuleLoader(options: FileSystemLoaderOptions = {}): ModuleLoader {
+  const {
+    getModuleCache = (realm) => realm.HostDefined.resolverCache,
+    sync,
+    allowAbsoluteSpecifier,
+    canImport,
+  } = options;
+
+  return (referrer, moduleRequest, _hostDefined, finish, suggestError) => {
+    const realm = (referrer instanceof Realm ? referrer : referrer.Realm) as ManagedRealm;
+    let type: ResolvedResult['type'];
+    for (const attribute of moduleRequest.Attributes) {
+      if (attribute.Key === 'type') {
+        const value = attribute.Value;
+        if (value !== 'json' && value !== 'text' && value !== 'bytes') {
+          suggestError(`Unsupported import type "${value}" (only "json", "bytes" and "text" are supported)`);
+          finish(undefined);
+          return;
+        }
+        type = value;
+      } else {
+        suggestError(`Unsupported import attribute "${attribute.Key}"`);
+        finish(undefined);
+        return;
+      }
+    }
+    const cache = getModuleCache(realm);
+    let resolvedPath: string;
+
+    const isPathToRoot = moduleRequest.Specifier.startsWith('/');
+    const isFileURL = moduleRequest.Specifier.startsWith('file://');
+    const isRelativeSpecifier = moduleRequest.Specifier.startsWith('./') || moduleRequest.Specifier.startsWith('../');
+    if (isPathToRoot) {
+      if (allowAbsoluteSpecifier) resolvedPath = moduleRequest.Specifier;
+      else {
+        suggestError(`Root specifier "${moduleRequest.Specifier}" is not allowed for locating file system modules`);
+        finish(undefined);
+        return;
+      }
+    } else if (isFileURL) {
+      resolvedPath = moduleRequest.Specifier;
+    } else if (isRelativeSpecifier) {
+      const referrerSpecifier = referrer.HostDefined?.specifier;
+      if (!referrerSpecifier) {
+        const pop = realm.pushTopContext();
+        finish(Throw.SyntaxError(`Cannot resolve relative module specifier "${moduleRequest.Specifier}" without referrer`));
+        pop?.();
+        return;
+      }
+      const specifierPath = referrerSpecifier.startsWith('file://') ? fileURLToPath(referrerSpecifier) : referrerSpecifier;
+      if (!isAbsolute(specifierPath)) {
+        suggestError(`Referrer "${referrerSpecifier}" cannot be used to locate module request "${moduleRequest.Specifier}"`);
+        finish(undefined);
+        return;
+      }
+      const dir = dirname(specifierPath);
+      resolvedPath = resolve(dir, moduleRequest.Specifier);
+    } else {
+      finish(undefined);
+      return;
+    }
+
+    if (canImport) {
+      canImport(resolvedPath, (result) => {
+        if (!result) {
+          const pop = realm.pushTopContext();
+          finish(Throw.SyntaxError(`Import module "${resolvedPath}" is not allowed`));
+          pop?.();
+          return;
+        }
+        next();
+      });
+    } else {
+      next();
+    }
+
+    function next() {
+      let resolvedAttributes: readonly ImportAttributeRecord[];
+      if (resolvedPath.endsWith('.json') && type === undefined) {
+        type = 'json';
+        Assert(moduleRequest.Attributes.length === 0);
+        resolvedAttributes = [{ Key: 'type', Value: 'json' }];
+      } else {
+        resolvedAttributes = moduleRequest.Attributes;
+      }
+      let cacheKey: ModuleCacheKey;
+      if (cache) {
+        cacheKey = cache.toCacheKey({ Specifier: resolvedPath, Attributes: resolvedAttributes });
+        cache.load(cacheKey, loader, finish);
+      } else {
+        loader(finish);
+      }
+    }
+
+    function loader(callback: (result: PlainCompletion<AbstractModuleRecord>) => void) {
+      if (type === 'bytes') {
+        loadBytes(resolvedPath, (err, data) => {
+          if (err) {
+            const pop = realm.pushTopContext();
+            callback(Throw.SyntaxError('$1', String((err as Error).message)));
+            pop?.();
+          } else callback(realm.createBytesModule(data));
+        });
+      } else {
+        load(resolvedPath, (err, data) => {
+          if (err) {
+            const pop = realm.pushTopContext();
+            callback(Throw.SyntaxError('$1', String((err as Error).message)));
+            pop?.();
+          } else if (type === undefined) {
+            callback(realm.compileModule(data, { specifier: resolvedPath }));
+          } else if (type === 'json') {
+            callback(realm.createJSONModule(data));
+          } else if (type === 'text') {
+            callback(realm.createTextModule(data));
+          } else {
+            Assert(type !== 'bytes');
+            throw OutOfRange.exhaustive(type);
+          }
+        });
+      }
+    }
+
+    function load(path: string, callback: (err: unknown, data: string) => void) {
+      if (sync) {
+        try {
+          const data = readFileSync(path, 'utf8');
+          callback(null, data);
+        } catch (err) {
+          callback(err, null!);
+        }
+      } else {
+        const job: Job = {
+          queueName: 'module-loader',
+          job: function* moduleLoaderJob() {
+            callback(result.err, result.data);
+            return Value.undefined;
+          },
+          callerRealm: undefined,
+          callerScriptOrModule: Value.null,
+        };
+        const result = { err: null as unknown, data: '' };
+        surroundingAgent.eventLoop.enqueueAsync('poll', job, (enqueue) => {
+          readFile(path, 'utf8').then(
+            (data) => {
+              result.err = null;
+              result.data = data;
+              enqueue();
+            },
+            (err) => {
+              result.err = err;
+              result.data = '';
+              enqueue();
+            },
+          );
+        });
+      }
+    }
+    function loadBytes(path: string, callback: (err: unknown, data: Uint8Array) => void) {
+      if (sync) {
+        try {
+          const data = readFileSync(path);
+          callback(null, new Uint8Array(data));
+        } catch (err) {
+          callback(err, null!);
+        }
+      } else {
+        const job: Job = {
+          queueName: 'module-loader',
+          job: function* moduleLoaderBytesJob() {
+            callback(result.err, result.data);
+            return Value.undefined;
+          },
+          callerRealm: undefined,
+          callerScriptOrModule: Value.null,
+        };
+        const result = { err: null as unknown, data: new Uint8Array() };
+        surroundingAgent.eventLoop.enqueueAsync('poll', job, (enqueue) => {
+          readFile(path).then(
+            (data) => {
+              result.err = null;
+              result.data = new Uint8Array(data);
+              enqueue();
+            },
+            (err) => {
+              result.err = err;
+              result.data = new Uint8Array();
+              enqueue();
+            },
+          );
+        });
+      }
+    }
+  };
+}
+
+export const fileSystemModuleLoader = createFileSystemModuleLoader();
+export const fileSystemModuleLoaderSync = createFileSystemModuleLoader({ sync: true });

package/lib-src/node/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "references": [{ "path": "../inspector" }, { "path": "../../src" }],
+  "compilerOptions": {
+    "incremental": true,
+    "declarationDir": "../../lib/node",
+    "tsBuildInfoFile": "../../lib/node/.tsbuildinfo",
+    "erasableSyntaxOnly": true,
+    "rewriteRelativeImportExtensions": true,
+    "rootDir": "./",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "outDir": "../../lib/node/"
+  },
+  "include": [
+    "./example.mts",
+    "./bin.mts",
+    "./inspector.mts",
+    "./module.mts"
+  ]
+}

package/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@engine262/engine262",
+  "version": "0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0",
+  "packageManager": "npm@9.8.0",
+  "description": "Implementation of ECMA-262 in JavaScript",
+  "author": "engine262 Contributors",
+  "license": "MIT",
+  "homepage": "https://github.com/engine262/engine262#readme",
+  "bugs": {
+    "url": "https://github.com/engine262/engine262/issues"
+  },
+  "main": "lib/engine262.js",
+  "types": "./declaration/index.d.mts",
+  "imports": {
+    "#self": {
+      "rollup": "./src/index.mts",
+      "types": "./declaration/index.d.mts",
+      "default": "./lib/engine262.mjs"
+    },
+    "#self/inspector": {
+      "types": "./lib/inspector/index.d.mts",
+      "default": "./lib/inspector.mjs"
+    }
+  },
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./declaration/index.d.mts",
+        "default": "./lib/engine262.js"
+      },
+      "import": {
+        "types": "./declaration/index.d.mts",
+        "default": "./lib/engine262.mjs"
+      }
+    },
+    "./inspector": {
+      "require": {
+        "types": "./declaration-inspector/index.d.mts",
+        "default": "./lib/inspector.js"
+      },
+      "import": {
+        "types": "./declaration-inspector/index.d.mts",
+        "default": "./lib/inspector.mjs"
+      }
+    },
+    "./lib/": "./lib/"
+  },
+  "scripts": {
+    "start": "node --enable-source-maps ./lib-src/node/bin.mts",
+    "inspector": "node ./website/server.mjs -c-1",
+    "lint": "tsgo -b ./test/eslint-plugin-engine262 && eslint test/ src/ bin/ lib-src/ scripts/ --cache",
+    "lint:fix": "npm run lint -- --fix",
+    "prebuild:err": "node scripts/generate_error_message_hint.mts",
+    "prebuild:bundle_test262_harness": "node scripts/bundle_test262_harness.mts",
+    "watch": "run-p \"watch:*\"",
+    "build": "run-s prebuild:bundle_test262_harness prebuild:err build:regex_data build:dts build:engine",
+    "build:regex_data": "node scripts/gen_regex_sets.mts",
+    "build:dts": "tsgo -b .",
+    "watch:dts": "tsgo -b . -w",
+    "build:engine": "rollup -c ./scripts/rollup.config.mts",
+    "watch:engine": "npm run build:engine -- --watch",
+    "spec:update": "node scripts/update_spec.mts",
+    "test": "run-s -c test:inspector test:owned test:json test:test262",
+    "test:test262": "node test/test262/test262.mts",
+    "test:owned": "vitest test/engine262 --watch=false",
+    "test:owned:watch": "vitest test/engine262",
+    "test:json": "node test/json/json.mts",
+    "test:inspector": "vitest test/inspector --watch=false",
+    "test:inspector:watch": "vitest test/inspector",
+    "coverage": "c8 --reporter=lcov npm run test",
+    "prepublishOnly": "node scripts/tag_version_with_git_hash.mts",
+    "postpublish": "git reset --hard HEAD"
+  },
+  "bin": {
+    "engine262": "lib/node/bin.mjs"
+  },
+  "files": [
+    "bin",
+    "declaration",
+    "declaration-inspector",
+    "!declaration/.tsbuildinfo",
+    "!lib/node/.tsbuildinfo",
+    "!lib/node/tsconfig.json",
+    "!lib/inspector/.tsbuildinfo",
+    "!lib/inspector/tsconfig.json",
+    "lib",
+    "src",
+    "lib-src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/engine262/engine262.git"
+  },
+  "peerDependencies": {
+    "ws": "^8.18.0"
+  },
+  "peerDependenciesMeta": {
+    "ws": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^8.0.0",
+    "@babel/core": "^8.0.0",
+    "@babel/plugin-proposal-decorators": "^8.0.0",
+    "@babel/plugin-transform-explicit-resource-management": "^8.0.0",
+    "@babel/preset-env": "^8.0.0",
+    "@babel/preset-typescript": "^8.0.0",
+    "@engine262/eslint-plugin": "file:test/eslint-plugin-engine262",
+    "@eslint/js": "^10.0.1",
+    "@pppp606/ink-chart": "^0.2.4",
+    "@rollup/plugin-commonjs": "^29.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@types/babel__code-frame": "^7.27.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/estree": "^1.0.8",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.5.2",
+    "@types/react": "^19.2.14",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/utils": "^8.63.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260404.1",
+    "@unicode/unicode-17.0.0": "^1.6.16",
+    "@vitest/coverage-v8": "^4.1.2",
+    "c8": "^11.0.0",
+    "cli-highlight": "^2.1.11",
+    "devtools-protocol": "^0.0.1608973",
+    "eslint": "^10.7.0",
+    "eslint-plugin-import-x": "^4.17.1",
+    "http-server": "^14.1.1",
+    "ink": "6.6.0",
+    "ink-task-list": "^2.0.0",
+    "js-yaml": "^4.1.0",
+    "jsbd": "^0.0.11",
+    "npm-run-all": "^4.1.5",
+    "react": "^19.2.4",
+    "rollup": "^4.54.0",
+    "tinyglobby": "^0.2.15",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.63.0",
+    "vitest": "^4.1.2",
+    "ws": "^8.20.0",
+    "zod": "^4.4.3"
+  }
+}

package/src/abstract-ops/all.mts

@@ -0,0 +1,38 @@
+export * from './arguments-operations.mts';
+export * from './array-objects.mts';
+export * from './arraybuffer-objects.mts';
+export * from './async-function-operations.mts';
+export * from './async-generator-objects.mts';
+export * from './data-types-and-values.mts';
+export * from './dataview-objects.mts';
+export * from './date-objects.mts';
+export * from './disposable-operations.mts';
+export * from './error-objects.mts';
+export * from './execution-contexts.mts';
+export * from './function-operations.mts';
+export * from './generator-operations.mts';
+export * from './global-object.mts';
+export * from './immutable-prototype-objects.mts';
+export * from './import-calls.mts';
+export * from './iterator-operations.mts';
+export * from './keyed-collections.mts';
+export * from './module-namespace-exotic-objects.mts';
+export * from './module-records.mts';
+export * from './notational-conventions.mts';
+export * from './object-operations.mts';
+export * from './objects.mts';
+export * from './private-names.mts';
+export * from './promise-operations.mts';
+export * from './proxy-objects.mts';
+export * from './realms.mts';
+export * from './reference-operations.mts';
+export * from './regexp-objects.mts';
+export * from './shadow-realm.mts';
+export * from './spec-types.mts';
+export * from './string-objects.mts';
+export * from './symbol-objects.mts';
+export * from './temporal/all.mts';
+export * from './testing-comparison.mts';
+export * from './type-conversion.mts';
+export * from './typedarray-objects.mts';
+export * from './weak-operations.mts';

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

@@ -0,0 +1,246 @@
+import {
+  Q, X, BoundNames, surroundingAgent,
+  JSStringSet, type Mutable, type ParseNode,
+  Assert,
+  CreateBuiltinFunction,
+  CreateDataProperty,
+  DefinePropertyOrThrow,
+  ToString,
+  SameValue,
+  MakeBasicObject,
+  OrdinaryObjectCreate,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGet,
+  OrdinarySet,
+  OrdinaryDelete,
+  Get,
+  Set,
+  HasOwnProperty,
+  IsAccessorDescriptor,
+  IsDataDescriptor,
+  F,
+  type OrdinaryObject,
+  Descriptor,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type ObjectInternalMethods,
+  EnvironmentRecord,
+  type ECMAScriptFunctionObject,
+} from '#self';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-arguments-exotic-objects */
+export interface MappedArgumentsObject extends OrdinaryObject {
+  readonly ParameterMap: ObjectValue;
+}
+export interface UnmappedArgumentsObject extends OrdinaryObject {
+  readonly ParameterMap: UndefinedValue;
+}
+
+export function isArgumentExoticObject(value: Value): value is MappedArgumentsObject | UnmappedArgumentsObject {
+  return 'ParameterMap' in value;
+}
+
+const ArgumentExoticObject = {
+  * GetOwnProperty(P) {
+    const args = this;
+    const desc = OrdinaryGetOwnProperty(args, P);
+    if (desc === Value.undefined) {
+      return desc;
+    }
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    if (isMapped === Value.true) {
+      return Descriptor({ ...desc, Value: Q(yield* Get(map, P)) });
+    }
+    return desc;
+  },
+  * DefineOwnProperty(P, Desc) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    let newArgDesc = Desc;
+    if (isMapped === Value.true && IsDataDescriptor(Desc) === true) {
+      if (Desc.Value === undefined && Desc.Writable !== undefined && Desc.Writable === Value.false) {
+        newArgDesc = Descriptor({ ...Desc, Value: X(Get(map, P)) });
+      }
+    }
+    const allowed = Q(yield* OrdinaryDefineOwnProperty(args, P, newArgDesc));
+    if (allowed === Value.false) {
+      return Value.false;
+    }
+    if (isMapped === Value.true) {
+      if (IsAccessorDescriptor(Desc) === true) {
+        yield* map.Delete(P);
+      } else {
+        if (Desc.Value !== undefined) {
+          const setStatus = yield* Set(map, P, Desc.Value, Value.false);
+          Assert(setStatus === Value.true);
+        }
+        if (Desc.Writable !== undefined && Desc.Writable === Value.false) {
+          yield* map.Delete(P);
+        }
+      }
+    }
+    return Value.true;
+  },
+  * Get(P, Receiver) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    if (isMapped === Value.false) {
+      return Q(yield* OrdinaryGet(args, P, Receiver));
+    } else {
+      return yield* Get(map, P);
+    }
+  },
+  * Set(P, V, Receiver) {
+    const args = this;
+    let isMapped;
+    let map;
+    if (!SameValue(args, Receiver)) {
+      isMapped = false;
+    } else {
+      map = args.ParameterMap;
+      isMapped = X(HasOwnProperty(map, P)) === Value.true;
+    }
+    if (isMapped) {
+      const setStatus = yield* Set(map!, P, V, Value.false);
+      Assert(setStatus === Value.true);
+    }
+    return Q(yield* OrdinarySet(args, P, V, Receiver));
+  },
+  * Delete(P) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    const result = Q(yield* OrdinaryDelete(args, P));
+    if (result === Value.true && isMapped === Value.true) {
+      yield* map.Delete(P);
+    }
+    return result;
+  },
+} satisfies Partial<ObjectInternalMethods<MappedArgumentsObject>>;
+
+/** https://tc39.es/ecma262/#sec-createunmappedargumentsobject */
+export function CreateUnmappedArgumentsObject(argumentsList: Arguments) {
+  const len = argumentsList.length;
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'), ['ParameterMap']) as Mutable<UnmappedArgumentsObject>;
+  obj.ParameterMap = Value.undefined;
+  X(DefinePropertyOrThrow(obj, Value('length'), Descriptor({
+    Value: F(len),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  let index = 0;
+  while (index < len) {
+    const val = argumentsList[index];
+    X(CreateDataProperty(obj, X(ToString(F(index))), val!));
+    index += 1;
+  }
+  X(DefinePropertyOrThrow(obj, wellKnownSymbols.iterator, Descriptor({
+    Value: surroundingAgent.intrinsic('%Array.prototype.values%'),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  X(DefinePropertyOrThrow(obj, Value('callee'), Descriptor({
+    Getter: surroundingAgent.intrinsic('%ThrowTypeError%'),
+    Setter: surroundingAgent.intrinsic('%ThrowTypeError%'),
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-makearggetter */
+function MakeArgGetter(name: JSStringValue, env: EnvironmentRecord) {
+  // 1. Let getterClosure be a new Abstract Closure with no parameters that captures name and env and performs the following steps when called:
+  //   a. Return env.GetBindingValue(name, false).
+  const getterClosure = () => env.GetBindingValue(name, Value.false);
+  // 2. Let getter be ! CreateBuiltinFunction(getterClosure, 0, "", « »).
+  const getter = X(CreateBuiltinFunction(getterClosure, 0, Value(''), ['Name', 'Env']));
+  // 3. NOTE: getter is never directly accessible to ECMAScript code.
+  // 4. Return getter.
+  return getter;
+}
+
+/** https://tc39.es/ecma262/#sec-makeargsetter */
+function MakeArgSetter(name: JSStringValue, env: EnvironmentRecord) {
+  // 1. Let setterClosure be a new Abstract Closure with parameters (value) that captures name and env and performs the following steps when called:
+  //   a. Return env.SetMutableBinding(name, value, false).
+  const setterClosure = ([value = Value.undefined]: Arguments) => env.SetMutableBinding(name, value, Value.false);
+  // 2. Let setter be ! CreateBuiltinFunction(setterClosure, 1, "", « »).
+  const setter = X(CreateBuiltinFunction(setterClosure, 1, Value(''), ['Name', 'Env']));
+  // 3. NOTE: setter is never directly accessible to ECMAScript code.
+  // 4. Return setter.
+  return setter;
+}
+
+/** https://tc39.es/ecma262/#sec-createmappedargumentsobject */
+export function CreateMappedArgumentsObject(func: ECMAScriptFunctionObject, formals: ParseNode.FormalParameters, argumentsList: Arguments, env: EnvironmentRecord) {
+  // Assert: formals does not contain a rest parameter, any binding
+  // patterns, or any initializers. It may contain duplicate identifiers.
+  const len = argumentsList.length;
+  const obj = X(MakeBasicObject(['Prototype', 'Extensible', 'ParameterMap']));
+  obj.GetOwnProperty = ArgumentExoticObject.GetOwnProperty;
+  obj.DefineOwnProperty = ArgumentExoticObject.DefineOwnProperty;
+  obj.Get = ArgumentExoticObject.Get;
+  obj.Set = ArgumentExoticObject.Set;
+  obj.Delete = ArgumentExoticObject.Delete;
+  obj.Prototype = surroundingAgent.intrinsic('%Object.prototype%');
+  const map = OrdinaryObjectCreate(Value.null);
+  obj.ParameterMap = map;
+  const parameterNames = BoundNames(formals);
+  const numberOfParameters = parameterNames.length;
+  let index = 0;
+  while (index < len) {
+    const val = argumentsList[index]!;
+    X(CreateDataProperty(obj, X(ToString(F(index))), val));
+    index += 1;
+  }
+  X(DefinePropertyOrThrow(obj, Value('length'), Descriptor({
+    Value: F(len),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  const mappedNames = new JSStringSet();
+  index = numberOfParameters - 1;
+  while (index >= 0) {
+    const name = parameterNames[index];
+    if (!mappedNames.has(name)) {
+      mappedNames.add(name);
+      if (index < len) {
+        const g = MakeArgGetter(name, env);
+        const p = MakeArgSetter(name, env);
+        X(map.DefineOwnProperty(X(ToString(F(index))), Descriptor({
+          Setter: p,
+          Getter: g,
+          Enumerable: Value.false,
+          Configurable: Value.true,
+        })));
+      }
+    }
+    index -= 1;
+  }
+  X(DefinePropertyOrThrow(obj, wellKnownSymbols.iterator, Descriptor({
+    Value: surroundingAgent.intrinsic('%Array.prototype.values%'),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  X(DefinePropertyOrThrow(obj, Value('callee'), Descriptor({
+    Value: func,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  return obj;
+}