@percy/core 1.0.0-beta.76 → 1.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 The core component of Percy's CLI and SDKs that handles creating builds, discovering snapshot
 assets, uploading snapshots, and finalizing builds. Uses `@percy/client` for API communication, a
-Puppeteer browser for asset discovery, and starts a local API server for posting snapshots from
+Chromium browser for asset discovery, and starts a local API server for posting snapshots from
 other processes.
 
 - [Usage](#usage)
@@ -49,6 +49,7 @@ The following options can also be defined within a Percy config file
   - `enableJavaScript` — Enable JavaScript for screenshots (**default** `false`)
 - `discovery` — Asset discovery options
   - `allowedHostnames` — Array of allowed hostnames to capture assets from
+  - `disallowedHostnames` — Array of hostnames where requests will be aborted
   - `requestHeaders` — Request headers used when discovering snapshot assets
   - `authorization` — Basic auth `username` and `password` for protected snapshot assets
   - `disableCache` — Disable asset caching (**default** `false`)
@@ -127,10 +128,13 @@ await percy.idle()
 
 ### `#snapshot(options)`
 
-Performs asset discovery for a snapshot and queues uploading the snapshot to the associated Percy
-build. When an existing DOM snapshot is provided, it is served as the root resource during asset
-discovery. When no existing DOM snapshot is provided, a new one will be captured using any provided
-snapshot capture options.
+Takes one or more snapshots of a page while discovering resources to upload with the snapshot. Once
+asset discovery has completed, the queued snapshot will resolve and an upload task will be queued
+separately. Accepts several different syntaxes for taking snapshots in various ways.
+
+All available syntaxes will push snapshots into the snapshot queue without the need to await on the
+method directly. This method resolves after the snapshot upload is queued, but does not await on the
+upload to complete.
 
 ``` js
 // snapshots can be handled concurrently, no need to await
@@ -140,37 +144,61 @@ percy.snapshot({
   domSnapshot: domSnapshot,
   clientInfo: 'my-sdk',
   environmentInfo: 'my-lib'
-  ...snapshotOptions
 })
 
+// without a domSnapshot, capture options will be used to take one
 percy.snapshot({
   name: 'Snapshot 2',
-  url: 'http://localhost:3000/',
-  ...snapshotOptions,
-  
-  // without a domSnapshot, capture options will be used to take one
+  url: 'http://localhost:3000',
   waitForTimeout: 1000,
   waitForSelector: '.done-loading',
   execute: async () => {},
   additionalSnapshots: [{
     name: 'Snapshot 2.1',
-    execute: () => {},
-    ...snapshotOptions
+    execute: () => {}
   }]
 })
+
+// alternate shorthand syntax 
+percy.snapshot({
+  baseUrl: 'http://localhost:3000',
+  snapshots: ['/', '/about', '/contact'],
+  options: {
+    widths: [600, 1200]
+  }
+})
+
+// gather snapshots from an external sitemap
+percy.snapshot({
+  sitemap: 'https://example.com/sitemap.xml',
+  exclude: ['/blog/*']
+})
+
+// start a server and take static snapshots
+percy.snapshot({
+  serve: './public',
+  cleanUrls: true,
+})
 ```
 
 #### Options
 
+When capturing a single snapshot, the snapshot URL may be provided as the only argument rather than
+a snapshot options object. When providing an options object, a few alternate syntaxes are available
+depending on the provided properties ([see alternate syntaxes below](#alternate-syntaxes)).
+
+**Common options** accepted for each snapshot:
+
 - `url` — Snapshot URL (**required**)
 - `name` — Snapshot name
 - `domSnapshot` — Snapshot DOM string
-- `clientInfo` — Additional client info
-- `environmentInfo` — Additional environment info
 - `discovery` - Limited snapshot specific discovery options
-  - `allowedHostnames`, `requestHeaders`, `authorization`, `disableCache`, `userAgent`
+  - `allowedHostnames`, `disallowedHostnames`, `requestHeaders`, `authorization`, `disableCache`, `userAgent`
 
-**Capture options** can only be provided when `domSnapshot` is missing.
+Common snapshot options are also accepted and will override instance snapshot options. [See instance
+options](#options) for common snapshot and discovery options.
+
+**Capture options** can only be provided when `domSnapshot` is missing:
 
 - `waitForTimeout` — Milliseconds to wait before taking a snapshot
 - `waitForSelector` — CSS selector to wait for before taking a snapshot
@@ -180,9 +208,49 @@ percy.snapshot({
   - `prefix` — Snapshot name prefix (**required** if no `name` or `suffix`)
   - `suffix` — Snapshot name suffix (**required** if no `name` or `prefix`)
   - `waitForTimeout`, `waitForSelector`, `execute` — See above
+  
+#### Alternate syntaxes
 
-Common snapshot options are also accepted and will override instance snapshot options. [See instance
-options](#options) for common snapshot and discovery options.
+All snapshot syntaxes can be provided as items within an array. For example, a single method call
+can upload multiple DOM snapshots, capture multiple external snapshots, crawl a sitemap for
+snapshots, and host a local static server for snapshots.
+
+**Shared options** accepted by all syntaxes:
+
+- `clientInfo` — Client info to include with the build
+- `environmentInfo` — Environment info to include with the build
+
+The following alternate syntaxes may **not** be combined with snapshot options, but rather offer
+alternate methods for taking multiple snapshots.
+
+**List options** can only be provided when a top-level `snapshots` is present:
+
+- `snapshots` — An array of snapshot URLs or snapshot options (**required**)
+- `baseUrl` — The full base URL (including protocol) used when snapshot URLs only include a pathname
+- `include`/`exclude` — Include and exclude matching snapshot names
+- `options` — Additional options to apply to snapshots
+  - `include`/`exclude` — Include and exclude snapshots to apply these options to
+  -  [Common snapshot and capture options](#options) (**excluding** `url`, `domSnapshot`)
+  
+**Sitemap options** can only be provided when a top-level `sitemap` is present:
+
+- `sitemap` — The URL where an XML sitemap can be located (**required**)
+- `include`/`exclude` — Include and exclude matching snapshot names
+- `options` — Additional options to apply to snapshots
+  - `include`/`exclude` — Include and exclude snapshots to apply these options to
+  -  [Common snapshot and capture options](#options) (**excluding** `url`, `domSnapshot`)
+  
+**Server options** can only be provided when a top-level `serve` is present:
+
+- `serve` — The static directory to serve relative to the current working directory (**required**)
+- `baseUrl` — The base URL to serve the directory at, starting with a forward slash (/)
+- `cleanUrls` — Set to `true` to strip `.html` and `index.html` from served URLs
+- `rewrites` — A source-destination map for rewriting source URLs into destination pathnames
+- `snapshots` — An array of specific snapshots to take while serving the static directory
+- `include`/`exclude` — Include and exclude matching snapshot names
+- `options` — Additional options to apply to snapshots
+  - `include`/`exclude` — Include and exclude snapshots to apply these options to
+  -  [Common snapshot and capture options](#options) (**excluding** `url`, `domSnapshot`)
 
 ## Advanced
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.0.0-beta.76",
+  "version": "1.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,16 +10,24 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "dist/index.js",
-  "types": "types/index.d.ts",
+  "engines": {
+    "node": ">=14"
+  },
   "files": [
-    "dist",
-    "post-install.js",
-    "types/index.d.ts",
-    "test/helpers/server.js"
+    "./dist",
+    "./post-install.js",
+    "./types/index.d.ts",
+    "./test/helpers/server.js"
   ],
-  "engines": {
-    "node": ">=12"
+  "main": "./dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./utils": "./dist/utils.js",
+    "./config": "./dist/config.js",
+    "./install": "./dist/install.js",
+    "./test/helpers": "./test/helpers/index.js"
   },
   "scripts": {
     "build": "node ../../scripts/build",
@@ -30,17 +38,19 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.0.0-beta.76",
-    "@percy/config": "1.0.0-beta.76",
-    "@percy/dom": "1.0.0-beta.76",
-    "@percy/logger": "1.0.0-beta.76",
+    "@percy/client": "1.0.0",
+    "@percy/config": "1.0.0",
+    "@percy/dom": "1.0.0",
+    "@percy/logger": "1.0.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
+    "fast-glob": "^3.2.11",
+    "micromatch": "^4.0.4",
     "mime-types": "^2.1.34",
     "path-to-regexp": "^6.2.0",
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "gitHead": "445af68d8e270e2a35fc74e26422ed5d3c91d2ae"
+  "gitHead": "6df509421a60144e4f9f5d59dc57a5675372a0b2"
 }

package/dist/api.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createPercyServer = createPercyServer;
-
-var _fs = _interopRequireDefault(require("fs"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _server = _interopRequireDefault(require("./server"));
-
-var _package = _interopRequireDefault(require("../package.json"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function createPercyServer(percy, port) {
-  return new _server.default({
-    port
-  }) // facilitate logger websocket connections
-  .websocket(ws => _logger.default.connect(ws)) // general middleware
-  .route((req, res, next) => {
-    // treat all request bodies as json
-    if (req.body) try {
-      req.body = JSON.parse(req.body);
-    } catch {} // add version header
-
-    res.setHeader('Access-Control-Expose-Headers', '*, X-Percy-Core-Version');
-    res.setHeader('X-Percy-Core-Version', _package.default.version); // return json errors
-
-    return next().catch(e => {
-      var _e$status;
-
-      return res.json((_e$status = e.status) !== null && _e$status !== void 0 ? _e$status : 500, {
-        error: e.message,
-        success: false
-      });
-    });
-  }) // healthcheck returns basic information
-  .route('get', '/percy/healthcheck', (req, res) => res.json(200, {
-    loglevel: percy.loglevel(),
-    config: percy.config,
-    build: percy.build,
-    success: true
-  })) // get or set config options
-  .route(['get', 'post'], '/percy/config', async (req, res) => res.json(200, {
-    config: req.body ? await percy.setConfig(req.body) : percy.config,
-    success: true
-  })) // responds once idle (may take a long time)
-  .route('get', '/percy/idle', async (req, res) => res.json(200, {
-    success: await percy.idle().then(() => true)
-  })) // convenient @percy/dom bundle
-  .route('get', '/percy/dom.js', (req, res) => {
-    return res.file(200, require.resolve('@percy/dom'));
-  }) // legacy agent wrapper for @percy/dom
-  .route('get', '/percy-agent.js', async (req, res) => {
-    (0, _logger.default)('core:server').deprecated(['It looks like you’re using @percy/cli with an older SDK.', 'Please upgrade to the latest version to fix this warning.', 'See these docs for more info: https:docs.percy.io/docs/migrating-to-percy-cli'].join(' '));
-    let content = await _fs.default.promises.readFile(require.resolve('@percy/dom'), 'utf-8');
-    let wrapper = '(window.PercyAgent = class { snapshot(n, o) { return PercyDOM.serialize(o); } });';
-    return res.send(200, 'applicaton/javascript', content.concat(wrapper));
-  }) // post one or more snapshots
-  .route('post', '/percy/snapshot', async (req, res) => {
-    let snapshot = percy.snapshot(req.body);
-    if (!req.url.searchParams.has('async')) await snapshot;
-    return res.json(200, {
-      success: true
-    });
-  }) // stops percy at the end of the current event loop
-  .route('/percy/stop', (req, res) => {
-    setImmediate(() => percy.stop());
-    return res.json(200, {
-      success: true
-    });
-  });
-}

package/dist/browser.js

@@ -1,363 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Browser = void 0;
-
-var _os = _interopRequireDefault(require("os"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _fs = require("fs");
-
-var _crossSpawn = _interopRequireDefault(require("cross-spawn"));
-
-var _events = _interopRequireDefault(require("events"));
-
-var _ws = _interopRequireDefault(require("ws"));
-
-var _rimraf = _interopRequireDefault(require("rimraf"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _install = _interopRequireDefault(require("./install"));
-
-var _session = _interopRequireDefault(require("./session"));
-
-var _page = _interopRequireDefault(require("./page"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-
-function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
-
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-
-function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
-var _callbacks = /*#__PURE__*/new WeakMap();
-
-var _lastid = /*#__PURE__*/new WeakMap();
-
-class Browser extends _events.default {
-  constructor({
-    executable = process.env.PERCY_BROWSER_EXECUTABLE,
-    headless = true,
-    cookies = [],
-    args = [],
-    timeout
-  }) {
-    super();
-
-    _defineProperty(this, "log", (0, _logger.default)('core:browser'));
-
-    _defineProperty(this, "sessions", new Map());
-
-    _defineProperty(this, "readyState", null);
-
-    _defineProperty(this, "closed", false);
-
-    _classPrivateFieldInitSpec(this, _callbacks, {
-      writable: true,
-      value: new Map()
-    });
-
-    _classPrivateFieldInitSpec(this, _lastid, {
-      writable: true,
-      value: 0
-    });
-
-    _defineProperty(this, "args", [// disable the translate popup
-    '--disable-features=Translate', // disable several subsystems which run network requests in the background
-    '--disable-background-networking', // disable task throttling of timer tasks from background pages
-    '--disable-background-timer-throttling', // disable backgrounding renderer processes
-    '--disable-renderer-backgrounding', // disable backgrounding renderers for occluded windows (reduce nondeterminism)
-    '--disable-backgrounding-occluded-windows', // disable crash reporting
-    '--disable-breakpad', // disable client side phishing detection
-    '--disable-client-side-phishing-detection', // disable default component extensions with background pages for performance
-    '--disable-component-extensions-with-background-pages', // disable installation of default apps on first run
-    '--disable-default-apps', // work-around for environments where a small /dev/shm partition causes crashes
-    '--disable-dev-shm-usage', // disable extensions
-    '--disable-extensions', // disable hang monitor dialogs in renderer processes
-    '--disable-hang-monitor', // disable inter-process communication flooding protection for javascript
-    '--disable-ipc-flooding-protection', // disable web notifications and the push API
-    '--disable-notifications', // disable the prompt when a POST request causes page navigation
-    '--disable-prompt-on-repost', // disable syncing browser data with google accounts
-    '--disable-sync', // disable site-isolation to make network requests easier to intercept
-    '--disable-site-isolation-trials', // disable the first run tasks, whether or not it's actually the first run
-    '--no-first-run', // disable the sandbox for all process types that are normally sandboxed
-    '--no-sandbox', // enable indication that browser is controlled by automation
-    '--enable-automation', // specify a consistent encryption backend across platforms
-    '--password-store=basic', // use a mock keychain on Mac to prevent blocking permissions dialogs
-    '--use-mock-keychain', // enable remote debugging on the first available port
-    '--remote-debugging-port=0']);
-
-    this.launchTimeout = timeout;
-    this.executable = executable;
-    this.headless = headless;
-    /* istanbul ignore next: only false for debugging */
-
-    if (this.headless) this.args.push('--headless', '--hide-scrollbars', '--mute-audio');
-
-    for (let a of args) if (!this.args.includes(a)) this.args.push(a); // transform cookies object to an array of cookie params
-
-
-    this.cookies = Array.isArray(cookies) ? cookies : Object.entries(cookies).map(([name, value]) => ({
-      name,
-      value
-    }));
-  }
-
-  async launch() {
-    // already launching or launched
-    if (this.readyState != null) return;
-    this.readyState = 0; // check if any provided executable exists
-
-    if (this.executable && !(0, _fs.existsSync)(this.executable)) {
-      this.log.error(`Browser executable not found: ${this.executable}`);
-      this.executable = null;
-    } // download and install the browser if not already present
-
-
-    this.executable || (this.executable = await _install.default.chromium()); // create a temporary profile directory
-
-    this.profile = await _fs.promises.mkdtemp(_path.default.join(_os.default.tmpdir(), 'percy-browser-')); // spawn the browser process detached in its own group and session
-
-    let args = this.args.concat(`--user-data-dir=${this.profile}`);
-    this.log.debug('Launching browser');
-    this.process = (0, _crossSpawn.default)(this.executable, args, {
-      detached: process.platform !== 'win32'
-    }); // connect a websocket to the devtools address
-
-    let addr = await this.address(this.launchTimeout);
-    this.ws = new _ws.default(addr, {
-      perMessageDeflate: false
-    }); // wait until the websocket has connected
-
-    await new Promise(resolve => this.ws.once('open', resolve));
-    this.ws.on('message', data => this._handleMessage(data)); // get version information
-
-    this.version = await this.send('Browser.getVersion');
-    this.log.debug(`Browser connected [${this.process.pid}]: ${this.version.product}`);
-    this.readyState = 1;
-  }
-
-  isConnected() {
-    var _this$ws;
-
-    return ((_this$ws = this.ws) === null || _this$ws === void 0 ? void 0 : _this$ws.readyState) === _ws.default.OPEN;
-  }
-
-  async close() {
-    var _this$process4, _this$ws2;
-
-    // not running, already closed, or closing
-    if (this._closed) return this._closed;
-    this.readyState = 2;
-    this.log.debug('Closing browser'); // resolves when the browser has closed
-
-    this._closed = Promise.all([new Promise(resolve => {
-      /* istanbul ignore next: race condition paranoia */
-      if (!this.process || this.process.exitCode) resolve();else this.process.on('exit', resolve);
-    }), new Promise(resolve => {
-      /* istanbul ignore next: race condition paranoia */
-      if (!this.isConnected()) resolve();else this.ws.on('close', resolve);
-    })]).then(() => {
-      var _this$process, _this$process2, _this$process3;
-
-      // needed due to a bug in Node 12 - https://github.com/nodejs/node/issues/27097
-      (_this$process = this.process) === null || _this$process === void 0 ? void 0 : _this$process.stdin.end();
-      (_this$process2 = this.process) === null || _this$process2 === void 0 ? void 0 : _this$process2.stdout.end();
-      (_this$process3 = this.process) === null || _this$process3 === void 0 ? void 0 : _this$process3.stderr.end();
-      /* istanbul ignore next:
-       *   this might fail on some systems but ultimately it is just a temp file */
-
-      if (this.profile) {
-        // attempt to clean up the profile directory
-        return new Promise((resolve, reject) => {
-          (0, _rimraf.default)(this.profile, e => e ? reject(e) : resolve());
-        }).catch(error => {
-          this.log.debug('Could not clean up temporary browser profile directory.');
-          this.log.debug(error);
-        });
-      }
-    }).then(() => {
-      this.log.debug('Browser closed');
-      this.readyState = 3;
-    }); // reject any pending callbacks
-
-    for (let callback of _classPrivateFieldGet(this, _callbacks).values()) {
-      callback.reject(Object.assign(callback.error, {
-        message: `Protocol error (${callback.method}): Browser closed.`
-      }));
-    } // trigger rejecting pending session callbacks
-
-
-    for (let session of this.sessions.values()) {
-      session._handleClose();
-    } // clear own callbacks and sessions
-
-
-    _classPrivateFieldGet(this, _callbacks).clear();
-
-    this.sessions.clear();
-    /* istanbul ignore next:
-     *   difficult to test failure here without mocking private properties */
-
-    if ((_this$process4 = this.process) !== null && _this$process4 !== void 0 && _this$process4.pid && !this.process.killed) {
-      // always force close the browser process
-      try {
-        this.process.kill('SIGKILL');
-      } catch (error) {
-        throw new Error(`Unable to close the browser: ${error.stack}`);
-      }
-    } // close the socket connection
-
-
-    (_this$ws2 = this.ws) === null || _this$ws2 === void 0 ? void 0 : _this$ws2.close(); // wait for the browser to close
-
-    return this._closed;
-  }
-
-  async page(options = {}) {
-    let {
-      targetId
-    } = await this.send('Target.createTarget', {
-      url: ''
-    });
-    let {
-      sessionId
-    } = await this.send('Target.attachToTarget', {
-      targetId,
-      flatten: true
-    });
-    let page = new _page.default(this.sessions.get(sessionId), options);
-    await page._handleAttachedToTarget();
-    return page;
-  }
-
-  async send(method, params) {
-    /* istanbul ignore next:
-     *   difficult to test failure here without mocking private properties */
-    if (!this.isConnected()) throw new Error('Browser not connected'); // every command needs a unique id
-
-    let id = _classPrivateFieldSet(this, _lastid, +_classPrivateFieldGet(this, _lastid) + 1);
-
-    if (!params && typeof method === 'object') {
-      // allow providing a raw message as the only argument and return the id
-      this.ws.send(JSON.stringify({ ...method,
-        id
-      }));
-      return id;
-    } else {
-      // send the message payload
-      this.ws.send(JSON.stringify({
-        id,
-        method,
-        params
-      })); // will resolve or reject when a matching response is received
-
-      return new Promise((resolve, reject) => {
-        _classPrivateFieldGet(this, _callbacks).set(id, {
-          error: new Error(),
-          resolve,
-          reject,
-          method
-        });
-      });
-    }
-  } // Returns the devtools websocket address. If not already known, will watch the browser's
-  // stderr and resolves when it emits the devtools protocol address or rejects if the process
-  // exits for any reason or if the address does not appear after the timeout.
-
-
-  async address(timeout = 30000) {
-    this._address || (this._address = await new Promise((resolve, reject) => {
-      let stderr = '';
-
-      let handleData = chunk => {
-        stderr += chunk = chunk.toString();
-        let match = chunk.match(/^DevTools listening on (ws:\/\/.*)$/m);
-        if (match) cleanup(() => resolve(match[1]));
-      };
-
-      let handleExitClose = () => handleError();
-
-      let handleError = error => cleanup(() => {
-        var _error$message;
-
-        return reject(new Error(`Failed to launch browser. ${(_error$message = error === null || error === void 0 ? void 0 : error.message) !== null && _error$message !== void 0 ? _error$message : ''}\n${stderr}'\n\n`));
-      });
-
-      let cleanup = callback => {
-        clearTimeout(timeoutId);
-        this.process.stderr.off('data', handleData);
-        this.process.stderr.off('close', handleExitClose);
-        this.process.off('exit', handleExitClose);
-        this.process.off('error', handleError);
-        callback();
-      };
-
-      let timeoutId = setTimeout(() => handleError(new Error(`Timed out after ${timeout}ms`)), timeout);
-      this.process.stderr.on('data', handleData);
-      this.process.stderr.on('close', handleExitClose);
-      this.process.on('exit', handleExitClose);
-      this.process.on('error', handleError);
-    }));
-    return this._address;
-  }
-
-  _handleMessage(data) {
-    data = JSON.parse(data);
-
-    if (data.method === 'Target.attachedToTarget') {
-      // create a new session reference when attached to a target
-      let session = new _session.default(this, data);
-      this.sessions.set(session.sessionId, session);
-    } else if (data.method === 'Target.detachedFromTarget') {
-      // remove the old session reference when detached from a target
-      let session = this.sessions.get(data.params.sessionId);
-      this.sessions.delete(data.params.sessionId);
-      session === null || session === void 0 ? void 0 : session._handleClose();
-    }
-
-    if (data.sessionId) {
-      // message was for a specific session that sent it
-      let session = this.sessions.get(data.sessionId);
-      session === null || session === void 0 ? void 0 : session._handleMessage(data);
-    } else if (data.id && _classPrivateFieldGet(this, _callbacks).has(data.id)) {
-      // resolve or reject a pending promise created with #send()
-      let callback = _classPrivateFieldGet(this, _callbacks).get(data.id);
-
-      _classPrivateFieldGet(this, _callbacks).delete(data.id);
-      /* istanbul ignore next: races with page._handleMessage() */
-
-
-      if (data.error) {
-        callback.reject(Object.assign(callback.error, {
-          message: `Protocol error (${callback.method}): ${data.error.message}` + ('data' in data.error ? `: ${data.error.data}` : '')
-        }));
-      } else {
-        callback.resolve(data.result);
-      }
-    } else {
-      // emit the message as an event
-      this.emit(data.method, data.params);
-    }
-  }
-
-}
-
-exports.Browser = Browser;
-var _default = Browser;
-exports.default = _default;