@bigbinary/neeto-playwright-commons 1.8.16 → 1.8.18

package/index.cjs.js

@@ -3,16 +3,17 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var test = require('@playwright/test');
-var require$$0 = require('fs');
+var require$$0$1 = require('fs');
 var ramda = require('ramda');
 var faker = require('@faker-js/faker');
 var MailosaurClient = require('mailosaur');
 var dayjs = require('dayjs');
-var require$$2 = require('os');
-var require$$0$1 = require('path');
-var require$$0$2 = require('util');
-var require$$0$3 = require('stream');
-var require$$0$4 = require('events');
+var require$$1 = require('tty');
+var require$$0$3 = require('util');
+var require$$0$2 = require('os');
+var require$$0$4 = require('path');
+var require$$0$5 = require('stream');
+var require$$0$6 = require('events');
 var playwrightI18nextFixture = require('playwright-i18next-fixture');
 var neetoCist = require('@bigbinary/neeto-cist');
 var require$$3 = require('crypto');
@@ -38,15 +39,16 @@ function _interopNamespace(e) {
 }
 
 var test__default = /*#__PURE__*/_interopDefaultLegacy(test);
-var require$$0__namespace = /*#__PURE__*/_interopNamespace(require$$0);
-var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var require$$0__namespace = /*#__PURE__*/_interopNamespace(require$$0$1);
+var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 var MailosaurClient__default = /*#__PURE__*/_interopDefaultLegacy(MailosaurClient);
 var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
-var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
-var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
-var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
-var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
+var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
+var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$5);
+var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 
 const ENVIRONMENT = {
@@ -193,12 +195,12 @@ const COMMON_SELECTORS = {
 
 class CustomCommands {
     constructor(page, request, baseURL = process.env.BASE_URL) {
-        this.interceptMultipleResponses = ({ responseUrl = "", times = 1, baseUrl, customPageContext, timeout = 35000, } = {}) => {
+        this.interceptMultipleResponses = ({ responseUrl = "", responseStatus = 200, times = 1, baseUrl, customPageContext, timeout = 35000, } = {}) => {
             const pageContext = customPageContext !== null && customPageContext !== void 0 ? customPageContext : this.page;
             return Promise.all([...new Array(times)].map(() => pageContext.waitForResponse((response) => {
                 var _a, _b, _c;
                 if (response.request().resourceType() === "xhr" &&
-                    response.status() === 200 &&
+                    response.status() === responseStatus &&
                     response.url().includes(responseUrl) &&
                     response.url().startsWith((_a = baseUrl !== null && baseUrl !== void 0 ? baseUrl : this.baseURL) !== null && _a !== void 0 ? _a : "") &&
                     !this.responses.includes((_b = response.headers()) === null || _b === void 0 ? void 0 : _b["x-request-id"])) {
@@ -350,6 +352,2821 @@ const generateStagingData = (product = "invoice") => {
     };
 };
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function () {
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var src = {exports: {}};
+
+var browser$1 = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+var common$7;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common$7;
+	hasRequiredCommon = 1;
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
+
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
+
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
+
+				const self = debug;
+
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+
+				args[0] = createDebug.coerce(args[0]);
+
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
+				}
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
+					}
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
+			}
+
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
+					}
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
+				}
+			});
+
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
+			}
+
+			return debug;
+		}
+
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			let i;
+			const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+			const len = split.length;
+
+			for (i = 0; i < len; i++) {
+				if (!split[i]) {
+					// ignore empty strings
+					continue;
+				}
+
+				namespaces = split[i].replace(/\*/g, '.*?');
+
+				if (namespaces[0] === '-') {
+					createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+				} else {
+					createDebug.names.push(new RegExp('^' + namespaces + '$'));
+				}
+			}
+		}
+
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names.map(toNamespace),
+				...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
+		}
+
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			if (name[name.length - 1] === '*') {
+				return true;
+			}
+
+			let i;
+			let len;
+
+			for (i = 0, len = createDebug.skips.length; i < len; i++) {
+				if (createDebug.skips[i].test(name)) {
+					return false;
+				}
+			}
+
+			for (i = 0, len = createDebug.names.length; i < len; i++) {
+				if (createDebug.names[i].test(name)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		* Convert regexp to namespace
+		*
+		* @param {RegExp} regxep
+		* @return {String} namespace
+		* @api private
+		*/
+		function toNamespace(regexp) {
+			return regexp.toString()
+				.substring(2, regexp.toString().length - 2)
+				.replace(/\.\*\?$/, '*');
+		}
+
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
+			}
+			return val;
+		}
+
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+
+		createDebug.enable(createDebug.load());
+
+		return createDebug;
+	}
+
+	common$7 = setup;
+	return common$7;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser$1.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
+			}
+
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+		}
+
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
+
+			if (!this.useColors) {
+				return;
+			}
+
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
+		}
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		};
+} (browser$1, browser$1.exports));
+	return browser$1.exports;
+}
+
+var node = {exports: {}};
+
+var hasFlag;
+var hasRequiredHasFlag;
+
+function requireHasFlag () {
+	if (hasRequiredHasFlag) return hasFlag;
+	hasRequiredHasFlag = 1;
+
+	hasFlag = (flag, argv = process.argv) => {
+		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+		const position = argv.indexOf(prefix + flag);
+		const terminatorPosition = argv.indexOf('--');
+		return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+	};
+	return hasFlag;
+}
+
+var supportsColor_1;
+var hasRequiredSupportsColor;
+
+function requireSupportsColor () {
+	if (hasRequiredSupportsColor) return supportsColor_1;
+	hasRequiredSupportsColor = 1;
+	const os = require$$0__default["default"];
+	const tty = require$$1__default["default"];
+	const hasFlag = requireHasFlag();
+
+	const {env} = process;
+
+	let forceColor;
+	if (hasFlag('no-color') ||
+		hasFlag('no-colors') ||
+		hasFlag('color=false') ||
+		hasFlag('color=never')) {
+		forceColor = 0;
+	} else if (hasFlag('color') ||
+		hasFlag('colors') ||
+		hasFlag('color=true') ||
+		hasFlag('color=always')) {
+		forceColor = 1;
+	}
+
+	if ('FORCE_COLOR' in env) {
+		if (env.FORCE_COLOR === 'true') {
+			forceColor = 1;
+		} else if (env.FORCE_COLOR === 'false') {
+			forceColor = 0;
+		} else {
+			forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+		}
+	}
+
+	function translateLevel(level) {
+		if (level === 0) {
+			return false;
+		}
+
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+
+	function supportsColor(haveStream, streamIsTTY) {
+		if (forceColor === 0) {
+			return 0;
+		}
+
+		if (hasFlag('color=16m') ||
+			hasFlag('color=full') ||
+			hasFlag('color=truecolor')) {
+			return 3;
+		}
+
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+
+		if (haveStream && !streamIsTTY && forceColor === undefined) {
+			return 0;
+		}
+
+		const min = forceColor || 0;
+
+		if (env.TERM === 'dumb') {
+			return min;
+		}
+
+		if (process.platform === 'win32') {
+			// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+			// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+			const osRelease = os.release().split('.');
+			if (
+				Number(osRelease[0]) >= 10 &&
+				Number(osRelease[2]) >= 10586
+			) {
+				return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			}
+
+			return 1;
+		}
+
+		if ('CI' in env) {
+			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+				return 1;
+			}
+
+			return min;
+		}
+
+		if ('TEAMCITY_VERSION' in env) {
+			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		}
+
+		if (env.COLORTERM === 'truecolor') {
+			return 3;
+		}
+
+		if ('TERM_PROGRAM' in env) {
+			const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+			switch (env.TERM_PROGRAM) {
+				case 'iTerm.app':
+					return version >= 3 ? 3 : 2;
+				case 'Apple_Terminal':
+					return 2;
+				// No default
+			}
+		}
+
+		if (/-256(color)?$/i.test(env.TERM)) {
+			return 2;
+		}
+
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+			return 1;
+		}
+
+		if ('COLORTERM' in env) {
+			return 1;
+		}
+
+		return min;
+	}
+
+	function getSupportLevel(stream) {
+		const level = supportsColor(stream, stream && stream.isTTY);
+		return translateLevel(level);
+	}
+
+	supportsColor_1 = {
+		supportsColor: getSupportLevel,
+		stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+		stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+	};
+	return supportsColor_1;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		const tty = require$$1__default["default"];
+		const util = require$$0__default$1["default"];
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
+			() => {},
+			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+		);
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const supportsColor = requireSupportsColor();
+
+			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+				exports.colors = [
+					20,
+					21,
+					26,
+					27,
+					32,
+					33,
+					38,
+					39,
+					40,
+					41,
+					42,
+					43,
+					44,
+					45,
+					56,
+					57,
+					62,
+					63,
+					68,
+					69,
+					74,
+					75,
+					76,
+					77,
+					78,
+					79,
+					80,
+					81,
+					92,
+					93,
+					98,
+					99,
+					112,
+					113,
+					128,
+					129,
+					134,
+					135,
+					148,
+					149,
+					160,
+					161,
+					162,
+					163,
+					164,
+					165,
+					166,
+					167,
+					168,
+					169,
+					170,
+					171,
+					172,
+					173,
+					178,
+					179,
+					184,
+					185,
+					196,
+					197,
+					198,
+					199,
+					200,
+					201,
+					202,
+					203,
+					204,
+					205,
+					206,
+					207,
+					208,
+					209,
+					214,
+					215,
+					220,
+					221
+				];
+			}
+		} catch (error) {
+			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		}
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.format(...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		};
+} (node, node.exports));
+	return node.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+(function (module) {
+	if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+		module.exports = requireBrowser();
+	} else {
+		module.exports = requireNode();
+	}
+} (src));
+
+var debug$3 = /*@__PURE__*/getDefaultExportFromCjs(src.exports);
+
+/*!
+ * playwright-extra v4.3.5 by berstend
+ * https://github.com/berstend/puppeteer-extra/tree/master/packages/playwright-extra#readme
+ * @license MIT
+ */
+
+/** Node.js module loader helper */
+class Loader {
+    constructor(moduleName, packageNames) {
+        this.moduleName = moduleName;
+        this.packageNames = packageNames;
+    }
+    /**
+     * Lazy load a top level export from another module by wrapping it in a JS proxy.
+     *
+     * This allows us to re-export e.g. `devices` from `playwright` while redirecting direct calls
+     * to it to the module version the user has installed, rather than shipping with a hardcoded version.
+     *
+     * If we don't do this and the user doesn't have the target module installed we'd throw immediately when our code is imported.
+     *
+     * We use a "super" Proxy defining all traps, so calls like `Object.keys(playwright.devices).length` will return the correct value.
+     */
+    lazyloadExportOrDie(exportName) {
+        const that = this;
+        const trapHandler = Object.fromEntries(Object.getOwnPropertyNames(Reflect).map((name) => [
+            name,
+            function (target, ...args) {
+                const moduleExport = that.loadModuleOrDie()[exportName];
+                const customTarget = moduleExport;
+                const result = Reflect[name](customTarget || target, ...args);
+                return result;
+            }
+        ]));
+        return new Proxy({}, trapHandler);
+    }
+    /** Load the module if possible */
+    loadModule() {
+        return requirePackages(this.packageNames);
+    }
+    /** Load the module if possible or throw */
+    loadModuleOrDie() {
+        const module = requirePackages(this.packageNames);
+        if (module) {
+            return module;
+        }
+        throw this.requireError;
+    }
+    get requireError() {
+        const moduleNamePretty = this.moduleName.charAt(0).toUpperCase() + this.moduleName.slice(1);
+        return new Error(`
+  ${moduleNamePretty} is missing. :-)
+
+  I've tried loading ${this.packageNames
+            .map(p => `"${p}"`)
+            .join(', ')} - no luck.
+
+  Make sure you install one of those packages or use the named 'addExtra' export,
+  to patch a specific (and maybe non-standard) implementation of ${moduleNamePretty}.
+
+  To get the latest stable version of ${moduleNamePretty} run:
+  'yarn add ${this.moduleName}' or 'npm i ${this.moduleName}'
+  `);
+    }
+}
+function requirePackages(packageNames) {
+    for (const name of packageNames) {
+        try {
+            return require(name);
+        }
+        catch (_) {
+            continue; // noop
+        }
+    }
+    return;
+}
+/** Playwright specific module loader */
+const playwrightLoader = new Loader('playwright', [
+    'playwright-core',
+    'playwright'
+]);
+
+const debug = debug$3('playwright-extra:puppeteer-compat');
+const isPlaywrightPage = (obj) => {
+    return 'unroute' in obj;
+};
+const isPlaywrightFrame = (obj) => {
+    return ['parentFrame', 'frameLocator'].every(x => x in obj);
+};
+const isPlaywrightBrowser = (obj) => {
+    return 'newContext' in obj;
+};
+const isPuppeteerCompat = (obj) => {
+    return !!obj && typeof obj === 'object' && !!obj.isCompatShim;
+};
+const cache = {
+    objectToShim: new Map(),
+    cdpSession: {
+        page: new Map(),
+        browser: new Map()
+    }
+};
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+function addPuppeteerCompat(object) {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    if (cache.objectToShim.has(object)) {
+        return cache.objectToShim.get(object);
+    }
+    if (isPuppeteerCompat(object)) {
+        return object;
+    }
+    debug('addPuppeteerCompat', cache.objectToShim.size);
+    if (isPlaywrightPage(object) || isPlaywrightFrame(object)) {
+        const shim = createPageShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    if (isPlaywrightBrowser(object)) {
+        const shim = createBrowserShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    debug('Received unknown object:', Reflect.ownKeys(object));
+    return object;
+}
+// Only chromium browsers support CDP
+const dummyCDPClient = {
+    send: async (...args) => {
+        debug('dummy CDP client called', 'send', args);
+    },
+    on: (...args) => {
+        debug('dummy CDP client called', 'on', args);
+    }
+};
+async function getPageCDPSession(page) {
+    let session = cache.cdpSession.page.get(page);
+    if (session) {
+        debug('getPageCDPSession: use existing');
+        return session;
+    }
+    debug('getPageCDPSession: use new');
+    const context = isPlaywrightFrame(page)
+        ? page.page().context()
+        : page.context();
+    try {
+        session = await context.newCDPSession(page);
+        cache.cdpSession.page.set(page, session);
+        return session;
+    }
+    catch (err) {
+        debug('getPageCDPSession: error while creating session:', err.message);
+        debug('getPageCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+async function getBrowserCDPSession(browser) {
+    let session = cache.cdpSession.browser.get(browser);
+    if (session) {
+        debug('getBrowserCDPSession: use existing');
+        return session;
+    }
+    debug('getBrowserCDPSession: use new');
+    try {
+        session = await browser.newBrowserCDPSession();
+        cache.cdpSession.browser.set(browser, session);
+        return session;
+    }
+    catch (err) {
+        debug('getBrowserCDPSession: error while creating session:', err.message);
+        debug('getBrowserCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+function createPageShim(page) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(page, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('page - get', objId, prop);
+            if (prop === '_client') {
+                return () => ({
+                    send: async (method, params) => {
+                        const session = await getPageCDPSession(page);
+                        return await session.send(method, params);
+                    },
+                    on: (event, listener) => {
+                        getPageCDPSession(page).then(session => {
+                            session.on(event, listener);
+                        });
+                    }
+                });
+            }
+            if (prop === 'setBypassCSP') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Page.setBypassCSP', {
+                        enabled
+                    });
+                };
+            }
+            if (prop === 'setUserAgent') {
+                return async (userAgent, userAgentMetadata) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Emulation.setUserAgentOverride', {
+                        userAgent,
+                        userAgentMetadata
+                    });
+                };
+            }
+            if (prop === 'browser') {
+                if (isPlaywrightPage(page)) {
+                    return () => {
+                        let browser = page.context().browser();
+                        if (!browser) {
+                            debug('page.browser() - not available, most likely due to launchPersistentContext');
+                            // Use a page shim as quick drop-in (so browser.userAgent() still works)
+                            browser = page;
+                        }
+                        return addPuppeteerCompat(browser);
+                    };
+                }
+            }
+            if (prop === 'evaluateOnNewDocument') {
+                if (isPlaywrightPage(page)) {
+                    return async function (pageFunction, ...args) {
+                        return await page.addInitScript(pageFunction, args[0]);
+                    };
+                }
+            }
+            // Only relevant when page is being used a pseudo stand-in for the browser object (launchPersistentContext)
+            if (prop === 'userAgent') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+function createBrowserShim(browser) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(browser, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('browser - get', objId, prop);
+            if (prop === 'pages') {
+                return () => browser
+                    .contexts()
+                    .flatMap(c => c.pages().map(page => addPuppeteerCompat(page)));
+            }
+            if (prop === 'userAgent') {
+                return async () => {
+                    const session = await getBrowserCDPSession(browser);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+
+const debug$1 = debug$3('playwright-extra:plugins');
+class PluginList {
+    constructor() {
+        this._plugins = [];
+        this._dependencyDefaults = new Map();
+        this._dependencyResolution = new Map();
+    }
+    /**
+     * Get a list of all registered plugins.
+     */
+    get list() {
+        return this._plugins;
+    }
+    /**
+     * Get the names of all registered plugins.
+     */
+    get names() {
+        return this._plugins.map(p => p.name);
+    }
+    /**
+     * Add a new plugin to the list (after checking if it's well-formed).
+     *
+     * @param plugin
+     * @internal
+     */
+    add(plugin) {
+        var _a;
+        if (!this.isValidPluginInstance(plugin)) {
+            return false;
+        }
+        if (!!plugin.onPluginRegistered) {
+            plugin.onPluginRegistered({ framework: 'playwright' });
+        }
+        // PuppeteerExtraPlugin: Populate `_childClassMembers` list containing methods defined by the plugin
+        if (!!plugin._registerChildClassMembers) {
+            plugin._registerChildClassMembers(Object.getPrototypeOf(plugin));
+        }
+        if ((_a = plugin.requirements) === null || _a === void 0 ? void 0 : _a.has('dataFromPlugins')) {
+            plugin.getDataFromPlugins = this.getData.bind(this);
+        }
+        this._plugins.push(plugin);
+        return true;
+    }
+    /** Check if the shape of a plugin is correct or warn */
+    isValidPluginInstance(plugin) {
+        if (!plugin ||
+            typeof plugin !== 'object' ||
+            !plugin._isPuppeteerExtraPlugin) {
+            console.error(`Warning: Plugin is not derived from PuppeteerExtraPlugin, ignoring.`, plugin);
+            return false;
+        }
+        if (!plugin.name) {
+            console.error(`Warning: Plugin with no name registering, ignoring.`, plugin);
+            return false;
+        }
+        return true;
+    }
+    /** Error callback in case calling a plugin method throws an error. Can be overwritten. */
+    onPluginError(plugin, method, err) {
+        console.warn(`An error occured while executing "${method}" in plugin "${plugin.name}":`, err);
+    }
+    /**
+     * Define default values for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * @param dependencyPath - The string by which the dependency is listed (not the plugin name)
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyDefaults('stealth/evasions/webgl.vendor', { vendor: 'Bob', renderer: 'Alice' })
+     */
+    setDependencyDefaults(dependencyPath, opts) {
+        this._dependencyDefaults.set(dependencyPath, opts);
+        return this;
+    }
+    /**
+     * Define custom plugin modules for plugins implicitly required through the `dependencies` plugin stanza.
+     *
+     * Using this will prevent dynamic imports from being used, which JS bundlers often have issues with.
+     *
+     * @example
+     * chromium.use(stealth)
+     * chromium.plugins.setDependencyResolution('stealth/evasions/webgl.vendor', VendorPlugin)
+     */
+    setDependencyResolution(dependencyPath, pluginModule) {
+        this._dependencyResolution.set(dependencyPath, pluginModule);
+        return this;
+    }
+    /**
+     * Prepare plugins to be used (resolve dependencies, ordering)
+     * @internal
+     */
+    prepare() {
+        this.resolveDependencies();
+        this.order();
+    }
+    /** Return all plugins using the supplied method */
+    filterByMethod(methodName) {
+        return this._plugins.filter(plugin => {
+            // PuppeteerExtraPlugin: The base class will already define all methods, hence we need to do a different check
+            if (!!plugin._childClassMembers &&
+                Array.isArray(plugin._childClassMembers)) {
+                return plugin._childClassMembers.includes(methodName);
+            }
+            return methodName in plugin;
+        });
+    }
+    /** Conditionally add puppeteer compatibility to values provided to the plugins */
+    _addPuppeteerCompatIfNeeded(plugin, method, args) {
+        const canUseShim = plugin._isPuppeteerExtraPlugin && !plugin.noPuppeteerShim;
+        const methodWhitelist = [
+            'onBrowser',
+            'onPageCreated',
+            'onPageClose',
+            'afterConnect',
+            'afterLaunch'
+        ];
+        const shouldUseShim = methodWhitelist.includes(method);
+        if (!canUseShim || !shouldUseShim) {
+            return args;
+        }
+        debug$1('add puppeteer compatibility', plugin.name, method);
+        return [...args.map(arg => addPuppeteerCompat(arg))];
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Will not await results to dispatch events as fast as possible to all plugins.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    dispatch(method, ...args) {
+        var _a, _b;
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatch', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                const fnType = (_b = (_a = plugin[method]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                debug$1('dispatch to plugin', {
+                    plugin: plugin.name,
+                    method,
+                    fnType
+                });
+                if (fnType === 'AsyncFunction') {
+                    ;
+                    plugin[method](...args).catch((err) => this.onPluginError(plugin, method, err));
+                }
+                else {
+                    ;
+                    plugin[method](...args);
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+            }
+        }
+    }
+    /**
+     * Dispatch plugin lifecycle events in a typesafe way.
+     * Only Plugins that expose the supplied property will be called.
+     *
+     * Can also be used to get a definite return value after passing it to plugins:
+     * Calls plugins sequentially and passes on a value (waterfall style).
+     *
+     * The plugins can either modify the value or return an updated one.
+     * Will return the latest, updated value which ran through all plugins.
+     *
+     * By convention only the first argument will be used as the updated value.
+     *
+     * @param method - The lifecycle method name
+     * @param args - Optional: Any arguments to be supplied to the plugin methods
+     * @internal
+     */
+    async dispatchBlocking(method, ...args) {
+        const plugins = this.filterByMethod(method);
+        debug$1('dispatchBlocking', method, {
+            all: this._plugins.length,
+            filteredByMethod: plugins.length
+        });
+        let retValue = null;
+        for (const plugin of plugins) {
+            try {
+                args = this._addPuppeteerCompatIfNeeded.bind(this)(plugin, method, args);
+                retValue = await plugin[method](...args);
+                // In case we got a return value use that as new first argument for followup function calls
+                if (retValue !== undefined) {
+                    args[0] = retValue;
+                }
+            }
+            catch (err) {
+                this.onPluginError(plugin, method, err);
+                return retValue;
+            }
+        }
+        return retValue;
+    }
+    /**
+     * Order plugins that have expressed a special placement requirement.
+     *
+     * This is useful/necessary for e.g. plugins that depend on the data from other plugins.
+     *
+     * @private
+     */
+    order() {
+        debug$1('order:before', this.names);
+        const runLast = this._plugins
+            .filter(p => { var _a; return (_a = p.requirements) === null || _a === void 0 ? void 0 : _a.has('runLast'); })
+            .map(p => p.name);
+        for (const name of runLast) {
+            const index = this._plugins.findIndex(p => p.name === name);
+            this._plugins.push(this._plugins.splice(index, 1)[0]);
+        }
+        debug$1('order:after', this.names);
+    }
+    /**
+     * Collects the exposed `data` property of all registered plugins.
+     * Will be reduced/flattened to a single array.
+     *
+     * Can be accessed by plugins that listed the `dataFromPlugins` requirement.
+     *
+     * Implemented mainly for plugins that need data from other plugins (e.g. `user-preferences`).
+     *
+     * @see [PuppeteerExtraPlugin]/data
+     * @param name - Filter data by optional name
+     *
+     * @private
+     */
+    getData(name) {
+        const data = this._plugins
+            .filter((p) => !!p.data)
+            .map((p) => (Array.isArray(p.data) ? p.data : [p.data]))
+            .reduce((acc, arr) => [...acc, ...arr], []);
+        return name ? data.filter((d) => d.name === name) : data;
+    }
+    /**
+     * Handle `plugins` stanza (already instantiated plugins that don't require dynamic imports)
+     */
+    resolvePluginsStanza() {
+        debug$1('resolvePluginsStanza');
+        const pluginNames = new Set(this.names);
+        this._plugins
+            .filter(p => !!p.plugins && p.plugins.length)
+            .filter(p => !pluginNames.has(p.name)) // TBD: Do we want to filter out existing?
+            .forEach(parent => {
+            (parent.plugins || []).forEach(p => {
+                debug$1(parent.name, 'adding missing plugin', p.name);
+                this.add(p);
+            });
+        });
+    }
+    /**
+     * Handle `dependencies` stanza (which requires dynamic imports)
+     *
+     * Plugins can define `dependencies` as a Set or Array of dependency paths, or a Map with additional opts
+     *
+     * @note
+     * - The default opts for implicit dependencies can be defined using `setDependencyDefaults()`
+     * - Dynamic imports can be avoided by providing plugin modules with `setDependencyResolution()`
+     */
+    resolveDependenciesStanza() {
+        debug$1('resolveDependenciesStanza');
+        /** Attempt to dynamically require a plugin module */
+        const requireDependencyOrDie = (parentName, dependencyPath) => {
+            // If the user provided the plugin module already we use that
+            if (this._dependencyResolution.has(dependencyPath)) {
+                return this._dependencyResolution.get(dependencyPath);
+            }
+            const possiblePrefixes = ['puppeteer-extra-plugin-']; // could be extended later
+            const isAlreadyPrefixed = possiblePrefixes.some(prefix => dependencyPath.startsWith(prefix));
+            const packagePaths = [];
+            // If the dependency is not already prefixed we attempt to require all possible combinations to find one that works
+            if (!isAlreadyPrefixed) {
+                packagePaths.push(...possiblePrefixes.map(prefix => prefix + dependencyPath));
+            }
+            // We always attempt to require the path verbatim (as a last resort)
+            packagePaths.push(dependencyPath);
+            const pluginModule = requirePackages(packagePaths);
+            if (pluginModule) {
+                return pluginModule;
+            }
+            const explanation = `
+The plugin '${parentName}' listed '${dependencyPath}' as dependency,
+which could not be found. Please install it:
+
+${packagePaths
+                .map(packagePath => `yarn add ${packagePath.split('/')[0]}`)
+                .join(`\n or:\n`)}
+
+Note: You don't need to require the plugin yourself,
+unless you want to modify it's default settings.
+
+If your bundler has issues with dynamic imports take a look at '.plugins.setDependencyResolution()'.
+      `;
+            console.warn(explanation);
+            throw new Error('Plugin dependency not found');
+        };
+        const existingPluginNames = new Set(this.names);
+        const recursivelyLoadMissingDependencies = ({ name: parentName, dependencies }) => {
+            if (!dependencies) {
+                return;
+            }
+            const processDependency = (dependencyPath, opts) => {
+                const pluginModule = requireDependencyOrDie(parentName, dependencyPath);
+                opts = opts || this._dependencyDefaults.get(dependencyPath) || {};
+                const plugin = pluginModule(opts);
+                if (existingPluginNames.has(plugin.name)) {
+                    debug$1(parentName, '=> dependency already exists:', plugin.name);
+                    return;
+                }
+                existingPluginNames.add(plugin.name);
+                debug$1(parentName, '=> adding new dependency:', plugin.name, opts);
+                this.add(plugin);
+                return recursivelyLoadMissingDependencies(plugin);
+            };
+            if (dependencies instanceof Set || Array.isArray(dependencies)) {
+                return [...dependencies].forEach(dependencyPath => processDependency(dependencyPath));
+            }
+            if (dependencies instanceof Map) {
+                // Note: `k,v => v,k` (Map + forEach will reverse the order)
+                return dependencies.forEach((v, k) => processDependency(k, v));
+            }
+        };
+        this.list.forEach(recursivelyLoadMissingDependencies);
+    }
+    /**
+     * Lightweight plugin dependency management to require plugins and code mods on demand.
+     * @private
+     */
+    resolveDependencies() {
+        debug$1('resolveDependencies');
+        this.resolvePluginsStanza();
+        this.resolveDependenciesStanza();
+    }
+}
+
+const debug$2 = debug$3('playwright-extra');
+/**
+ * Modular plugin framework to teach `playwright` new tricks.
+ */
+class PlaywrightExtraClass {
+    constructor(_launcher) {
+        this._launcher = _launcher;
+        this.plugins = new PluginList();
+    }
+    /**
+     * The **main interface** to register plugins.
+     *
+     * Can be called multiple times to enable multiple plugins.
+     *
+     * Plugins derived from `PuppeteerExtraPlugin` will be used with a compatiblity layer.
+     *
+     * @example
+     * chromium.use(plugin1).use(plugin2)
+     * firefox.use(plugin1).use(plugin2)
+     *
+     * @see [PuppeteerExtraPlugin]
+     *
+     * @return The same `PlaywrightExtra` instance (for optional chaining)
+     */
+    use(plugin) {
+        const isValid = plugin && 'name' in plugin;
+        if (!isValid) {
+            throw new Error('A plugin must be provided to .use()');
+        }
+        if (this.plugins.add(plugin)) {
+            debug$2('Plugin registered', plugin.name);
+        }
+        return this;
+    }
+    /**
+     * In order to support a default export which will require vanilla playwright automatically,
+     * as well as `addExtra` to patch a provided launcher, we need to so some gymnastics here.
+     *
+     * Otherwise this would throw immediately, even when only using the `addExtra` export with an arbitrary compatible launcher.
+     *
+     * The solution is to make the vanilla launcher optional and only throw once we try to effectively use and can't find it.
+     *
+     * @internal
+     */
+    get launcher() {
+        if (!this._launcher) {
+            throw playwrightLoader.requireError;
+        }
+        return this._launcher;
+    }
+    async launch(...args) {
+        if (!this.launcher.launch) {
+            throw new Error('Launcher does not support "launch"');
+        }
+        let [options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launch', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        debug$2('launch with options', options);
+        if ('userDataDir' in options) {
+            debug$2("A plugin defined userDataDir during .launch, which isn't supported by playwright - ignoring");
+            delete options.userDataDir;
+        }
+        const browser = await this.launcher['launch'](options);
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterLaunch', browser);
+        return browser;
+    }
+    async launchPersistentContext(...args) {
+        if (!this.launcher.launchPersistentContext) {
+            throw new Error('Launcher does not support "launchPersistentContext"');
+        }
+        let [userDataDir, options] = args;
+        options = Object.assign({ args: [] }, (options || {})); // Initialize args array
+        debug$2('launchPersistentContext', options);
+        this.plugins.prepare();
+        // Give plugins the chance to modify the options before continuing
+        options =
+            (await this.plugins.dispatchBlocking('beforeLaunch', options)) || options;
+        const context = await this.launcher['launchPersistentContext'](userDataDir, options);
+        await this.plugins.dispatchBlocking('afterLaunch', context);
+        this._bindBrowserContextEvents(context);
+        return context;
+    }
+    async connect(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connect) {
+            throw new Error('Launcher does not support "connect"');
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connect
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ wsEndpoint: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connect', options);
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const wsEndpoint = options.wsEndpoint;
+        if (wsEndpointAsString) {
+            delete options.wsEndpoint;
+            args.push(wsEndpoint, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connect'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async connectOverCDP(wsEndpointOrOptions, wsOptions = {}) {
+        if (!this.launcher.connectOverCDP) {
+            throw new Error(`Launcher does not implement 'connectOverCDP'`);
+        }
+        this.plugins.prepare();
+        // Playwright currently supports two function signatures for .connectOverCDP
+        let options = {};
+        let wsEndpointAsString = false;
+        if (typeof wsEndpointOrOptions === 'object') {
+            options = Object.assign(Object.assign({}, wsEndpointOrOptions), wsOptions);
+        }
+        else {
+            wsEndpointAsString = true;
+            options = Object.assign({ endpointURL: wsEndpointOrOptions }, wsOptions);
+        }
+        debug$2('connectOverCDP');
+        // Give plugins the chance to modify the options before launch/connect
+        options =
+            (await this.plugins.dispatchBlocking('beforeConnect', options)) || options;
+        // Follow call signature of end user
+        const args = [];
+        const endpointURL = options.endpointURL;
+        if (wsEndpointAsString) {
+            delete options.endpointURL;
+            args.push(endpointURL, options);
+        }
+        else {
+            args.push(options);
+        }
+        const browser = (await this.launcher['connectOverCDP'](...args));
+        await this.plugins.dispatchBlocking('onBrowser', browser);
+        await this._bindBrowserEvents(browser);
+        await this.plugins.dispatchBlocking('afterConnect', browser);
+        return browser;
+    }
+    async _bindBrowserContextEvents(context, contextOptions) {
+        debug$2('_bindBrowserContextEvents');
+        this.plugins.dispatch('onContextCreated', context, contextOptions);
+        // Make sure things like `addInitScript` show an effect on the very first page as well
+        context.newPage = ((originalMethod, ctx) => {
+            return async () => {
+                const page = await originalMethod.call(ctx);
+                await page.goto('about:blank');
+                return page;
+            };
+        })(context.newPage, context);
+        context.on('close', () => {
+            // When using `launchPersistentContext` context closing is the same as browser closing
+            if (!context.browser()) {
+                this.plugins.dispatch('onDisconnected');
+            }
+        });
+        context.on('page', page => {
+            this.plugins.dispatch('onPageCreated', page);
+            page.on('close', () => {
+                this.plugins.dispatch('onPageClose', page);
+            });
+        });
+    }
+    async _bindBrowserEvents(browser) {
+        debug$2('_bindPlaywrightBrowserEvents');
+        browser.on('disconnected', () => {
+            this.plugins.dispatch('onDisconnected', browser);
+        });
+        // Note: `browser.newPage` will implicitly call `browser.newContext` as well
+        browser.newContext = ((originalMethod, ctx) => {
+            return async (options = {}) => {
+                const contextOptions = (await this.plugins.dispatchBlocking('beforeContext', options, browser)) || options;
+                const context = await originalMethod.call(ctx, contextOptions);
+                this._bindBrowserContextEvents(context, contextOptions);
+                return context;
+            };
+        })(browser.newContext, browser);
+    }
+}
+/**
+ * PlaywrightExtra class with additional launcher methods.
+ *
+ * Augments the class with an instance proxy to pass on methods that are not augmented to the original target.
+ *
+ */
+const PlaywrightExtra = new Proxy(PlaywrightExtraClass, {
+    construct(classTarget, args) {
+        debug$2(`create instance of ${classTarget.name}`);
+        const result = Reflect.construct(classTarget, args);
+        return new Proxy(result, {
+            get(target, prop) {
+                if (prop in target) {
+                    return Reflect.get(target, prop);
+                }
+                debug$2('proxying property to original launcher: ', prop);
+                return Reflect.get(target.launcher, prop);
+            }
+        });
+    }
+});
+
+/**
+ * Augment the provided Playwright browser launcher with plugin functionality.
+ *
+ * Using `addExtra` will always create a fresh PlaywrightExtra instance.
+ *
+ * @example
+ * import playwright from 'playwright'
+ * import { addExtra } from 'playwright-extra'
+ *
+ * const chromium = addExtra(playwright.chromium)
+ * chromium.use(plugin)
+ *
+ * @param launcher - Playwright (or compatible) browser launcher
+ */
+const addExtra = (launcher) => new PlaywrightExtra(launcher);
+/**
+ * This object can be used to launch or connect to Chromium with plugin functionality.
+ *
+ * This default export will behave exactly the same as the regular playwright
+ * (just with extra plugin functionality) and can be used as a drop-in replacement.
+ *
+ * Behind the scenes it will try to require either the `playwright-core`
+ * or `playwright` module from the installed dependencies.
+ *
+ * @note
+ * Due to Node.js import caching this will result in a single
+ * PlaywrightExtra instance, even when used in different files. If you need multiple
+ * instances with different plugins please use `addExtra`.
+ *
+ * @example
+ * // javascript import
+ * const { chromium } = require('playwright-extra')
+ *
+ * // typescript/es6 module import
+ * import { chromium } from 'playwright-extra'
+ *
+ * // Add plugins
+ * chromium.use(...)
+ */
+const chromium = addExtra((playwrightLoader.loadModule() || {}).chromium);
+/**
+ * This object can be used to launch or connect to Firefox with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+addExtra((playwrightLoader.loadModule() || {}).firefox);
+/**
+ * This object can be used to launch or connect to Webkit with plugin functionality
+ * @note This export will always return the same instance, if you wish to use multiple instances with different plugins use `addExtra`
+ */
+addExtra((playwrightLoader.loadModule() || {}).webkit);
+// Other playwright module exports we simply re-export with lazy loading
+playwrightLoader.lazyloadExportOrDie('_android');
+playwrightLoader.lazyloadExportOrDie('_electron');
+playwrightLoader.lazyloadExportOrDie('request');
+playwrightLoader.lazyloadExportOrDie('selectors');
+playwrightLoader.lazyloadExportOrDie('devices');
+playwrightLoader.lazyloadExportOrDie('errors');
+
+/*!
+ * puppeteer-extra-plugin v3.2.2 by berstend
+ * https://github.com/berstend/puppeteer-extra/tree/master/packages/puppeteer-extra-plugin
+ * @license MIT
+ */
+
+/** @private */
+const merge$1 = require('merge-deep');
+/**
+ * Base class for `puppeteer-extra` plugins.
+ *
+ * Provides convenience methods to avoid boilerplate.
+ *
+ * All common `puppeteer` browser events will be bound to
+ * the plugin instance, if a respectively named class member is found.
+ *
+ * Please refer to the [puppeteer API documentation](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md) as well.
+ *
+ * @example
+ * // hello-world-plugin.js
+ * const { PuppeteerExtraPlugin } = require('puppeteer-extra-plugin')
+ *
+ * class Plugin extends PuppeteerExtraPlugin {
+ *   constructor (opts = { }) { super(opts) }
+ *
+ *   get name () { return 'hello-world' }
+ *
+ *   async onPageCreated (page) {
+ *     this.debug('page created', page.url())
+ *     const ua = await page.browser().userAgent()
+ *     this.debug('user agent', ua)
+ *   }
+ * }
+ *
+ * module.exports = function (pluginConfig) { return new Plugin(pluginConfig) }
+ *
+ *
+ * // foo.js
+ * const puppeteer = require('puppeteer-extra')
+ * puppeteer.use(require('./hello-world-plugin')())
+ *
+ * ;(async () => {
+ *   const browser = await puppeteer.launch({headless: false})
+ *   const page = await browser.newPage()
+ *   await page.goto('http://example.com', {waitUntil: 'domcontentloaded'})
+ *   await browser.close()
+ * })()
+ *
+ */
+class PuppeteerExtraPlugin$1 {
+    constructor(opts) {
+        this._debugBase = debug$3(`puppeteer-extra-plugin:base:${this.name}`);
+        this._childClassMembers = [];
+        this._opts = merge$1(this.defaults, opts || {});
+        this._debugBase('Initialized.');
+    }
+    /**
+     * Plugin name (required).
+     *
+     * Convention:
+     * - Package: `puppeteer-extra-plugin-anonymize-ua`
+     * - Name: `anonymize-ua`
+     *
+     * @example
+     * get name () { return 'anonymize-ua' }
+     */
+    get name() {
+        throw new Error('Plugin must override "name"');
+    }
+    /**
+     * Plugin defaults (optional).
+     *
+     * If defined will be ([deep-](https://github.com/jonschlinkert/merge-deep))merged with the (optional) user supplied options (supplied during plugin instantiation).
+     *
+     * The result of merging defaults with user supplied options can be accessed through `this.opts`.
+     *
+     * @see [[opts]]
+     *
+     * @example
+     * get defaults () {
+     *   return {
+     *     stripHeadless: true,
+     *     makeWindows: true,
+     *     customFn: null
+     *   }
+     * }
+     *
+     * // Users can overwrite plugin defaults during instantiation:
+     * puppeteer.use(require('puppeteer-extra-plugin-foobar')({ makeWindows: false }))
+     */
+    get defaults() {
+        return {};
+    }
+    /**
+     * Plugin requirements (optional).
+     *
+     * Signal certain plugin requirements to the base class and the user.
+     *
+     * Currently supported:
+     * - `launch`
+     *   - If the plugin only supports locally created browser instances (no `puppeteer.connect()`),
+     *     will output a warning to the user.
+     * - `headful`
+     *   - If the plugin doesn't work in `headless: true` mode,
+     *     will output a warning to the user.
+     * - `dataFromPlugins`
+     *   - In case the plugin requires data from other plugins.
+     *     will enable usage of `this.getDataFromPlugins()`.
+     * - `runLast`
+     *   - In case the plugin prefers to run after the others.
+     *     Useful when the plugin needs data from others.
+     *
+     * @example
+     * get requirements () {
+     *   return new Set(['runLast', 'dataFromPlugins'])
+     * }
+     */
+    get requirements() {
+        return new Set([]);
+    }
+    /**
+     * Plugin dependencies (optional).
+     *
+     * Missing plugins will be required() by puppeteer-extra.
+     *
+     * @example
+     * get dependencies () {
+     *   return new Set(['user-preferences'])
+     * }
+     * // Will ensure the 'puppeteer-extra-plugin-user-preferences' plugin is loaded.
+     */
+    get dependencies() {
+        return new Set([]);
+    }
+    /**
+     * Plugin data (optional).
+     *
+     * Plugins can expose data (an array of objects), which in turn can be consumed by other plugins,
+     * that list the `dataFromPlugins` requirement (by using `this.getDataFromPlugins()`).
+     *
+     * Convention: `[ {name: 'Any name', value: 'Any value'} ]`
+     *
+     * @see [[getDataFromPlugins]]
+     *
+     * @example
+     * // plugin1.js
+     * get data () {
+     *   return [
+     *     {
+     *       name: 'userPreferences',
+     *       value: { foo: 'bar' }
+     *     },
+     *     {
+     *       name: 'userPreferences',
+     *       value: { hello: 'world' }
+     *     }
+     *   ]
+     *
+     * // plugin2.js
+     * get requirements () { return new Set(['dataFromPlugins']) }
+     *
+     * async beforeLaunch () {
+     *   const prefs = this.getDataFromPlugins('userPreferences').map(d => d.value)
+     *   this.debug(prefs) // => [ { foo: 'bar' }, { hello: 'world' } ]
+     * }
+     */
+    get data() {
+        return [];
+    }
+    /**
+     * Access the plugin options (usually the `defaults` merged with user defined options)
+     *
+     * To skip the auto-merging of defaults with user supplied opts don't define a `defaults`
+     * property and set the `this._opts` Object in your plugin constructor directly.
+     *
+     * @see [[defaults]]
+     *
+     * @example
+     * get defaults () { return { foo: "bar" } }
+     *
+     * async onPageCreated (page) {
+     *   this.debug(this.opts.foo) // => bar
+     * }
+     */
+    get opts() {
+        return this._opts;
+    }
+    /**
+     *  Convenience debug logger based on the [debug] module.
+     *  Will automatically namespace the logging output to the plugin package name.
+     *  [debug]: https://www.npmjs.com/package/debug
+     *
+     *  ```bash
+     *  # toggle output using environment variables
+     *  DEBUG=puppeteer-extra-plugin:<plugin_name> node foo.js
+     *  # to debug all the things:
+     *  DEBUG=puppeteer-extra,puppeteer-extra-plugin:* node foo.js
+     *  ```
+     *
+     * @example
+     * this.debug('hello world')
+     * // will output e.g. 'puppeteer-extra-plugin:anonymize-ua hello world'
+     */
+    get debug() {
+        return debug$3(`puppeteer-extra-plugin:${this.name}`);
+    }
+    /**
+     * Before a new browser instance is created/launched.
+     *
+     * Can be used to modify the puppeteer launch options by modifying or returning them.
+     *
+     * Plugins using this method will be called in sequence to each
+     * be able to update the launch options.
+     *
+     * @example
+     * async beforeLaunch (options) {
+     *   if (this.opts.flashPluginPath) {
+     *     options.args.push(`--ppapi-flash-path=${this.opts.flashPluginPath}`)
+     *   }
+     * }
+     *
+     * @param options - Puppeteer launch options
+     */
+    async beforeLaunch(options) {
+        // noop
+    }
+    /**
+     * After the browser has launched.
+     *
+     * Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+     * It's possible that `pupeeteer.launch` will be  called multiple times and more than one browser created.
+     * In order to make the plugins as stateless as possible don't store a reference to the browser instance
+     * in the plugin but rather consider alternatives.
+     *
+     * E.g. when using `onPageCreated` you can get a browser reference by using `page.browser()`.
+     *
+     * Alternatively you could expose a class method that takes a browser instance as a parameter to work with:
+     *
+     * ```es6
+     * const fancyPlugin = require('puppeteer-extra-plugin-fancy')()
+     * puppeteer.use(fancyPlugin)
+     * const browser = await puppeteer.launch()
+     * await fancyPlugin.killBrowser(browser)
+     * ```
+     *
+     * @param  browser - The `puppeteer` browser instance.
+     * @param  opts.options - Puppeteer launch options used.
+     *
+     * @example
+     * async afterLaunch (browser, opts) {
+     *   this.debug('browser has been launched', opts.options)
+     * }
+     */
+    async afterLaunch(browser, opts = { options: {} }) {
+        // noop
+    }
+    /**
+     * Before connecting to an existing browser instance.
+     *
+     * Can be used to modify the puppeteer connect options by modifying or returning them.
+     *
+     * Plugins using this method will be called in sequence to each
+     * be able to update the launch options.
+     *
+     * @param  {Object} options - Puppeteer connect options
+     * @return {Object=}
+     */
+    async beforeConnect(options) {
+        // noop
+    }
+    /**
+     * After connecting to an existing browser instance.
+     *
+     * > Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+     *
+     * @param browser - The `puppeteer` browser instance.
+     * @param  {Object} opts
+     * @param  {Object} opts.options - Puppeteer connect options used.
+     *
+     */
+    async afterConnect(browser, opts = {}) {
+        // noop
+    }
+    /**
+     * Called when a browser instance is available.
+     *
+     * This applies to both `puppeteer.launch()` and `puppeteer.connect()`.
+     *
+     * Convenience method created for plugins that need access to a browser instance
+     * and don't mind if it has been created through `launch` or `connect`.
+     *
+     * > Note: Don't assume that there will only be a single browser instance during the lifecycle of a plugin.
+     *
+     * @param browser - The `puppeteer` browser instance.
+     */
+    async onBrowser(browser, opts) {
+        // noop
+    }
+    /**
+     * Called when a target is created, for example when a new page is opened by window.open or browser.newPage.
+     *
+     * > Note: This includes target creations in incognito browser contexts.
+     *
+     * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+     *
+     * @param  {Puppeteer.Target} target
+     */
+    async onTargetCreated(target) {
+        // noop
+    }
+    /**
+     * Same as `onTargetCreated` but prefiltered to only contain Pages, for convenience.
+     *
+     * > Note: This includes page creations in incognito browser contexts.
+     *
+     * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+     *
+     * @param  {Puppeteer.Target} target
+     *
+     * @example
+     * async onPageCreated (page) {
+     *   let ua = await page.browser().userAgent()
+     *   if (this.opts.stripHeadless) {
+     *     ua = ua.replace('HeadlessChrome/', 'Chrome/')
+     *   }
+     *   this.debug('new ua', ua)
+     *   await page.setUserAgent(ua)
+     * }
+     */
+    async onPageCreated(page) {
+        // noop
+    }
+    /**
+     * Called when the url of a target changes.
+     *
+     * > Note: This includes target changes in incognito browser contexts.
+     *
+     * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+     *
+     * @param  {Puppeteer.Target} target
+     */
+    async onTargetChanged(target) {
+        // noop
+    }
+    /**
+     * Called when a target is destroyed, for example when a page is closed.
+     *
+     * > Note: This includes target destructions in incognito browser contexts.
+     *
+     * > Note: This includes browser instances created through `.launch()` as well as `.connect()`.
+     *
+     * @param  {Puppeteer.Target} target
+     */
+    async onTargetDestroyed(target) {
+        // noop
+    }
+    /**
+     * Called when Puppeteer gets disconnected from the Chromium instance.
+     *
+     * This might happen because of one of the following:
+     * - Chromium is closed or crashed
+     * - The `browser.disconnect` method was called
+     */
+    async onDisconnected() {
+        // noop
+    }
+    /**
+     * **Deprecated:** Since puppeteer v1.6.0 `onDisconnected` has been improved
+     * and should be used instead of `onClose`.
+     *
+     * In puppeteer < v1.6.0 `onDisconnected` was not catching all exit scenarios.
+     * In order for plugins to clean up properly (e.g. deleting temporary files)
+     * the `onClose` method had been introduced.
+     *
+     * > Note: Might be called multiple times on exit.
+     *
+     * > Note: This only includes browser instances created through `.launch()`.
+     */
+    async onClose() {
+        // noop
+    }
+    /**
+     * After the plugin has been registered in `puppeteer-extra`.
+     *
+     * Normally right after `puppeteer.use(plugin)` is called
+     */
+    async onPluginRegistered() {
+        // noop
+    }
+    /**
+     * Helper method to retrieve `data` objects from other plugins.
+     *
+     * A plugin needs to state the `dataFromPlugins` requirement
+     * in order to use this method. Will be mapped to `puppeteer.getPluginData`.
+     *
+     * @param name - Filter data by `name` property
+     *
+     * @see [data]
+     * @see [requirements]
+     */
+    getDataFromPlugins(name) {
+        return [];
+    }
+    /**
+     * Will match plugin dependencies against all currently registered plugins.
+     * Is being called by `puppeteer-extra` and used to require missing dependencies.
+     *
+     * @param  {Array<Object>} plugins
+     * @return {Set} - list of missing plugin names
+     *
+     * @private
+     */
+    _getMissingDependencies(plugins) {
+        const pluginNames = new Set(plugins.map((p) => p.name));
+        const missing = new Set(Array.from(this.dependencies.values()).filter(x => !pluginNames.has(x)));
+        return missing;
+    }
+    /**
+     * Conditionally bind browser/process events to class members.
+     * The idea is to reduce event binding boilerplate in plugins.
+     *
+     * For efficiency we make sure the plugin is using the respective event
+     * by checking the child class members before registering the listener.
+     *
+     * @param  {<Puppeteer.Browser>} browser
+     * @param  {Object} opts - Options
+     * @param  {string} opts.context - Puppeteer context (launch/connect)
+     * @param  {Object} [opts.options] - Puppeteer launch or connect options
+     * @param  {Array<string>} [opts.defaultArgs] - The default flags that Chromium will be launched with
+     *
+     * @private
+     */
+    async _bindBrowserEvents(browser, opts = {}) {
+        if (this._hasChildClassMember('onTargetCreated') ||
+            this._hasChildClassMember('onPageCreated')) {
+            browser.on('targetcreated', this._onTargetCreated.bind(this));
+        }
+        if (this._hasChildClassMember('onTargetChanged') && this.onTargetChanged) {
+            browser.on('targetchanged', this.onTargetChanged.bind(this));
+        }
+        if (this._hasChildClassMember('onTargetDestroyed') &&
+            this.onTargetDestroyed) {
+            browser.on('targetdestroyed', this.onTargetDestroyed.bind(this));
+        }
+        if (this._hasChildClassMember('onDisconnected') && this.onDisconnected) {
+            browser.on('disconnected', this.onDisconnected.bind(this));
+        }
+        if (opts.context === 'launch' && this._hasChildClassMember('onClose')) {
+            // The disconnect event has been improved since puppeteer v1.6.0
+            // onClose is being kept mostly for legacy reasons
+            if (this.onClose) {
+                process.on('exit', this.onClose.bind(this));
+                browser.on('disconnected', this.onClose.bind(this));
+                if (opts.options.handleSIGINT !== false) {
+                    process.on('SIGINT', this.onClose.bind(this));
+                }
+                if (opts.options.handleSIGTERM !== false) {
+                    process.on('SIGTERM', this.onClose.bind(this));
+                }
+                if (opts.options.handleSIGHUP !== false) {
+                    process.on('SIGHUP', this.onClose.bind(this));
+                }
+            }
+        }
+        if (opts.context === 'launch' && this.afterLaunch) {
+            await this.afterLaunch(browser, opts);
+        }
+        if (opts.context === 'connect' && this.afterConnect) {
+            await this.afterConnect(browser, opts);
+        }
+        if (this.onBrowser)
+            await this.onBrowser(browser, opts);
+    }
+    /**
+     * @private
+     */
+    async _onTargetCreated(target) {
+        if (this.onTargetCreated)
+            await this.onTargetCreated(target);
+        // Pre filter pages for plugin developers convenience
+        if (target.type() === 'page') {
+            try {
+                const page = await target.page();
+                if (!page) {
+                    return;
+                }
+                const validPage = 'isClosed' in page && !page.isClosed();
+                if (this.onPageCreated && validPage) {
+                    await this.onPageCreated(page);
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+    /**
+     * @private
+     */
+    _register(prototype) {
+        this._registerChildClassMembers(prototype);
+        if (this.onPluginRegistered)
+            this.onPluginRegistered();
+    }
+    /**
+     * @private
+     */
+    _registerChildClassMembers(prototype) {
+        this._childClassMembers = Object.getOwnPropertyNames(prototype);
+    }
+    /**
+     * @private
+     */
+    _hasChildClassMember(name) {
+        return !!this._childClassMembers.includes(name);
+    }
+    /**
+     * @private
+     */
+    get _isPuppeteerExtraPlugin() {
+        return true;
+    }
+}
+
+var index_esm = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    PuppeteerExtraPlugin: PuppeteerExtraPlugin$1
+});
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(index_esm);
+
+const { PuppeteerExtraPlugin } = require$$0;
+
+/**
+ * Stealth mode: Applies various techniques to make detection of headless puppeteer harder. 💯
+ *
+ * ### Purpose
+ * There are a couple of ways the use of puppeteer can easily be detected by a target website.
+ * The addition of `HeadlessChrome` to the user-agent being only the most obvious one.
+ *
+ * The goal of this plugin is to be the definite companion to puppeteer to avoid
+ * detection, applying new techniques as they surface.
+ *
+ * As this cat & mouse game is in it's infancy and fast-paced the plugin
+ * is kept as flexibile as possible, to support quick testing and iterations.
+ *
+ * ### Modularity
+ * This plugin uses `puppeteer-extra`'s dependency system to only require
+ * code mods for evasions that have been enabled, to keep things modular and efficient.
+ *
+ * The `stealth` plugin is a convenience wrapper that requires multiple [evasion techniques](./evasions/)
+ * automatically and comes with defaults. You could also bypass the main module and require
+ * specific evasion plugins yourself, if you whish to do so (as they're standalone `puppeteer-extra` plugins):
+ *
+ * ```es6
+ * // bypass main module and require a specific stealth plugin directly:
+ * puppeteer.use(require('puppeteer-extra-plugin-stealth/evasions/console.debug')())
+ * ```
+ *
+ * ### Contributing
+ * PRs are welcome, if you want to add a new evasion technique I suggest you
+ * look at the [template](./evasions/_template) to kickstart things.
+ *
+ * ### Kudos
+ * Thanks to [Evan Sangaline](https://intoli.com/blog/not-possible-to-block-chrome-headless/) and [Paul Irish](https://github.com/paulirish/headless-cat-n-mouse) for kickstarting the discussion!
+ *
+ * ---
+ *
+ * @todo
+ * - white-/blacklist with url globs (make this a generic plugin method?)
+ * - dynamic whitelist based on function evaluation
+ *
+ * @example
+ * const puppeteer = require('puppeteer-extra')
+ * // Enable stealth plugin with all evasions
+ * puppeteer.use(require('puppeteer-extra-plugin-stealth')())
+ *
+ *
+ * ;(async () => {
+ *   // Launch the browser in headless mode and set up a page.
+ *   const browser = await puppeteer.launch({ args: ['--no-sandbox'], headless: true })
+ *   const page = await browser.newPage()
+ *
+ *   // Navigate to the page that will perform the tests.
+ *   const testUrl = 'https://intoli.com/blog/' +
+ *     'not-possible-to-block-chrome-headless/chrome-headless-test.html'
+ *   await page.goto(testUrl)
+ *
+ *   // Save a screenshot of the results.
+ *   const screenshotPath = '/tmp/headless-test-result.png'
+ *   await page.screenshot({path: screenshotPath})
+ *   console.log('have a look at the screenshot:', screenshotPath)
+ *
+ *   await browser.close()
+ * })()
+ *
+ * @param {Object} [opts] - Options
+ * @param {Set<string>} [opts.enabledEvasions] - Specify which evasions to use (by default all)
+ *
+ */
+class StealthPlugin extends PuppeteerExtraPlugin {
+  constructor(opts = {}) {
+    super(opts);
+  }
+
+  get name() {
+    return 'stealth'
+  }
+
+  get defaults() {
+    const availableEvasions = new Set([
+      'chrome.app',
+      'chrome.csi',
+      'chrome.loadTimes',
+      'chrome.runtime',
+      'defaultArgs',
+      'iframe.contentWindow',
+      'media.codecs',
+      'navigator.hardwareConcurrency',
+      'navigator.languages',
+      'navigator.permissions',
+      'navigator.plugins',
+      'navigator.webdriver',
+      'sourceurl',
+      'user-agent-override',
+      'webgl.vendor',
+      'window.outerdimensions'
+    ]);
+    return {
+      availableEvasions,
+      // Enable all available evasions by default
+      enabledEvasions: new Set([...availableEvasions])
+    }
+  }
+
+  /**
+   * Requires evasion techniques dynamically based on configuration.
+   *
+   * @private
+   */
+  get dependencies() {
+    return new Set(
+      [...this.opts.enabledEvasions].map(e => `${this.name}/evasions/${e}`)
+    )
+  }
+
+  /**
+   * Get all available evasions.
+   *
+   * Please look into the [evasions directory](./evasions/) for an up to date list.
+   *
+   * @type {Set<string>} - A Set of all available evasions.
+   *
+   * @example
+   * const pluginStealth = require('puppeteer-extra-plugin-stealth')()
+   * console.log(pluginStealth.availableEvasions) // => Set { 'user-agent', 'console.debug' }
+   * puppeteer.use(pluginStealth)
+   */
+  get availableEvasions() {
+    return this.defaults.availableEvasions
+  }
+
+  /**
+   * Get all enabled evasions.
+   *
+   * Enabled evasions can be configured either through `opts` or by modifying this property.
+   *
+   * @type {Set<string>} - A Set of all enabled evasions.
+   *
+   * @example
+   * // Remove specific evasion from enabled ones dynamically
+   * const pluginStealth = require('puppeteer-extra-plugin-stealth')()
+   * pluginStealth.enabledEvasions.delete('console.debug')
+   * puppeteer.use(pluginStealth)
+   */
+  get enabledEvasions() {
+    return this.opts.enabledEvasions
+  }
+
+  /**
+   * @private
+   */
+  set enabledEvasions(evasions) {
+    this.opts.enabledEvasions = evasions;
+  }
+
+  async onBrowser(browser) {
+    if (browser && browser.setMaxListeners) {
+      // Increase event emitter listeners to prevent MaxListenersExceededWarning
+      browser.setMaxListeners(30);
+    }
+  }
+}
+
+/**
+ * Default export, PuppeteerExtraStealthPlugin
+ *
+ * @param {Object} [opts] - Options
+ * @param {Set<string>} [opts.enabledEvasions] - Specify which evasions to use (by default all)
+ */
+const defaultExport = opts => new StealthPlugin(opts);
+var puppeteerExtraPluginStealth = defaultExport;
+
+var stealth = test.test.extend({
+    browser: async ({ browser }, use) => {
+        await browser.close();
+        chromium.use(puppeteerExtraPluginStealth());
+        const stealthBrowser = await chromium.launch();
+        await use(stealthBrowser);
+        await stealthBrowser.close();
+    },
+});
+
 const LOWERCASED = "__LOWERCASED__";
 const FORMATS = {
     boldList: "boldList",
@@ -406,8 +3223,6 @@ const removeTagsProcessor = {
     },
 };
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 var tasks = {};
 
 var utils$k = {};
@@ -470,8 +3285,8 @@ var path$a = {};
 
 Object.defineProperty(path$a, "__esModule", { value: true });
 path$a.convertPosixPathToPattern = path$a.convertWindowsPathToPattern = path$a.convertPathToPattern = path$a.escapePosixPath = path$a.escapeWindowsPath = path$a.escape = path$a.removeLeadingDotSegment = path$a.makeAbsolute = path$a.unixify = void 0;
-const os$1 = require$$2__default["default"];
-const path$9 = require$$0__default["default"];
+const os$1 = require$$0__default["default"];
+const path$9 = require$$0__default$2["default"];
 const IS_WINDOWS_PLATFORM = os$1.platform() === 'win32';
 const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 /**
@@ -711,8 +3526,8 @@ var isGlob$1 = function isGlob(str, options) {
 };
 
 var isGlob = isGlob$1;
-var pathPosixDirname = require$$0__default["default"].posix.dirname;
-var isWin32 = require$$2__default["default"].platform() === 'win32';
+var pathPosixDirname = require$$0__default$2["default"].posix.dirname;
+var isWin32 = require$$0__default["default"].platform() === 'win32';
 
 var slash = '/';
 var backslash = /\\/g;
@@ -2175,7 +4990,7 @@ var picomatch$2 = {exports: {}};
 
 var utils$f = {};
 
-const path$8 = require$$0__default["default"];
+const path$8 = require$$0__default$2["default"];
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -2355,7 +5170,7 @@ var constants$3 = {
 
 (function (exports) {
 
-	const path = require$$0__default["default"];
+	const path = require$$0__default$2["default"];
 	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
@@ -3899,7 +6714,7 @@ parse$2.fastpaths = (input, options) => {
 
 var parse_1 = parse$2;
 
-const path$7 = require$$0__default["default"];
+const path$7 = require$$0__default$2["default"];
 const scan = scan_1;
 const parse$1 = parse_1;
 const utils$c = utils$f;
@@ -4713,7 +7528,7 @@ var micromatch_1 = micromatch$1;
 
 Object.defineProperty(pattern$1, "__esModule", { value: true });
 pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
-const path$6 = require$$0__default["default"];
+const path$6 = require$$0__default$2["default"];
 const globParent = globParent$1;
 const micromatch = micromatch_1;
 const GLOBSTAR = '**';
@@ -4908,7 +7723,7 @@ var stream$4 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0__default$2["default"];
+const Stream = require$$0__default$3["default"];
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -5288,7 +8103,7 @@ var fs$6 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0__default$3["default"];
+	const fs = require$$0__default$4["default"];
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5639,7 +8454,7 @@ var fs$2 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0__default$3["default"];
+	const fs = require$$0__default$4["default"];
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5658,7 +8473,7 @@ var fs$2 = {};
 } (fs$2));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$4 = require$$0__default["default"];
+const path$4 = require$$0__default$2["default"];
 const fsStat$3 = out$1;
 const fs$1 = fs$2;
 class Settings$1 {
@@ -6077,7 +8892,7 @@ class Reader$1 {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$4, "__esModule", { value: true });
-const events_1 = require$$0__default$4["default"];
+const events_1 = require$$0__default$5["default"];
 const fsScandir$2 = out$2;
 const fastq = queue.exports;
 const common$1 = common$3;
@@ -6206,7 +9021,7 @@ function callSuccessCallback(callback, entries) {
 var stream$2 = {};
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$5 = require$$0__default$2["default"];
+const stream_1$5 = require$$0__default$3["default"];
 const async_1$3 = async$4;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -6319,7 +9134,7 @@ sync$3.default = SyncProvider;
 var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$3 = require$$0__default["default"];
+const path$3 = require$$0__default$2["default"];
 const fsScandir = out$2;
 class Settings {
     constructor(_options = {}) {
@@ -6381,7 +9196,7 @@ function getSettings(settingsOrOptions = {}) {
 var reader = {};
 
 Object.defineProperty(reader, "__esModule", { value: true });
-const path$2 = require$$0__default["default"];
+const path$2 = require$$0__default$2["default"];
 const fsStat$2 = out$1;
 const utils$6 = utils$k;
 class Reader {
@@ -6416,7 +9231,7 @@ reader.default = Reader;
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$3 = require$$0__default$2["default"];
+const stream_1$3 = require$$0__default$3["default"];
 const fsStat$1 = out$1;
 const fsWalk$2 = out$3;
 const reader_1$2 = reader;
@@ -6769,7 +9584,7 @@ class EntryTransformer {
 entry.default = EntryTransformer;
 
 Object.defineProperty(provider, "__esModule", { value: true });
-const path$1 = require$$0__default["default"];
+const path$1 = require$$0__default$2["default"];
 const deep_1 = deep;
 const entry_1 = entry$1;
 const error_1 = error;
@@ -6842,7 +9657,7 @@ async$7.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0__default$2["default"];
+const stream_1$1 = require$$0__default$3["default"];
 const stream_2 = stream$1;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -6947,8 +9762,8 @@ var settings = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0__default$3["default"];
-	const os = require$$2__default["default"];
+	const fs = require$$0__default$4["default"];
+	const os = require$$0__default["default"];
 	/**
 	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
 	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
@@ -8255,9 +11070,9 @@ var require$$4 = {
 	browser: browser
 };
 
-const fs = require$$0__default$3["default"];
-const path = require$$0__default["default"];
-const os = require$$2__default["default"];
+const fs = require$$0__default$4["default"];
+const path = require$$0__default$2["default"];
+const os = require$$0__default["default"];
 const crypto = require$$3__default["default"];
 const packageJson = require$$4;
 
@@ -8769,6 +11584,7 @@ exports.readFileSyncIfExists = readFileSyncIfExists;
 exports.removeCredentialFile = removeCredentialFile;
 exports.shouldSkipSetupAndTeardown = shouldSkipSetupAndTeardown;
 exports.skipTest = skipTest;
+exports.stealthTest = stealth;
 exports.tableUtils = tableUtils;
 exports.updateCredentials = updateCredentials;
 exports.writeDataToFile = writeDataToFile;