@engine262/engine262 0.0.1-093c8cb33fc82c295390da3d9e124c21ad7e6281

package/inspector/methods.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const engine262 = require('..');
+const { getContext } = require('./context');
+
+module.exports = {
+  Debugger: {
+    enable() {
+      return { debuggerId: 'debugger.0' };
+    },
+    setAsyncCallStackDepth() {},
+    setBlackboxPatterns() {},
+    setPauseOnExceptions() {},
+  },
+  Profiler: {
+    enable() {},
+  },
+  Runtime: {
+    enable() {},
+    compileScript() {
+      return { scriptId: 'script.0' };
+    },
+    callFunctionOn(options) {
+      const context = getContext(options.executionContextId);
+      const { Value: F } = context.realm.evaluateScript(`(${options.functionDeclaration})`);
+      const thisValue = options.objectId
+        ? context.getObject(options.objectId)
+        : engine262.Value.undefined;
+      const args = options.arguments.map((a) => {
+        if ('value' in a) {
+          return new engine262.Value(context.realm, a.value);
+        }
+        if ('objectId' in a) {
+          return context.getObject(a.objectId);
+        }
+        if ('unserializableValue' in a) {
+          throw new RangeError();
+        }
+        return engine262.Value.undefined;
+      });
+      const r = engine262.Call(F, thisValue, args);
+      return context.createEvaluationResult(r, options);
+    },
+    evaluate(options) {
+      if (options.throwOnSideEffect || options.awaitPromise) {
+        return {
+          exceptionDetails: {
+            text: 'unsupported',
+            lineNumber: 0,
+            columnNumber: 0,
+          },
+        };
+      }
+
+      const context = getContext(options.contextId);
+      const r = context.realm.evaluateScript(options.expression);
+      return context.createEvaluationResult(r, options);
+    },
+    getHeapUsage() {
+      return { usedSize: 0, totalSize: 0 };
+    },
+    getIsolateId() {
+      return { id: 'isolate.0' };
+    },
+    getProperties(options) {
+      const context = getContext();
+      const object = context.getObject(options.objectId);
+
+      const properties = context.getProperties(object, options);
+      if (properties instanceof engine262.AbruptCompletion) {
+        return context.createEvaluationResult(properties, options);
+      }
+
+      return {
+        result: properties.properties,
+        internalProperties: properties.internalProperties,
+      };
+    },
+    globalLexicalScopeNames({ executionContextId }) {
+      const context = getContext(executionContextId);
+      const envRec = context.realm.realm.GlobalEnv.EnvironmentRecord;
+      const names = Map.prototype.keys.call(envRec.DeclarativeRecord.bindings);
+      return {
+        names: [...names],
+      };
+    },
+    releaseObjectGroup({ objectGroup }) {
+      getContext().releaseObjectGroup(objectGroup);
+    },
+    runIfWaitingForDebugger(params, ctx) {
+      ctx.sendEvent('Runtime.executionContextCreated', {
+        context: {
+          id: '0',
+          origin: 'file://',
+          name: 'context.0',
+          auxData: {},
+        },
+      });
+    },
+  },
+  HeapProfiler: {
+    enable() {},
+    collectGarbage() {},
+  },
+};

package/inspector/server.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const http = require('http');
+const WebSocket = require('ws'); // eslint-disable-line import/no-extraneous-dependencies
+const packageJson = require('../package.json');
+const protocol = require('./js_protocol.json');
+const methods = require('./methods');
+
+const server = http.createServer((req, res) => {
+  if (req.method !== 'GET') {
+    res.writeHead(405);
+    res.end();
+    return;
+  }
+
+  const json = (obj) => {
+    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;
+  }
+});
+
+const wss = new WebSocket.Server({ server });
+
+wss.on('connection', (ws) => {
+  const send = (obj) => {
+    const s = JSON.stringify(obj);
+    // console.log('<-', s);
+    ws.send(s);
+  };
+
+  ws._socket.unref();
+
+  const context = {
+    sendEvent(event, params) {
+      send({ method: event, params });
+    },
+  };
+
+  ws.on('message', (data) => {
+    // console.log('->', data);
+    const { id, method, params } = JSON.parse(data);
+    const [k, v] = method.split('.');
+    Promise.resolve(methods[k][v](params, context))
+      .then((result = {}) => {
+        send({ id, result });
+      });
+  });
+});
+
+server.listen(9229, '127.0.0.1', () => {
+  console.log('Debugger listening at localhost:9229'); // eslint-disable-line no-console
+});
+server.unref();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@engine262/engine262",
+  "version": "0.0.1-093c8cb33fc82c295390da3d9e124c21ad7e6281",
+  "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": "dist/engine262",
+  "scripts": {
+    "lint": "eslint rollup.config.js test/ src/ bin/ inspector/ scripts/ --cache --ext=js,mjs",
+    "build": "npm run build:regex_data && npm run build:engine",
+    "build:regex_data": "node scripts/gen_regex_sets.js",
+    "build:engine": "rollup -c",
+    "test": "bash test/test_root.sh",
+    "test:test262": "node test/test262/test262.js",
+    "test:supplemental": "node test/supplemental.js",
+    "test:json": "node test/json/json.js",
+    "coverage": "c8 --reporter=lcov npm run test",
+    "prepublishOnly": "node scripts/tag_version_with_git_hash.js",
+    "postpublish": "git reset --hard HEAD"
+  },
+  "bin": {
+    "engine262": "bin/engine262.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/engine262/engine262.git"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.13",
+    "@babel/eslint-parser": "^7.12.13",
+    "@babel/plugin-proposal-optional-chaining": "^7.12.13",
+    "@engine262/eslint-plugin": "file:./test/eslint-plugin-engine262",
+    "@rollup/plugin-babel": "^5.2.3",
+    "@rollup/plugin-commonjs": "^17.1.0",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^11.1.1",
+    "@snek/source-map-support": "^1.0.4",
+    "@unicode/unicode-13.0.0": "^1.0.3",
+    "acorn": "^8.0.5",
+    "c8": "^7.5.0",
+    "eslint": "^7.19.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.22.1",
+    "glob": "^7.1.6",
+    "js-yaml": "^3.14.0",
+    "minimatch": "^3.0.4",
+    "rollup": "^2.38.5",
+    "ws": "^7.2.3"
+  }
+}