@checkly/playwright-core 1.42.17 → 1.47.11

package/lib/server/bidi/bidiBrowser.js

@@ -0,0 +1,296 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Network = exports.BidiBrowserContext = exports.BidiBrowser = void 0;
+var _eventsHelper = require("../../utils/eventsHelper");
+var _browser = require("../browser");
+var _browserContext = require("../browserContext");
+var network = _interopRequireWildcard(require("../network"));
+var _bidiConnection = require("./bidiConnection");
+var _bidiNetworkManager = require("./bidiNetworkManager");
+var _bidiPage = require("./bidiPage");
+var bidi = _interopRequireWildcard(require("./third_party/bidiProtocol"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class BidiBrowser extends _browser.Browser {
+  static async connect(parent, transport, options) {
+    const browser = new BidiBrowser(parent, transport, options);
+    if (options.__testHookOnConnectToBrowser) await options.__testHookOnConnectToBrowser();
+    const sessionStatus = await browser._browserSession.send('session.status', {});
+    if (!sessionStatus.ready) throw new Error('Bidi session is not ready. ' + sessionStatus.message);
+    let proxy;
+    if (options.proxy) {
+      proxy = {
+        proxyType: 'manual'
+      };
+      const url = new URL(options.proxy.server); // Validate proxy server.
+      switch (url.protocol) {
+        case 'http:':
+          proxy.httpProxy = url.host;
+          break;
+        case 'https:':
+          proxy.httpsProxy = url.host;
+          break;
+        case 'socks4:':
+          proxy.socksProxy = url.host;
+          proxy.socksVersion = 4;
+          break;
+        case 'socks5:':
+          proxy.socksProxy = url.host;
+          proxy.socksVersion = 5;
+          break;
+        default:
+          throw new Error('Invalid proxy server protocol: ' + options.proxy.server);
+      }
+      if (options.proxy.bypass) proxy.noProxy = options.proxy.bypass.split(',');
+      // TODO: support authentication.
+    }
+    browser._bidiSessionInfo = await browser._browserSession.send('session.new', {
+      capabilities: {
+        alwaysMatch: {
+          acceptInsecureCerts: false,
+          proxy,
+          unhandledPromptBehavior: {
+            default: bidi.Session.UserPromptHandlerType.Ignore
+          },
+          webSocketUrl: true
+        }
+      }
+    });
+    await browser._browserSession.send('session.subscribe', {
+      events: ['browsingContext', 'network', 'log', 'script']
+    });
+    return browser;
+  }
+  constructor(parent, transport, options) {
+    super(parent, options);
+    this._connection = void 0;
+    this._browserSession = void 0;
+    this._bidiSessionInfo = void 0;
+    this._contexts = new Map();
+    this._bidiPages = new Map();
+    this._eventListeners = void 0;
+    this._connection = new _bidiConnection.BidiConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
+    this._browserSession = this._connection.browserSession;
+    this._eventListeners = [_eventsHelper.eventsHelper.addEventListener(this._browserSession, 'browsingContext.contextCreated', this._onBrowsingContextCreated.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'script.realmDestroyed', this._onScriptRealmDestroyed.bind(this))];
+  }
+  _onDisconnect() {
+    this._didClose();
+  }
+  async doCreateNewContext(options) {
+    const {
+      userContext
+    } = await this._browserSession.send('browser.createUserContext', {});
+    const context = new BidiBrowserContext(this, userContext, options);
+    await context._initialize();
+    this._contexts.set(userContext, context);
+    return context;
+  }
+  contexts() {
+    return Array.from(this._contexts.values());
+  }
+  version() {
+    return this._bidiSessionInfo.capabilities.browserVersion;
+  }
+  userAgent() {
+    return this._bidiSessionInfo.capabilities.userAgent;
+  }
+  isConnected() {
+    return !this._connection.isClosed();
+  }
+  _onBrowsingContextCreated(event) {
+    if (event.parent) {
+      const parentFrameId = event.parent;
+      for (const page of this._bidiPages.values()) {
+        const parentFrame = page._page._frameManager.frame(parentFrameId);
+        if (!parentFrame) continue;
+        page._session.addFrameBrowsingContext(event.context);
+        page._page._frameManager.frameAttached(event.context, parentFrameId);
+        return;
+      }
+      return;
+    }
+    let context = this._contexts.get(event.userContext);
+    if (!context) context = this._defaultContext;
+    if (!context) return;
+    const session = this._connection.createMainFrameBrowsingContextSession(event.context);
+    const opener = event.originalOpener && this._bidiPages.get(event.originalOpener);
+    const page = new _bidiPage.BidiPage(context, session, opener || null);
+    this._bidiPages.set(event.context, page);
+  }
+  _onBrowsingContextDestroyed(event) {
+    if (event.parent) {
+      this._browserSession.removeFrameBrowsingContext(event.context);
+      const parentFrameId = event.parent;
+      for (const page of this._bidiPages.values()) {
+        const parentFrame = page._page._frameManager.frame(parentFrameId);
+        if (!parentFrame) continue;
+        page._page._frameManager.frameDetached(event.context);
+        return;
+      }
+      return;
+    }
+    const bidiPage = this._bidiPages.get(event.context);
+    if (!bidiPage) return;
+    bidiPage.didClose();
+    this._bidiPages.delete(event.context);
+  }
+  _onScriptRealmDestroyed(event) {
+    for (const page of this._bidiPages.values()) {
+      if (page._onRealmDestroyed(event)) return;
+    }
+  }
+}
+exports.BidiBrowser = BidiBrowser;
+class BidiBrowserContext extends _browserContext.BrowserContext {
+  constructor(browser, browserContextId, options) {
+    super(browser, options, browserContextId);
+    this._authenticateProxyViaHeader();
+  }
+  pages() {
+    return [];
+  }
+  async newPageDelegate() {
+    (0, _browserContext.assertBrowserContextIsNotOwned)(this);
+    const {
+      context
+    } = await this._browser._browserSession.send('browsingContext.create', {
+      type: bidi.BrowsingContext.CreateType.Window,
+      userContext: this._browserContextId
+    });
+    return this._browser._bidiPages.get(context);
+  }
+  async doGetCookies(urls) {
+    const {
+      cookies
+    } = await this._browser._browserSession.send('storage.getCookies', {
+      partition: {
+        type: 'storageKey',
+        userContext: this._browserContextId
+      }
+    });
+    return network.filterCookies(cookies.map(c => {
+      var _c$expiry;
+      const copy = {
+        name: c.name,
+        value: (0, _bidiNetworkManager.bidiBytesValueToString)(c.value),
+        domain: c.domain,
+        path: c.path,
+        httpOnly: c.httpOnly,
+        secure: c.secure,
+        expires: (_c$expiry = c.expiry) !== null && _c$expiry !== void 0 ? _c$expiry : -1,
+        sameSite: c.sameSite ? fromBidiSameSite(c.sameSite) : 'None'
+      };
+      return copy;
+    }), urls);
+  }
+  async addCookies(cookies) {
+    cookies = network.rewriteCookies(cookies);
+    const promises = cookies.map(c => {
+      const cookie = {
+        name: c.name,
+        value: {
+          type: 'string',
+          value: c.value
+        },
+        domain: c.domain,
+        path: c.path,
+        httpOnly: c.httpOnly,
+        secure: c.secure,
+        sameSite: c.sameSite && toBidiSameSite(c.sameSite),
+        expiry: c.expires === -1 || c.expires === undefined ? undefined : Math.round(c.expires)
+      };
+      return this._browser._browserSession.send('storage.setCookie', {
+        cookie,
+        partition: {
+          type: 'storageKey',
+          userContext: this._browserContextId
+        }
+      });
+    });
+    await Promise.all(promises);
+  }
+  async doClearCookies() {
+    await this._browser._browserSession.send('storage.deleteCookies', {
+      partition: {
+        type: 'storageKey',
+        userContext: this._browserContextId
+      }
+    });
+  }
+  async doGrantPermissions(origin, permissions) {}
+  async doClearPermissions() {}
+  async setGeolocation(geolocation) {}
+  async setExtraHTTPHeaders(headers) {}
+  async setUserAgent(userAgent) {}
+  async setOffline(offline) {}
+  async doSetHTTPCredentials(httpCredentials) {}
+  async doAddInitScript(initScript) {
+    // for (const page of this.pages())
+    //   await (page._delegate as WKPage)._updateBootstrapScript();
+  }
+  async doRemoveNonInternalInitScripts() {}
+  async doUpdateRequestInterception() {}
+  onClosePersistent() {}
+  async clearCache() {}
+  async doClose(reason) {
+    // TODO: implement for persistent context
+    if (!this._browserContextId) return;
+    await this._browser._browserSession.send('browser.removeUserContext', {
+      userContext: this._browserContextId
+    });
+    this._browser._contexts.delete(this._browserContextId);
+  }
+  async cancelDownload(uuid) {}
+}
+exports.BidiBrowserContext = BidiBrowserContext;
+function fromBidiSameSite(sameSite) {
+  switch (sameSite) {
+    case 'strict':
+      return 'Strict';
+    case 'lax':
+      return 'Lax';
+    case 'none':
+      return 'None';
+  }
+  return 'None';
+}
+function toBidiSameSite(sameSite) {
+  switch (sameSite) {
+    case 'Strict':
+      return bidi.Network.SameSite.Strict;
+    case 'Lax':
+      return bidi.Network.SameSite.Lax;
+    case 'None':
+      return bidi.Network.SameSite.None;
+  }
+  return bidi.Network.SameSite.None;
+}
+let Network = exports.Network = void 0;
+(function (_Network) {
+  let SameSite = /*#__PURE__*/function (SameSite) {
+    SameSite["Strict"] = "strict";
+    SameSite["Lax"] = "lax";
+    SameSite["None"] = "none";
+    return SameSite;
+  }({});
+  _Network.SameSite = SameSite;
+})(Network || (exports.Network = Network = {}));

package/lib/server/bidi/bidiConnection.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kBrowserCloseMessageId = exports.BidiSession = exports.BidiConnection = void 0;
+var _events = require("events");
+var _utils = require("../../utils");
+var _debugLogger = require("../../utils/debugLogger");
+var _helper = require("../helper");
+var _protocolError = require("../protocolError");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// BidiPlaywright uses this special id to issue Browser.close command which we
+// should ignore.
+const kBrowserCloseMessageId = exports.kBrowserCloseMessageId = 0;
+class BidiConnection {
+  constructor(transport, onDisconnect, protocolLogger, browserLogsCollector) {
+    this._transport = void 0;
+    this._onDisconnect = void 0;
+    this._protocolLogger = void 0;
+    this._browserLogsCollector = void 0;
+    this._browserDisconnectedLogs = void 0;
+    this._lastId = 0;
+    this._closed = false;
+    this.browserSession = void 0;
+    this._browsingContextToSession = new Map();
+    this._transport = transport;
+    this._onDisconnect = onDisconnect;
+    this._protocolLogger = protocolLogger;
+    this._browserLogsCollector = browserLogsCollector;
+    this.browserSession = new BidiSession(this, '', message => {
+      this.rawSend(message);
+    });
+    this._transport.onmessage = this._dispatchMessage.bind(this);
+    // onclose should be set last, since it can be immediately called.
+    this._transport.onclose = this._onClose.bind(this);
+  }
+  nextMessageId() {
+    return ++this._lastId;
+  }
+  rawSend(message) {
+    this._protocolLogger('send', message);
+    this._transport.send(message);
+  }
+  _dispatchMessage(message) {
+    this._protocolLogger('receive', message);
+    const object = message;
+    // Bidi messages do not have a common session identifier, so we
+    // route them based on BrowsingContext.
+    if (object.type === 'event') {
+      var _object$params$source;
+      // Route page events to the right session.
+      let context;
+      if ('context' in object.params) context = object.params.context;else if (object.method === 'log.entryAdded') context = (_object$params$source = object.params.source) === null || _object$params$source === void 0 ? void 0 : _object$params$source.context;
+      if (context) {
+        const session = this._browsingContextToSession.get(context);
+        if (session) {
+          session.dispatchMessage(message);
+          return;
+        }
+      }
+    } else if (message.id) {
+      // Find caller session.
+      for (const session of this._browsingContextToSession.values()) {
+        if (session.hasCallback(message.id)) {
+          session.dispatchMessage(message);
+          return;
+        }
+      }
+    }
+    this.browserSession.dispatchMessage(message);
+  }
+  _onClose(reason) {
+    this._closed = true;
+    this._transport.onmessage = undefined;
+    this._transport.onclose = undefined;
+    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
+    this.browserSession.dispose();
+    this._onDisconnect();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  close() {
+    if (!this._closed) this._transport.close();
+  }
+  createMainFrameBrowsingContextSession(bowsingContextId) {
+    const result = new BidiSession(this, bowsingContextId, message => this.rawSend(message));
+    this._browsingContextToSession.set(bowsingContextId, result);
+    return result;
+  }
+}
+exports.BidiConnection = BidiConnection;
+class BidiSession extends _events.EventEmitter {
+  constructor(connection, sessionId, rawSend) {
+    super();
+    this.connection = void 0;
+    this.sessionId = void 0;
+    this._disposed = false;
+    this._rawSend = void 0;
+    this._callbacks = new Map();
+    this._crashed = false;
+    this._browsingContexts = new Set();
+    this.on = void 0;
+    this.addListener = void 0;
+    this.off = void 0;
+    this.removeListener = void 0;
+    this.once = void 0;
+    this.setMaxListeners(0);
+    this.connection = connection;
+    this.sessionId = sessionId;
+    this._rawSend = rawSend;
+    this.on = super.on;
+    this.off = super.removeListener;
+    this.addListener = super.addListener;
+    this.removeListener = super.removeListener;
+    this.once = super.once;
+  }
+  addFrameBrowsingContext(context) {
+    this._browsingContexts.add(context);
+    this.connection._browsingContextToSession.set(context, this);
+  }
+  removeFrameBrowsingContext(context) {
+    this._browsingContexts.delete(context);
+    this.connection._browsingContextToSession.delete(context);
+  }
+  async send(method, params) {
+    if (this._crashed || this._disposed || this.connection._browserDisconnectedLogs) throw new _protocolError.ProtocolError(this._crashed ? 'crashed' : 'closed', undefined, this.connection._browserDisconnectedLogs);
+    const id = this.connection.nextMessageId();
+    const messageObj = {
+      id,
+      method,
+      params
+    };
+    this._rawSend(messageObj);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(id, {
+        resolve,
+        reject,
+        error: new _protocolError.ProtocolError('error', method)
+      });
+    });
+  }
+  sendMayFail(method, params) {
+    return this.send(method, params).catch(error => _debugLogger.debugLogger.log('error', error));
+  }
+  markAsCrashed() {
+    this._crashed = true;
+  }
+  isDisposed() {
+    return this._disposed;
+  }
+  dispose() {
+    this._disposed = true;
+    this.connection._browsingContextToSession.delete(this.sessionId);
+    for (const context of this._browsingContexts) this.connection._browsingContextToSession.delete(context);
+    this._browsingContexts.clear();
+    for (const callback of this._callbacks.values()) {
+      callback.error.type = this._crashed ? 'crashed' : 'closed';
+      callback.error.logs = this.connection._browserDisconnectedLogs;
+      callback.reject(callback.error);
+    }
+    this._callbacks.clear();
+  }
+  hasCallback(id) {
+    return this._callbacks.has(id);
+  }
+  dispatchMessage(message) {
+    const object = message;
+    if (object.id === kBrowserCloseMessageId) return;
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.type === 'error') {
+        callback.error.setMessage(object.error + '\nMessage: ' + object.message);
+        callback.reject(callback.error);
+      } else if (object.type === 'success') {
+        callback.resolve(object.result);
+      } else {
+        callback.error.setMessage('Internal error, unexpected response type: ' + JSON.stringify(object));
+        callback.reject(callback.error);
+      }
+    } else if (object.id) {
+      // Response might come after session has been disposed and rejected all callbacks.
+      (0, _utils.assert)(this.isDisposed());
+    } else {
+      Promise.resolve().then(() => this.emit(object.method, object.params));
+    }
+  }
+}
+exports.BidiSession = BidiSession;

package/lib/server/bidi/bidiExecutionContext.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BidiExecutionContext = void 0;
+var _utilityScriptSerializers = require("../isomorphic/utilityScriptSerializers");
+var js = _interopRequireWildcard(require("../javascript"));
+var _bidiDeserializer = require("./third_party/bidiDeserializer");
+var bidi = _interopRequireWildcard(require("./third_party/bidiProtocol"));
+var _bidiSerializer = require("./third_party/bidiSerializer");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class BidiExecutionContext {
+  constructor(session, realmInfo) {
+    this._session = void 0;
+    this._target = void 0;
+    this._session = session;
+    if (realmInfo.type === 'window') {
+      // Simple realm does not seem to work for Window contexts.
+      this._target = {
+        context: realmInfo.context,
+        sandbox: realmInfo.sandbox
+      };
+    } else {
+      this._target = {
+        realm: realmInfo.realm
+      };
+    }
+  }
+  async rawEvaluateJSON(expression) {
+    const response = await this._session.send('script.evaluate', {
+      expression,
+      target: this._target,
+      serializationOptions: {
+        maxObjectDepth: 10,
+        maxDomDepth: 10
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'success') return _bidiDeserializer.BidiDeserializer.deserialize(response.result);
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  async rawEvaluateHandle(expression) {
+    const response = await this._session.send('script.evaluate', {
+      expression,
+      target: this._target,
+      resultOwnership: bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'success') {
+      if ('handle' in response.result) return response.result.handle;
+      throw new js.JavaScriptErrorInEvaluate('Cannot get handle: ' + JSON.stringify(response.result));
+    }
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  rawCallFunctionNoReply(func, ...args) {
+    throw new Error('Method not implemented.');
+  }
+  async evaluateWithArguments(functionDeclaration, returnByValue, utilityScript, values, objectIds) {
+    const response = await this._session.send('script.callFunction', {
+      functionDeclaration,
+      target: this._target,
+      arguments: [{
+        handle: utilityScript._objectId
+      }, ...values.map(_bidiSerializer.BidiSerializer.serialize), ...objectIds.map(handle => ({
+        handle
+      }))],
+      resultOwnership: returnByValue ? undefined : bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: returnByValue ? {} : {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    if (response.type === 'success') {
+      if (returnByValue) return (0, _utilityScriptSerializers.parseEvaluationResultValue)(_bidiDeserializer.BidiDeserializer.deserialize(response.result));
+      const objectId = 'handle' in response.result ? response.result.handle : undefined;
+      return utilityScript._context.createHandle({
+        objectId,
+        ...response.result
+      });
+    }
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+  async getProperties(context, objectId) {
+    throw new Error('Method not implemented.');
+  }
+  createHandle(context, jsRemoteObject) {
+    const remoteObject = jsRemoteObject;
+    return new js.JSHandle(context, remoteObject.type, renderPreview(remoteObject), jsRemoteObject.objectId, remoteObjectValue(remoteObject));
+  }
+  async releaseHandle(objectId) {
+    await this._session.send('script.disown', {
+      target: this._target,
+      handles: [objectId]
+    });
+  }
+  objectCount(objectId) {
+    throw new Error('Method not implemented.');
+  }
+  async rawCallFunction(functionDeclaration, arg) {
+    const response = await this._session.send('script.callFunction', {
+      functionDeclaration,
+      target: this._target,
+      arguments: [arg],
+      resultOwnership: bidi.Script.ResultOwnership.Root,
+      // Necessary for the handle to be returned.
+      serializationOptions: {
+        maxObjectDepth: 0,
+        maxDomDepth: 0
+      },
+      awaitPromise: true,
+      userActivation: true
+    });
+    if (response.type === 'exception') throw new js.JavaScriptErrorInEvaluate(response.exceptionDetails.text + '\nFull val: ' + JSON.stringify(response.exceptionDetails));
+    if (response.type === 'success') return response.result;
+    throw new js.JavaScriptErrorInEvaluate('Unexpected response type: ' + JSON.stringify(response));
+  }
+}
+exports.BidiExecutionContext = BidiExecutionContext;
+function renderPreview(remoteObject) {
+  if (remoteObject.type === 'undefined') return 'undefined';
+  if (remoteObject.type === 'null') return 'null';
+  if ('value' in remoteObject) return String(remoteObject.value);
+  return `<${remoteObject.type}>`;
+}
+function remoteObjectValue(remoteObject) {
+  if (remoteObject.type === 'undefined') return undefined;
+  if (remoteObject.type === 'null') return null;
+  if (remoteObject.type === 'number' && typeof remoteObject.value === 'string') return js.parseUnserializableValue(remoteObject.value);
+  if ('value' in remoteObject) return remoteObject.value;
+  return undefined;
+}