@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/lib/inspector.mjs

@@ -0,0 +1,674 @@
+/*!
+ * 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.
+ */
+
+import { Type, Value, IsArray, EnsureCompletion, Get, R, evalQ, ObjectValue, IsAccessorDescriptor, UndefinedValue, SymbolValue, JSStringValue, IsPromise, Descriptor, surroundingAgent, ToString, ThrowCompletion, Call, OrdinaryObjectCreate, DefinePropertyOrThrow, CreateBuiltinFunction, CreateDataProperty, isArrayBufferObject, DetachArrayBuffer, CreateNonEnumerableDataPropertyOrThrow } from './engine262.mjs';
+
+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 = 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 === 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 (IsArray(object) === Value.true) {
+        result.className = 'Array';
+        const v = EnsureCompletion(Get(object, Value('length')));
+        if (v.Type === 'normal') {
+          result.description = `Array(${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 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 (IsArray(object) === Value.true) {
+        const v = EnsureCompletion(Get(object, Value('length')));
+        if (v.Type === 'normal') {
+          result.preview.description = `Array(${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 = evalQ(Q => {
+      let p = object;
+      while (p instanceof ObjectValue) {
+        for (const key of Q(p.OwnPropertyKeys())) {
+          const desc = Q(p.GetOwnProperty(key));
+          if (options.accessorPropertiesOnly && !IsAccessorDescriptor(desc)) {
+            continue;
+          }
+          if (desc instanceof UndefinedValue) {
+            return;
+          }
+          const descriptor = {
+            name: key instanceof JSStringValue ? key.stringValue() : '',
+            value: desc.Value ? wrap(desc.Value) : undefined,
+            writable: desc.Writable === Value.true,
+            get: desc.Get ? wrap(desc.Get) : undefined,
+            set: desc.Set ? wrap(desc.Set) : undefined,
+            configurable: desc.Configurable === Value.true,
+            enumerable: desc.Enumerable === Value.true,
+            wasThrown: false,
+            isOwn: p === object,
+            symbol: key instanceof 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 (IsPromise(object) === 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 = evalQ(Q => {
+      const keys = Q(object.OwnPropertyKeys());
+      for (const key of keys) {
+        if (IsArray(object) === Value.true && key.type === 'String' && key.stringValue() === 'length') {
+          continue;
+        }
+        const desc = Q(object.GetOwnProperty(key));
+        const descriptor = {
+          type: 'object',
+          name: key instanceof JSStringValue ? key.stringValue() : `Symbol(${key.Description instanceof JSStringValue ? key.Description.stringValue() : ''})`
+        };
+        if (desc instanceof Descriptor && desc.Value) {
+          descriptor.valuePreview = wrap(desc.Value).preview;
+          switch (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 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 (IsPromise(object) === Value.true) {
+      properties.push({
+        name: '[[PromiseState]]',
+        type: 'string',
+        value: object.PromiseState
+      });
+    }
+    return properties;
+  }
+  createExceptionDetails(completion, options) {
+    let text = '';
+    surroundingAgent.debugger_scopePreview(() => {
+      evalQ(Q => {
+        const value = completion.Value;
+        if (value instanceof ObjectValue) {
+          const stack = Q(Get(value, Value('stack')));
+          if (stack !== Value.undefined) {
+            text += Q(ToString(stack)).stringValue();
+          }
+        }
+      });
+    });
+    return {
+      text,
+      lineNumber: 0,
+      columnNumber: 0,
+      exceptionId: 0,
+      exception: this.toRemoteObject(completion.Value, options)
+    };
+  }
+  createEvaluationResult(completion, options) {
+    completion = EnsureCompletion(completion);
+    if (completion instanceof ThrowCompletion) {
+      return {
+        exceptionDetails: this.createExceptionDetails(completion, options),
+        result: this.toRemoteObject(completion.Value, options)
+      };
+    } else {
+      if (!(completion.Value instanceof Value)) {
+        throw new RangeError('Invalid completion value');
+      }
+      return {
+        result: this.toRemoteObject(completion.Value, options)
+      };
+    }
+  }
+}
+function getObjectValueSubtype(object) {
+  switch (true) {
+    case IsArray(object) === 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) : Value.undefined;
+    const args = options.arguments?.map(a => {
+      if ('value' in a) {
+        return Value(a.value);
+      }
+      if (a.objectId) {
+        return context.getObject(a.objectId);
+      }
+      if ('unserializableValue' in a) {
+        throw new RangeError();
+      }
+      return Value.undefined;
+    });
+    const r = 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 ObjectValue) {
+      return {
+        // @ts-expect-error
+        exceptionDetails: context.createExceptionDetails(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 = OrdinaryObjectCreate(realm.Intrinsics['%Object.prototype%']);
+    DefinePropertyOrThrow(realm.GlobalObject, Value('console'), Descriptor({
+      Configurable: Value.true,
+      Enumerable: Value.false,
+      Writable: Value.true,
+      Value: console
+    }));
+    consoleMethods.forEach(method => {
+      const f = CreateBuiltinFunction(args => {
+        if (surroundingAgent.debugger_isPreviewing) {
+          return Value.undefined;
+        }
+        if (defaultBehaviour[method]) {
+          const completion = defaultBehaviour[method](args);
+          if (completion instanceof ThrowCompletion) {
+            return completion;
+          }
+        }
+        if (realm.HostDefined.attachingInspector instanceof Inspector) {
+          realm.HostDefined.attachingInspector.console(realm, method, args);
+        }
+        return Value.undefined;
+      }, 1, Value(method), []);
+      CreateDataProperty(console, Value(method), f);
+    });
+  });
+}
+function createInternals(realm) {
+  realm.scope(() => {
+    const $ = OrdinaryObjectCreate.from({
+      debugger: () => {
+        if (surroundingAgent.debugger_isPreviewing) {
+          return;
+        }
+        // eslint-disable-next-line no-debugger
+        debugger;
+      },
+      detachArrayBuffer: object => {
+        if (!isArrayBufferObject(object)) {
+          return surroundingAgent.Throw('TypeError', 'Raw', 'Argument must be an ArrayBuffer');
+        }
+        return DetachArrayBuffer(object);
+      }
+    });
+    CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, 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)
+  };
+}
+
+export { Inspector, createConsole, createInternals };
+//# sourceMappingURL=inspector.mjs.map