@percy/core 1.0.0-beta.7 → 1.0.0-beta.73

package/README.md

@@ -5,32 +5,67 @@ assets, uploading snapshots, and finalizing builds. Uses `@percy/client` for API
 Puppeteer browser for asset discovery, and starts a local API server for posting snapshots from
 other processes.
 
+- [Usage](#usage)
+  - [`#start()`](#start)
+  - [`#stop()`](#stopforce)
+  - [`#idle()`](#idle)
+  - [`#snapshot()`](#snapshotoptions)
+- [Advanced](#advanced)
+  - [Download discovery browser on install](#download-discovery-browser-on-install)
+  - [Skipping discovery browser download](#skipping-discovery-browser-download)
+
 ## Usage
 
-The `Percy` class will manage a Percy build and perform asset discovery on snapshots before
-uploading them to Percy. It also hosts a local API server for Percy SDKs to communicate with.
+A `Percy` class instance can manage a Percy build, take page snapshots, and perform snapshot asset
+discovery. It also hosts a local API server for Percy SDKs to communicate with.
 
 ``` js
 import Percy from '@percy/core'
 
-const percy = new Percy({
-  token: PERCY_TOKEN,        // defaults to PERCY_TOKEN environment variable
-  loglevel: 'info',          // what level logs to write to console
-  server: true,              // start a local API server
-  port: 5338,                // port to start the API server at
-  concurrency: 5,            // concurrency of the #capture() method
-  snapshot: {},              // global snapshot options (see snapshots section)
-  discovery: {               // asset discovery options
-    allowedHostnames: [],      // list of hostnames allowed to capture from
-    networkIdleTimeout: 100,   // how long before network is considered idle
-    disableAssetCache: false,  // disable discovered asset caching
-    concurrency: 5,            // asset discovery concurrency
-    launchOptions: {}          // browser launch options
-  },
-  ...config                  // additional config options accessible by SDKs
-})
+// create a new instance
+const percy = new Percy(percyOptions)
+
+// create a new instance and start it
+const percy = await Percy.start(percyOptions)
 ```
 
+#### Options
+
+- `token` — Your project's `PERCY_TOKEN` (**default** `process.env.PERCY_TOKEN`)
+- `loglevel` — Logger level, one of `"info"`, `"warn"`, `"error"`, `"debug"` (**default** `"info"`)
+- `server` — Controls whether an API server is created (**default** `true`)
+- `port` — API server port (**default** `5338`)
+- `clientInfo` — Client info sent to Percy via a user-agent string
+- `environmentInfo` — Environment info also sent with the user-agent string
+- `deferUploads` — Defer creating a build and uploading snapshots until later
+- `skipUploads` — Skip creating a build and uploading snapshots altogether
+
+The following options can also be defined within a Percy config file
+
+- `snapshot` — Snapshot options applied to each snapshot
+  - `widths` — Widths to take screenshots at (**default** `[375, 1280]`)
+  - `minHeight` — Minimum screenshot height (**default** `1024`)
+  - `percyCSS` — Percy specific CSS to inject into the snapshot
+  - `enableJavaScript` — Enable JavaScript for screenshots (**default** `false`)
+- `discovery` — Asset discovery options
+  - `allowedHostnames` — Array of allowed hostnames to capture assets from
+  - `requestHeaders` — Request headers used when discovering snapshot assets
+  - `authorization` — Basic auth `username` and `password` for protected snapshot assets
+  - `disableCache` — Disable asset caching (**default** `false`)
+  - `userAgent` — Custom user-agent string used when requesting assets
+  - `cookies` — Browser cookies to use when requesting assets
+  - `networkIdleTimeout` — Milliseconds to wait for the network to idle (**default** `100`)
+  - `concurrency` — Asset discovery concerrency (**default** `5`)
+  - `launchOptions` — Asset discovery browser launch options
+    - `executable` — Browser executable path (**default** `process.env.PERCY_BROWSER_EXECUTABLE`)
+    - `timeout` — Discovery launch timeout, in milliseconds (**default** `30000`)
+    - `args` — Additional browser process arguments
+    - `headless` — Runs the browser headlessy (**default** `true`)
+    
+Additional Percy config file options are also allowed and will override any options defined by a
+local config file. These config file options are also made available to SDKs via the local API
+health check endpoint.
+
 ### `#start()`
 
 Starting a `Percy` instance will start a local API server, start the asset discovery browser, and
@@ -39,81 +74,137 @@ create a new Percy build. If an asset discovery browser is not found, one will b
 ``` js
 await percy.start()
 // [percy] Percy has started!
-// [percy] Created build #1: https://percy.io/org/project/123
 ```
 
 #### API Server
 
 Starting a `Percy` instance will start a local API server unless `server` is `false`. The server can
-be found at `http://localhost:5338/` or at the provided `port` number. All POST requests accept a
-JSON body with the `application/json` content-type.
+be found at `http://localhost:5338/` or at the provided `port` number.
 
 - GET `/percy/healthcheck` – Responds with information about the running instance
 - GET `/percy/dom.js` – Responds with the [`@percy/dom`](./packages/dom) library
+- GET `/percy/idle` - Responds when the running instance is [idle](#idle)
 - POST `/percy/snapshot` – Calls [`#snapshot()`](#snapshotoptions) with provided snapshot options
-- POST `/percy/stop` - Remotely [stops](#stop) the running `Percy` instance
+- POST `/percy/stop` - Remotely [stops](#stopforce) the running `Percy` instance
 
-### `#snapshot(options)`
+### `#stop([force])`
 
-Performs asset discovery for the provided DOM snapshot at widths specified here or in the instance's
-provided `snapshot` option. This is the primary method used by Percy SDKs to upload snapshots.
+Stopping a `Percy` instance will wait for any pending snapshots, close the asset discovery browser,
+close the local API server, and finalize the current Percy build. When uploads are deferred,
+stopping the instance will also trigger processing of the upload queue. When `force` is `true`,
+queues are cleared and closed to prevent queued snapshots from running.
 
 ``` js
-// snapshots can be handled concurrently, no need to await
-percy.snapshot({
-  name: 'My Snapshot',           // required name
-  url: 'http://localhost:3000',  // required url
-  domSnapshot: domSnapshot,      // required DOM string
-  widths: [500, 1280],           // widths to discover resources
-  minimumHeight: 1024,           // minimum height used when screenshotting
-  percyCSS: '',                  // percy specific css to inject
-  requestHeaders: {},            // asset request headers such as authorization
-  clientInfo: '',                // user-agent client info for the SDK
-  environmentInfo: ''            // user-agent environment info for the SDK
-})
+await percy.stop()
+// [percy] Processing 3 snapshots...
+// [percy] Snapshot taken: Snapshot one
+// [percy] Snapshot taken: Snapshot two
+// [percy] Snapshot taken: Snapshot three
+// [percy] Uploading 3 snapshots...
+// [percy] Finalized build #1: https://percy.io/org/project/123
+
+await percy.stop(true)
+// [percy] Stopping percy...
+// [percy] Finalized build #1: https://percy.io/org/project/123
 ```
 
-### `#capture(options)`
+### `#idle()`
 
-Navigates to a URL and captures a snapshot or multiple snapshots of a page after optionally
-interacting with the page. Any [`#snapshot()`](#snapshotoptions) options can also be provided, with
-the exception of `domSnapshot`.
+This method will resolve shortly after pending snapshots and uploads have completed and no more have
+started. Queued tasks are not considered pending unless they are actively running, so deferred
+uploads will not be awaited on with this method.
 
 ``` js
-// pages can be captured concurrently, no need to await
-percy.capture({
-  name: 'My Snapshot',            // snapshot name
-  url: 'http://localhost:3000/',  // required page URL
-  waitFor: selectorOrTimeout,     // selector or timeout to wait for before snapshotting
-  execute: async (page) => {},    // async page function to execute before snapshotting
-  snapshots: [{                   // additional snapshots to take on this page
-    name: 'Second Snapshot',        // additional snapshot name
-    execute: async (page) => {},    // additional snapshot page function
-    ...options                      // ...additional snapshot options
-  }],
-  ...options                      // ...other snapshot options
-})
+percy.snapshot(...);
+percy.snapshot(...);
+percy.snapshot(...);
+
+await percy.idle()
+// [percy] Snapshot taken: ...
+// [percy] Snapshot taken: ...
+// [percy] Snapshot taken: ...
 ```
 
-### `#stop()`
+### `#snapshot(options)`
 
-Stopping a `Percy` instance will wait for any pending snapshots, close the asset discovery browser,
-close the local API server, and finalize the current Percy build.
+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.
 
 ``` js
-await percy.stop()
-// [percy] Stopping percy...
-// [percy] Waiting for 1 snapshot(s) to complete
-// [percy] Snapshot taken: My Snapshot
-// [percy] Finalized build #1: https://percy.io/org/project/123
-// [percy] Done
+// snapshots can be handled concurrently, no need to await
+percy.snapshot({
+  name: 'Snapshot 1',
+  url: 'http://localhost:3000',
+  domSnapshot: domSnapshot,
+  clientInfo: 'my-sdk',
+  environmentInfo: 'my-lib'
+  ...snapshotOptions
+})
+
+percy.snapshot({
+  name: 'Snapshot 2',
+  url: 'http://localhost:3000/',
+  ...snapshotOptions,
+  
+  // without a domSnapshot, capture options will be used to take one
+  waitForTimeout: 1000,
+  waitForSelector: '.done-loading',
+  execute: async () => {},
+  additionalSnapshots: [{
+    name: 'Snapshot 2.1',
+    execute: () => {},
+    ...snapshotOptions
+  }]
+})
 ```
 
+#### Options
+
+- `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`
+
+**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
+- `execute` — Function or function body to execute within the page before taking a snapshot
+- `additionalSnapshots` — Array of additional sequential snapshots to take of the page
+  - `name` — Snapshot name (**required** if no `prefix` or `suffix`)
+  - `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
+
+Common snapshot options are also accepted and will override instance snapshot options. [See instance
+options](#options) for common snapshot and discovery options.
+
 ## Advanced
 
-### Puppeteer Executable Path
+### Download discovery browser on install
+
+By default, the browser is only downloaded when asset discovery is started for the first time. This
+is because many features of the CLI do not require a browser at all, and automatically downloading a
+browser creates a much heavier footprint than needed for those features. However, if your CI caches
+dependencies after the install step, the browser will not be cached and will be downloaded every
+time Percy runs without it.
+
+If the environment variable `PERCY_POSTINSTALL_BROWSER` is present and truthy, then the browser will
+be downloaded after the package is installed to allow it to be cached. You can also require
+`@percy/core/post-install` within another node module to trigger the browser download manually.
+
+### Skipping discovery browser download
 
-To avoid downloading the browser used for asset discovery, the local browser executable can be
-defined with an `executablePath` option provided within `discovery.launchOptions`. This options
-falls back to the `PUPPETEER_EXECUTABLE_PATH` environment variable if defined.
+If your CI comes with a Chromium binary pre-installed and you wish to skip Percy's own browser
+installation, you can set the respective `discovery.launchOptions.executable` config option. When
+the executable at the provided path exists, the default download will be skipped and the provided
+binary will be used instead. This option can also be set using the `PERCY_BROWSER_EXECUTABLE`
+environment variable.
 
+> **Warning!** Percy is only tested against the browser it downloads automatically. When providing a
+> custom browser executable, you may experience unexpected issues.

package/dist/browser.js

@@ -0,0 +1,363 @@
+"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;