pokeedex 0.1.0

data/node_modules/playwright-core/lib/server/webkit/wkAccessibility.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAccessibilityTree = getAccessibilityTree;
+/**
+ * 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.
+ */
+
+async function getAccessibilityTree(session, needle) {
+  const objectId = needle ? needle._objectId : undefined;
+  const {
+    axNode
+  } = await session.send('Page.accessibilitySnapshot', {
+    objectId
+  });
+  const tree = new WKAXNode(axNode);
+  return {
+    tree,
+    needle: needle ? tree._findNeedle() : null
+  };
+}
+const WKRoleToARIARole = new Map(Object.entries({
+  'TextField': 'textbox'
+}));
+
+// WebKit localizes role descriptions on mac, but the english versions only add noise.
+const WKUnhelpfulRoleDescriptions = new Map(Object.entries({
+  'WebArea': 'HTML content',
+  'Summary': 'summary',
+  'DescriptionList': 'description list',
+  'ImageMap': 'image map',
+  'ListMarker': 'list marker',
+  'Video': 'video playback',
+  'Mark': 'highlighted',
+  'contentinfo': 'content information',
+  'Details': 'details',
+  'DescriptionListDetail': 'description',
+  'DescriptionListTerm': 'term',
+  'alertdialog': 'web alert dialog',
+  'dialog': 'web dialog',
+  'status': 'application status',
+  'tabpanel': 'tab panel',
+  'application': 'web application'
+}));
+class WKAXNode {
+  constructor(payload) {
+    this._payload = void 0;
+    this._children = void 0;
+    this._payload = payload;
+    this._children = [];
+    for (const payload of this._payload.children || []) this._children.push(new WKAXNode(payload));
+  }
+  children() {
+    return this._children;
+  }
+  _findNeedle() {
+    if (this._payload.found) return this;
+    for (const child of this._children) {
+      const found = child._findNeedle();
+      if (found) return found;
+    }
+    return null;
+  }
+  isControl() {
+    switch (this._payload.role) {
+      case 'button':
+      case 'checkbox':
+      case 'ColorWell':
+      case 'combobox':
+      case 'DisclosureTriangle':
+      case 'listbox':
+      case 'menu':
+      case 'menubar':
+      case 'menuitem':
+      case 'menuitemcheckbox':
+      case 'menuitemradio':
+      case 'radio':
+      case 'scrollbar':
+      case 'searchbox':
+      case 'slider':
+      case 'spinbutton':
+      case 'switch':
+      case 'tab':
+      case 'textbox':
+      case 'TextField':
+      case 'tree':
+        return true;
+      default:
+        return false;
+    }
+  }
+  _isTextControl() {
+    switch (this._payload.role) {
+      case 'combobox':
+      case 'searchfield':
+      case 'textbox':
+      case 'TextField':
+        return true;
+    }
+    return false;
+  }
+  _name() {
+    if (this._payload.role === 'text') return this._payload.value || '';
+    return this._payload.name || '';
+  }
+  isInteresting(insideControl) {
+    const {
+      role,
+      focusable
+    } = this._payload;
+    const name = this._name();
+    if (role === 'ScrollArea') return false;
+    if (role === 'WebArea') return true;
+    if (focusable || role === 'MenuListOption') return true;
+
+    // If it's not focusable but has a control role, then it's interesting.
+    if (this.isControl()) return true;
+
+    // A non focusable child of a control is not interesting
+    if (insideControl) return false;
+    return this.isLeafNode() && !!name;
+  }
+  _hasRedundantTextChild() {
+    if (this._children.length !== 1) return false;
+    const child = this._children[0];
+    return child._payload.role === 'text' && this._payload.name === child._payload.value;
+  }
+  isLeafNode() {
+    if (!this._children.length) return true;
+    // WebKit on Linux ignores everything inside text controls, normalize this behavior
+    if (this._isTextControl()) return true;
+    // WebKit for mac has text nodes inside heading, li, menuitem, a, and p nodes
+    if (this._hasRedundantTextChild()) return true;
+    return false;
+  }
+  serialize() {
+    const node = {
+      role: WKRoleToARIARole.get(this._payload.role) || this._payload.role,
+      name: this._name()
+    };
+    if ('description' in this._payload && this._payload.description !== node.name) node.description = this._payload.description;
+    if ('roledescription' in this._payload) {
+      const roledescription = this._payload.roledescription;
+      if (roledescription !== this._payload.role && WKUnhelpfulRoleDescriptions.get(this._payload.role) !== roledescription) node.roledescription = roledescription;
+    }
+    if ('value' in this._payload && this._payload.role !== 'text') {
+      if (typeof this._payload.value === 'string') node.valueString = this._payload.value;else if (typeof this._payload.value === 'number') node.valueNumber = this._payload.value;
+    }
+    if ('checked' in this._payload) node.checked = this._payload.checked === 'true' ? 'checked' : this._payload.checked === 'false' ? 'unchecked' : 'mixed';
+    if ('pressed' in this._payload) node.pressed = this._payload.pressed === 'true' ? 'pressed' : this._payload.pressed === 'false' ? 'released' : 'mixed';
+    const userStringProperties = ['keyshortcuts', 'valuetext'];
+    for (const userStringProperty of userStringProperties) {
+      if (!(userStringProperty in this._payload)) continue;
+      node[userStringProperty] = this._payload[userStringProperty];
+    }
+    const booleanProperties = ['disabled', 'expanded', 'focused', 'modal', 'multiselectable', 'readonly', 'required', 'selected'];
+    for (const booleanProperty of booleanProperties) {
+      // WebArea and ScrollArea treat focus differently than other nodes. They report whether their frame  has focus,
+      // not whether focus is specifically on the root node.
+      if (booleanProperty === 'focused' && (this._payload.role === 'WebArea' || this._payload.role === 'ScrollArea')) continue;
+      const value = this._payload[booleanProperty];
+      if (!value) continue;
+      node[booleanProperty] = value;
+    }
+    const numericalProperties = ['level', 'valuemax', 'valuemin'];
+    for (const numericalProperty of numericalProperties) {
+      if (!(numericalProperty in this._payload)) continue;
+      node[numericalProperty] = this._payload[numericalProperty];
+    }
+    const tokenProperties = ['autocomplete', 'haspopup', 'invalid'];
+    for (const tokenProperty of tokenProperties) {
+      const value = this._payload[tokenProperty];
+      if (!value || value === 'false') continue;
+      node[tokenProperty] = value;
+    }
+    const orientationIsApplicable = new Set(['ScrollArea', 'scrollbar', 'listbox', 'combobox', 'menu', 'tree', 'separator', 'slider', 'tablist', 'toolbar']);
+    if (this._payload.orientation && orientationIsApplicable.has(this._payload.role)) node.orientation = this._payload.orientation;
+    return node;
+  }
+}

data/node_modules/playwright-core/lib/server/webkit/wkBrowser.js

@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WKBrowserContext = exports.WKBrowser = void 0;
+var _browser = require("../browser");
+var _browserContext = require("../browserContext");
+var _utils = require("../../utils");
+var network = _interopRequireWildcard(require("../network"));
+var _wkConnection = require("./wkConnection");
+var _wkPage = require("./wkPage");
+var _errors = require("../errors");
+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 2017 Google Inc. All rights reserved.
+ * Modifications 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.
+ */
+
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15';
+const BROWSER_VERSION = '18.0';
+class WKBrowser extends _browser.Browser {
+  static async connect(parent, transport, options) {
+    const browser = new WKBrowser(parent, transport, options);
+    if (options.__testHookOnConnectToBrowser) await options.__testHookOnConnectToBrowser();
+    const promises = [browser._browserSession.send('Playwright.enable')];
+    if (options.persistent) {
+      var _options$persistent;
+      (_options$persistent = options.persistent).userAgent || (_options$persistent.userAgent = DEFAULT_USER_AGENT);
+      browser._defaultContext = new WKBrowserContext(browser, undefined, options.persistent);
+      promises.push(browser._defaultContext._initialize());
+    }
+    await Promise.all(promises);
+    return browser;
+  }
+  constructor(parent, transport, options) {
+    super(parent, options);
+    this._connection = void 0;
+    this._browserSession = void 0;
+    this._contexts = new Map();
+    this._wkPages = new Map();
+    this._connection = new _wkConnection.WKConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
+    this._browserSession = this._connection.browserSession;
+    this._browserSession.on('Playwright.pageProxyCreated', this._onPageProxyCreated.bind(this));
+    this._browserSession.on('Playwright.pageProxyDestroyed', this._onPageProxyDestroyed.bind(this));
+    this._browserSession.on('Playwright.provisionalLoadFailed', event => this._onProvisionalLoadFailed(event));
+    this._browserSession.on('Playwright.windowOpen', event => this._onWindowOpen(event));
+    this._browserSession.on('Playwright.downloadCreated', this._onDownloadCreated.bind(this));
+    this._browserSession.on('Playwright.downloadFilenameSuggested', this._onDownloadFilenameSuggested.bind(this));
+    this._browserSession.on('Playwright.downloadFinished', this._onDownloadFinished.bind(this));
+    this._browserSession.on('Playwright.screencastFinished', this._onScreencastFinished.bind(this));
+    this._browserSession.on(_wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this));
+  }
+  _onDisconnect() {
+    for (const wkPage of this._wkPages.values()) wkPage.didClose();
+    this._wkPages.clear();
+    for (const video of this._idToVideo.values()) video.artifact.reportFinished(new _errors.TargetClosedError());
+    this._idToVideo.clear();
+    this._didClose();
+  }
+  async doCreateNewContext(options) {
+    const createOptions = options.proxy ? {
+      // Enable socks5 hostname resolution on Windows. Workaround can be removed once fixed upstream.
+      // See https://github.com/microsoft/playwright/issues/20451
+      proxyServer: process.platform === 'win32' ? options.proxy.server.replace(/^socks5:\/\//, 'socks5h://') : options.proxy.server,
+      proxyBypassList: options.proxy.bypass
+    } : undefined;
+    const {
+      browserContextId
+    } = await this._browserSession.send('Playwright.createContext', createOptions);
+    options.userAgent = options.userAgent || DEFAULT_USER_AGENT;
+    const context = new WKBrowserContext(this, browserContextId, options);
+    await context._initialize();
+    this._contexts.set(browserContextId, context);
+    return context;
+  }
+  contexts() {
+    return Array.from(this._contexts.values());
+  }
+  version() {
+    return BROWSER_VERSION;
+  }
+  userAgent() {
+    return DEFAULT_USER_AGENT;
+  }
+  _onDownloadCreated(payload) {
+    const page = this._wkPages.get(payload.pageProxyId);
+    if (!page) return;
+    // In some cases, e.g. blob url download, we receive only frameScheduledNavigation
+    // but no signals that the navigation was canceled and replaced by download. Fix it
+    // here by simulating cancelled provisional load which matches downloads from network.
+    //
+    // TODO: this is racy, because download might be unrelated any navigation, and we will
+    // abort navigation that is still running. We should be able to fix this by
+    // instrumenting policy decision start/proceed/cancel.
+    page._page._frameManager.frameAbortedNavigation(payload.frameId, 'Download is starting');
+    let originPage = page._initializedPage;
+    // If it's a new window download, report it on the opener page.
+    if (!originPage) {
+      // Resume the page creation with an error. The page will automatically close right
+      // after the download begins.
+      page._firstNonInitialNavigationCommittedReject(new Error('Starting new page download'));
+      if (page._opener) originPage = page._opener._initializedPage;
+    }
+    if (!originPage) return;
+    this._downloadCreated(originPage, payload.uuid, payload.url);
+  }
+  _onDownloadFilenameSuggested(payload) {
+    this._downloadFilenameSuggested(payload.uuid, payload.suggestedFilename);
+  }
+  _onDownloadFinished(payload) {
+    this._downloadFinished(payload.uuid, payload.error);
+  }
+  _onScreencastFinished(payload) {
+    var _this$_takeVideo;
+    (_this$_takeVideo = this._takeVideo(payload.screencastId)) === null || _this$_takeVideo === void 0 || _this$_takeVideo.reportFinished();
+  }
+  _onPageProxyCreated(event) {
+    const pageProxyId = event.pageProxyId;
+    let context = null;
+    if (event.browserContextId) {
+      // FIXME: we don't know about the default context id, so assume that all targets from
+      // unknown contexts are created in the 'default' context which can in practice be represented
+      // by multiple actual contexts in WebKit. Solving this properly will require adding context
+      // lifecycle events.
+      context = this._contexts.get(event.browserContextId) || null;
+    }
+    if (!context) context = this._defaultContext;
+    if (!context) return;
+    const pageProxySession = new _wkConnection.WKSession(this._connection, pageProxyId, message => {
+      this._connection.rawSend({
+        ...message,
+        pageProxyId
+      });
+    });
+    const opener = event.openerId ? this._wkPages.get(event.openerId) : undefined;
+    const wkPage = new _wkPage.WKPage(context, pageProxySession, opener || null);
+    this._wkPages.set(pageProxyId, wkPage);
+  }
+  _onPageProxyDestroyed(event) {
+    const pageProxyId = event.pageProxyId;
+    const wkPage = this._wkPages.get(pageProxyId);
+    if (!wkPage) return;
+    wkPage.didClose();
+    this._wkPages.delete(pageProxyId);
+  }
+  _onPageProxyMessageReceived(event) {
+    const wkPage = this._wkPages.get(event.pageProxyId);
+    if (!wkPage) return;
+    wkPage.dispatchMessageToSession(event.message);
+  }
+  _onProvisionalLoadFailed(event) {
+    const wkPage = this._wkPages.get(event.pageProxyId);
+    if (!wkPage) return;
+    wkPage.handleProvisionalLoadFailed(event);
+  }
+  _onWindowOpen(event) {
+    const wkPage = this._wkPages.get(event.pageProxyId);
+    if (!wkPage) return;
+    wkPage.handleWindowOpen(event);
+  }
+  isConnected() {
+    return !this._connection.isClosed();
+  }
+}
+exports.WKBrowser = WKBrowser;
+class WKBrowserContext extends _browserContext.BrowserContext {
+  constructor(browser, browserContextId, options) {
+    super(browser, options, browserContextId);
+    this._validateEmulatedViewport(options.viewport);
+    this._authenticateProxyViaHeader();
+  }
+  async _initialize() {
+    (0, _utils.assert)(!this._wkPages().length);
+    const browserContextId = this._browserContextId;
+    const promises = [super._initialize()];
+    promises.push(this._browser._browserSession.send('Playwright.setDownloadBehavior', {
+      behavior: this._options.acceptDownloads === 'accept' ? 'allow' : 'deny',
+      downloadPath: this._browser.options.downloadsPath,
+      browserContextId
+    }));
+    if (this._options.ignoreHTTPSErrors) promises.push(this._browser._browserSession.send('Playwright.setIgnoreCertificateErrors', {
+      browserContextId,
+      ignore: true
+    }));
+    if (this._options.locale) promises.push(this._browser._browserSession.send('Playwright.setLanguages', {
+      browserContextId,
+      languages: [this._options.locale]
+    }));
+    if (this._options.geolocation) promises.push(this.setGeolocation(this._options.geolocation));
+    if (this._options.offline) promises.push(this.setOffline(this._options.offline));
+    if (this._options.httpCredentials) promises.push(this.setHTTPCredentials(this._options.httpCredentials));
+    await Promise.all(promises);
+  }
+  _wkPages() {
+    return Array.from(this._browser._wkPages.values()).filter(wkPage => wkPage._browserContext === this);
+  }
+  pages() {
+    return this._wkPages().map(wkPage => wkPage._initializedPage).filter(pageOrNull => !!pageOrNull);
+  }
+  async newPageDelegate() {
+    (0, _browserContext.assertBrowserContextIsNotOwned)(this);
+    const {
+      pageProxyId
+    } = await this._browser._browserSession.send('Playwright.createPage', {
+      browserContextId: this._browserContextId
+    });
+    return this._browser._wkPages.get(pageProxyId);
+  }
+  async doGetCookies(urls) {
+    const {
+      cookies
+    } = await this._browser._browserSession.send('Playwright.getAllCookies', {
+      browserContextId: this._browserContextId
+    });
+    return network.filterCookies(cookies.map(c => {
+      const copy = {
+        ...c
+      };
+      copy.expires = c.expires === -1 ? -1 : c.expires / 1000;
+      delete copy.session;
+      return copy;
+    }), urls);
+  }
+  async addCookies(cookies) {
+    const cc = network.rewriteCookies(cookies).map(c => ({
+      ...c,
+      session: c.expires === -1 || c.expires === undefined,
+      expires: c.expires && c.expires !== -1 ? c.expires * 1000 : c.expires
+    }));
+    await this._browser._browserSession.send('Playwright.setCookies', {
+      cookies: cc,
+      browserContextId: this._browserContextId
+    });
+  }
+  async doClearCookies() {
+    await this._browser._browserSession.send('Playwright.deleteAllCookies', {
+      browserContextId: this._browserContextId
+    });
+  }
+  async doGrantPermissions(origin, permissions) {
+    await Promise.all(this.pages().map(page => page._delegate._grantPermissions(origin, permissions)));
+  }
+  async doClearPermissions() {
+    await Promise.all(this.pages().map(page => page._delegate._clearPermissions()));
+  }
+  async setGeolocation(geolocation) {
+    (0, _browserContext.verifyGeolocation)(geolocation);
+    this._options.geolocation = geolocation;
+    const payload = geolocation ? {
+      ...geolocation,
+      timestamp: Date.now()
+    } : undefined;
+    await this._browser._browserSession.send('Playwright.setGeolocationOverride', {
+      browserContextId: this._browserContextId,
+      geolocation: payload
+    });
+  }
+  async setExtraHTTPHeaders(headers) {
+    this._options.extraHTTPHeaders = headers;
+    for (const page of this.pages()) await page._delegate.updateExtraHTTPHeaders();
+  }
+  async setUserAgent(userAgent) {
+    this._options.userAgent = userAgent;
+    for (const page of this.pages()) await page._delegate.updateUserAgent();
+  }
+  async setOffline(offline) {
+    this._options.offline = offline;
+    for (const page of this.pages()) await page._delegate.updateOffline();
+  }
+  async doSetHTTPCredentials(httpCredentials) {
+    this._options.httpCredentials = httpCredentials;
+    for (const page of this.pages()) await page._delegate.updateHttpCredentials();
+  }
+  async doAddInitScript(initScript) {
+    for (const page of this.pages()) await page._delegate._updateBootstrapScript();
+  }
+  async doRemoveNonInternalInitScripts() {
+    for (const page of this.pages()) await page._delegate._updateBootstrapScript();
+  }
+  async doUpdateRequestInterception() {
+    for (const page of this.pages()) await page._delegate.updateRequestInterception();
+  }
+  onClosePersistent() {}
+  async clearCache() {
+    // We use ephemeral contexts so there is no disk cache.
+    await this._browser._browserSession.send('Playwright.clearMemoryCache', {
+      browserContextId: this._browserContextId
+    });
+  }
+  async doClose(reason) {
+    if (!this._browserContextId) {
+      await Promise.all(this._wkPages().map(wkPage => wkPage._stopVideo()));
+      // Closing persistent context should close the browser.
+      await this._browser.close({
+        reason
+      });
+    } else {
+      await this._browser._browserSession.send('Playwright.deleteContext', {
+        browserContextId: this._browserContextId
+      });
+      this._browser._contexts.delete(this._browserContextId);
+    }
+  }
+  async cancelDownload(uuid) {
+    await this._browser._browserSession.send('Playwright.cancelDownload', {
+      uuid
+    });
+  }
+  _validateEmulatedViewport(viewportSize) {
+    if (!viewportSize) return;
+    if (process.platform === 'win32' && this._browser.options.headful && (viewportSize.width < 250 || viewportSize.height < 240)) throw new Error(`WebKit on Windows has a minimal viewport of 250x240.`);
+  }
+}
+exports.WKBrowserContext = WKBrowserContext;

data/node_modules/playwright-core/lib/server/webkit/wkConnection.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kPageProxyMessageReceived = exports.kBrowserCloseMessageId = exports.WKSession = exports.WKConnection = void 0;
+var _events = require("events");
+var _utils = require("../../utils");
+var _debugLogger = require("../../utils/debugLogger");
+var _helper = require("../helper");
+var _protocolError = require("../protocolError");
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications 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.
+ */
+
+// WKPlaywright uses this special id to issue Browser.close command which we
+// should ignore.
+const kBrowserCloseMessageId = exports.kBrowserCloseMessageId = -9999;
+
+// We emulate kPageProxyMessageReceived message to unify it with Browser.pageProxyCreated
+// and Browser.pageProxyDestroyed for easier management.
+const kPageProxyMessageReceived = exports.kPageProxyMessageReceived = Symbol('kPageProxyMessageReceived');
+class WKConnection {
+  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._transport = transport;
+    this._onDisconnect = onDisconnect;
+    this._protocolLogger = protocolLogger;
+    this._browserLogsCollector = browserLogsCollector;
+    this.browserSession = new WKSession(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);
+    if (message.id === kBrowserCloseMessageId) return;
+    if (message.pageProxyId) {
+      const payload = {
+        message: message,
+        pageProxyId: message.pageProxyId
+      };
+      this.browserSession.dispatchMessage({
+        method: kPageProxyMessageReceived,
+        params: payload
+      });
+      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();
+  }
+}
+exports.WKConnection = WKConnection;
+class WKSession 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.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;
+  }
+  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() {
+    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();
+    this._disposed = true;
+  }
+  dispatchMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error) {
+        callback.error.setMessage(object.error.message);
+        callback.reject(callback.error);
+      } else {
+        callback.resolve(object.result);
+      }
+    } else if (object.id && !object.error) {
+      // 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.WKSession = WKSession;