@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/lib/inspector.js

@@ -0,0 +1,682 @@
+/*!
+ * engine262 0.0.1 07c72085c73f960bcf0aa06db807321f3b446518
+ *
+ * Copyright (c) 2018 engine262 Contributors
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('./engine262.mjs')) :
+  typeof define === 'function' && define.amd ? define(['exports', './engine262.mjs'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@engine262/engine262/inspector"] = {}, global["@engine262/engine262"]));
+})(this, (function (exports, engine262_mjs) { 'use strict';
+
+  class InspectorContext {
+    realm;
+    #idToObject = new Map();
+    #objectToId = new Map();
+    #objectCounter = 0;
+    #previewStack = [];
+    constructor(realm) {
+      this.realm = realm;
+    }
+    internObject(object, group = 'default') {
+      if (this.#objectToId.has(object)) {
+        return this.#objectToId.get(object);
+      }
+      const id = `${group}:${this.#objectCounter}`;
+      this.#objectCounter += 1;
+      this.#idToObject.set(id, object);
+      this.#objectToId.set(object, id);
+      return id;
+    }
+    releaseObject(id) {
+      const object = this.#idToObject.get(id);
+      if (object) {
+        this.#idToObject.delete(id);
+        this.#objectToId.delete(object);
+      }
+    }
+    releaseObjectGroup(group) {
+      for (const [id, object] of this.#idToObject.entries()) {
+        if (id.startsWith(group)) {
+          this.#idToObject.delete(id);
+          this.#objectToId.delete(object);
+        }
+      }
+    }
+    getObject(objectId) {
+      return this.#idToObject.get(objectId);
+    }
+    toRemoteObject(object, options) {
+      const type = engine262_mjs.Type(object);
+      switch (type) {
+        case 'Null':
+          return {
+            type: 'object',
+            subtype: 'null',
+            value: null
+          };
+        case 'Undefined':
+          return {
+            type: 'undefined'
+          };
+        case 'String':
+          return {
+            type: 'string',
+            value: object.stringValue()
+          };
+        case 'Number':
+          {
+            const result = {
+              type: 'number'
+            };
+            const v = object.numberValue(); // eslint-disable-line @engine262/mathematical-value
+            if (!Number.isFinite(v)) {
+              result.unserializableValue = v.toString();
+            } else {
+              result.value = v;
+            }
+            return result;
+          }
+        case 'Boolean':
+          return {
+            type: 'boolean',
+            value: object.booleanValue()
+          };
+        case 'BigInt':
+          return {
+            type: 'bigint',
+            unserializableValue: `${object.bigintValue().toString()}n`
+          };
+        // eslint-disable-line @engine262/mathematical-value
+        case 'Symbol':
+          return {
+            type: 'symbol',
+            description: object.Description === engine262_mjs.Value.undefined ? 'Symbol()'
+            // TODO: well-known symbols
+            : `Symbol.for(${object.Description.stringValue()})`
+          };
+      }
+      const result = {
+        type: 'object',
+        objectId: this.internObject(object, options.objectGroup)
+      };
+      // "iterator" | "generator"
+      if ('Call' in object) {
+        result.type = 'function';
+      } else {
+        result.subtype = getObjectValueSubtype(object);
+        if (engine262_mjs.IsArray(object) === engine262_mjs.Value.true) {
+          result.className = 'Array';
+          const v = engine262_mjs.EnsureCompletion(engine262_mjs.Get(object, engine262_mjs.Value('length')));
+          if (v.Type === 'normal') {
+            result.description = `Array(${engine262_mjs.R(v.Value)})`;
+          }
+        }
+      }
+      if (options.generatePreview && result.type === 'object' && result.subtype !== 'null' && !this.#previewStack.includes(object)) {
+        this.#previewStack.push(object);
+        const properties_completion = this.getPropertyPreview(object, options);
+        const properties = properties_completion instanceof engine262_mjs.ThrowCompletion ? [] : properties_completion;
+        let entries;
+        if ('MapData' in object) {
+          entries = object.MapData.filter(x => x.Key && x.Value).map(d => ({
+            key: this.toRemoteObject(d.Key, options).preview,
+            value: this.toRemoteObject(d.Value, options).preview
+          }));
+        }
+        this.#previewStack.pop();
+        result.preview = {
+          type: result.type,
+          subtype: result.subtype,
+          overflow: properties.length > 5,
+          properties: properties.slice(0, 5),
+          entries
+        };
+        if (engine262_mjs.IsArray(object) === engine262_mjs.Value.true) {
+          const v = engine262_mjs.EnsureCompletion(engine262_mjs.Get(object, engine262_mjs.Value('length')));
+          if (v.Type === 'normal') {
+            result.preview.description = `Array(${engine262_mjs.R(v.Value)})`;
+          }
+        }
+      }
+      return result;
+    }
+    getProperties(object, options) {
+      const wrap = v => this.toRemoteObject(v, options);
+      const properties = [];
+      const internalProperties = [];
+      const privateProperties = [];
+      object.PrivateElements.forEach(value => {
+        privateProperties.push({
+          name: value.Key.Description.stringValue(),
+          value: value.Value ? wrap(value.Value) : undefined,
+          get: value.Get ? wrap(value.Get) : undefined,
+          set: value.Set ? wrap(value.Set) : undefined
+        });
+      });
+      const value = engine262_mjs.evalQ(Q => {
+        let p = object;
+        while (p instanceof engine262_mjs.ObjectValue) {
+          for (const key of Q(p.OwnPropertyKeys())) {
+            const desc = Q(p.GetOwnProperty(key));
+            if (options.accessorPropertiesOnly && !engine262_mjs.IsAccessorDescriptor(desc)) {
+              continue;
+            }
+            if (desc instanceof engine262_mjs.UndefinedValue) {
+              return;
+            }
+            const descriptor = {
+              name: key instanceof engine262_mjs.JSStringValue ? key.stringValue() : '',
+              value: desc.Value ? wrap(desc.Value) : undefined,
+              writable: desc.Writable === engine262_mjs.Value.true,
+              get: desc.Get ? wrap(desc.Get) : undefined,
+              set: desc.Set ? wrap(desc.Set) : undefined,
+              configurable: desc.Configurable === engine262_mjs.Value.true,
+              enumerable: desc.Enumerable === engine262_mjs.Value.true,
+              wasThrown: false,
+              isOwn: p === object,
+              symbol: key instanceof engine262_mjs.SymbolValue ? wrap(key) : undefined
+            };
+            properties.push(descriptor);
+          }
+          if (options.ownProperties) {
+            break;
+          }
+          p = Q(p.GetPrototypeOf());
+        }
+      });
+      if (value.Type === 'throw') {
+        return {
+          result: [],
+          exceptionDetails: this.createExceptionDetails(value, options)
+        };
+      }
+      if (engine262_mjs.IsPromise(object) === engine262_mjs.Value.true) {
+        internalProperties.push({
+          name: '[[PromiseState]]',
+          value: {
+            type: 'string',
+            value: object.PromiseState
+          }
+        });
+        internalProperties.push({
+          name: '[[PromiseResult]]',
+          value: wrap(object.PromiseResult)
+        });
+      }
+      return {
+        result: properties,
+        internalProperties,
+        privateProperties
+      };
+    }
+    getPropertyPreview(object, options) {
+      const wrap = v => this.toRemoteObject(v, options);
+      const properties = [];
+      const value = engine262_mjs.evalQ(Q => {
+        const keys = Q(object.OwnPropertyKeys());
+        for (const key of keys) {
+          if (engine262_mjs.IsArray(object) === engine262_mjs.Value.true && key.type === 'String' && key.stringValue() === 'length') {
+            continue;
+          }
+          const desc = Q(object.GetOwnProperty(key));
+          const descriptor = {
+            type: 'object',
+            name: key instanceof engine262_mjs.JSStringValue ? key.stringValue() : `Symbol(${key.Description instanceof engine262_mjs.JSStringValue ? key.Description.stringValue() : ''})`
+          };
+          if (desc instanceof engine262_mjs.Descriptor && desc.Value) {
+            descriptor.valuePreview = wrap(desc.Value).preview;
+            switch (engine262_mjs.Type(desc.Value)) {
+              case 'Object':
+                if ('Call' in desc.Value) {
+                  descriptor.type = 'function';
+                } else {
+                  descriptor.type = 'object';
+                  descriptor.subtype = getObjectValueSubtype(desc.Value);
+                }
+                break;
+              case 'Null':
+                descriptor.type = 'object';
+                descriptor.subtype = 'null';
+                descriptor.value = 'null';
+                break;
+              case 'Undefined':
+                descriptor.type = 'undefined';
+                descriptor.value = 'undefined';
+                break;
+              case 'String':
+                descriptor.type = 'string';
+                descriptor.value = desc.Value.stringValue();
+                break;
+              case 'Number':
+                {
+                  descriptor.type = 'number';
+                  descriptor.value = desc.Value.numberValue().toString(); // eslint-disable-line @engine262/mathematical-value
+                  break;
+                }
+              case 'Boolean':
+                descriptor.type = 'boolean';
+                descriptor.value = desc.Value.booleanValue().toString();
+                break;
+              case 'BigInt':
+                descriptor.type = 'bigint';
+                descriptor.value = `${desc.Value.bigintValue().toString()}n`; // eslint-disable-line @engine262/mathematical-value
+                break;
+              case 'Symbol':
+                {
+                  descriptor.type = 'symbol';
+                  const description = desc.Value.Description instanceof engine262_mjs.JSStringValue ? desc.Value.Description.stringValue() : '';
+                  descriptor.value = `Symbol(${description})`;
+                  break;
+                }
+              default:
+                throw new RangeError();
+            }
+          } else {
+            descriptor.type = 'accessor';
+          }
+          properties.push(descriptor);
+        }
+      });
+      if (value.Type === 'throw') {
+        return value;
+      }
+      if (engine262_mjs.IsPromise(object) === engine262_mjs.Value.true) {
+        properties.push({
+          name: '[[PromiseState]]',
+          type: 'string',
+          value: object.PromiseState
+        });
+      }
+      return properties;
+    }
+    createExceptionDetails(completion, options) {
+      let text = '';
+      engine262_mjs.surroundingAgent.debugger_scopePreview(() => {
+        engine262_mjs.evalQ(Q => {
+          const value = completion.Value;
+          if (value instanceof engine262_mjs.ObjectValue) {
+            const stack = Q(engine262_mjs.Get(value, engine262_mjs.Value('stack')));
+            if (stack !== engine262_mjs.Value.undefined) {
+              text += Q(engine262_mjs.ToString(stack)).stringValue();
+            }
+          }
+        });
+      });
+      return {
+        text,
+        lineNumber: 0,
+        columnNumber: 0,
+        exceptionId: 0,
+        exception: this.toRemoteObject(completion.Value, options)
+      };
+    }
+    createEvaluationResult(completion, options) {
+      completion = engine262_mjs.EnsureCompletion(completion);
+      if (completion instanceof engine262_mjs.ThrowCompletion) {
+        return {
+          exceptionDetails: this.createExceptionDetails(completion, options),
+          result: this.toRemoteObject(completion.Value, options)
+        };
+      } else {
+        if (!(completion.Value instanceof engine262_mjs.Value)) {
+          throw new RangeError('Invalid completion value');
+        }
+        return {
+          result: this.toRemoteObject(completion.Value, options)
+        };
+      }
+    }
+  }
+  function getObjectValueSubtype(object) {
+    switch (true) {
+      case engine262_mjs.IsArray(object) === engine262_mjs.Value.true:
+        return 'array';
+      case 'RegExpMatcher' in object:
+        return 'regexp';
+      case 'DateValue' in object:
+        return 'date';
+      case 'MapData' in object:
+        return 'map';
+      case 'SetData' in object:
+        return 'set';
+      case 'WeakMapData' in object:
+        return 'weakmap';
+      case 'WeakSetData' in object:
+        return 'weakset';
+      case 'GeneratorState' in object:
+        return 'generator';
+      case 'ErrorData' in object:
+        return 'error';
+      case 'ProxyTarget' in object:
+        return 'proxy';
+      case 'PromiseState' in object:
+        return 'promise';
+      case 'TypedArrayName' in object:
+        return 'typedarray';
+      case 'ArrayBufferData' in object:
+        return 'arraybuffer';
+      case 'DataView' in object:
+        return 'dataview';
+      default:
+        return undefined;
+    }
+  }
+
+  const Debugger = {
+    enable(_req) {
+      return {
+        debuggerId: 'debugger.0'
+      };
+    },
+    setAsyncCallStackDepth() {},
+    setBlackboxPatterns() {},
+    setPauseOnExceptions() {},
+    setBlackboxExecutionContexts() {},
+    setBreakpointByUrl() {
+      return {
+        breakpointId: '0',
+        locations: []
+      };
+    }
+  };
+  const Profiler = {
+    enable() {}
+  };
+  const Runtime = {
+    discardConsoleEntries() {},
+    enable() {},
+    compileScript() {
+      return {
+        scriptId: 'script.0'
+      };
+    },
+    callFunctionOn(options, {
+      getContext
+    }) {
+      const context = getContext(options.executionContextId);
+      const {
+        Value: F
+      } = context.realm.evaluateScript(`(${options.functionDeclaration})`);
+      const thisValue = options.objectId ? context.getObject(options.objectId) : engine262_mjs.Value.undefined;
+      const args = options.arguments?.map(a => {
+        if ('value' in a) {
+          return engine262_mjs.Value(a.value);
+        }
+        if (a.objectId) {
+          return context.getObject(a.objectId);
+        }
+        if ('unserializableValue' in a) {
+          throw new RangeError();
+        }
+        return engine262_mjs.Value.undefined;
+      });
+      const r = engine262_mjs.Call(F, thisValue, args || []);
+      // @ts-expect-error
+      return context.createEvaluationResult(r, options);
+    },
+    evaluate(options, {
+      preference,
+      getContext
+    }) {
+      if (options.awaitPromise || !preference.preview && options.throwOnSideEffect) {
+        return {
+          result: {
+            type: 'undefined'
+          },
+          exceptionDetails: {
+            text: 'unsupported',
+            lineNumber: 0,
+            columnNumber: 0,
+            exceptionId: 0
+          }
+        };
+      }
+      const context = getContext(options.contextId);
+      // TODO: introduce devtool scoping
+      const finalSource = options.throwOnSideEffect ? `{\n${options.expression}}\n` : options.expression;
+      const r = context.realm.evaluateScript(finalSource, {
+        inspectorPreview: options.throwOnSideEffect
+      });
+      // @ts-expect-error
+      return context.createEvaluationResult(r, options);
+    },
+    getExceptionDetails(req, {
+      getContext
+    }) {
+      const context = getContext();
+      const object = context.getObject(req.errorObjectId);
+      if (object instanceof engine262_mjs.ObjectValue) {
+        return {
+          // @ts-expect-error
+          exceptionDetails: context.createExceptionDetails(engine262_mjs.ThrowCompletion(object), {})
+        };
+      }
+      return {
+        exceptionDetails: {
+          text: 'unsupported',
+          lineNumber: 0,
+          columnNumber: 0,
+          exceptionId: 0
+        }
+      };
+    },
+    getHeapUsage() {
+      return {
+        usedSize: 0,
+        totalSize: 0,
+        backingStorageSize: 0,
+        embedderHeapUsedSize: 0
+      };
+    },
+    getIsolateId() {
+      return {
+        id: 'isolate.0'
+      };
+    },
+    getProperties(options, {
+      getContext
+    }) {
+      const context = getContext();
+      const object = context.getObject(options.objectId);
+      // @ts-expect-error
+      return context.getProperties(object, options);
+    },
+    globalLexicalScopeNames({
+      executionContextId
+    }, {
+      getContext
+    }) {
+      const context = getContext(executionContextId);
+      const envRec = context.realm.GlobalEnv;
+      const names = Array.from(envRec.DeclarativeRecord.bindings.keys(), v => v.stringValue());
+      return {
+        names
+      };
+    },
+    releaseObject(req, {
+      getContext
+    }) {
+      getContext().releaseObject(req.objectId);
+    },
+    releaseObjectGroup({
+      objectGroup
+    }, {
+      getContext
+    }) {
+      getContext().releaseObjectGroup(objectGroup);
+    },
+    runIfWaitingForDebugger(_, ctx) {
+      ctx.sendEvent['Runtime.executionContextCreated']({
+        context: {
+          id: 0,
+          origin: 'eval',
+          name: 'top',
+          uniqueId: ''
+        }
+      });
+    }
+  };
+  const HeapProfiler = {
+    enable() {},
+    collectGarbage() {}
+  };
+
+  var impl = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Debugger: Debugger,
+    HeapProfiler: HeapProfiler,
+    Profiler: Profiler,
+    Runtime: Runtime
+  });
+
+  const consoleMethods = ['log', 'debug', 'info', 'error', 'warning', 'dir', 'dirxml', 'table', 'trace', 'clear', 'startGroup', 'startGroupCollapsed', 'endGroup', 'assert', 'profile', 'profileEnd', 'count', 'timeEnd'];
+  function createConsole(realm, defaultBehaviour) {
+    realm.scope(() => {
+      const console = engine262_mjs.OrdinaryObjectCreate(realm.Intrinsics['%Object.prototype%']);
+      engine262_mjs.DefinePropertyOrThrow(realm.GlobalObject, engine262_mjs.Value('console'), engine262_mjs.Descriptor({
+        Configurable: engine262_mjs.Value.true,
+        Enumerable: engine262_mjs.Value.false,
+        Writable: engine262_mjs.Value.true,
+        Value: console
+      }));
+      consoleMethods.forEach(method => {
+        const f = engine262_mjs.CreateBuiltinFunction(args => {
+          if (engine262_mjs.surroundingAgent.debugger_isPreviewing) {
+            return engine262_mjs.Value.undefined;
+          }
+          if (defaultBehaviour[method]) {
+            const completion = defaultBehaviour[method](args);
+            if (completion instanceof engine262_mjs.ThrowCompletion) {
+              return completion;
+            }
+          }
+          if (realm.HostDefined.attachingInspector instanceof Inspector) {
+            realm.HostDefined.attachingInspector.console(realm, method, args);
+          }
+          return engine262_mjs.Value.undefined;
+        }, 1, engine262_mjs.Value(method), []);
+        engine262_mjs.CreateDataProperty(console, engine262_mjs.Value(method), f);
+      });
+    });
+  }
+  function createInternals(realm) {
+    realm.scope(() => {
+      const $ = engine262_mjs.OrdinaryObjectCreate.from({
+        debugger: () => {
+          if (engine262_mjs.surroundingAgent.debugger_isPreviewing) {
+            return;
+          }
+          // eslint-disable-next-line no-debugger
+          debugger;
+        },
+        detachArrayBuffer: object => {
+          if (!engine262_mjs.isArrayBufferObject(object)) {
+            return engine262_mjs.surroundingAgent.Throw('TypeError', 'Raw', 'Argument must be an ArrayBuffer');
+          }
+          return engine262_mjs.DetachArrayBuffer(object);
+        }
+      });
+      engine262_mjs.CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, engine262_mjs.Value('$'), $);
+    });
+  }
+
+  const ignoreNamespaces = ['Network'];
+  const ignoreMethods = [];
+  class Inspector {
+    preference = {
+      preview: false,
+      previewDebug: false
+    };
+    #contexts = [];
+    attachRealm(realm) {
+      this.#contexts.push(new InspectorContext(realm));
+      realm.HostDefined.attachingInspector = this;
+    }
+    onMessage(id, methodArg, params) {
+      if (ignoreMethods.includes(methodArg)) {
+        return;
+      }
+      const [namespace, method] = methodArg.split('.');
+      if (ignoreNamespaces.includes(namespace)) {
+        return;
+      }
+      if (!(namespace in impl)) {
+        // eslint-disable-next-line no-console
+        console.error(`Unknown namespace requested: ${namespace}`);
+        return;
+      }
+      const ns = impl[namespace];
+      if (!(method in ns)) {
+        // eslint-disable-next-line no-console
+        console.error(`Unknown method requested: ${namespace}.${method}`);
+        return;
+      }
+      const f = ns[method];
+      new Promise(resolve => {
+        resolve(f(params, this.#context));
+      }).then((result = {}) => {
+        this.send({
+          id,
+          result
+        });
+      });
+    }
+    sendEvent = Object.create(new Proxy({}, {
+      get: (_, key) => {
+        const f = params => {
+          this.send({
+            method: key,
+            params
+          });
+        };
+        Object.defineProperty(this.sendEvent, key, {
+          value: f
+        });
+        return f;
+      }
+    }));
+    console(realm, type, args) {
+      const context = this.#contexts.findIndex(c => c.realm === realm);
+      this.sendEvent['Runtime.consoleAPICalled']({
+        type,
+        // @ts-expect-error
+        args: args.map(x => this.#contexts[context].toRemoteObject(x, {
+          generatePreview: true
+        })),
+        executionContextId: context,
+        timestamp: Date.now()
+      });
+    }
+    #context = {
+      sendEvent: this.sendEvent,
+      preference: this.preference,
+      getContext: (id = 0) => this.#contexts.at(id)
+    };
+  }
+
+  exports.Inspector = Inspector;
+  exports.createConsole = createConsole;
+  exports.createInternals = createInternals;
+
+}));
+//# sourceMappingURL=inspector.js.map