@checkly/playwright-core 1.42.17 → 1.47.11

package/lib/client/eventEmitter.js

@@ -0,0 +1,314 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventEmitter = void 0;
+var _events = require("events");
+var _utils = require("../utils");
+/**
+ * Copyright Joyent, Inc. and other Node contributors.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+class EventEmitter {
+  constructor() {
+    this._events = undefined;
+    this._eventsCount = 0;
+    this._maxListeners = undefined;
+    this._pendingHandlers = new Map();
+    this._rejectionHandler = void 0;
+    if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = Object.create(null);
+      this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || undefined;
+    this.on = this.addListener;
+    this.off = this.removeListener;
+  }
+  setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || Number.isNaN(n)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+    this._maxListeners = n;
+    return this;
+  }
+  getMaxListeners() {
+    return this._maxListeners === undefined ? _events.EventEmitter.defaultMaxListeners : this._maxListeners;
+  }
+  emit(type, ...args) {
+    const events = this._events;
+    if (events === undefined) return false;
+    const handler = events === null || events === void 0 ? void 0 : events[type];
+    if (handler === undefined) return false;
+    if (typeof handler === 'function') {
+      this._callHandler(type, handler, args);
+    } else {
+      const len = handler.length;
+      const listeners = handler.slice();
+      for (let i = 0; i < len; ++i) this._callHandler(type, listeners[i], args);
+    }
+    return true;
+  }
+  _callHandler(type, handler, args) {
+    const promise = Reflect.apply(handler, this, args);
+    if (!(promise instanceof Promise)) return;
+    let set = this._pendingHandlers.get(type);
+    if (!set) {
+      set = new Set();
+      this._pendingHandlers.set(type, set);
+    }
+    set.add(promise);
+    promise.catch(e => {
+      if (this._rejectionHandler) this._rejectionHandler(e);else throw e;
+    }).finally(() => set.delete(promise));
+  }
+  addListener(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  on(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  _addListener(type, listener, prepend) {
+    checkListener(listener);
+    let events = this._events;
+    let existing;
+    if (events === undefined) {
+      events = this._events = Object.create(null);
+      this._eventsCount = 0;
+    } else {
+      // To avoid recursion in the case that type === "newListener"! Before
+      // adding it to the listeners, first emit "newListener".
+      if (events.newListener !== undefined) {
+        this.emit('newListener', type, unwrapListener(listener));
+
+        // Re-assign `events` because a newListener handler could have caused the
+        // this._events to be assigned to a new object
+        events = this._events;
+      }
+      existing = events[type];
+    }
+    if (existing === undefined) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      existing = events[type] = listener;
+      ++this._eventsCount;
+    } else {
+      if (typeof existing === 'function') {
+        // Adding the second element, need to change to array.
+        existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+        // If we've already got an array, just append.
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+
+      // Check for listener leak
+      const m = this.getMaxListeners();
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        // No error code for this since it is a Warning
+        const w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit');
+        w.name = 'MaxListenersExceededWarning';
+        w.emitter = this;
+        w.type = type;
+        w.count = existing.length;
+        if (!(0, _utils.isUnderTest)()) {
+          // eslint-disable-next-line no-console
+          console.warn(w);
+        }
+      }
+    }
+    return this;
+  }
+  prependListener(type, listener) {
+    return this._addListener(type, listener, true);
+  }
+  once(type, listener) {
+    checkListener(listener);
+    this.on(type, new OnceWrapper(this, type, listener).wrapperFunction);
+    return this;
+  }
+  prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, new OnceWrapper(this, type, listener).wrapperFunction);
+    return this;
+  }
+  removeListener(type, listener) {
+    checkListener(listener);
+    const events = this._events;
+    if (events === undefined) return this;
+    const list = events[type];
+    if (list === undefined) return this;
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0) {
+        this._events = Object.create(null);
+      } else {
+        var _listener;
+        delete events[type];
+        if (events.removeListener) this.emit('removeListener', type, (_listener = list.listener) !== null && _listener !== void 0 ? _listener : listener);
+      }
+    } else if (typeof list !== 'function') {
+      let position = -1;
+      let originalListener;
+      for (let i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || wrappedListener(list[i]) === listener) {
+          originalListener = wrappedListener(list[i]);
+          position = i;
+          break;
+        }
+      }
+      if (position < 0) return this;
+      if (position === 0) list.shift();else list.splice(position, 1);
+      if (list.length === 1) events[type] = list[0];
+      if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener);
+    }
+    return this;
+  }
+  off(type, listener) {
+    return this.removeListener(type, listener);
+  }
+  removeAllListeners(type, options) {
+    this._removeAllListeners(type);
+    if (!options) return this;
+    if (options.behavior === 'wait') {
+      const errors = [];
+      this._rejectionHandler = error => errors.push(error);
+      // eslint-disable-next-line internal-playwright/await-promise-in-class-returns
+      return this._waitFor(type).then(() => {
+        if (errors.length) throw errors[0];
+      });
+    }
+    if (options.behavior === 'ignoreErrors') this._rejectionHandler = () => {};
+
+    // eslint-disable-next-line internal-playwright/await-promise-in-class-returns
+    return Promise.resolve();
+  }
+  _removeAllListeners(type) {
+    const events = this._events;
+    if (!events) return;
+
+    // not listening for removeListener, no need to emit
+    if (!events.removeListener) {
+      if (type === undefined) {
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+      } else if (events[type] !== undefined) {
+        if (--this._eventsCount === 0) this._events = Object.create(null);else delete events[type];
+      }
+      return;
+    }
+
+    // emit removeListener for all listeners on all events
+    if (type === undefined) {
+      const keys = Object.keys(events);
+      let key;
+      for (let i = 0; i < keys.length; ++i) {
+        key = keys[i];
+        if (key === 'removeListener') continue;
+        this._removeAllListeners(key);
+      }
+      this._removeAllListeners('removeListener');
+      this._events = Object.create(null);
+      this._eventsCount = 0;
+      return;
+    }
+    const listeners = events[type];
+    if (typeof listeners === 'function') {
+      this.removeListener(type, listeners);
+    } else if (listeners !== undefined) {
+      // LIFO order
+      for (let i = listeners.length - 1; i >= 0; i--) this.removeListener(type, listeners[i]);
+    }
+  }
+  listeners(type) {
+    return this._listeners(this, type, true);
+  }
+  rawListeners(type) {
+    return this._listeners(this, type, false);
+  }
+  listenerCount(type) {
+    const events = this._events;
+    if (events !== undefined) {
+      const listener = events[type];
+      if (typeof listener === 'function') return 1;
+      if (listener !== undefined) return listener.length;
+    }
+    return 0;
+  }
+  eventNames() {
+    return this._eventsCount > 0 && this._events ? Reflect.ownKeys(this._events) : [];
+  }
+  async _waitFor(type) {
+    let promises = [];
+    if (type) {
+      promises = [...(this._pendingHandlers.get(type) || [])];
+    } else {
+      promises = [];
+      for (const [, pending] of this._pendingHandlers) promises.push(...pending);
+    }
+    await Promise.all(promises);
+  }
+  _listeners(target, type, unwrap) {
+    const events = target._events;
+    if (events === undefined) return [];
+    const listener = events[type];
+    if (listener === undefined) return [];
+    if (typeof listener === 'function') return unwrap ? [unwrapListener(listener)] : [listener];
+    return unwrap ? unwrapListeners(listener) : listener.slice();
+  }
+}
+exports.EventEmitter = EventEmitter;
+function checkListener(listener) {
+  if (typeof listener !== 'function') throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+}
+class OnceWrapper {
+  constructor(eventEmitter, eventType, listener) {
+    this._fired = false;
+    this.wrapperFunction = void 0;
+    this._listener = void 0;
+    this._eventEmitter = void 0;
+    this._eventType = void 0;
+    this._eventEmitter = eventEmitter;
+    this._eventType = eventType;
+    this._listener = listener;
+    this.wrapperFunction = this._handle.bind(this);
+    this.wrapperFunction.listener = listener;
+  }
+  _handle(...args) {
+    if (this._fired) return;
+    this._fired = true;
+    this._eventEmitter.removeListener(this._eventType, this.wrapperFunction);
+    return this._listener.apply(this._eventEmitter, args);
+  }
+}
+function unwrapListener(l) {
+  var _wrappedListener;
+  return (_wrappedListener = wrappedListener(l)) !== null && _wrappedListener !== void 0 ? _wrappedListener : l;
+}
+function unwrapListeners(arr) {
+  return arr.map(l => {
+    var _wrappedListener2;
+    return (_wrappedListener2 = wrappedListener(l)) !== null && _wrappedListener2 !== void 0 ? _wrappedListener2 : l;
+  });
+}
+function wrappedListener(l) {
+  return l.listener;
+}

package/lib/client/fetch.js

@@ -13,6 +13,7 @@ var _channelOwner = require("./channelOwner");
 var _network = require("./network");
 var _tracing = require("./tracing");
 var _errors = require("./errors");
+var _browserContext = require("./browserContext");
 var _fetch = require("../checkly/fetch");
 let _Symbol$asyncDispose, _Symbol$asyncDispose2, _util$inspect$custom;
 /**
@@ -54,12 +55,13 @@ class APIRequest {
       ...options,
       extraHTTPHeaders: options.extraHTTPHeaders ? (0, _utils.headersObjectToArray)(options.extraHTTPHeaders) : undefined,
       storageState,
-      tracesDir
+      tracesDir,
+      clientCertificates: await (0, _browserContext.toClientCertificatesProtocol)(options.clientCertificates)
     })).request);
     this._contexts.add(context);
     context._request = this;
     context._tracing._tracesDir = tracesDir;
-    await context._instrumentation.onDidCreateRequestContext(context);
+    await context._instrumentation.runAfterCreateRequestContext(context);
     return context;
   }
 }
@@ -73,15 +75,23 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
     super(parent, type, guid, initializer);
     this._request = void 0;
     this._tracing = void 0;
+    this._closeReason = void 0;
     this._tracing = _tracing.Tracing.from(initializer.tracing);
   }
   async [_Symbol$asyncDispose]() {
     await this.dispose();
   }
-  async dispose() {
+  async dispose(options = {}) {
     var _this$_request;
-    await this._instrumentation.onWillCloseRequestContext(this);
-    await this._channel.dispose();
+    this._closeReason = options.reason;
+    await this._instrumentation.runBeforeCloseRequestContext(this);
+    try {
+      await this._channel.dispose(options);
+    } catch (e) {
+      if ((0, _errors.isTargetClosedError)(e)) return;
+      throw e;
+    }
+    this._tracing._resetStackCounter();
     (_this$_request = this._request) === null || _this$_request === void 0 || _this$_request._contexts.delete(this);
   }
   async delete(url, options) {
@@ -138,13 +148,14 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
     this.writeApiCallToDisk(options);
     return await this._wrapApiCall(async () => {
       var _options$request, _options$request2, _options$request3;
+      if (this._closeReason) throw new _errors.TargetClosedError(this._closeReason);
       (0, _utils.assert)(options.request || typeof options.url === 'string', 'First argument must be either URL string or Request');
       (0, _utils.assert)((options.data === undefined ? 0 : 1) + (options.form === undefined ? 0 : 1) + (options.multipart === undefined ? 0 : 1) <= 1, `Only one of 'data', 'form' or 'multipart' can be specified`);
-      (0, _utils.assert)(options.maxRedirects === undefined || options.maxRedirects >= 0, `'maxRedirects' should be greater than or equal to '0'`);
+      (0, _utils.assert)(options.maxRedirects === undefined || options.maxRedirects >= 0, `'maxRedirects' must be greater than or equal to '0'`);
+      (0, _utils.assert)(options.maxRetries === undefined || options.maxRetries >= 0, `'maxRetries' must be greater than or equal to '0'`);
       const url = options.url !== undefined ? options.url : options.request.url();
-      const params = objectToArray(options.params);
+      const params = mapParamsToArray(options.params);
       const method = options.method || ((_options$request = options.request) === null || _options$request === void 0 ? void 0 : _options$request.method());
-      const maxRedirects = options.maxRedirects;
       // Cannot call allHeaders() here as the request may be paused inside route handler.
       const headersObj = options.headers || ((_options$request2 = options.request) === null || _options$request2 === void 0 ? void 0 : _options$request2.headers());
       const headers = headersObj ? (0, _utils.headersObjectToArray)(headersObj) : undefined;
@@ -166,26 +177,29 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
         formData = objectToArray(options.form);
       } else if (options.multipart) {
         multipartData = [];
-        // Convert file-like values to ServerFilePayload structs.
-        for (const [name, value] of Object.entries(options.multipart)) {
-          if (isFilePayload(value)) {
-            const payload = value;
-            if (!Buffer.isBuffer(payload.buffer)) throw new Error(`Unexpected buffer type of 'data.${name}'`);
-            multipartData.push({
-              name,
-              file: filePayloadToJson(payload)
-            });
-          } else if (value instanceof _fs.default.ReadStream) {
-            multipartData.push({
-              name,
-              file: await readStreamToJson(value)
-            });
-          } else {
-            multipartData.push({
-              name,
-              value: String(value)
-            });
+        if (globalThis.FormData && options.multipart instanceof FormData) {
+          const form = options.multipart;
+          for (const [name, value] of form.entries()) {
+            if ((0, _utils.isString)(value)) {
+              multipartData.push({
+                name,
+                value
+              });
+            } else {
+              const file = {
+                name: value.name,
+                mimeType: value.type,
+                buffer: Buffer.from(await value.arrayBuffer())
+              };
+              multipartData.push({
+                name,
+                file
+              });
+            }
           }
+        } else {
+          // Convert file-like values to ServerFilePayload structs.
+          for (const [name, value] of Object.entries(options.multipart)) multipartData.push(await toFormField(name, value));
         }
       }
       if (postDataBuffer === undefined && jsonData === undefined && formData === undefined && multipartData === undefined) postDataBuffer = ((_options$request3 = options.request) === null || _options$request3 === void 0 ? void 0 : _options$request3.postDataBuffer()) || undefined;
@@ -204,7 +218,8 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
         timeout: options.timeout,
         failOnStatusCode: options.failOnStatusCode,
         ignoreHTTPSErrors: options.ignoreHTTPSErrors,
-        maxRedirects: maxRedirects,
+        maxRedirects: options.maxRedirects,
+        maxRetries: options.maxRetries,
         tokenizedURL: options.tokenizedURL,
         ...fixtures,
         ...(0, _fetch.getClientCertificates)(options)
@@ -222,6 +237,26 @@ class APIRequestContext extends _channelOwner.ChannelOwner {
   }
 }
 exports.APIRequestContext = APIRequestContext;
+async function toFormField(name, value) {
+  if (isFilePayload(value)) {
+    const payload = value;
+    if (!Buffer.isBuffer(payload.buffer)) throw new Error(`Unexpected buffer type of 'data.${name}'`);
+    return {
+      name,
+      file: filePayloadToJson(payload)
+    };
+  } else if (value instanceof _fs.default.ReadStream) {
+    return {
+      name,
+      file: await readStreamToJson(value)
+    };
+  } else {
+    return {
+      name,
+      value: String(value)
+    };
+  }
+}
 function isJsonParsable(value) {
   if (typeof value !== 'string') return false;
   try {
@@ -353,6 +388,24 @@ function objectToArray(map) {
   });
   return result;
 }
+function queryStringToArray(queryString) {
+  const searchParams = new URLSearchParams(queryString);
+  return searchParamsToArray(searchParams);
+}
+function searchParamsToArray(searchParams) {
+  if (searchParams.size === 0) return undefined;
+  const result = [];
+  for (const [name, value] of searchParams.entries()) result.push({
+    name,
+    value
+  });
+  return result;
+}
+function mapParamsToArray(params) {
+  if (params instanceof URLSearchParams) return searchParamsToArray(params);
+  if (typeof params === 'string') return queryStringToArray(params);
+  return objectToArray(params);
+}
 function isFilePayload(value) {
   return typeof value === 'object' && value['name'] && value['mimeType'] && value['buffer'];
 }

package/lib/client/frame.js

@@ -17,7 +17,6 @@ var _events = require("events");
 var _waiter = require("./waiter");
 var _events2 = require("./events");
 var _types = require("./types");
-var _network2 = require("../utils/network");
 var _clientHelper = require("./clientHelper");
 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; }
@@ -111,7 +110,7 @@ class Frame extends _channelOwner.ChannelOwner {
         // Any failed navigation results in a rejection.
         if (event.error) return true;
         waiter.log(`  navigated to "${event.url}"`);
-        return (0, _network2.urlMatches)((_this$_page = this._page) === null || _this$_page === void 0 ? void 0 : _this$_page.context()._options.baseURL, event.url, options.url);
+        return (0, _utils.urlMatches)((_this$_page = this._page) === null || _this$_page === void 0 ? void 0 : _this$_page.context()._options.baseURL, event.url, options.url);
       });
       if (navigatedEvent.error) {
         const e = new Error(navigatedEvent.error);
@@ -147,7 +146,7 @@ class Frame extends _channelOwner.ChannelOwner {
   }
   async waitForURL(url, options = {}) {
     var _this$_page2;
-    if ((0, _network2.urlMatches)((_this$_page2 = this._page) === null || _this$_page2 === void 0 ? void 0 : _this$_page2.context()._options.baseURL, this.url(), url)) return await this.waitForLoadState(options.waitUntil, options);
+    if ((0, _utils.urlMatches)((_this$_page2 = this._page) === null || _this$_page2 === void 0 ? void 0 : _this$_page2.context()._options.baseURL, this.url(), url)) return await this.waitForLoadState(options.waitUntil, options);
     await this.waitForNavigation({
       url,
       ...options
@@ -179,7 +178,6 @@ class Frame extends _channelOwner.ChannelOwner {
     const result = await this._channel.evaluateExpression({
       expression: String(pageFunction),
       isFunction: typeof pageFunction === 'function',
-      exposeUtilityScript: true,
       arg: (0, _jsHandle.serializeArgument)(arg)
     });
     return (0, _jsHandle.parseResult)(result.value);

package/lib/client/jsHandle.js

@@ -9,6 +9,7 @@ exports.parseResult = parseResult;
 exports.serializeArgument = serializeArgument;
 var _channelOwner = require("./channelOwner");
 var _serializers = require("../protocol/serializers");
+var _errors = require("./errors");
 let _Symbol$asyncDispose;
 /**
  * Copyright (c) Microsoft Corporation.
@@ -78,7 +79,12 @@ class JSHandle extends _channelOwner.ChannelOwner {
     await this.dispose();
   }
   async dispose() {
-    return await this._channel.dispose();
+    try {
+      await this._channel.dispose();
+    } catch (e) {
+      if ((0, _errors.isTargetClosedError)(e)) return;
+      throw e;
+    }
   }
   async _objectCount() {
     return await this._wrapApiCall(async () => {

package/lib/client/locator.js

@@ -71,6 +71,9 @@ class Locator {
       }
     });
   }
+  _equals(locator) {
+    return this._frame === locator._frame && this._selector === locator._selector;
+  }
   page() {
     return this._frame.page();
   }
@@ -174,6 +177,9 @@ class Locator {
   async elementHandles() {
     return await this._frame.$$(this._selector);
   }
+  contentFrame() {
+    return new FrameLocator(this._frame, this._selector);
+  }
   first() {
     return new Locator(this._frame, this._selector + ' >> nth=0');
   }
@@ -409,6 +415,9 @@ class FrameLocator {
   getByRole(role, options = {}) {
     return this.locator((0, _locatorUtils.getByRoleSelector)(role, options));
   }
+  owner() {
+    return new Locator(this._frame, this._frameSelector);
+  }
   frameLocator(selector) {
     return new FrameLocator(this._frame, this._frameSelector + ' >> internal:control=enter-frame >> ' + selector);
   }

package/lib/client/network.js

@@ -15,9 +15,8 @@ var _utils = require("../utils");
 var _manualPromise = require("../utils/manualPromise");
 var _events = require("./events");
 var _waiter = require("./waiter");
-var _network = require("../utils/network");
-var _multimap = require("../utils/multimap");
 var _fetch = require("./fetch");
+var _errors = require("./errors");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
@@ -54,7 +53,6 @@ class Request extends _channelOwner.ChannelOwner {
     this._redirectedFrom = Request.fromNullable(initializer.redirectedFrom);
     if (this._redirectedFrom) this._redirectedFrom._redirectedTo = this;
     this._provisionalHeaders = new RawHeaders(initializer.headers);
-    this._fallbackOverrides.postDataBuffer = initializer.postData;
     this._timing = {
       startTime: 0,
       domainLookupStart: -1,
@@ -77,17 +75,17 @@ class Request extends _channelOwner.ChannelOwner {
     return this._fallbackOverrides.method || this._initializer.method;
   }
   postData() {
-    var _this$_fallbackOverri;
-    return ((_this$_fallbackOverri = this._fallbackOverrides.postDataBuffer) === null || _this$_fallbackOverri === void 0 ? void 0 : _this$_fallbackOverri.toString('utf-8')) || null;
+    var _ref;
+    return ((_ref = this._fallbackOverrides.postDataBuffer || this._initializer.postData) === null || _ref === void 0 ? void 0 : _ref.toString('utf-8')) || null;
   }
   postDataBuffer() {
-    return this._fallbackOverrides.postDataBuffer || null;
+    return this._fallbackOverrides.postDataBuffer || this._initializer.postData || null;
   }
   postDataJSON() {
     const postData = this.postData();
     if (!postData) return null;
     const contentType = this.headers()['content-type'];
-    if (contentType === 'application/x-www-form-urlencoded') {
+    if (contentType !== null && contentType !== void 0 && contentType.includes('application/x-www-form-urlencoded')) {
       const entries = {};
       const parsed = new _url.URLSearchParams(postData);
       for (const [k, v] of parsed.entries()) entries[k] = v;
@@ -520,7 +518,7 @@ class RouteHandler {
     return patterns;
   }
   matches(requestURL) {
-    return (0, _network.urlMatches)(this._baseURL, requestURL, this.url);
+    return (0, _utils.urlMatches)(this._baseURL, requestURL, this.url);
   }
   async handle(route) {
     const handlerInvocation = {
@@ -533,6 +531,11 @@ class RouteHandler {
     } catch (e) {
       // If the handler was stopped (without waiting for completion), we ignore all exceptions.
       if (this._ignoreException) return false;
+      if ((0, _errors.isTargetClosedError)(e)) {
+        // We are failing in the handler because the target close closed.
+        // Give user a hint!
+        (0, _utils.rewriteErrorMessage)(e, `"${e.message}" while running route callback.\nConsider awaiting \`await page.unrouteAll({ behavior: 'ignoreErrors' })\`\nbefore the end of the test to ignore remaining routes in flight.`);
+      }
       throw e;
     } finally {
       handlerInvocation.complete.resolve();
@@ -577,7 +580,7 @@ class RawHeaders {
   }
   constructor(headers) {
     this._headersArray = void 0;
-    this._headersMap = new _multimap.MultiMap();
+    this._headersMap = new _utils.MultiMap();
     this._headersArray = headers;
     for (const header of headers) this._headersMap.set(header.name.toLowerCase(), header.value);
   }