@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/lib-src/node/inspector.mts

@@ -0,0 +1,124 @@
+import http from 'node:http';
+import https from 'node:https';
+import { WebSocketServer } from 'ws';
+import packageJson from '../../package.json' with { type: 'json' };
+// Note: typescript will not copy json files, so it will not appear in the lib directory
+// eslint-disable-next-line import/no-useless-path-segments
+import protocol from '../../lib-src/inspector/js_protocol.json' with { type: 'json' };
+import { Inspector } from '../inspector/index.mts';
+
+const ANSI = {
+  reset: '\u001b[0m',
+  red: '\u001b[31m',
+  green: '\u001b[32m',
+  yellow: '\u001b[33m',
+  blue: '\u001b[34m',
+};
+
+export class NodeWebsocketInspector extends Inspector {
+  _server: http.Server | https.Server;
+
+  _ws: WebSocketServer;
+
+  isDebug = false;
+
+  protected override send(data: object): void {
+    const s = JSON.stringify(data);
+    this._ws.clients.forEach((ws) => {
+      ws.send(s);
+    });
+  }
+
+  protected constructor(server: http.Server | https.Server, isDebug: boolean) {
+    super();
+    this._server = server;
+    const ws = new WebSocketServer({ server });
+    this._ws = ws;
+    ws.on('connection', (ws) => {
+      const send = (obj: unknown) => {
+        const s = JSON.stringify(obj);
+        ws.send(s);
+      };
+
+      const sendEvent = Object.create(new Proxy({}, {
+        get: (_, key: string) => {
+          const f = (params: Record<string, unknown>) => {
+            send({ method: key, params });
+          };
+          Object.defineProperty(sendEvent, key, { value: key });
+          return f;
+        },
+      }));
+
+      ws.on('message', (data: string) => {
+        const { id, method, params } = JSON.parse(data);
+        if (isDebug) {
+          process.stdout.write(`${ANSI.green}${method}${ANSI.reset}: ${JSON.stringify(params)}\n`);
+        }
+        this.onMessage(id, method, params);
+      });
+    });
+  }
+
+  static inspectorHTTPServer(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) {
+    if (req.method !== 'GET') {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+
+    const json = (obj: unknown) => {
+      const s = JSON.stringify(obj);
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(s),
+      });
+      res.end(s);
+    };
+
+    switch (req.url) {
+      case '/json':
+      case '/json/list':
+        json([{
+          description: `${packageJson.name} instance`,
+          devtoolsFrontendUrl: 'chrome-devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=localhost:9229/',
+          devtoolsFrontendUrlCompat: 'chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=localhost:9229/',
+          faviconUrl: 'https://avatars0.githubusercontent.com/u/51185628',
+          id: 'inspector.0',
+          title: 'engine262',
+          type: 'node',
+          url: `file://${process.cwd()}`,
+          webSocketDebuggerUrl: 'ws://localhost:9229/',
+        }]);
+        break;
+      case '/json/version':
+        json({
+          'Browser': `${packageJson.name}/v${packageJson.version}`,
+          'Protocol-Version': `${protocol.version.major}.${protocol.version.minor}`,
+        });
+        break;
+      case '/json/protocol':
+        json(protocol);
+        break;
+      default:
+        res.writeHead(404);
+        res.end();
+        break;
+    }
+  }
+
+  static new(port = 9229, host = '127.0.0.1', isDebug = !!process.env.DEBUG) {
+    const server = http.createServer(NodeWebsocketInspector.inspectorHTTPServer);
+    const inspector = new NodeWebsocketInspector(server, isDebug);
+    return new Promise<NodeWebsocketInspector>((resolve) => {
+      server.listen(port, host, () => {
+        resolve(inspector);
+      });
+    });
+  }
+
+  stop() {
+    this._server.close();
+    this._ws.close();
+  }
+}

package/lib-src/node/module.mts

@@ -0,0 +1,64 @@
+import { readFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  evalQ, ManagedRealm, NullValue, Realm, Throw, type AgentHostDefined,
+} from '#self';
+
+export function createLoadImportedModule(getCache = (realm: ManagedRealm) => realm.HostDefined.resolverCache) {
+  const loadImportedModule: NonNullable<AgentHostDefined['loadImportedModule']> = (referrer, specifier, _hostDefined, finish) => {
+    if (referrer instanceof Realm || referrer instanceof NullValue) {
+      throw new Error('Internal error: loadImportedModule called without a ScriptOrModule referrer.');
+    }
+    const realm = referrer.Realm as ManagedRealm;
+    const cache = getCache(realm);
+
+    evalQ(async (Q) => {
+      const base = path.dirname(referrer.HostDefined.specifier!);
+      const resolved = path.resolve(base, specifier);
+      if (cache?.has(resolved)) {
+        finish(cache!.get(resolved)!);
+        return;
+      }
+      try {
+        const source = await readFile(resolved, 'utf8');
+        const m = Q(resolved.endsWith('.json')
+          ? realm.createJSONModule(resolved, source)
+          : realm.createSourceTextModule(resolved, source));
+        cache?.set(resolved, m);
+        finish(m);
+      } catch (error) {
+        finish(Throw('SyntaxError', 'CouldNotResolveModule', specifier));
+      }
+    });
+  };
+  const loadImportedModuleSync: NonNullable<AgentHostDefined['loadImportedModule']> = (referrer, specifier, _hostDefined, finish) => {
+    if (referrer instanceof Realm || referrer instanceof NullValue) {
+      throw new Error('Internal error: loadImportedModule called without a ScriptOrModule referrer.');
+    }
+    const realm = referrer.Realm as ManagedRealm;
+    const cache = getCache(realm);
+
+    evalQ((Q) => {
+      const base = path.dirname(referrer.HostDefined.specifier!);
+      const resolved = path.resolve(base, specifier);
+      if (cache?.has(resolved)) {
+        finish(cache.get(resolved)!);
+        return;
+      }
+      try {
+        const source = readFileSync(resolved, 'utf8');
+        const m = Q(resolved.endsWith('.json')
+          ? realm.createJSONModule(resolved, source)
+          : realm.createSourceTextModule(resolved, source));
+        cache?.set(resolved, m);
+        finish(m);
+      } catch (error) {
+        finish(Throw('SyntaxError', 'CouldNotResolveModule', specifier));
+      }
+    });
+  };
+  return { loadImportedModule, loadImportedModuleSync };
+}
+
+export const { loadImportedModule, loadImportedModuleSync } = createLoadImportedModule();

package/lib-src/node/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "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": [
+    "./bin.mts",
+    "./inspector.mts",
+    "./module.mts"
+  ]
+}

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@engine262/engine262",
+  "version": "0.0.1-07c72085c73f960bcf0aa06db807321f3b446518",
+  "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/api.d.mts",
+  "imports": {
+    "#self": {
+      "rollup": "./src/api.mts",
+      "types": "./declaration/api.d.mts",
+      "default": "./lib/engine262.mjs"
+    }
+  },
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./declaration/api.d.mts",
+        "default": "./lib/engine262.js"
+      },
+      "import": {
+        "types": "./declaration/api.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 --disable-warning=ExperimentalWarning --experimental-strip-types ./lib-src/node/bin.mts",
+    "lint": "eslint test/ src/ bin/ lib-src/ scripts/ --cache --ext=js,mjs,mts",
+    "lint:fix": "eslint test/ src/ bin/ lib-src/ scripts/ --cache --ext=js,mjs,mts --fix",
+    "build": "run-s build:*",
+    "build:regex_data": "node scripts/gen_regex_sets.js",
+    "build:dts": "tsc -b .",
+    "build:engine": "NODE_OPTIONS='--enable-source-maps --disable-warning=ExperimentalWarning --experimental-strip-types' rollup -c ./scripts/rollup.config.mts",
+    "build-watch:engine": "npm run build:engine -- --watch",
+    "check": "tsc -b .",
+    "check:watch": "tsc -b . --watch",
+    "test": "bash test/test_root.sh",
+    "test:test262": "node --enable-source-maps --disable-warning=ExperimentalWarning --experimental-strip-types test/test262/test262.mts",
+    "test:supplemental": "node --enable-source-maps --disable-warning=ExperimentalWarning --experimental-strip-types test/supplemental.mts",
+    "test:json": "node --enable-source-maps --disable-warning=ExperimentalWarning --experimental-strip-types test/json/json.mts",
+    "coverage": "c8 --reporter=lcov npm run test",
+    "prepublishOnly": "node scripts/tag_version_with_git_hash.js",
+    "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": "^7.26.2",
+    "@babel/core": "^7.26.9",
+    "@babel/plugin-proposal-decorators": "^7.25.9",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.26.0",
+    "@engine262/eslint-plugin": "file:test/eslint-plugin-engine262",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@stylistic/eslint-plugin-js": "^3.1.0",
+    "@types/babel__code-frame": "^7.0.6",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.13.4",
+    "@types/ws": "^8.5.14",
+    "@typescript-eslint/eslint-plugin": "^8.24.1",
+    "@typescript-eslint/parser": "^8.24.1",
+    "@unicode/unicode-16.0.0": "^1.6.5",
+    "acorn": "^8.14.0",
+    "c8": "^10.1.3",
+    "devtools-protocol": "^0.0.1425554",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globby": "^14.1.0",
+    "js-yaml": "^4.1.0",
+    "minimatch": "^10.0.1",
+    "npm-run-all": "^4.1.5",
+    "rollup": "^4.34.8",
+    "typescript": "5.8.1-rc",
+    "ws": "^8.18.0"
+  },
+  "overrides": {
+    "typescript": "5.8.1-rc"
+  }
+}

package/src/abstract-ops/all.mts

@@ -0,0 +1,34 @@
+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 './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 './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 './spec-types.mts';
+export * from './string-objects.mts';
+export * from './symbol-objects.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 { surroundingAgent } from '../engine.mts';
+import {
+  Descriptor,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type ObjectInternalMethods,
+} from '../value.mts';
+import { BoundNames } from '../static-semantics/all.mts';
+import { Q, X } from '../completion.mts';
+import { JSStringSet, type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  CreateDataProperty,
+  DefinePropertyOrThrow,
+  ToString,
+  SameValue,
+  MakeBasicObject,
+  OrdinaryObjectCreate,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGet,
+  OrdinarySet,
+  OrdinaryDelete,
+  Get,
+  Set,
+  HasOwnProperty,
+  IsAccessorDescriptor,
+  IsDataDescriptor,
+  F,
+  type OrdinaryObject,
+} from './all.mts';
+import type { EnvironmentRecord } 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;
+}
+
+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(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(OrdinaryDefineOwnProperty(args, P, newArgDesc));
+    if (allowed === Value.false) {
+      return Value.false;
+    }
+    if (isMapped === Value.true) {
+      if (IsAccessorDescriptor(Desc) === true) {
+        map.Delete(P);
+      } else {
+        if (Desc.Value !== undefined) {
+          const setStatus = Set(map, P, Desc.Value, Value.false);
+          Assert(setStatus === Value.true);
+        }
+        if (Desc.Writable !== undefined && Desc.Writable === Value.false) {
+          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(OrdinaryGet(args, P, Receiver));
+    } else {
+      return Get(map, P);
+    }
+  },
+  Set(P, V, Receiver) {
+    const args = this;
+    let isMapped;
+    let map;
+    if (SameValue(args, Receiver) === Value.false) {
+      isMapped = false;
+    } else {
+      map = args.ParameterMap;
+      isMapped = X(HasOwnProperty(map, P)) === Value.true;
+    }
+    if (isMapped) {
+      const setStatus = Set(map!, P, V, Value.false);
+      Assert(setStatus === Value.true);
+    }
+    return Q(OrdinarySet(args, P, V, Receiver));
+  },
+  Delete(P) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    const result = Q(OrdinaryDelete(args, P));
+    if (result === Value.true && isMapped === Value.true) {
+      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;
+  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({
+    Get: surroundingAgent.intrinsic('%ThrowTypeError%'),
+    Set: 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: ObjectValue, 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({
+          Set: p,
+          Get: 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;
+}