@builderbot/bot 1.3.15-alpha.149 → 1.3.15-alpha.151

package/dist/index.cjs

@@ -655,11 +655,15 @@ function getDefaultExportFromCjs (x) {
 }
 
 function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
   var f = n.default;
 	if (typeof f == "function") {
 		var a = function a () {
-			if (this instanceof a) {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch {}
+			if (isInstance) {
         return Reflect.construct(f, arguments, this.constructor);
 			}
 			return f.apply(this, arguments);
@@ -681,83 +685,90 @@ function getAugmentedNamespace(n) {
 
 var picocolors = {exports: {}};
 
-let p = process || {}, argv = p.argv || [], env = p.env || {};
-let isColorSupported =
-	!(!!env.NO_COLOR || argv.includes("--no-color")) &&
-	(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
+var hasRequiredPicocolors;
 
-let formatter = (open, close, replace = open) =>
-	input => {
-		let string = "" + input, index = string.indexOf(close, open.length);
-		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
-	};
+function requirePicocolors () {
+	if (hasRequiredPicocolors) return picocolors.exports;
+	hasRequiredPicocolors = 1;
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported =
+		!(!!env.NO_COLOR || argv.includes("--no-color")) &&
+		(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
 
-let replaceClose = (string, close, replace, index) => {
-	let result = "", cursor = 0;
-	do {
-		result += string.substring(cursor, index) + replace;
-		cursor = index + close.length;
-		index = string.indexOf(close, cursor);
-	} while (~index)
-	return result + string.substring(cursor)
-};
+	let formatter = (open, close, replace = open) =>
+		input => {
+			let string = "" + input, index = string.indexOf(close, open.length);
+			return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
+		};
 
-let createColors = (enabled = isColorSupported) => {
-	let f = enabled ? formatter : () => String;
-	return {
-		isColorSupported: enabled,
-		reset: f("\x1b[0m", "\x1b[0m"),
-		bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-		dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-		italic: f("\x1b[3m", "\x1b[23m"),
-		underline: f("\x1b[4m", "\x1b[24m"),
-		inverse: f("\x1b[7m", "\x1b[27m"),
-		hidden: f("\x1b[8m", "\x1b[28m"),
-		strikethrough: f("\x1b[9m", "\x1b[29m"),
-
-		black: f("\x1b[30m", "\x1b[39m"),
-		red: f("\x1b[31m", "\x1b[39m"),
-		green: f("\x1b[32m", "\x1b[39m"),
-		yellow: f("\x1b[33m", "\x1b[39m"),
-		blue: f("\x1b[34m", "\x1b[39m"),
-		magenta: f("\x1b[35m", "\x1b[39m"),
-		cyan: f("\x1b[36m", "\x1b[39m"),
-		white: f("\x1b[37m", "\x1b[39m"),
-		gray: f("\x1b[90m", "\x1b[39m"),
-
-		bgBlack: f("\x1b[40m", "\x1b[49m"),
-		bgRed: f("\x1b[41m", "\x1b[49m"),
-		bgGreen: f("\x1b[42m", "\x1b[49m"),
-		bgYellow: f("\x1b[43m", "\x1b[49m"),
-		bgBlue: f("\x1b[44m", "\x1b[49m"),
-		bgMagenta: f("\x1b[45m", "\x1b[49m"),
-		bgCyan: f("\x1b[46m", "\x1b[49m"),
-		bgWhite: f("\x1b[47m", "\x1b[49m"),
-
-		blackBright: f("\x1b[90m", "\x1b[39m"),
-		redBright: f("\x1b[91m", "\x1b[39m"),
-		greenBright: f("\x1b[92m", "\x1b[39m"),
-		yellowBright: f("\x1b[93m", "\x1b[39m"),
-		blueBright: f("\x1b[94m", "\x1b[39m"),
-		magentaBright: f("\x1b[95m", "\x1b[39m"),
-		cyanBright: f("\x1b[96m", "\x1b[39m"),
-		whiteBright: f("\x1b[97m", "\x1b[39m"),
-
-		bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-		bgRedBright: f("\x1b[101m", "\x1b[49m"),
-		bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-		bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-		bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-		bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-		bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-		bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
-	}
-};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index)
+		return result + string.substring(cursor)
+	};
 
-picocolors.exports = createColors();
-picocolors.exports.createColors = createColors;
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1b[0m", "\x1b[0m"),
+			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+			italic: f("\x1b[3m", "\x1b[23m"),
+			underline: f("\x1b[4m", "\x1b[24m"),
+			inverse: f("\x1b[7m", "\x1b[27m"),
+			hidden: f("\x1b[8m", "\x1b[28m"),
+			strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+			black: f("\x1b[30m", "\x1b[39m"),
+			red: f("\x1b[31m", "\x1b[39m"),
+			green: f("\x1b[32m", "\x1b[39m"),
+			yellow: f("\x1b[33m", "\x1b[39m"),
+			blue: f("\x1b[34m", "\x1b[39m"),
+			magenta: f("\x1b[35m", "\x1b[39m"),
+			cyan: f("\x1b[36m", "\x1b[39m"),
+			white: f("\x1b[37m", "\x1b[39m"),
+			gray: f("\x1b[90m", "\x1b[39m"),
+
+			bgBlack: f("\x1b[40m", "\x1b[49m"),
+			bgRed: f("\x1b[41m", "\x1b[49m"),
+			bgGreen: f("\x1b[42m", "\x1b[49m"),
+			bgYellow: f("\x1b[43m", "\x1b[49m"),
+			bgBlue: f("\x1b[44m", "\x1b[49m"),
+			bgMagenta: f("\x1b[45m", "\x1b[49m"),
+			bgCyan: f("\x1b[46m", "\x1b[49m"),
+			bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+			blackBright: f("\x1b[90m", "\x1b[39m"),
+			redBright: f("\x1b[91m", "\x1b[39m"),
+			greenBright: f("\x1b[92m", "\x1b[39m"),
+			yellowBright: f("\x1b[93m", "\x1b[39m"),
+			blueBright: f("\x1b[94m", "\x1b[39m"),
+			magentaBright: f("\x1b[95m", "\x1b[39m"),
+			cyanBright: f("\x1b[96m", "\x1b[39m"),
+			whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+			bgRedBright: f("\x1b[101m", "\x1b[49m"),
+			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
+		}
+	};
+
+	picocolors.exports = createColors();
+	picocolors.exports.createColors = createColors;
+	return picocolors.exports;
+}
 
-var picocolorsExports = picocolors.exports;
+var picocolorsExports = /*@__PURE__*/ requirePicocolors();
 var color = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
 const NODE_ENV = process.env.NODE_ENV || 'dev';
@@ -2148,710 +2159,725 @@ function requireSrc$1 () {
 	return src$1.exports;
 }
 
-var debug$2;
+var debug_1;
+var hasRequiredDebug$1;
 
-var debug_1 = function () {
-  if (!debug$2) {
-    try {
-      /* eslint global-require: off */
-      debug$2 = requireSrc$1()("follow-redirects");
-    }
-    catch (error) { /* */ }
-    if (typeof debug$2 !== "function") {
-      debug$2 = function () { /* */ };
-    }
-  }
-  debug$2.apply(null, arguments);
-};
+function requireDebug$1 () {
+	if (hasRequiredDebug$1) return debug_1;
+	hasRequiredDebug$1 = 1;
+	var debug;
 
-var url$1 = require$$0$6;
-var URL$1 = url$1.URL;
-var http$1 = require$$1$3;
-var https = require$$2$1;
-var Writable = require$$1$2.Writable;
-var assert = require$$4$1;
-var debug$1 = debug_1;
-
-// Preventive platform detection
-// istanbul ignore next
-(function detectUnsupportedEnvironment() {
-  var looksLikeNode = typeof process !== "undefined";
-  var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-  var looksLikeV8 = isFunction(Error.captureStackTrace);
-  if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
-    console.warn("The follow-redirects package should be excluded from browser builds.");
-  }
-}());
-
-// Whether to use the native URL object or the legacy url module
-var useNativeURL = false;
-try {
-  assert(new URL$1(""));
-}
-catch (error) {
-  useNativeURL = error.code === "ERR_INVALID_URL";
+	debug_1 = function () {
+	  if (!debug) {
+	    try {
+	      /* eslint global-require: off */
+	      debug = requireSrc$1()("follow-redirects");
+	    }
+	    catch (error) { /* */ }
+	    if (typeof debug !== "function") {
+	      debug = function () { /* */ };
+	    }
+	  }
+	  debug.apply(null, arguments);
+	};
+	return debug_1;
 }
 
-// URL fields to preserve in copy operations
-var preservedUrlFields = [
-  "auth",
-  "host",
-  "hostname",
-  "href",
-  "path",
-  "pathname",
-  "port",
-  "protocol",
-  "query",
-  "search",
-  "hash",
-];
+var hasRequiredFollowRedirects;
+
+function requireFollowRedirects () {
+	if (hasRequiredFollowRedirects) return followRedirects.exports;
+	hasRequiredFollowRedirects = 1;
+	var url = require$$0$6;
+	var URL = url.URL;
+	var http = require$$1$3;
+	var https = require$$2$1;
+	var Writable = require$$1$2.Writable;
+	var assert = require$$4$1;
+	var debug = requireDebug$1();
+
+	// Preventive platform detection
+	// istanbul ignore next
+	(function detectUnsupportedEnvironment() {
+	  var looksLikeNode = typeof process !== "undefined";
+	  var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+	  var looksLikeV8 = isFunction(Error.captureStackTrace);
+	  if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
+	    console.warn("The follow-redirects package should be excluded from browser builds.");
+	  }
+	}());
 
-// Create handlers that pass events from native requests
-var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
-var eventHandlers = Object.create(null);
-events.forEach(function (event) {
-  eventHandlers[event] = function (arg1, arg2, arg3) {
-    this._redirectable.emit(event, arg1, arg2, arg3);
-  };
-});
+	// Whether to use the native URL object or the legacy url module
+	var useNativeURL = false;
+	try {
+	  assert(new URL(""));
+	}
+	catch (error) {
+	  useNativeURL = error.code === "ERR_INVALID_URL";
+	}
 
-// Error types with codes
-var InvalidUrlError = createErrorType(
-  "ERR_INVALID_URL",
-  "Invalid URL",
-  TypeError
-);
-var RedirectionError = createErrorType(
-  "ERR_FR_REDIRECTION_FAILURE",
-  "Redirected request failed"
-);
-var TooManyRedirectsError = createErrorType(
-  "ERR_FR_TOO_MANY_REDIRECTS",
-  "Maximum number of redirects exceeded",
-  RedirectionError
-);
-var MaxBodyLengthExceededError = createErrorType(
-  "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
-  "Request body larger than maxBodyLength limit"
-);
-var WriteAfterEndError = createErrorType(
-  "ERR_STREAM_WRITE_AFTER_END",
-  "write after end"
-);
-
-// istanbul ignore next
-var destroy = Writable.prototype.destroy || noop;
-
-// An HTTP(S) request that can be redirected
-function RedirectableRequest(options, responseCallback) {
-  // Initialize the request
-  Writable.call(this);
-  this._sanitizeOptions(options);
-  this._options = options;
-  this._ended = false;
-  this._ending = false;
-  this._redirectCount = 0;
-  this._redirects = [];
-  this._requestBodyLength = 0;
-  this._requestBodyBuffers = [];
-
-  // Attach a callback if passed
-  if (responseCallback) {
-    this.on("response", responseCallback);
-  }
-
-  // React to responses of native requests
-  var self = this;
-  this._onNativeResponse = function (response) {
-    try {
-      self._processResponse(response);
-    }
-    catch (cause) {
-      self.emit("error", cause instanceof RedirectionError ?
-        cause : new RedirectionError({ cause: cause }));
-    }
-  };
+	// URL fields to preserve in copy operations
+	var preservedUrlFields = [
+	  "auth",
+	  "host",
+	  "hostname",
+	  "href",
+	  "path",
+	  "pathname",
+	  "port",
+	  "protocol",
+	  "query",
+	  "search",
+	  "hash",
+	];
+
+	// Create handlers that pass events from native requests
+	var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
+	var eventHandlers = Object.create(null);
+	events.forEach(function (event) {
+	  eventHandlers[event] = function (arg1, arg2, arg3) {
+	    this._redirectable.emit(event, arg1, arg2, arg3);
+	  };
+	});
 
-  // Perform the first request
-  this._performRequest();
-}
-RedirectableRequest.prototype = Object.create(Writable.prototype);
+	// Error types with codes
+	var InvalidUrlError = createErrorType(
+	  "ERR_INVALID_URL",
+	  "Invalid URL",
+	  TypeError
+	);
+	var RedirectionError = createErrorType(
+	  "ERR_FR_REDIRECTION_FAILURE",
+	  "Redirected request failed"
+	);
+	var TooManyRedirectsError = createErrorType(
+	  "ERR_FR_TOO_MANY_REDIRECTS",
+	  "Maximum number of redirects exceeded",
+	  RedirectionError
+	);
+	var MaxBodyLengthExceededError = createErrorType(
+	  "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
+	  "Request body larger than maxBodyLength limit"
+	);
+	var WriteAfterEndError = createErrorType(
+	  "ERR_STREAM_WRITE_AFTER_END",
+	  "write after end"
+	);
 
-RedirectableRequest.prototype.abort = function () {
-  destroyRequest(this._currentRequest);
-  this._currentRequest.abort();
-  this.emit("abort");
-};
+	// istanbul ignore next
+	var destroy = Writable.prototype.destroy || noop;
+
+	// An HTTP(S) request that can be redirected
+	function RedirectableRequest(options, responseCallback) {
+	  // Initialize the request
+	  Writable.call(this);
+	  this._sanitizeOptions(options);
+	  this._options = options;
+	  this._ended = false;
+	  this._ending = false;
+	  this._redirectCount = 0;
+	  this._redirects = [];
+	  this._requestBodyLength = 0;
+	  this._requestBodyBuffers = [];
+
+	  // Attach a callback if passed
+	  if (responseCallback) {
+	    this.on("response", responseCallback);
+	  }
 
-RedirectableRequest.prototype.destroy = function (error) {
-  destroyRequest(this._currentRequest, error);
-  destroy.call(this, error);
-  return this;
-};
+	  // React to responses of native requests
+	  var self = this;
+	  this._onNativeResponse = function (response) {
+	    try {
+	      self._processResponse(response);
+	    }
+	    catch (cause) {
+	      self.emit("error", cause instanceof RedirectionError ?
+	        cause : new RedirectionError({ cause: cause }));
+	    }
+	  };
 
-// Writes buffered data to the current native request
-RedirectableRequest.prototype.write = function (data, encoding, callback) {
-  // Writing is not allowed if end has been called
-  if (this._ending) {
-    throw new WriteAfterEndError();
-  }
-
-  // Validate input and shift parameters if necessary
-  if (!isString(data) && !isBuffer(data)) {
-    throw new TypeError("data should be a string, Buffer or Uint8Array");
-  }
-  if (isFunction(encoding)) {
-    callback = encoding;
-    encoding = null;
-  }
-
-  // Ignore empty buffers, since writing them doesn't invoke the callback
-  // https://github.com/nodejs/node/issues/22066
-  if (data.length === 0) {
-    if (callback) {
-      callback();
-    }
-    return;
-  }
-  // Only write when we don't exceed the maximum body length
-  if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
-    this._requestBodyLength += data.length;
-    this._requestBodyBuffers.push({ data: data, encoding: encoding });
-    this._currentRequest.write(data, encoding, callback);
-  }
-  // Error when we exceed the maximum body length
-  else {
-    this.emit("error", new MaxBodyLengthExceededError());
-    this.abort();
-  }
-};
+	  // Perform the first request
+	  this._performRequest();
+	}
+	RedirectableRequest.prototype = Object.create(Writable.prototype);
 
-// Ends the current native request
-RedirectableRequest.prototype.end = function (data, encoding, callback) {
-  // Shift parameters if necessary
-  if (isFunction(data)) {
-    callback = data;
-    data = encoding = null;
-  }
-  else if (isFunction(encoding)) {
-    callback = encoding;
-    encoding = null;
-  }
-
-  // Write data if needed and end
-  if (!data) {
-    this._ended = this._ending = true;
-    this._currentRequest.end(null, null, callback);
-  }
-  else {
-    var self = this;
-    var currentRequest = this._currentRequest;
-    this.write(data, encoding, function () {
-      self._ended = true;
-      currentRequest.end(null, null, callback);
-    });
-    this._ending = true;
-  }
-};
+	RedirectableRequest.prototype.abort = function () {
+	  destroyRequest(this._currentRequest);
+	  this._currentRequest.abort();
+	  this.emit("abort");
+	};
 
-// Sets a header value on the current native request
-RedirectableRequest.prototype.setHeader = function (name, value) {
-  this._options.headers[name] = value;
-  this._currentRequest.setHeader(name, value);
-};
+	RedirectableRequest.prototype.destroy = function (error) {
+	  destroyRequest(this._currentRequest, error);
+	  destroy.call(this, error);
+	  return this;
+	};
 
-// Clears a header value on the current native request
-RedirectableRequest.prototype.removeHeader = function (name) {
-  delete this._options.headers[name];
-  this._currentRequest.removeHeader(name);
-};
+	// Writes buffered data to the current native request
+	RedirectableRequest.prototype.write = function (data, encoding, callback) {
+	  // Writing is not allowed if end has been called
+	  if (this._ending) {
+	    throw new WriteAfterEndError();
+	  }
 
-// Global timeout for all underlying requests
-RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
-  var self = this;
-
-  // Destroys the socket on timeout
-  function destroyOnTimeout(socket) {
-    socket.setTimeout(msecs);
-    socket.removeListener("timeout", socket.destroy);
-    socket.addListener("timeout", socket.destroy);
-  }
-
-  // Sets up a timer to trigger a timeout event
-  function startTimer(socket) {
-    if (self._timeout) {
-      clearTimeout(self._timeout);
-    }
-    self._timeout = setTimeout(function () {
-      self.emit("timeout");
-      clearTimer();
-    }, msecs);
-    destroyOnTimeout(socket);
-  }
-
-  // Stops a timeout from triggering
-  function clearTimer() {
-    // Clear the timeout
-    if (self._timeout) {
-      clearTimeout(self._timeout);
-      self._timeout = null;
-    }
+	  // Validate input and shift parameters if necessary
+	  if (!isString(data) && !isBuffer(data)) {
+	    throw new TypeError("data should be a string, Buffer or Uint8Array");
+	  }
+	  if (isFunction(encoding)) {
+	    callback = encoding;
+	    encoding = null;
+	  }
 
-    // Clean up all attached listeners
-    self.removeListener("abort", clearTimer);
-    self.removeListener("error", clearTimer);
-    self.removeListener("response", clearTimer);
-    self.removeListener("close", clearTimer);
-    if (callback) {
-      self.removeListener("timeout", callback);
-    }
-    if (!self.socket) {
-      self._currentRequest.removeListener("socket", startTimer);
-    }
-  }
-
-  // Attach callback if passed
-  if (callback) {
-    this.on("timeout", callback);
-  }
-
-  // Start the timer if or when the socket is opened
-  if (this.socket) {
-    startTimer(this.socket);
-  }
-  else {
-    this._currentRequest.once("socket", startTimer);
-  }
-
-  // Clean up on events
-  this.on("socket", destroyOnTimeout);
-  this.on("abort", clearTimer);
-  this.on("error", clearTimer);
-  this.on("response", clearTimer);
-  this.on("close", clearTimer);
-
-  return this;
-};
+	  // Ignore empty buffers, since writing them doesn't invoke the callback
+	  // https://github.com/nodejs/node/issues/22066
+	  if (data.length === 0) {
+	    if (callback) {
+	      callback();
+	    }
+	    return;
+	  }
+	  // Only write when we don't exceed the maximum body length
+	  if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+	    this._requestBodyLength += data.length;
+	    this._requestBodyBuffers.push({ data: data, encoding: encoding });
+	    this._currentRequest.write(data, encoding, callback);
+	  }
+	  // Error when we exceed the maximum body length
+	  else {
+	    this.emit("error", new MaxBodyLengthExceededError());
+	    this.abort();
+	  }
+	};
 
-// Proxy all other public ClientRequest methods
-[
-  "flushHeaders", "getHeader",
-  "setNoDelay", "setSocketKeepAlive",
-].forEach(function (method) {
-  RedirectableRequest.prototype[method] = function (a, b) {
-    return this._currentRequest[method](a, b);
-  };
-});
+	// Ends the current native request
+	RedirectableRequest.prototype.end = function (data, encoding, callback) {
+	  // Shift parameters if necessary
+	  if (isFunction(data)) {
+	    callback = data;
+	    data = encoding = null;
+	  }
+	  else if (isFunction(encoding)) {
+	    callback = encoding;
+	    encoding = null;
+	  }
 
-// Proxy all public ClientRequest properties
-["aborted", "connection", "socket"].forEach(function (property) {
-  Object.defineProperty(RedirectableRequest.prototype, property, {
-    get: function () { return this._currentRequest[property]; },
-  });
-});
+	  // Write data if needed and end
+	  if (!data) {
+	    this._ended = this._ending = true;
+	    this._currentRequest.end(null, null, callback);
+	  }
+	  else {
+	    var self = this;
+	    var currentRequest = this._currentRequest;
+	    this.write(data, encoding, function () {
+	      self._ended = true;
+	      currentRequest.end(null, null, callback);
+	    });
+	    this._ending = true;
+	  }
+	};
 
-RedirectableRequest.prototype._sanitizeOptions = function (options) {
-  // Ensure headers are always present
-  if (!options.headers) {
-    options.headers = {};
-  }
-
-  // Since http.request treats host as an alias of hostname,
-  // but the url module interprets host as hostname plus port,
-  // eliminate the host property to avoid confusion.
-  if (options.host) {
-    // Use hostname if set, because it has precedence
-    if (!options.hostname) {
-      options.hostname = options.host;
-    }
-    delete options.host;
-  }
-
-  // Complete the URL object when necessary
-  if (!options.pathname && options.path) {
-    var searchPos = options.path.indexOf("?");
-    if (searchPos < 0) {
-      options.pathname = options.path;
-    }
-    else {
-      options.pathname = options.path.substring(0, searchPos);
-      options.search = options.path.substring(searchPos);
-    }
-  }
-};
+	// Sets a header value on the current native request
+	RedirectableRequest.prototype.setHeader = function (name, value) {
+	  this._options.headers[name] = value;
+	  this._currentRequest.setHeader(name, value);
+	};
 
+	// Clears a header value on the current native request
+	RedirectableRequest.prototype.removeHeader = function (name) {
+	  delete this._options.headers[name];
+	  this._currentRequest.removeHeader(name);
+	};
 
-// Executes the next native request (initial or redirect)
-RedirectableRequest.prototype._performRequest = function () {
-  // Load the native protocol
-  var protocol = this._options.protocol;
-  var nativeProtocol = this._options.nativeProtocols[protocol];
-  if (!nativeProtocol) {
-    throw new TypeError("Unsupported protocol " + protocol);
-  }
-
-  // If specified, use the agent corresponding to the protocol
-  // (HTTP and HTTPS use different types of agents)
-  if (this._options.agents) {
-    var scheme = protocol.slice(0, -1);
-    this._options.agent = this._options.agents[scheme];
-  }
-
-  // Create the native request and set up its event handlers
-  var request = this._currentRequest =
-        nativeProtocol.request(this._options, this._onNativeResponse);
-  request._redirectable = this;
-  for (var event of events) {
-    request.on(event, eventHandlers[event]);
-  }
-
-  // RFC7230§5.3.1: When making a request directly to an origin server, […]
-  // a client MUST send only the absolute path […] as the request-target.
-  this._currentUrl = /^\//.test(this._options.path) ?
-    url$1.format(this._options) :
-    // When making a request to a proxy, […]
-    // a client MUST send the target URI in absolute-form […].
-    this._options.path;
-
-  // End a redirected request
-  // (The first request must be ended explicitly with RedirectableRequest#end)
-  if (this._isRedirect) {
-    // Write the request entity and end
-    var i = 0;
-    var self = this;
-    var buffers = this._requestBodyBuffers;
-    (function writeNext(error) {
-      // Only write if this request has not been redirected yet
-      // istanbul ignore else
-      if (request === self._currentRequest) {
-        // Report any write errors
-        // istanbul ignore if
-        if (error) {
-          self.emit("error", error);
-        }
-        // Write the next buffer if there are still left
-        else if (i < buffers.length) {
-          var buffer = buffers[i++];
-          // istanbul ignore else
-          if (!request.finished) {
-            request.write(buffer.data, buffer.encoding, writeNext);
-          }
-        }
-        // End the request if `end` has been called on us
-        else if (self._ended) {
-          request.end();
-        }
-      }
-    }());
-  }
-};
+	// Global timeout for all underlying requests
+	RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
+	  var self = this;
 
-// Processes a response from the current native request
-RedirectableRequest.prototype._processResponse = function (response) {
-  // Store the redirected response
-  var statusCode = response.statusCode;
-  if (this._options.trackRedirects) {
-    this._redirects.push({
-      url: this._currentUrl,
-      headers: response.headers,
-      statusCode: statusCode,
-    });
-  }
-
-  // RFC7231§6.4: The 3xx (Redirection) class of status code indicates
-  // that further action needs to be taken by the user agent in order to
-  // fulfill the request. If a Location header field is provided,
-  // the user agent MAY automatically redirect its request to the URI
-  // referenced by the Location field value,
-  // even if the specific status code is not understood.
-
-  // If the response is not a redirect; return it as-is
-  var location = response.headers.location;
-  if (!location || this._options.followRedirects === false ||
-      statusCode < 300 || statusCode >= 400) {
-    response.responseUrl = this._currentUrl;
-    response.redirects = this._redirects;
-    this.emit("response", response);
-
-    // Clean up
-    this._requestBodyBuffers = [];
-    return;
-  }
-
-  // The response is a redirect, so abort the current request
-  destroyRequest(this._currentRequest);
-  // Discard the remainder of the response to avoid waiting for data
-  response.destroy();
-
-  // RFC7231§6.4: A client SHOULD detect and intervene
-  // in cyclical redirections (i.e., "infinite" redirection loops).
-  if (++this._redirectCount > this._options.maxRedirects) {
-    throw new TooManyRedirectsError();
-  }
-
-  // Store the request headers if applicable
-  var requestHeaders;
-  var beforeRedirect = this._options.beforeRedirect;
-  if (beforeRedirect) {
-    requestHeaders = Object.assign({
-      // The Host header was set by nativeProtocol.request
-      Host: response.req.getHeader("host"),
-    }, this._options.headers);
-  }
-
-  // RFC7231§6.4: Automatic redirection needs to done with
-  // care for methods not known to be safe, […]
-  // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change
-  // the request method from POST to GET for the subsequent request.
-  var method = this._options.method;
-  if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" ||
-      // RFC7231§6.4.4: The 303 (See Other) status code indicates that
-      // the server is redirecting the user agent to a different resource […]
-      // A user agent can perform a retrieval request targeting that URI
-      // (a GET or HEAD request if using HTTP) […]
-      (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) {
-    this._options.method = "GET";
-    // Drop a possible entity and headers related to it
-    this._requestBodyBuffers = [];
-    removeMatchingHeaders(/^content-/i, this._options.headers);
-  }
-
-  // Drop the Host header, as the redirect might lead to a different host
-  var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
-
-  // If the redirect is relative, carry over the host of the last request
-  var currentUrlParts = parseUrl(this._currentUrl);
-  var currentHost = currentHostHeader || currentUrlParts.host;
-  var currentUrl = /^\w+:/.test(location) ? this._currentUrl :
-    url$1.format(Object.assign(currentUrlParts, { host: currentHost }));
-
-  // Create the redirected request
-  var redirectUrl = resolveUrl(location, currentUrl);
-  debug$1("redirecting to", redirectUrl.href);
-  this._isRedirect = true;
-  spreadUrlObject(redirectUrl, this._options);
-
-  // Drop confidential headers when redirecting to a less secure protocol
-  // or to a different domain that is not a superdomain
-  if (redirectUrl.protocol !== currentUrlParts.protocol &&
-     redirectUrl.protocol !== "https:" ||
-     redirectUrl.host !== currentHost &&
-     !isSubdomain(redirectUrl.host, currentHost)) {
-    removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
-  }
-
-  // Evaluate the beforeRedirect callback
-  if (isFunction(beforeRedirect)) {
-    var responseDetails = {
-      headers: response.headers,
-      statusCode: statusCode,
-    };
-    var requestDetails = {
-      url: currentUrl,
-      method: method,
-      headers: requestHeaders,
-    };
-    beforeRedirect(this._options, responseDetails, requestDetails);
-    this._sanitizeOptions(this._options);
-  }
+	  // Destroys the socket on timeout
+	  function destroyOnTimeout(socket) {
+	    socket.setTimeout(msecs);
+	    socket.removeListener("timeout", socket.destroy);
+	    socket.addListener("timeout", socket.destroy);
+	  }
 
-  // Perform the redirected request
-  this._performRequest();
-};
+	  // Sets up a timer to trigger a timeout event
+	  function startTimer(socket) {
+	    if (self._timeout) {
+	      clearTimeout(self._timeout);
+	    }
+	    self._timeout = setTimeout(function () {
+	      self.emit("timeout");
+	      clearTimer();
+	    }, msecs);
+	    destroyOnTimeout(socket);
+	  }
 
-// Wraps the key/value object of protocols with redirect functionality
-function wrap(protocols) {
-  // Default settings
-  var exports$1 = {
-    maxRedirects: 21,
-    maxBodyLength: 10 * 1024 * 1024,
-  };
-
-  // Wrap each protocol
-  var nativeProtocols = {};
-  Object.keys(protocols).forEach(function (scheme) {
-    var protocol = scheme + ":";
-    var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
-    var wrappedProtocol = exports$1[scheme] = Object.create(nativeProtocol);
-
-    // Executes a request, following redirects
-    function request(input, options, callback) {
-      // Parse parameters, ensuring that input is an object
-      if (isURL(input)) {
-        input = spreadUrlObject(input);
-      }
-      else if (isString(input)) {
-        input = spreadUrlObject(parseUrl(input));
-      }
-      else {
-        callback = options;
-        options = validateUrl(input);
-        input = { protocol: protocol };
-      }
-      if (isFunction(options)) {
-        callback = options;
-        options = null;
-      }
-
-      // Set defaults
-      options = Object.assign({
-        maxRedirects: exports$1.maxRedirects,
-        maxBodyLength: exports$1.maxBodyLength,
-      }, input, options);
-      options.nativeProtocols = nativeProtocols;
-      if (!isString(options.host) && !isString(options.hostname)) {
-        options.hostname = "::1";
-      }
-
-      assert.equal(options.protocol, protocol, "protocol mismatch");
-      debug$1("options", options);
-      return new RedirectableRequest(options, callback);
-    }
+	  // Stops a timeout from triggering
+	  function clearTimer() {
+	    // Clear the timeout
+	    if (self._timeout) {
+	      clearTimeout(self._timeout);
+	      self._timeout = null;
+	    }
 
-    // Executes a GET request, following redirects
-    function get(input, options, callback) {
-      var wrappedRequest = wrappedProtocol.request(input, options, callback);
-      wrappedRequest.end();
-      return wrappedRequest;
-    }
+	    // Clean up all attached listeners
+	    self.removeListener("abort", clearTimer);
+	    self.removeListener("error", clearTimer);
+	    self.removeListener("response", clearTimer);
+	    self.removeListener("close", clearTimer);
+	    if (callback) {
+	      self.removeListener("timeout", callback);
+	    }
+	    if (!self.socket) {
+	      self._currentRequest.removeListener("socket", startTimer);
+	    }
+	  }
 
-    // Expose the properties on the wrapped protocol
-    Object.defineProperties(wrappedProtocol, {
-      request: { value: request, configurable: true, enumerable: true, writable: true },
-      get: { value: get, configurable: true, enumerable: true, writable: true },
-    });
-  });
-  return exports$1;
-}
+	  // Attach callback if passed
+	  if (callback) {
+	    this.on("timeout", callback);
+	  }
 
-function noop() { /* empty */ }
-
-function parseUrl(input) {
-  var parsed;
-  // istanbul ignore else
-  if (useNativeURL) {
-    parsed = new URL$1(input);
-  }
-  else {
-    // Ensure the URL is valid and absolute
-    parsed = validateUrl(url$1.parse(input));
-    if (!isString(parsed.protocol)) {
-      throw new InvalidUrlError({ input });
-    }
-  }
-  return parsed;
-}
+	  // Start the timer if or when the socket is opened
+	  if (this.socket) {
+	    startTimer(this.socket);
+	  }
+	  else {
+	    this._currentRequest.once("socket", startTimer);
+	  }
 
-function resolveUrl(relative, base) {
-  // istanbul ignore next
-  return useNativeURL ? new URL$1(relative, base) : parseUrl(url$1.resolve(base, relative));
-}
+	  // Clean up on events
+	  this.on("socket", destroyOnTimeout);
+	  this.on("abort", clearTimer);
+	  this.on("error", clearTimer);
+	  this.on("response", clearTimer);
+	  this.on("close", clearTimer);
 
-function validateUrl(input) {
-  if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
-    throw new InvalidUrlError({ input: input.href || input });
-  }
-  if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
-    throw new InvalidUrlError({ input: input.href || input });
-  }
-  return input;
-}
+	  return this;
+	};
 
-function spreadUrlObject(urlObject, target) {
-  var spread = target || {};
-  for (var key of preservedUrlFields) {
-    spread[key] = urlObject[key];
-  }
-
-  // Fix IPv6 hostname
-  if (spread.hostname.startsWith("[")) {
-    spread.hostname = spread.hostname.slice(1, -1);
-  }
-  // Ensure port is a number
-  if (spread.port !== "") {
-    spread.port = Number(spread.port);
-  }
-  // Concatenate path
-  spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
-
-  return spread;
-}
+	// Proxy all other public ClientRequest methods
+	[
+	  "flushHeaders", "getHeader",
+	  "setNoDelay", "setSocketKeepAlive",
+	].forEach(function (method) {
+	  RedirectableRequest.prototype[method] = function (a, b) {
+	    return this._currentRequest[method](a, b);
+	  };
+	});
 
-function removeMatchingHeaders(regex, headers) {
-  var lastValue;
-  for (var header in headers) {
-    if (regex.test(header)) {
-      lastValue = headers[header];
-      delete headers[header];
-    }
-  }
-  return (lastValue === null || typeof lastValue === "undefined") ?
-    undefined : String(lastValue).trim();
-}
+	// Proxy all public ClientRequest properties
+	["aborted", "connection", "socket"].forEach(function (property) {
+	  Object.defineProperty(RedirectableRequest.prototype, property, {
+	    get: function () { return this._currentRequest[property]; },
+	  });
+	});
 
-function createErrorType(code, message, baseClass) {
-  // Create constructor
-  function CustomError(properties) {
-    // istanbul ignore else
-    if (isFunction(Error.captureStackTrace)) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-    Object.assign(this, properties || {});
-    this.code = code;
-    this.message = this.cause ? message + ": " + this.cause.message : message;
-  }
-
-  // Attach constructor and set default properties
-  CustomError.prototype = new (baseClass || Error)();
-  Object.defineProperties(CustomError.prototype, {
-    constructor: {
-      value: CustomError,
-      enumerable: false,
-    },
-    name: {
-      value: "Error [" + code + "]",
-      enumerable: false,
-    },
-  });
-  return CustomError;
-}
+	RedirectableRequest.prototype._sanitizeOptions = function (options) {
+	  // Ensure headers are always present
+	  if (!options.headers) {
+	    options.headers = {};
+	  }
 
-function destroyRequest(request, error) {
-  for (var event of events) {
-    request.removeListener(event, eventHandlers[event]);
-  }
-  request.on("error", noop);
-  request.destroy(error);
-}
+	  // Since http.request treats host as an alias of hostname,
+	  // but the url module interprets host as hostname plus port,
+	  // eliminate the host property to avoid confusion.
+	  if (options.host) {
+	    // Use hostname if set, because it has precedence
+	    if (!options.hostname) {
+	      options.hostname = options.host;
+	    }
+	    delete options.host;
+	  }
 
-function isSubdomain(subdomain, domain) {
-  assert(isString(subdomain) && isString(domain));
-  var dot = subdomain.length - domain.length - 1;
-  return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
-}
+	  // Complete the URL object when necessary
+	  if (!options.pathname && options.path) {
+	    var searchPos = options.path.indexOf("?");
+	    if (searchPos < 0) {
+	      options.pathname = options.path;
+	    }
+	    else {
+	      options.pathname = options.path.substring(0, searchPos);
+	      options.search = options.path.substring(searchPos);
+	    }
+	  }
+	};
 
-function isString(value) {
-  return typeof value === "string" || value instanceof String;
-}
 
-function isFunction(value) {
-  return typeof value === "function";
-}
+	// Executes the next native request (initial or redirect)
+	RedirectableRequest.prototype._performRequest = function () {
+	  // Load the native protocol
+	  var protocol = this._options.protocol;
+	  var nativeProtocol = this._options.nativeProtocols[protocol];
+	  if (!nativeProtocol) {
+	    throw new TypeError("Unsupported protocol " + protocol);
+	  }
 
-function isBuffer(value) {
-  return typeof value === "object" && ("length" in value);
-}
+	  // If specified, use the agent corresponding to the protocol
+	  // (HTTP and HTTPS use different types of agents)
+	  if (this._options.agents) {
+	    var scheme = protocol.slice(0, -1);
+	    this._options.agent = this._options.agents[scheme];
+	  }
 
-function isURL(value) {
-  return URL$1 && value instanceof URL$1;
-}
+	  // Create the native request and set up its event handlers
+	  var request = this._currentRequest =
+	        nativeProtocol.request(this._options, this._onNativeResponse);
+	  request._redirectable = this;
+	  for (var event of events) {
+	    request.on(event, eventHandlers[event]);
+	  }
+
+	  // RFC7230§5.3.1: When making a request directly to an origin server, […]
+	  // a client MUST send only the absolute path […] as the request-target.
+	  this._currentUrl = /^\//.test(this._options.path) ?
+	    url.format(this._options) :
+	    // When making a request to a proxy, […]
+	    // a client MUST send the target URI in absolute-form […].
+	    this._options.path;
+
+	  // End a redirected request
+	  // (The first request must be ended explicitly with RedirectableRequest#end)
+	  if (this._isRedirect) {
+	    // Write the request entity and end
+	    var i = 0;
+	    var self = this;
+	    var buffers = this._requestBodyBuffers;
+	    (function writeNext(error) {
+	      // Only write if this request has not been redirected yet
+	      // istanbul ignore else
+	      if (request === self._currentRequest) {
+	        // Report any write errors
+	        // istanbul ignore if
+	        if (error) {
+	          self.emit("error", error);
+	        }
+	        // Write the next buffer if there are still left
+	        else if (i < buffers.length) {
+	          var buffer = buffers[i++];
+	          // istanbul ignore else
+	          if (!request.finished) {
+	            request.write(buffer.data, buffer.encoding, writeNext);
+	          }
+	        }
+	        // End the request if `end` has been called on us
+	        else if (self._ended) {
+	          request.end();
+	        }
+	      }
+	    }());
+	  }
+	};
+
+	// Processes a response from the current native request
+	RedirectableRequest.prototype._processResponse = function (response) {
+	  // Store the redirected response
+	  var statusCode = response.statusCode;
+	  if (this._options.trackRedirects) {
+	    this._redirects.push({
+	      url: this._currentUrl,
+	      headers: response.headers,
+	      statusCode: statusCode,
+	    });
+	  }
+
+	  // RFC7231§6.4: The 3xx (Redirection) class of status code indicates
+	  // that further action needs to be taken by the user agent in order to
+	  // fulfill the request. If a Location header field is provided,
+	  // the user agent MAY automatically redirect its request to the URI
+	  // referenced by the Location field value,
+	  // even if the specific status code is not understood.
+
+	  // If the response is not a redirect; return it as-is
+	  var location = response.headers.location;
+	  if (!location || this._options.followRedirects === false ||
+	      statusCode < 300 || statusCode >= 400) {
+	    response.responseUrl = this._currentUrl;
+	    response.redirects = this._redirects;
+	    this.emit("response", response);
+
+	    // Clean up
+	    this._requestBodyBuffers = [];
+	    return;
+	  }
+
+	  // The response is a redirect, so abort the current request
+	  destroyRequest(this._currentRequest);
+	  // Discard the remainder of the response to avoid waiting for data
+	  response.destroy();
+
+	  // RFC7231§6.4: A client SHOULD detect and intervene
+	  // in cyclical redirections (i.e., "infinite" redirection loops).
+	  if (++this._redirectCount > this._options.maxRedirects) {
+	    throw new TooManyRedirectsError();
+	  }
+
+	  // Store the request headers if applicable
+	  var requestHeaders;
+	  var beforeRedirect = this._options.beforeRedirect;
+	  if (beforeRedirect) {
+	    requestHeaders = Object.assign({
+	      // The Host header was set by nativeProtocol.request
+	      Host: response.req.getHeader("host"),
+	    }, this._options.headers);
+	  }
+
+	  // RFC7231§6.4: Automatic redirection needs to done with
+	  // care for methods not known to be safe, […]
+	  // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change
+	  // the request method from POST to GET for the subsequent request.
+	  var method = this._options.method;
+	  if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" ||
+	      // RFC7231§6.4.4: The 303 (See Other) status code indicates that
+	      // the server is redirecting the user agent to a different resource […]
+	      // A user agent can perform a retrieval request targeting that URI
+	      // (a GET or HEAD request if using HTTP) […]
+	      (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+	    this._options.method = "GET";
+	    // Drop a possible entity and headers related to it
+	    this._requestBodyBuffers = [];
+	    removeMatchingHeaders(/^content-/i, this._options.headers);
+	  }
+
+	  // Drop the Host header, as the redirect might lead to a different host
+	  var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+
+	  // If the redirect is relative, carry over the host of the last request
+	  var currentUrlParts = parseUrl(this._currentUrl);
+	  var currentHost = currentHostHeader || currentUrlParts.host;
+	  var currentUrl = /^\w+:/.test(location) ? this._currentUrl :
+	    url.format(Object.assign(currentUrlParts, { host: currentHost }));
+
+	  // Create the redirected request
+	  var redirectUrl = resolveUrl(location, currentUrl);
+	  debug("redirecting to", redirectUrl.href);
+	  this._isRedirect = true;
+	  spreadUrlObject(redirectUrl, this._options);
+
+	  // Drop confidential headers when redirecting to a less secure protocol
+	  // or to a different domain that is not a superdomain
+	  if (redirectUrl.protocol !== currentUrlParts.protocol &&
+	     redirectUrl.protocol !== "https:" ||
+	     redirectUrl.host !== currentHost &&
+	     !isSubdomain(redirectUrl.host, currentHost)) {
+	    removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+	  }
+
+	  // Evaluate the beforeRedirect callback
+	  if (isFunction(beforeRedirect)) {
+	    var responseDetails = {
+	      headers: response.headers,
+	      statusCode: statusCode,
+	    };
+	    var requestDetails = {
+	      url: currentUrl,
+	      method: method,
+	      headers: requestHeaders,
+	    };
+	    beforeRedirect(this._options, responseDetails, requestDetails);
+	    this._sanitizeOptions(this._options);
+	  }
+
+	  // Perform the redirected request
+	  this._performRequest();
+	};
+
+	// Wraps the key/value object of protocols with redirect functionality
+	function wrap(protocols) {
+	  // Default settings
+	  var exports$1 = {
+	    maxRedirects: 21,
+	    maxBodyLength: 10 * 1024 * 1024,
+	  };
+
+	  // Wrap each protocol
+	  var nativeProtocols = {};
+	  Object.keys(protocols).forEach(function (scheme) {
+	    var protocol = scheme + ":";
+	    var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+	    var wrappedProtocol = exports$1[scheme] = Object.create(nativeProtocol);
+
+	    // Executes a request, following redirects
+	    function request(input, options, callback) {
+	      // Parse parameters, ensuring that input is an object
+	      if (isURL(input)) {
+	        input = spreadUrlObject(input);
+	      }
+	      else if (isString(input)) {
+	        input = spreadUrlObject(parseUrl(input));
+	      }
+	      else {
+	        callback = options;
+	        options = validateUrl(input);
+	        input = { protocol: protocol };
+	      }
+	      if (isFunction(options)) {
+	        callback = options;
+	        options = null;
+	      }
+
+	      // Set defaults
+	      options = Object.assign({
+	        maxRedirects: exports$1.maxRedirects,
+	        maxBodyLength: exports$1.maxBodyLength,
+	      }, input, options);
+	      options.nativeProtocols = nativeProtocols;
+	      if (!isString(options.host) && !isString(options.hostname)) {
+	        options.hostname = "::1";
+	      }
+
+	      assert.equal(options.protocol, protocol, "protocol mismatch");
+	      debug("options", options);
+	      return new RedirectableRequest(options, callback);
+	    }
+
+	    // Executes a GET request, following redirects
+	    function get(input, options, callback) {
+	      var wrappedRequest = wrappedProtocol.request(input, options, callback);
+	      wrappedRequest.end();
+	      return wrappedRequest;
+	    }
+
+	    // Expose the properties on the wrapped protocol
+	    Object.defineProperties(wrappedProtocol, {
+	      request: { value: request, configurable: true, enumerable: true, writable: true },
+	      get: { value: get, configurable: true, enumerable: true, writable: true },
+	    });
+	  });
+	  return exports$1;
+	}
+
+	function noop() { /* empty */ }
+
+	function parseUrl(input) {
+	  var parsed;
+	  // istanbul ignore else
+	  if (useNativeURL) {
+	    parsed = new URL(input);
+	  }
+	  else {
+	    // Ensure the URL is valid and absolute
+	    parsed = validateUrl(url.parse(input));
+	    if (!isString(parsed.protocol)) {
+	      throw new InvalidUrlError({ input });
+	    }
+	  }
+	  return parsed;
+	}
+
+	function resolveUrl(relative, base) {
+	  // istanbul ignore next
+	  return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+	}
+
+	function validateUrl(input) {
+	  if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+	    throw new InvalidUrlError({ input: input.href || input });
+	  }
+	  if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+	    throw new InvalidUrlError({ input: input.href || input });
+	  }
+	  return input;
+	}
+
+	function spreadUrlObject(urlObject, target) {
+	  var spread = target || {};
+	  for (var key of preservedUrlFields) {
+	    spread[key] = urlObject[key];
+	  }
+
+	  // Fix IPv6 hostname
+	  if (spread.hostname.startsWith("[")) {
+	    spread.hostname = spread.hostname.slice(1, -1);
+	  }
+	  // Ensure port is a number
+	  if (spread.port !== "") {
+	    spread.port = Number(spread.port);
+	  }
+	  // Concatenate path
+	  spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+
+	  return spread;
+	}
+
+	function removeMatchingHeaders(regex, headers) {
+	  var lastValue;
+	  for (var header in headers) {
+	    if (regex.test(header)) {
+	      lastValue = headers[header];
+	      delete headers[header];
+	    }
+	  }
+	  return (lastValue === null || typeof lastValue === "undefined") ?
+	    undefined : String(lastValue).trim();
+	}
+
+	function createErrorType(code, message, baseClass) {
+	  // Create constructor
+	  function CustomError(properties) {
+	    // istanbul ignore else
+	    if (isFunction(Error.captureStackTrace)) {
+	      Error.captureStackTrace(this, this.constructor);
+	    }
+	    Object.assign(this, properties || {});
+	    this.code = code;
+	    this.message = this.cause ? message + ": " + this.cause.message : message;
+	  }
+
+	  // Attach constructor and set default properties
+	  CustomError.prototype = new (baseClass || Error)();
+	  Object.defineProperties(CustomError.prototype, {
+	    constructor: {
+	      value: CustomError,
+	      enumerable: false,
+	    },
+	    name: {
+	      value: "Error [" + code + "]",
+	      enumerable: false,
+	    },
+	  });
+	  return CustomError;
+	}
+
+	function destroyRequest(request, error) {
+	  for (var event of events) {
+	    request.removeListener(event, eventHandlers[event]);
+	  }
+	  request.on("error", noop);
+	  request.destroy(error);
+	}
+
+	function isSubdomain(subdomain, domain) {
+	  assert(isString(subdomain) && isString(domain));
+	  var dot = subdomain.length - domain.length - 1;
+	  return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
+	}
+
+	function isString(value) {
+	  return typeof value === "string" || value instanceof String;
+	}
+
+	function isFunction(value) {
+	  return typeof value === "function";
+	}
+
+	function isBuffer(value) {
+	  return typeof value === "object" && ("length" in value);
+	}
+
+	function isURL(value) {
+	  return URL && value instanceof URL;
+	}
 
-// Exports
-followRedirects.exports = wrap({ http: http$1, https: https });
-followRedirects.exports.wrap = wrap;
+	// Exports
+	followRedirects.exports = wrap({ http: http, https: https });
+	followRedirects.exports.wrap = wrap;
+	return followRedirects.exports;
+}
 
-var followRedirectsExports = followRedirects.exports;
+var followRedirectsExports = requireFollowRedirects();
 
 var mimeTypes$1 = {};
 
@@ -14861,537 +14887,545 @@ var bodyParser = {exports: {}};
  * MIT Licensed
  */
 
-/**
- * Module dependencies.
- */
+var depd_1;
+var hasRequiredDepd;
 
-var relative = path.relative;
+function requireDepd () {
+	if (hasRequiredDepd) return depd_1;
+	hasRequiredDepd = 1;
+	/**
+	 * Module dependencies.
+	 */
 
-/**
- * Module exports.
- */
+	var relative = path.relative;
 
-var depd_1 = depd;
+	/**
+	 * Module exports.
+	 */
 
-/**
- * Get the path to base files on.
- */
+	depd_1 = depd;
 
-var basePath = process.cwd();
+	/**
+	 * Get the path to base files on.
+	 */
 
-/**
- * Determine if namespace is contained in the string.
- */
+	var basePath = process.cwd();
 
-function containsNamespace (str, namespace) {
-  var vals = str.split(/[ ,]+/);
-  var ns = String(namespace).toLowerCase();
+	/**
+	 * Determine if namespace is contained in the string.
+	 */
 
-  for (var i = 0; i < vals.length; i++) {
-    var val = vals[i];
+	function containsNamespace (str, namespace) {
+	  var vals = str.split(/[ ,]+/);
+	  var ns = String(namespace).toLowerCase();
 
-    // namespace contained
-    if (val && (val === '*' || val.toLowerCase() === ns)) {
-      return true
-    }
-  }
+	  for (var i = 0; i < vals.length; i++) {
+	    var val = vals[i];
 
-  return false
-}
+	    // namespace contained
+	    if (val && (val === '*' || val.toLowerCase() === ns)) {
+	      return true
+	    }
+	  }
 
-/**
- * Convert a data descriptor to accessor descriptor.
- */
+	  return false
+	}
 
-function convertDataDescriptorToAccessor (obj, prop, message) {
-  var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
-  var value = descriptor.value;
+	/**
+	 * Convert a data descriptor to accessor descriptor.
+	 */
 
-  descriptor.get = function getter () { return value };
+	function convertDataDescriptorToAccessor (obj, prop, message) {
+	  var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+	  var value = descriptor.value;
 
-  if (descriptor.writable) {
-    descriptor.set = function setter (val) { return (value = val) };
-  }
+	  descriptor.get = function getter () { return value };
 
-  delete descriptor.value;
-  delete descriptor.writable;
+	  if (descriptor.writable) {
+	    descriptor.set = function setter (val) { return (value = val) };
+	  }
 
-  Object.defineProperty(obj, prop, descriptor);
+	  delete descriptor.value;
+	  delete descriptor.writable;
 
-  return descriptor
-}
+	  Object.defineProperty(obj, prop, descriptor);
 
-/**
- * Create arguments string to keep arity.
- */
+	  return descriptor
+	}
 
-function createArgumentsString (arity) {
-  var str = '';
+	/**
+	 * Create arguments string to keep arity.
+	 */
 
-  for (var i = 0; i < arity; i++) {
-    str += ', arg' + i;
-  }
+	function createArgumentsString (arity) {
+	  var str = '';
 
-  return str.substr(2)
-}
+	  for (var i = 0; i < arity; i++) {
+	    str += ', arg' + i;
+	  }
 
-/**
- * Create stack string from stack.
- */
+	  return str.substr(2)
+	}
 
-function createStackString (stack) {
-  var str = this.name + ': ' + this.namespace;
+	/**
+	 * Create stack string from stack.
+	 */
 
-  if (this.message) {
-    str += ' deprecated ' + this.message;
-  }
+	function createStackString (stack) {
+	  var str = this.name + ': ' + this.namespace;
 
-  for (var i = 0; i < stack.length; i++) {
-    str += '\n    at ' + stack[i].toString();
-  }
+	  if (this.message) {
+	    str += ' deprecated ' + this.message;
+	  }
 
-  return str
-}
+	  for (var i = 0; i < stack.length; i++) {
+	    str += '\n    at ' + stack[i].toString();
+	  }
 
-/**
- * Create deprecate for namespace in caller.
- */
+	  return str
+	}
 
-function depd (namespace) {
-  if (!namespace) {
-    throw new TypeError('argument namespace is required')
-  }
+	/**
+	 * Create deprecate for namespace in caller.
+	 */
 
-  var stack = getStack();
-  var site = callSiteLocation(stack[1]);
-  var file = site[0];
+	function depd (namespace) {
+	  if (!namespace) {
+	    throw new TypeError('argument namespace is required')
+	  }
 
-  function deprecate (message) {
-    // call to self as log
-    log.call(deprecate, message);
-  }
+	  var stack = getStack();
+	  var site = callSiteLocation(stack[1]);
+	  var file = site[0];
 
-  deprecate._file = file;
-  deprecate._ignored = isignored(namespace);
-  deprecate._namespace = namespace;
-  deprecate._traced = istraced(namespace);
-  deprecate._warned = Object.create(null);
+	  function deprecate (message) {
+	    // call to self as log
+	    log.call(deprecate, message);
+	  }
 
-  deprecate.function = wrapfunction;
-  deprecate.property = wrapproperty;
+	  deprecate._file = file;
+	  deprecate._ignored = isignored(namespace);
+	  deprecate._namespace = namespace;
+	  deprecate._traced = istraced(namespace);
+	  deprecate._warned = Object.create(null);
 
-  return deprecate
-}
+	  deprecate.function = wrapfunction;
+	  deprecate.property = wrapproperty;
 
-/**
- * Determine if event emitter has listeners of a given type.
- *
- * The way to do this check is done three different ways in Node.js >= 0.8
- * so this consolidates them into a minimal set using instance methods.
- *
- * @param {EventEmitter} emitter
- * @param {string} type
- * @returns {boolean}
- * @private
- */
+	  return deprecate
+	}
+
+	/**
+	 * Determine if event emitter has listeners of a given type.
+	 *
+	 * The way to do this check is done three different ways in Node.js >= 0.8
+	 * so this consolidates them into a minimal set using instance methods.
+	 *
+	 * @param {EventEmitter} emitter
+	 * @param {string} type
+	 * @returns {boolean}
+	 * @private
+	 */
 
-function eehaslisteners (emitter, type) {
-  var count = typeof emitter.listenerCount !== 'function'
-    ? emitter.listeners(type).length
-    : emitter.listenerCount(type);
+	function eehaslisteners (emitter, type) {
+	  var count = typeof emitter.listenerCount !== 'function'
+	    ? emitter.listeners(type).length
+	    : emitter.listenerCount(type);
 
-  return count > 0
-}
+	  return count > 0
+	}
 
-/**
- * Determine if namespace is ignored.
- */
+	/**
+	 * Determine if namespace is ignored.
+	 */
 
-function isignored (namespace) {
-  if (process.noDeprecation) {
-    // --no-deprecation support
-    return true
-  }
+	function isignored (namespace) {
+	  if (process.noDeprecation) {
+	    // --no-deprecation support
+	    return true
+	  }
 
-  var str = process.env.NO_DEPRECATION || '';
+	  var str = process.env.NO_DEPRECATION || '';
 
-  // namespace ignored
-  return containsNamespace(str, namespace)
-}
+	  // namespace ignored
+	  return containsNamespace(str, namespace)
+	}
 
-/**
- * Determine if namespace is traced.
- */
+	/**
+	 * Determine if namespace is traced.
+	 */
 
-function istraced (namespace) {
-  if (process.traceDeprecation) {
-    // --trace-deprecation support
-    return true
-  }
+	function istraced (namespace) {
+	  if (process.traceDeprecation) {
+	    // --trace-deprecation support
+	    return true
+	  }
 
-  var str = process.env.TRACE_DEPRECATION || '';
+	  var str = process.env.TRACE_DEPRECATION || '';
 
-  // namespace traced
-  return containsNamespace(str, namespace)
-}
+	  // namespace traced
+	  return containsNamespace(str, namespace)
+	}
 
-/**
- * Display deprecation message.
- */
+	/**
+	 * Display deprecation message.
+	 */
 
-function log (message, site) {
-  var haslisteners = eehaslisteners(process, 'deprecation');
-
-  // abort early if no destination
-  if (!haslisteners && this._ignored) {
-    return
-  }
-
-  var caller;
-  var callFile;
-  var callSite;
-  var depSite;
-  var i = 0;
-  var seen = false;
-  var stack = getStack();
-  var file = this._file;
-
-  if (site) {
-    // provided site
-    depSite = site;
-    callSite = callSiteLocation(stack[1]);
-    callSite.name = depSite.name;
-    file = callSite[0];
-  } else {
-    // get call site
-    i = 2;
-    depSite = callSiteLocation(stack[i]);
-    callSite = depSite;
-  }
-
-  // get caller of deprecated thing in relation to file
-  for (; i < stack.length; i++) {
-    caller = callSiteLocation(stack[i]);
-    callFile = caller[0];
-
-    if (callFile === file) {
-      seen = true;
-    } else if (callFile === this._file) {
-      file = this._file;
-    } else if (seen) {
-      break
-    }
-  }
-
-  var key = caller
-    ? depSite.join(':') + '__' + caller.join(':')
-    : undefined;
-
-  if (key !== undefined && key in this._warned) {
-    // already warned
-    return
-  }
-
-  this._warned[key] = true;
-
-  // generate automatic message from call site
-  var msg = message;
-  if (!msg) {
-    msg = callSite === depSite || !callSite.name
-      ? defaultMessage(depSite)
-      : defaultMessage(callSite);
-  }
-
-  // emit deprecation if listeners exist
-  if (haslisteners) {
-    var err = DeprecationError(this._namespace, msg, stack.slice(i));
-    process.emit('deprecation', err);
-    return
-  }
-
-  // format and write message
-  var format = process.stderr.isTTY
-    ? formatColor
-    : formatPlain;
-  var output = format.call(this, msg, caller, stack.slice(i));
-  process.stderr.write(output + '\n', 'utf8');
-}
+	function log (message, site) {
+	  var haslisteners = eehaslisteners(process, 'deprecation');
 
-/**
- * Get call site location as array.
- */
+	  // abort early if no destination
+	  if (!haslisteners && this._ignored) {
+	    return
+	  }
 
-function callSiteLocation (callSite) {
-  var file = callSite.getFileName() || '<anonymous>';
-  var line = callSite.getLineNumber();
-  var colm = callSite.getColumnNumber();
+	  var caller;
+	  var callFile;
+	  var callSite;
+	  var depSite;
+	  var i = 0;
+	  var seen = false;
+	  var stack = getStack();
+	  var file = this._file;
+
+	  if (site) {
+	    // provided site
+	    depSite = site;
+	    callSite = callSiteLocation(stack[1]);
+	    callSite.name = depSite.name;
+	    file = callSite[0];
+	  } else {
+	    // get call site
+	    i = 2;
+	    depSite = callSiteLocation(stack[i]);
+	    callSite = depSite;
+	  }
 
-  if (callSite.isEval()) {
-    file = callSite.getEvalOrigin() + ', ' + file;
-  }
+	  // get caller of deprecated thing in relation to file
+	  for (; i < stack.length; i++) {
+	    caller = callSiteLocation(stack[i]);
+	    callFile = caller[0];
 
-  var site = [file, line, colm];
+	    if (callFile === file) {
+	      seen = true;
+	    } else if (callFile === this._file) {
+	      file = this._file;
+	    } else if (seen) {
+	      break
+	    }
+	  }
 
-  site.callSite = callSite;
-  site.name = callSite.getFunctionName();
+	  var key = caller
+	    ? depSite.join(':') + '__' + caller.join(':')
+	    : undefined;
 
-  return site
-}
+	  if (key !== undefined && key in this._warned) {
+	    // already warned
+	    return
+	  }
 
-/**
- * Generate a default message from the site.
- */
+	  this._warned[key] = true;
+
+	  // generate automatic message from call site
+	  var msg = message;
+	  if (!msg) {
+	    msg = callSite === depSite || !callSite.name
+	      ? defaultMessage(depSite)
+	      : defaultMessage(callSite);
+	  }
+
+	  // emit deprecation if listeners exist
+	  if (haslisteners) {
+	    var err = DeprecationError(this._namespace, msg, stack.slice(i));
+	    process.emit('deprecation', err);
+	    return
+	  }
 
-function defaultMessage (site) {
-  var callSite = site.callSite;
-  var funcName = site.name;
+	  // format and write message
+	  var format = process.stderr.isTTY
+	    ? formatColor
+	    : formatPlain;
+	  var output = format.call(this, msg, caller, stack.slice(i));
+	  process.stderr.write(output + '\n', 'utf8');
+	}
 
-  // make useful anonymous name
-  if (!funcName) {
-    funcName = '<anonymous@' + formatLocation(site) + '>';
-  }
+	/**
+	 * Get call site location as array.
+	 */
 
-  var context = callSite.getThis();
-  var typeName = context && callSite.getTypeName();
+	function callSiteLocation (callSite) {
+	  var file = callSite.getFileName() || '<anonymous>';
+	  var line = callSite.getLineNumber();
+	  var colm = callSite.getColumnNumber();
 
-  // ignore useless type name
-  if (typeName === 'Object') {
-    typeName = undefined;
-  }
+	  if (callSite.isEval()) {
+	    file = callSite.getEvalOrigin() + ', ' + file;
+	  }
 
-  // make useful type name
-  if (typeName === 'Function') {
-    typeName = context.name || typeName;
-  }
+	  var site = [file, line, colm];
 
-  return typeName && callSite.getMethodName()
-    ? typeName + '.' + funcName
-    : funcName
-}
+	  site.callSite = callSite;
+	  site.name = callSite.getFunctionName();
 
-/**
- * Format deprecation message without color.
- */
+	  return site
+	}
 
-function formatPlain (msg, caller, stack) {
-  var timestamp = new Date().toUTCString();
+	/**
+	 * Generate a default message from the site.
+	 */
 
-  var formatted = timestamp +
-    ' ' + this._namespace +
-    ' deprecated ' + msg;
+	function defaultMessage (site) {
+	  var callSite = site.callSite;
+	  var funcName = site.name;
 
-  // add stack trace
-  if (this._traced) {
-    for (var i = 0; i < stack.length; i++) {
-      formatted += '\n    at ' + stack[i].toString();
-    }
+	  // make useful anonymous name
+	  if (!funcName) {
+	    funcName = '<anonymous@' + formatLocation(site) + '>';
+	  }
 
-    return formatted
-  }
+	  var context = callSite.getThis();
+	  var typeName = context && callSite.getTypeName();
 
-  if (caller) {
-    formatted += ' at ' + formatLocation(caller);
-  }
+	  // ignore useless type name
+	  if (typeName === 'Object') {
+	    typeName = undefined;
+	  }
 
-  return formatted
-}
+	  // make useful type name
+	  if (typeName === 'Function') {
+	    typeName = context.name || typeName;
+	  }
 
-/**
- * Format deprecation message with color.
- */
+	  return typeName && callSite.getMethodName()
+	    ? typeName + '.' + funcName
+	    : funcName
+	}
 
-function formatColor (msg, caller, stack) {
-  var formatted = '\x1b[36;1m' + this._namespace + '\x1b[22;39m' + // bold cyan
-    ' \x1b[33;1mdeprecated\x1b[22;39m' + // bold yellow
-    ' \x1b[0m' + msg + '\x1b[39m'; // reset
+	/**
+	 * Format deprecation message without color.
+	 */
 
-  // add stack trace
-  if (this._traced) {
-    for (var i = 0; i < stack.length; i++) {
-      formatted += '\n    \x1b[36mat ' + stack[i].toString() + '\x1b[39m'; // cyan
-    }
+	function formatPlain (msg, caller, stack) {
+	  var timestamp = new Date().toUTCString();
 
-    return formatted
-  }
+	  var formatted = timestamp +
+	    ' ' + this._namespace +
+	    ' deprecated ' + msg;
 
-  if (caller) {
-    formatted += ' \x1b[36m' + formatLocation(caller) + '\x1b[39m'; // cyan
-  }
+	  // add stack trace
+	  if (this._traced) {
+	    for (var i = 0; i < stack.length; i++) {
+	      formatted += '\n    at ' + stack[i].toString();
+	    }
 
-  return formatted
-}
+	    return formatted
+	  }
 
-/**
- * Format call site location.
- */
+	  if (caller) {
+	    formatted += ' at ' + formatLocation(caller);
+	  }
 
-function formatLocation (callSite) {
-  return relative(basePath, callSite[0]) +
-    ':' + callSite[1] +
-    ':' + callSite[2]
-}
+	  return formatted
+	}
 
-/**
- * Get the stack as array of call sites.
- */
+	/**
+	 * Format deprecation message with color.
+	 */
 
-function getStack () {
-  var limit = Error.stackTraceLimit;
-  var obj = {};
-  var prep = Error.prepareStackTrace;
+	function formatColor (msg, caller, stack) {
+	  var formatted = '\x1b[36;1m' + this._namespace + '\x1b[22;39m' + // bold cyan
+	    ' \x1b[33;1mdeprecated\x1b[22;39m' + // bold yellow
+	    ' \x1b[0m' + msg + '\x1b[39m'; // reset
 
-  Error.prepareStackTrace = prepareObjectStackTrace;
-  Error.stackTraceLimit = Math.max(10, limit);
+	  // add stack trace
+	  if (this._traced) {
+	    for (var i = 0; i < stack.length; i++) {
+	      formatted += '\n    \x1b[36mat ' + stack[i].toString() + '\x1b[39m'; // cyan
+	    }
 
-  // capture the stack
-  Error.captureStackTrace(obj);
+	    return formatted
+	  }
 
-  // slice this function off the top
-  var stack = obj.stack.slice(1);
+	  if (caller) {
+	    formatted += ' \x1b[36m' + formatLocation(caller) + '\x1b[39m'; // cyan
+	  }
 
-  Error.prepareStackTrace = prep;
-  Error.stackTraceLimit = limit;
+	  return formatted
+	}
 
-  return stack
-}
+	/**
+	 * Format call site location.
+	 */
 
-/**
- * Capture call site stack from v8.
- */
+	function formatLocation (callSite) {
+	  return relative(basePath, callSite[0]) +
+	    ':' + callSite[1] +
+	    ':' + callSite[2]
+	}
 
-function prepareObjectStackTrace (obj, stack) {
-  return stack
-}
+	/**
+	 * Get the stack as array of call sites.
+	 */
 
-/**
- * Return a wrapped function in a deprecation message.
- */
+	function getStack () {
+	  var limit = Error.stackTraceLimit;
+	  var obj = {};
+	  var prep = Error.prepareStackTrace;
 
-function wrapfunction (fn, message) {
-  if (typeof fn !== 'function') {
-    throw new TypeError('argument fn must be a function')
-  }
+	  Error.prepareStackTrace = prepareObjectStackTrace;
+	  Error.stackTraceLimit = Math.max(10, limit);
 
-  var args = createArgumentsString(fn.length);
-  var stack = getStack();
-  var site = callSiteLocation(stack[1]);
+	  // capture the stack
+	  Error.captureStackTrace(obj);
 
-  site.name = fn.name;
+	  // slice this function off the top
+	  var stack = obj.stack.slice(1);
 
-  // eslint-disable-next-line no-new-func
-  var deprecatedfn = new Function('fn', 'log', 'deprecate', 'message', 'site',
-    '"use strict"\n' +
-    'return function (' + args + ') {' +
-    'log.call(deprecate, message, site)\n' +
-    'return fn.apply(this, arguments)\n' +
-    '}')(fn, log, this, message, site);
+	  Error.prepareStackTrace = prep;
+	  Error.stackTraceLimit = limit;
 
-  return deprecatedfn
-}
+	  return stack
+	}
 
-/**
- * Wrap property in a deprecation message.
- */
+	/**
+	 * Capture call site stack from v8.
+	 */
 
-function wrapproperty (obj, prop, message) {
-  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    throw new TypeError('argument obj must be object')
-  }
+	function prepareObjectStackTrace (obj, stack) {
+	  return stack
+	}
 
-  var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+	/**
+	 * Return a wrapped function in a deprecation message.
+	 */
 
-  if (!descriptor) {
-    throw new TypeError('must call property on owner object')
-  }
+	function wrapfunction (fn, message) {
+	  if (typeof fn !== 'function') {
+	    throw new TypeError('argument fn must be a function')
+	  }
 
-  if (!descriptor.configurable) {
-    throw new TypeError('property must be configurable')
-  }
+	  var args = createArgumentsString(fn.length);
+	  var stack = getStack();
+	  var site = callSiteLocation(stack[1]);
 
-  var deprecate = this;
-  var stack = getStack();
-  var site = callSiteLocation(stack[1]);
+	  site.name = fn.name;
 
-  // set site name
-  site.name = prop;
+	  // eslint-disable-next-line no-new-func
+	  var deprecatedfn = new Function('fn', 'log', 'deprecate', 'message', 'site',
+	    '"use strict"\n' +
+	    'return function (' + args + ') {' +
+	    'log.call(deprecate, message, site)\n' +
+	    'return fn.apply(this, arguments)\n' +
+	    '}')(fn, log, this, message, site);
 
-  // convert data descriptor
-  if ('value' in descriptor) {
-    descriptor = convertDataDescriptorToAccessor(obj, prop);
-  }
+	  return deprecatedfn
+	}
 
-  var get = descriptor.get;
-  var set = descriptor.set;
+	/**
+	 * Wrap property in a deprecation message.
+	 */
 
-  // wrap getter
-  if (typeof get === 'function') {
-    descriptor.get = function getter () {
-      log.call(deprecate, message, site);
-      return get.apply(this, arguments)
-    };
-  }
+	function wrapproperty (obj, prop, message) {
+	  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+	    throw new TypeError('argument obj must be object')
+	  }
 
-  // wrap setter
-  if (typeof set === 'function') {
-    descriptor.set = function setter () {
-      log.call(deprecate, message, site);
-      return set.apply(this, arguments)
-    };
-  }
+	  var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
 
-  Object.defineProperty(obj, prop, descriptor);
-}
+	  if (!descriptor) {
+	    throw new TypeError('must call property on owner object')
+	  }
 
-/**
- * Create DeprecationError for deprecation
- */
+	  if (!descriptor.configurable) {
+	    throw new TypeError('property must be configurable')
+	  }
 
-function DeprecationError (namespace, message, stack) {
-  var error = new Error();
-  var stackString;
-
-  Object.defineProperty(error, 'constructor', {
-    value: DeprecationError
-  });
-
-  Object.defineProperty(error, 'message', {
-    configurable: true,
-    enumerable: false,
-    value: message,
-    writable: true
-  });
-
-  Object.defineProperty(error, 'name', {
-    enumerable: false,
-    configurable: true,
-    value: 'DeprecationError',
-    writable: true
-  });
-
-  Object.defineProperty(error, 'namespace', {
-    configurable: true,
-    enumerable: false,
-    value: namespace,
-    writable: true
-  });
-
-  Object.defineProperty(error, 'stack', {
-    configurable: true,
-    enumerable: false,
-    get: function () {
-      if (stackString !== undefined) {
-        return stackString
-      }
-
-      // prepare stack trace
-      return (stackString = createStackString.call(this, stack))
-    },
-    set: function setter (val) {
-      stackString = val;
-    }
-  });
+	  var deprecate = this;
+	  var stack = getStack();
+	  var site = callSiteLocation(stack[1]);
+
+	  // set site name
+	  site.name = prop;
+
+	  // convert data descriptor
+	  if ('value' in descriptor) {
+	    descriptor = convertDataDescriptorToAccessor(obj, prop);
+	  }
+
+	  var get = descriptor.get;
+	  var set = descriptor.set;
+
+	  // wrap getter
+	  if (typeof get === 'function') {
+	    descriptor.get = function getter () {
+	      log.call(deprecate, message, site);
+	      return get.apply(this, arguments)
+	    };
+	  }
+
+	  // wrap setter
+	  if (typeof set === 'function') {
+	    descriptor.set = function setter () {
+	      log.call(deprecate, message, site);
+	      return set.apply(this, arguments)
+	    };
+	  }
+
+	  Object.defineProperty(obj, prop, descriptor);
+	}
+
+	/**
+	 * Create DeprecationError for deprecation
+	 */
+
+	function DeprecationError (namespace, message, stack) {
+	  var error = new Error();
+	  var stackString;
+
+	  Object.defineProperty(error, 'constructor', {
+	    value: DeprecationError
+	  });
+
+	  Object.defineProperty(error, 'message', {
+	    configurable: true,
+	    enumerable: false,
+	    value: message,
+	    writable: true
+	  });
+
+	  Object.defineProperty(error, 'name', {
+	    enumerable: false,
+	    configurable: true,
+	    value: 'DeprecationError',
+	    writable: true
+	  });
+
+	  Object.defineProperty(error, 'namespace', {
+	    configurable: true,
+	    enumerable: false,
+	    value: namespace,
+	    writable: true
+	  });
+
+	  Object.defineProperty(error, 'stack', {
+	    configurable: true,
+	    enumerable: false,
+	    get: function () {
+	      if (stackString !== undefined) {
+	        return stackString
+	      }
+
+	      // prepare stack trace
+	      return (stackString = createStackString.call(this, stack))
+	    },
+	    set: function setter (val) {
+	      stackString = val;
+	    }
+	  });
 
-  return error
+	  return error
+	}
+	return depd_1;
 }
 
 var bytes = {exports: {}};
@@ -16169,7 +16203,7 @@ function requireHttpErrors () {
 		 * @private
 		 */
 
-		var deprecate = depd_1('http-errors');
+		var deprecate = requireDepd()('http-errors');
 		var setPrototypeOf = requireSetprototypeof();
 		var statuses = requireStatuses();
 		var inherits = requireInherits();
@@ -28466,11 +28500,11 @@ function requireExtendNode () {
 	return extendNode;
 }
 
-var hasRequiredLib$1;
+var hasRequiredLib$2;
 
-function requireLib$1 () {
-	if (hasRequiredLib$1) return lib$2.exports;
-	hasRequiredLib$1 = 1;
+function requireLib$2 () {
+	if (hasRequiredLib$2) return lib$2.exports;
+	hasRequiredLib$2 = 1;
 	(function (module) {
 
 		// Some environments don't have global Buffer (e.g. React Native).
@@ -28723,7 +28757,7 @@ function requireRawBody () {
 	var asyncHooks = tryRequireAsyncHooks();
 	var bytes = requireBytes();
 	var createError = requireHttpErrors();
-	var iconv = requireLib$1();
+	var iconv = requireLib$2();
 	var unpipe = requireUnpipe();
 
 	/**
@@ -29412,7 +29446,7 @@ function requireRead () {
 	var createError = requireHttpErrors();
 	var destroy = requireDestroy();
 	var getBody = requireRawBody();
-	var iconv = requireLib$1();
+	var iconv = requireLib$2();
 	var onFinished = requireOnFinished();
 	var unpipe = requireUnpipe();
 	var zlib = require$$3$2;
@@ -30747,7 +30781,7 @@ function requireObjectInspect () {
 	    return $replace.call(str, sepRegex, '$&_');
 	}
 
-	var utilInspect = requireUtil_inspect();
+	var utilInspect = /*@__PURE__*/ requireUtil_inspect();
 	var inspectCustom = utilInspect.custom;
 	var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
 
@@ -31234,9 +31268,9 @@ function requireSideChannelList () {
 	if (hasRequiredSideChannelList) return sideChannelList;
 	hasRequiredSideChannelList = 1;
 
-	var inspect = requireObjectInspect();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
 
-	var $TypeError = requireType();
+	var $TypeError = /*@__PURE__*/ requireType();
 
 	/*
 	* This function traverses the list returning the node corresponding to the given key.
@@ -31525,7 +31559,7 @@ function requireSign () {
 	if (hasRequiredSign) return sign;
 	hasRequiredSign = 1;
 
-	var $isNaN = require_isNaN();
+	var $isNaN = /*@__PURE__*/ require_isNaN();
 
 	/** @type {import('./sign')} */
 	sign = function sign(number) {
@@ -31557,7 +31591,7 @@ function requireGopd () {
 	hasRequiredGopd = 1;
 
 	/** @type {import('.')} */
-	var $gOPD = requireGOPD();
+	var $gOPD = /*@__PURE__*/ requireGOPD();
 
 	if ($gOPD) {
 		try {
@@ -31688,7 +31722,7 @@ function requireObject_getPrototypeOf () {
 	if (hasRequiredObject_getPrototypeOf) return Object_getPrototypeOf;
 	hasRequiredObject_getPrototypeOf = 1;
 
-	var $Object = requireEsObjectAtoms();
+	var $Object = /*@__PURE__*/ requireEsObjectAtoms();
 
 	/** @type {import('./Object.getPrototypeOf')} */
 	Object_getPrototypeOf = $Object.getPrototypeOf || null;
@@ -31862,7 +31896,7 @@ function requireCallBindApplyHelpers () {
 	hasRequiredCallBindApplyHelpers = 1;
 
 	var bind = requireFunctionBind();
-	var $TypeError = requireType();
+	var $TypeError = /*@__PURE__*/ requireType();
 
 	var $call = requireFunctionCall();
 	var $actualApply = requireActualApply();
@@ -31885,7 +31919,7 @@ function requireGet () {
 	hasRequiredGet = 1;
 
 	var callBind = requireCallBindApplyHelpers();
-	var gOPD = requireGopd();
+	var gOPD = /*@__PURE__*/ requireGopd();
 
 	var hasProtoAccessor;
 	try {
@@ -31925,7 +31959,7 @@ function requireGetProto () {
 	var reflectGetProto = requireReflect_getPrototypeOf();
 	var originalGetProto = requireObject_getPrototypeOf();
 
-	var getDunderProto = requireGet();
+	var getDunderProto = /*@__PURE__*/ requireGet();
 
 	/** @type {import('.')} */
 	getProto = reflectGetProto
@@ -31975,23 +32009,23 @@ function requireGetIntrinsic () {
 
 	var undefined$1;
 
-	var $Object = requireEsObjectAtoms();
+	var $Object = /*@__PURE__*/ requireEsObjectAtoms();
 
-	var $Error = requireEsErrors();
-	var $EvalError = require_eval();
-	var $RangeError = requireRange();
-	var $ReferenceError = requireRef();
-	var $SyntaxError = requireSyntax();
-	var $TypeError = requireType();
-	var $URIError = requireUri();
+	var $Error = /*@__PURE__*/ requireEsErrors();
+	var $EvalError = /*@__PURE__*/ require_eval();
+	var $RangeError = /*@__PURE__*/ requireRange();
+	var $ReferenceError = /*@__PURE__*/ requireRef();
+	var $SyntaxError = /*@__PURE__*/ requireSyntax();
+	var $TypeError = /*@__PURE__*/ requireType();
+	var $URIError = /*@__PURE__*/ requireUri();
 
-	var abs = requireAbs();
-	var floor = requireFloor();
-	var max = requireMax();
-	var min = requireMin();
-	var pow = requirePow();
-	var round = requireRound();
-	var sign = requireSign();
+	var abs = /*@__PURE__*/ requireAbs();
+	var floor = /*@__PURE__*/ requireFloor();
+	var max = /*@__PURE__*/ requireMax();
+	var min = /*@__PURE__*/ requireMin();
+	var pow = /*@__PURE__*/ requirePow();
+	var round = /*@__PURE__*/ requireRound();
+	var sign = /*@__PURE__*/ requireSign();
 
 	var $Function = Function;
 
@@ -32002,8 +32036,8 @@ function requireGetIntrinsic () {
 		} catch (e) {}
 	};
 
-	var $gOPD = requireGopd();
-	var $defineProperty = requireEsDefineProperty();
+	var $gOPD = /*@__PURE__*/ requireGopd();
+	var $defineProperty = /*@__PURE__*/ requireEsDefineProperty();
 
 	var throwTypeError = function () {
 		throw new $TypeError();
@@ -32214,7 +32248,7 @@ function requireGetIntrinsic () {
 	};
 
 	var bind = requireFunctionBind();
-	var hasOwn = requireHasown();
+	var hasOwn = /*@__PURE__*/ requireHasown();
 	var $concat = bind.call($call, Array.prototype.concat);
 	var $spliceApply = bind.call($apply, Array.prototype.splice);
 	var $replace = bind.call($call, String.prototype.replace);
@@ -32359,7 +32393,7 @@ function requireCallBound () {
 	if (hasRequiredCallBound) return callBound;
 	hasRequiredCallBound = 1;
 
-	var GetIntrinsic = requireGetIntrinsic();
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
 
 	var callBindBasic = requireCallBindApplyHelpers();
 
@@ -32386,11 +32420,11 @@ function requireSideChannelMap () {
 	if (hasRequiredSideChannelMap) return sideChannelMap;
 	hasRequiredSideChannelMap = 1;
 
-	var GetIntrinsic = requireGetIntrinsic();
-	var callBound = requireCallBound();
-	var inspect = requireObjectInspect();
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
+	var callBound = /*@__PURE__*/ requireCallBound();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
 
-	var $TypeError = requireType();
+	var $TypeError = /*@__PURE__*/ requireType();
 	var $Map = GetIntrinsic('%Map%', true);
 
 	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => V} */
@@ -32462,12 +32496,12 @@ function requireSideChannelWeakmap () {
 	if (hasRequiredSideChannelWeakmap) return sideChannelWeakmap;
 	hasRequiredSideChannelWeakmap = 1;
 
-	var GetIntrinsic = requireGetIntrinsic();
-	var callBound = requireCallBound();
-	var inspect = requireObjectInspect();
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
+	var callBound = /*@__PURE__*/ requireCallBound();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
 	var getSideChannelMap = requireSideChannelMap();
 
-	var $TypeError = requireType();
+	var $TypeError = /*@__PURE__*/ requireType();
 	var $WeakMap = GetIntrinsic('%WeakMap%', true);
 
 	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => V} */
@@ -32554,8 +32588,8 @@ function requireSideChannel () {
 	if (hasRequiredSideChannel) return sideChannel;
 	hasRequiredSideChannel = 1;
 
-	var $TypeError = requireType();
-	var inspect = requireObjectInspect();
+	var $TypeError = /*@__PURE__*/ requireType();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
 	var getSideChannelList = requireSideChannelList();
 	var getSideChannelMap = requireSideChannelMap();
 	var getSideChannelWeakMap = requireSideChannelWeakmap();
@@ -32636,7 +32670,7 @@ function requireUtils () {
 	if (hasRequiredUtils) return utils;
 	hasRequiredUtils = 1;
 
-	var formats = requireFormats();
+	var formats = /*@__PURE__*/ requireFormats();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
@@ -32913,8 +32947,8 @@ function requireStringify () {
 	hasRequiredStringify = 1;
 
 	var getSideChannel = requireSideChannel();
-	var utils = requireUtils();
-	var formats = requireFormats();
+	var utils = /*@__PURE__*/ requireUtils();
+	var formats = /*@__PURE__*/ requireFormats();
 	var has = Object.prototype.hasOwnProperty;
 
 	var arrayPrefixGenerators = {
@@ -33269,14 +33303,14 @@ function requireStringify () {
 	return stringify_1;
 }
 
-var parse$4;
+var parse$1;
 var hasRequiredParse;
 
 function requireParse () {
-	if (hasRequiredParse) return parse$4;
+	if (hasRequiredParse) return parse$1;
 	hasRequiredParse = 1;
 
-	var utils = requireUtils();
+	var utils = /*@__PURE__*/ requireUtils();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
@@ -33577,7 +33611,7 @@ function requireParse () {
 	    };
 	};
 
-	parse$4 = function (str, opts) {
+	parse$1 = function (str, opts) {
 	    var options = normalizeParseOptions(opts);
 
 	    if (str === '' || str === null || typeof str === 'undefined') {
@@ -33602,19 +33636,19 @@ function requireParse () {
 
 	    return utils.compact(obj);
 	};
-	return parse$4;
+	return parse$1;
 }
 
 var lib$1;
-var hasRequiredLib;
+var hasRequiredLib$1;
 
-function requireLib () {
-	if (hasRequiredLib) return lib$1;
-	hasRequiredLib = 1;
+function requireLib$1 () {
+	if (hasRequiredLib$1) return lib$1;
+	hasRequiredLib$1 = 1;
 
-	var stringify = requireStringify();
-	var parse = requireParse();
-	var formats = requireFormats();
+	var stringify = /*@__PURE__*/ requireStringify();
+	var parse = /*@__PURE__*/ requireParse();
+	var formats = /*@__PURE__*/ requireFormats();
 
 	lib$1 = {
 	    formats: formats,
@@ -33647,7 +33681,7 @@ function requireUrlencoded () {
 	var contentType = requireContentType();
 	var createError = requireHttpErrors();
 	var debug = requireSrc()('body-parser:urlencoded');
-	var deprecate = depd_1('body-parser');
+	var deprecate = requireDepd()('body-parser');
 	var read = requireRead();
 	var typeis = requireTypeIs();
 
@@ -33869,7 +33903,7 @@ function requireUrlencoded () {
 	  // this uses a switch for static require analysis
 	  switch (name) {
 	    case 'qs':
-	      mod = requireLib();
+	      mod = /*@__PURE__*/ requireLib$1();
 	      break
 	    case 'querystring':
 	      mod = require$$8;
@@ -33938,159 +33972,166 @@ function requireUrlencoded () {
  * MIT Licensed
  */
 
-(function (module, exports$1) {
+var hasRequiredBodyParser;
 
-	/**
-	 * Module dependencies.
-	 * @private
-	 */
+function requireBodyParser () {
+	if (hasRequiredBodyParser) return bodyParser.exports;
+	hasRequiredBodyParser = 1;
+	(function (module, exports$1) {
 
-	var deprecate = depd_1('body-parser');
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
 
-	/**
-	 * Cache of loaded parsers.
-	 * @private
-	 */
+		var deprecate = requireDepd()('body-parser');
 
-	var parsers = Object.create(null);
+		/**
+		 * Cache of loaded parsers.
+		 * @private
+		 */
 
-	/**
-	 * @typedef Parsers
-	 * @type {function}
-	 * @property {function} json
-	 * @property {function} raw
-	 * @property {function} text
-	 * @property {function} urlencoded
-	 */
+		var parsers = Object.create(null);
 
-	/**
-	 * Module exports.
-	 * @type {Parsers}
-	 */
+		/**
+		 * @typedef Parsers
+		 * @type {function}
+		 * @property {function} json
+		 * @property {function} raw
+		 * @property {function} text
+		 * @property {function} urlencoded
+		 */
 
-	exports$1 = module.exports = deprecate.function(bodyParser,
-	  'bodyParser: use individual json/urlencoded middlewares');
+		/**
+		 * Module exports.
+		 * @type {Parsers}
+		 */
 
-	/**
-	 * JSON parser.
-	 * @public
-	 */
+		exports$1 = module.exports = deprecate.function(bodyParser,
+		  'bodyParser: use individual json/urlencoded middlewares');
 
-	Object.defineProperty(exports$1, 'json', {
-	  configurable: true,
-	  enumerable: true,
-	  get: createParserGetter('json')
-	});
+		/**
+		 * JSON parser.
+		 * @public
+		 */
 
-	/**
-	 * Raw parser.
-	 * @public
-	 */
+		Object.defineProperty(exports$1, 'json', {
+		  configurable: true,
+		  enumerable: true,
+		  get: createParserGetter('json')
+		});
 
-	Object.defineProperty(exports$1, 'raw', {
-	  configurable: true,
-	  enumerable: true,
-	  get: createParserGetter('raw')
-	});
+		/**
+		 * Raw parser.
+		 * @public
+		 */
 
-	/**
-	 * Text parser.
-	 * @public
-	 */
+		Object.defineProperty(exports$1, 'raw', {
+		  configurable: true,
+		  enumerable: true,
+		  get: createParserGetter('raw')
+		});
 
-	Object.defineProperty(exports$1, 'text', {
-	  configurable: true,
-	  enumerable: true,
-	  get: createParserGetter('text')
-	});
+		/**
+		 * Text parser.
+		 * @public
+		 */
 
-	/**
-	 * URL-encoded parser.
-	 * @public
-	 */
+		Object.defineProperty(exports$1, 'text', {
+		  configurable: true,
+		  enumerable: true,
+		  get: createParserGetter('text')
+		});
 
-	Object.defineProperty(exports$1, 'urlencoded', {
-	  configurable: true,
-	  enumerable: true,
-	  get: createParserGetter('urlencoded')
-	});
+		/**
+		 * URL-encoded parser.
+		 * @public
+		 */
 
-	/**
-	 * Create a middleware to parse json and urlencoded bodies.
-	 *
-	 * @param {object} [options]
-	 * @return {function}
-	 * @deprecated
-	 * @public
-	 */
+		Object.defineProperty(exports$1, 'urlencoded', {
+		  configurable: true,
+		  enumerable: true,
+		  get: createParserGetter('urlencoded')
+		});
 
-	function bodyParser (options) {
-	  // use default type for parsers
-	  var opts = Object.create(options || null, {
-	    type: {
-	      configurable: true,
-	      enumerable: true,
-	      value: undefined,
-	      writable: true
-	    }
-	  });
+		/**
+		 * Create a middleware to parse json and urlencoded bodies.
+		 *
+		 * @param {object} [options]
+		 * @return {function}
+		 * @deprecated
+		 * @public
+		 */
 
-	  var _urlencoded = exports$1.urlencoded(opts);
-	  var _json = exports$1.json(opts);
+		function bodyParser (options) {
+		  // use default type for parsers
+		  var opts = Object.create(options || null, {
+		    type: {
+		      configurable: true,
+		      enumerable: true,
+		      value: undefined,
+		      writable: true
+		    }
+		  });
 
-	  return function bodyParser (req, res, next) {
-	    _json(req, res, function (err) {
-	      if (err) return next(err)
-	      _urlencoded(req, res, next);
-	    });
-	  }
-	}
+		  var _urlencoded = exports$1.urlencoded(opts);
+		  var _json = exports$1.json(opts);
 
-	/**
-	 * Create a getter for loading a parser.
-	 * @private
-	 */
+		  return function bodyParser (req, res, next) {
+		    _json(req, res, function (err) {
+		      if (err) return next(err)
+		      _urlencoded(req, res, next);
+		    });
+		  }
+		}
 
-	function createParserGetter (name) {
-	  return function get () {
-	    return loadParser(name)
-	  }
-	}
+		/**
+		 * Create a getter for loading a parser.
+		 * @private
+		 */
 
-	/**
-	 * Load a parser module.
-	 * @private
-	 */
+		function createParserGetter (name) {
+		  return function get () {
+		    return loadParser(name)
+		  }
+		}
 
-	function loadParser (parserName) {
-	  var parser = parsers[parserName];
+		/**
+		 * Load a parser module.
+		 * @private
+		 */
 
-	  if (parser !== undefined) {
-	    return parser
-	  }
+		function loadParser (parserName) {
+		  var parser = parsers[parserName];
 
-	  // this uses a switch for static require analysis
-	  switch (parserName) {
-	    case 'json':
-	      parser = requireJson();
-	      break
-	    case 'raw':
-	      parser = requireRaw();
-	      break
-	    case 'text':
-	      parser = requireText();
-	      break
-	    case 'urlencoded':
-	      parser = requireUrlencoded();
-	      break
-	  }
+		  if (parser !== undefined) {
+		    return parser
+		  }
 
-	  // store to prevent invoking require()
-	  return (parsers[parserName] = parser)
-	} 
-} (bodyParser, bodyParser.exports));
+		  // this uses a switch for static require analysis
+		  switch (parserName) {
+		    case 'json':
+		      parser = requireJson();
+		      break
+		    case 'raw':
+		      parser = requireRaw();
+		      break
+		    case 'text':
+		      parser = requireText();
+		      break
+		    case 'urlencoded':
+		      parser = requireUrlencoded();
+		      break
+		  }
 
-var bodyParserExports = bodyParser.exports;
+		  // store to prevent invoking require()
+		  return (parsers[parserName] = parser)
+		} 
+	} (bodyParser, bodyParser.exports));
+	return bodyParser.exports;
+}
+
+var bodyParserExports = requireBodyParser();
 
 var lib = {exports: {}};
 
@@ -34099,91 +34140,100 @@ object-assign
 (c) Sindre Sorhus
 @license MIT
 */
-/* eslint-disable no-unused-vars */
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-function toObject(val) {
-	if (val === null || val === undefined) {
-		throw new TypeError('Object.assign cannot be called with null or undefined');
-	}
 
-	return Object(val);
-}
+var objectAssign;
+var hasRequiredObjectAssign;
 
-function shouldUseNative() {
-	try {
-		if (!Object.assign) {
-			return false;
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
 		}
 
-		// Detect buggy property enumeration order in older V8 versions.
+		return Object(val);
+	}
 
-		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
-		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
-		test1[5] = 'de';
-		if (Object.getOwnPropertyNames(test1)[0] === '5') {
-			return false;
-		}
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
 
-		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-		var test2 = {};
-		for (var i = 0; i < 10; i++) {
-			test2['_' + String.fromCharCode(i)] = i;
-		}
-		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
-			return test2[n];
-		});
-		if (order2.join('') !== '0123456789') {
-			return false;
-		}
+			// Detect buggy property enumeration order in older V8 versions.
 
-		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-		var test3 = {};
-		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
-			test3[letter] = letter;
-		});
-		if (Object.keys(Object.assign({}, test3)).join('') !==
-				'abcdefghijklmnopqrst') {
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
 			return false;
 		}
-
-		return true;
-	} catch (err) {
-		// We don't expect any of the above to throw, but better to be safe.
-		return false;
 	}
-}
 
-var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
-	var from;
-	var to = toObject(target);
-	var symbols;
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
 
-	for (var s = 1; s < arguments.length; s++) {
-		from = Object(arguments[s]);
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
 
-		for (var key in from) {
-			if (hasOwnProperty.call(from, key)) {
-				to[key] = from[key];
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
 			}
-		}
 
-		if (getOwnPropertySymbols) {
-			symbols = getOwnPropertySymbols(from);
-			for (var i = 0; i < symbols.length; i++) {
-				if (propIsEnumerable.call(from, symbols[i])) {
-					to[symbols[i]] = from[symbols[i]];
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
 				}
 			}
 		}
-	}
 
-	return to;
-};
+		return to;
+	};
+	return objectAssign;
+}
 
-var vary$1 = {exports: {}};
+var vary = {exports: {}};
 
 /*!
  * vary
@@ -34191,388 +34241,401 @@ var vary$1 = {exports: {}};
  * MIT Licensed
  */
 
-/**
- * Module exports.
- */
+var hasRequiredVary;
 
-vary$1.exports = vary;
-vary$1.exports.append = append;
+function requireVary () {
+	if (hasRequiredVary) return vary.exports;
+	hasRequiredVary = 1;
 
-/**
- * RegExp to match field-name in RFC 7230 sec 3.2
- *
- * field-name    = token
- * token         = 1*tchar
- * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
- *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
- *               / DIGIT / ALPHA
- *               ; any VCHAR, except delimiters
- */
+	/**
+	 * Module exports.
+	 */
 
-var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+	vary.exports = vary$1;
+	vary.exports.append = append;
 
-/**
- * Append a field to a vary header.
- *
- * @param {String} header
- * @param {String|Array} field
- * @return {String}
- * @public
- */
+	/**
+	 * RegExp to match field-name in RFC 7230 sec 3.2
+	 *
+	 * field-name    = token
+	 * token         = 1*tchar
+	 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+	 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+	 *               / DIGIT / ALPHA
+	 *               ; any VCHAR, except delimiters
+	 */
 
-function append (header, field) {
-  if (typeof header !== 'string') {
-    throw new TypeError('header argument is required')
-  }
+	var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 
-  if (!field) {
-    throw new TypeError('field argument is required')
-  }
+	/**
+	 * Append a field to a vary header.
+	 *
+	 * @param {String} header
+	 * @param {String|Array} field
+	 * @return {String}
+	 * @public
+	 */
 
-  // get fields array
-  var fields = !Array.isArray(field)
-    ? parse$3(String(field))
-    : field;
+	function append (header, field) {
+	  if (typeof header !== 'string') {
+	    throw new TypeError('header argument is required')
+	  }
 
-  // assert on invalid field names
-  for (var j = 0; j < fields.length; j++) {
-    if (!FIELD_NAME_REGEXP.test(fields[j])) {
-      throw new TypeError('field argument contains an invalid header name')
-    }
-  }
-
-  // existing, unspecified vary
-  if (header === '*') {
-    return header
-  }
-
-  // enumerate current values
-  var val = header;
-  var vals = parse$3(header.toLowerCase());
-
-  // unspecified vary
-  if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
-    return '*'
-  }
-
-  for (var i = 0; i < fields.length; i++) {
-    var fld = fields[i].toLowerCase();
-
-    // append value (case-preserving)
-    if (vals.indexOf(fld) === -1) {
-      vals.push(fld);
-      val = val
-        ? val + ', ' + fields[i]
-        : fields[i];
-    }
-  }
+	  if (!field) {
+	    throw new TypeError('field argument is required')
+	  }
 
-  return val
-}
+	  // get fields array
+	  var fields = !Array.isArray(field)
+	    ? parse(String(field))
+	    : field;
 
-/**
- * Parse a vary header into an array.
- *
- * @param {String} header
- * @return {Array}
- * @private
- */
+	  // assert on invalid field names
+	  for (var j = 0; j < fields.length; j++) {
+	    if (!FIELD_NAME_REGEXP.test(fields[j])) {
+	      throw new TypeError('field argument contains an invalid header name')
+	    }
+	  }
 
-function parse$3 (header) {
-  var end = 0;
-  var list = [];
-  var start = 0;
-
-  // gather tokens
-  for (var i = 0, len = header.length; i < len; i++) {
-    switch (header.charCodeAt(i)) {
-      case 0x20: /*   */
-        if (start === end) {
-          start = end = i + 1;
-        }
-        break
-      case 0x2c: /* , */
-        list.push(header.substring(start, end));
-        start = end = i + 1;
-        break
-      default:
-        end = i + 1;
-        break
-    }
-  }
+	  // existing, unspecified vary
+	  if (header === '*') {
+	    return header
+	  }
 
-  // final token
-  list.push(header.substring(start, end));
+	  // enumerate current values
+	  var val = header;
+	  var vals = parse(header.toLowerCase());
 
-  return list
-}
+	  // unspecified vary
+	  if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
+	    return '*'
+	  }
 
-/**
- * Mark that a request is varied on a header field.
- *
- * @param {Object} res
- * @param {String|Array} field
- * @public
- */
+	  for (var i = 0; i < fields.length; i++) {
+	    var fld = fields[i].toLowerCase();
+
+	    // append value (case-preserving)
+	    if (vals.indexOf(fld) === -1) {
+	      vals.push(fld);
+	      val = val
+	        ? val + ', ' + fields[i]
+	        : fields[i];
+	    }
+	  }
 
-function vary (res, field) {
-  if (!res || !res.getHeader || !res.setHeader) {
-    // quack quack
-    throw new TypeError('res argument is required')
-  }
-
-  // get existing header
-  var val = res.getHeader('Vary') || '';
-  var header = Array.isArray(val)
-    ? val.join(', ')
-    : String(val);
-
-  // set new header
-  if ((val = append(header, field))) {
-    res.setHeader('Vary', val);
-  }
+	  return val
+	}
+
+	/**
+	 * Parse a vary header into an array.
+	 *
+	 * @param {String} header
+	 * @return {Array}
+	 * @private
+	 */
+
+	function parse (header) {
+	  var end = 0;
+	  var list = [];
+	  var start = 0;
+
+	  // gather tokens
+	  for (var i = 0, len = header.length; i < len; i++) {
+	    switch (header.charCodeAt(i)) {
+	      case 0x20: /*   */
+	        if (start === end) {
+	          start = end = i + 1;
+	        }
+	        break
+	      case 0x2c: /* , */
+	        list.push(header.substring(start, end));
+	        start = end = i + 1;
+	        break
+	      default:
+	        end = i + 1;
+	        break
+	    }
+	  }
+
+	  // final token
+	  list.push(header.substring(start, end));
+
+	  return list
+	}
+
+	/**
+	 * Mark that a request is varied on a header field.
+	 *
+	 * @param {Object} res
+	 * @param {String|Array} field
+	 * @public
+	 */
+
+	function vary$1 (res, field) {
+	  if (!res || !res.getHeader || !res.setHeader) {
+	    // quack quack
+	    throw new TypeError('res argument is required')
+	  }
+
+	  // get existing header
+	  var val = res.getHeader('Vary') || '';
+	  var header = Array.isArray(val)
+	    ? val.join(', ')
+	    : String(val);
+
+	  // set new header
+	  if ((val = append(header, field))) {
+	    res.setHeader('Vary', val);
+	  }
+	}
+	return vary.exports;
 }
 
-var varyExports = vary$1.exports;
+var hasRequiredLib;
 
-(function () {
+function requireLib () {
+	if (hasRequiredLib) return lib.exports;
+	hasRequiredLib = 1;
+	(function () {
 
-  var assign = objectAssign;
-  var vary = varyExports;
+	  var assign = requireObjectAssign();
+	  var vary = requireVary();
 
-  var defaults = {
-    origin: '*',
-    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
-    preflightContinue: false,
-    optionsSuccessStatus: 204
-  };
+	  var defaults = {
+	    origin: '*',
+	    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+	    preflightContinue: false,
+	    optionsSuccessStatus: 204
+	  };
 
-  function isString(s) {
-    return typeof s === 'string' || s instanceof String;
-  }
+	  function isString(s) {
+	    return typeof s === 'string' || s instanceof String;
+	  }
 
-  function isOriginAllowed(origin, allowedOrigin) {
-    if (Array.isArray(allowedOrigin)) {
-      for (var i = 0; i < allowedOrigin.length; ++i) {
-        if (isOriginAllowed(origin, allowedOrigin[i])) {
-          return true;
-        }
-      }
-      return false;
-    } else if (isString(allowedOrigin)) {
-      return origin === allowedOrigin;
-    } else if (allowedOrigin instanceof RegExp) {
-      return allowedOrigin.test(origin);
-    } else {
-      return !!allowedOrigin;
-    }
-  }
-
-  function configureOrigin(options, req) {
-    var requestOrigin = req.headers.origin,
-      headers = [],
-      isAllowed;
-
-    if (!options.origin || options.origin === '*') {
-      // allow any origin
-      headers.push([{
-        key: 'Access-Control-Allow-Origin',
-        value: '*'
-      }]);
-    } else if (isString(options.origin)) {
-      // fixed origin
-      headers.push([{
-        key: 'Access-Control-Allow-Origin',
-        value: options.origin
-      }]);
-      headers.push([{
-        key: 'Vary',
-        value: 'Origin'
-      }]);
-    } else {
-      isAllowed = isOriginAllowed(requestOrigin, options.origin);
-      // reflect origin
-      headers.push([{
-        key: 'Access-Control-Allow-Origin',
-        value: isAllowed ? requestOrigin : false
-      }]);
-      headers.push([{
-        key: 'Vary',
-        value: 'Origin'
-      }]);
-    }
+	  function isOriginAllowed(origin, allowedOrigin) {
+	    if (Array.isArray(allowedOrigin)) {
+	      for (var i = 0; i < allowedOrigin.length; ++i) {
+	        if (isOriginAllowed(origin, allowedOrigin[i])) {
+	          return true;
+	        }
+	      }
+	      return false;
+	    } else if (isString(allowedOrigin)) {
+	      return origin === allowedOrigin;
+	    } else if (allowedOrigin instanceof RegExp) {
+	      return allowedOrigin.test(origin);
+	    } else {
+	      return !!allowedOrigin;
+	    }
+	  }
 
-    return headers;
-  }
+	  function configureOrigin(options, req) {
+	    var requestOrigin = req.headers.origin,
+	      headers = [],
+	      isAllowed;
+
+	    if (!options.origin || options.origin === '*') {
+	      // allow any origin
+	      headers.push([{
+	        key: 'Access-Control-Allow-Origin',
+	        value: '*'
+	      }]);
+	    } else if (isString(options.origin)) {
+	      // fixed origin
+	      headers.push([{
+	        key: 'Access-Control-Allow-Origin',
+	        value: options.origin
+	      }]);
+	      headers.push([{
+	        key: 'Vary',
+	        value: 'Origin'
+	      }]);
+	    } else {
+	      isAllowed = isOriginAllowed(requestOrigin, options.origin);
+	      // reflect origin
+	      headers.push([{
+	        key: 'Access-Control-Allow-Origin',
+	        value: isAllowed ? requestOrigin : false
+	      }]);
+	      headers.push([{
+	        key: 'Vary',
+	        value: 'Origin'
+	      }]);
+	    }
 
-  function configureMethods(options) {
-    var methods = options.methods;
-    if (methods.join) {
-      methods = options.methods.join(','); // .methods is an array, so turn it into a string
-    }
-    return {
-      key: 'Access-Control-Allow-Methods',
-      value: methods
-    };
-  }
-
-  function configureCredentials(options) {
-    if (options.credentials === true) {
-      return {
-        key: 'Access-Control-Allow-Credentials',
-        value: 'true'
-      };
-    }
-    return null;
-  }
-
-  function configureAllowedHeaders(options, req) {
-    var allowedHeaders = options.allowedHeaders || options.headers;
-    var headers = [];
-
-    if (!allowedHeaders) {
-      allowedHeaders = req.headers['access-control-request-headers']; // .headers wasn't specified, so reflect the request headers
-      headers.push([{
-        key: 'Vary',
-        value: 'Access-Control-Request-Headers'
-      }]);
-    } else if (allowedHeaders.join) {
-      allowedHeaders = allowedHeaders.join(','); // .headers is an array, so turn it into a string
-    }
-    if (allowedHeaders && allowedHeaders.length) {
-      headers.push([{
-        key: 'Access-Control-Allow-Headers',
-        value: allowedHeaders
-      }]);
-    }
+	    return headers;
+	  }
 
-    return headers;
-  }
+	  function configureMethods(options) {
+	    var methods = options.methods;
+	    if (methods.join) {
+	      methods = options.methods.join(','); // .methods is an array, so turn it into a string
+	    }
+	    return {
+	      key: 'Access-Control-Allow-Methods',
+	      value: methods
+	    };
+	  }
 
-  function configureExposedHeaders(options) {
-    var headers = options.exposedHeaders;
-    if (!headers) {
-      return null;
-    } else if (headers.join) {
-      headers = headers.join(','); // .headers is an array, so turn it into a string
-    }
-    if (headers && headers.length) {
-      return {
-        key: 'Access-Control-Expose-Headers',
-        value: headers
-      };
-    }
-    return null;
-  }
-
-  function configureMaxAge(options) {
-    var maxAge = (typeof options.maxAge === 'number' || options.maxAge) && options.maxAge.toString();
-    if (maxAge && maxAge.length) {
-      return {
-        key: 'Access-Control-Max-Age',
-        value: maxAge
-      };
-    }
-    return null;
-  }
-
-  function applyHeaders(headers, res) {
-    for (var i = 0, n = headers.length; i < n; i++) {
-      var header = headers[i];
-      if (header) {
-        if (Array.isArray(header)) {
-          applyHeaders(header, res);
-        } else if (header.key === 'Vary' && header.value) {
-          vary(res, header.value);
-        } else if (header.value) {
-          res.setHeader(header.key, header.value);
-        }
-      }
-    }
-  }
-
-  function cors(options, req, res, next) {
-    var headers = [],
-      method = req.method && req.method.toUpperCase && req.method.toUpperCase();
-
-    if (method === 'OPTIONS') {
-      // preflight
-      headers.push(configureOrigin(options, req));
-      headers.push(configureCredentials(options));
-      headers.push(configureMethods(options));
-      headers.push(configureAllowedHeaders(options, req));
-      headers.push(configureMaxAge(options));
-      headers.push(configureExposedHeaders(options));
-      applyHeaders(headers, res);
-
-      if (options.preflightContinue) {
-        next();
-      } else {
-        // Safari (and potentially other browsers) need content-length 0,
-        //   for 204 or they just hang waiting for a body
-        res.statusCode = options.optionsSuccessStatus;
-        res.setHeader('Content-Length', '0');
-        res.end();
-      }
-    } else {
-      // actual response
-      headers.push(configureOrigin(options, req));
-      headers.push(configureCredentials(options));
-      headers.push(configureExposedHeaders(options));
-      applyHeaders(headers, res);
-      next();
-    }
-  }
-
-  function middlewareWrapper(o) {
-    // if options are static (either via defaults or custom options passed in), wrap in a function
-    var optionsCallback = null;
-    if (typeof o === 'function') {
-      optionsCallback = o;
-    } else {
-      optionsCallback = function (req, cb) {
-        cb(null, o);
-      };
-    }
+	  function configureCredentials(options) {
+	    if (options.credentials === true) {
+	      return {
+	        key: 'Access-Control-Allow-Credentials',
+	        value: 'true'
+	      };
+	    }
+	    return null;
+	  }
 
-    return function corsMiddleware(req, res, next) {
-      optionsCallback(req, function (err, options) {
-        if (err) {
-          next(err);
-        } else {
-          var corsOptions = assign({}, defaults, options);
-          var originCallback = null;
-          if (corsOptions.origin && typeof corsOptions.origin === 'function') {
-            originCallback = corsOptions.origin;
-          } else if (corsOptions.origin) {
-            originCallback = function (origin, cb) {
-              cb(null, corsOptions.origin);
-            };
-          }
-
-          if (originCallback) {
-            originCallback(req.headers.origin, function (err2, origin) {
-              if (err2 || !origin) {
-                next(err2);
-              } else {
-                corsOptions.origin = origin;
-                cors(corsOptions, req, res, next);
-              }
-            });
-          } else {
-            next();
-          }
-        }
-      });
-    };
-  }
+	  function configureAllowedHeaders(options, req) {
+	    var allowedHeaders = options.allowedHeaders || options.headers;
+	    var headers = [];
+
+	    if (!allowedHeaders) {
+	      allowedHeaders = req.headers['access-control-request-headers']; // .headers wasn't specified, so reflect the request headers
+	      headers.push([{
+	        key: 'Vary',
+	        value: 'Access-Control-Request-Headers'
+	      }]);
+	    } else if (allowedHeaders.join) {
+	      allowedHeaders = allowedHeaders.join(','); // .headers is an array, so turn it into a string
+	    }
+	    if (allowedHeaders && allowedHeaders.length) {
+	      headers.push([{
+	        key: 'Access-Control-Allow-Headers',
+	        value: allowedHeaders
+	      }]);
+	    }
+
+	    return headers;
+	  }
+
+	  function configureExposedHeaders(options) {
+	    var headers = options.exposedHeaders;
+	    if (!headers) {
+	      return null;
+	    } else if (headers.join) {
+	      headers = headers.join(','); // .headers is an array, so turn it into a string
+	    }
+	    if (headers && headers.length) {
+	      return {
+	        key: 'Access-Control-Expose-Headers',
+	        value: headers
+	      };
+	    }
+	    return null;
+	  }
 
-  // can pass either an options hash, an options delegate, or nothing
-  lib.exports = middlewareWrapper;
+	  function configureMaxAge(options) {
+	    var maxAge = (typeof options.maxAge === 'number' || options.maxAge) && options.maxAge.toString();
+	    if (maxAge && maxAge.length) {
+	      return {
+	        key: 'Access-Control-Max-Age',
+	        value: maxAge
+	      };
+	    }
+	    return null;
+	  }
 
-}());
+	  function applyHeaders(headers, res) {
+	    for (var i = 0, n = headers.length; i < n; i++) {
+	      var header = headers[i];
+	      if (header) {
+	        if (Array.isArray(header)) {
+	          applyHeaders(header, res);
+	        } else if (header.key === 'Vary' && header.value) {
+	          vary(res, header.value);
+	        } else if (header.value) {
+	          res.setHeader(header.key, header.value);
+	        }
+	      }
+	    }
+	  }
 
-var libExports = lib.exports;
+	  function cors(options, req, res, next) {
+	    var headers = [],
+	      method = req.method && req.method.toUpperCase && req.method.toUpperCase();
+
+	    if (method === 'OPTIONS') {
+	      // preflight
+	      headers.push(configureOrigin(options, req));
+	      headers.push(configureCredentials(options));
+	      headers.push(configureMethods(options));
+	      headers.push(configureAllowedHeaders(options, req));
+	      headers.push(configureMaxAge(options));
+	      headers.push(configureExposedHeaders(options));
+	      applyHeaders(headers, res);
+
+	      if (options.preflightContinue) {
+	        next();
+	      } else {
+	        // Safari (and potentially other browsers) need content-length 0,
+	        //   for 204 or they just hang waiting for a body
+	        res.statusCode = options.optionsSuccessStatus;
+	        res.setHeader('Content-Length', '0');
+	        res.end();
+	      }
+	    } else {
+	      // actual response
+	      headers.push(configureOrigin(options, req));
+	      headers.push(configureCredentials(options));
+	      headers.push(configureExposedHeaders(options));
+	      applyHeaders(headers, res);
+	      next();
+	    }
+	  }
+
+	  function middlewareWrapper(o) {
+	    // if options are static (either via defaults or custom options passed in), wrap in a function
+	    var optionsCallback = null;
+	    if (typeof o === 'function') {
+	      optionsCallback = o;
+	    } else {
+	      optionsCallback = function (req, cb) {
+	        cb(null, o);
+	      };
+	    }
+
+	    return function corsMiddleware(req, res, next) {
+	      optionsCallback(req, function (err, options) {
+	        if (err) {
+	          next(err);
+	        } else {
+	          var corsOptions = assign({}, defaults, options);
+	          var originCallback = null;
+	          if (corsOptions.origin && typeof corsOptions.origin === 'function') {
+	            originCallback = corsOptions.origin;
+	          } else if (corsOptions.origin) {
+	            originCallback = function (origin, cb) {
+	              cb(null, corsOptions.origin);
+	            };
+	          }
+
+	          if (originCallback) {
+	            originCallback(req.headers.origin, function (err2, origin) {
+	              if (err2 || !origin) {
+	                next(err2);
+	              } else {
+	                corsOptions.origin = origin;
+	                cors(corsOptions, req, res, next);
+	              }
+	            });
+	          } else {
+	            next();
+	          }
+	        }
+	      });
+	    };
+	  }
+
+	  // can pass either an options hash, an options delegate, or nothing
+	  lib.exports = middlewareWrapper;
+
+	}());
+	return lib.exports;
+}
+
+var libExports = requireLib();
 var cors = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
 function every (arr, cb) {
@@ -34609,7 +34672,7 @@ function isMatch(arr, obj, idx) {
 	return (obj.val === idx && obj.type === STYPE) || (idx === SEP ? obj.type > PTYPE : obj.type !== STYPE && (idx || '').endsWith(obj.end));
 }
 
-function match$1(str, all) {
+function match(str, all) {
 	var i=0, tmp, segs=split(str), len=segs.length, l;
 	var fn = isMatch.bind(isMatch, segs);
 
@@ -34623,7 +34686,7 @@ function match$1(str, all) {
 	return [];
 }
 
-function parse$2(str) {
+function parse(str) {
 	if (str === SEP) {
 		return [{ old:str, type:STYPE, val:str, end:'' }];
 	}
@@ -34687,7 +34750,7 @@ function parse$2(str) {
 	return out;
 }
 
-function exec$1(str, arr) {
+function exec(str, arr) {
 	var i=0, x, y, segs=split(str), out={};
 	for (; i < arr.length; i++) {
 		x=segs[i]; y=arr[i];
@@ -34701,186 +34764,211 @@ function exec$1(str, arr) {
 
 var matchit = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    exec: exec$1,
-    match: match$1,
-    parse: parse$2
+    exec: exec,
+    match: match,
+    parse: parse
 });
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(matchit);
 
-const { exec, match, parse: parse$1 } = require$$0;
-
-class Trouter {
-	constructor(opts) {
-		this.opts = opts || {};
-		this.routes = {};
-		this.handlers = {};
-
-		this.all = this.add.bind(this, '*');
-		this.get = this.add.bind(this, 'GET');
-		this.head = this.add.bind(this, 'HEAD');
-		this.patch = this.add.bind(this, 'PATCH');
-		this.options = this.add.bind(this, 'OPTIONS');
-    this.connect = this.add.bind(this, 'CONNECT');
-		this.delete = this.add.bind(this, 'DELETE');
-    this.trace = this.add.bind(this, 'TRACE');
-		this.post = this.add.bind(this, 'POST');
-		this.put = this.add.bind(this, 'PUT');
-	}
+var trouter;
+var hasRequiredTrouter;
+
+function requireTrouter () {
+	if (hasRequiredTrouter) return trouter;
+	hasRequiredTrouter = 1;
+	const { exec, match, parse } = require$$0;
+
+	class Trouter {
+		constructor(opts) {
+			this.opts = opts || {};
+			this.routes = {};
+			this.handlers = {};
+
+			this.all = this.add.bind(this, '*');
+			this.get = this.add.bind(this, 'GET');
+			this.head = this.add.bind(this, 'HEAD');
+			this.patch = this.add.bind(this, 'PATCH');
+			this.options = this.add.bind(this, 'OPTIONS');
+	    this.connect = this.add.bind(this, 'CONNECT');
+			this.delete = this.add.bind(this, 'DELETE');
+	    this.trace = this.add.bind(this, 'TRACE');
+			this.post = this.add.bind(this, 'POST');
+			this.put = this.add.bind(this, 'PUT');
+		}
 
-	add(method, pattern, ...fns) {
-		// Save decoded pattern info
-		if (this.routes[method] === void 0) this.routes[method]=[];
-		this.routes[method].push(parse$1(pattern));
-		// Save route handler(s)
-		if (this.handlers[method] === void 0) this.handlers[method]={};
-		this.handlers[method][pattern] = fns;
-		// Allow chainable
-		return this;
-	}
+		add(method, pattern, ...fns) {
+			// Save decoded pattern info
+			if (this.routes[method] === void 0) this.routes[method]=[];
+			this.routes[method].push(parse(pattern));
+			// Save route handler(s)
+			if (this.handlers[method] === void 0) this.handlers[method]={};
+			this.handlers[method][pattern] = fns;
+			// Allow chainable
+			return this;
+		}
 
-	find(method, url) {
-		let arr = match(url, this.routes[method] || []);
-		if (arr.length === 0) {
-			arr = match(url, this.routes[method='*'] || []);
-			if (!arr.length) return false;
+		find(method, url) {
+			let arr = match(url, this.routes[method] || []);
+			if (arr.length === 0) {
+				arr = match(url, this.routes[method='*'] || []);
+				if (!arr.length) return false;
+			}
+			return {
+				params: exec(url, arr),
+				handlers: this.handlers[method][arr[0].old]
+			};
 		}
-		return {
-			params: exec(url, arr),
-			handlers: this.handlers[method][arr[0].old]
-		};
 	}
-}
 
-var trouter = Trouter;
-
-var url = function (req) {
-	let url = req.url;
-	if (url === void 0) return url;
+	trouter = Trouter;
+	return trouter;
+}
 
-	let obj = req._parsedUrl;
-	if (obj && obj._raw === url) return obj;
+var url;
+var hasRequiredUrl;
 
-	obj = {};
-	obj.query = obj.search = null;
-	obj.href = obj.path = obj.pathname = url;
+function requireUrl () {
+	if (hasRequiredUrl) return url;
+	hasRequiredUrl = 1;
+	url = function (req) {
+		let url = req.url;
+		if (url === void 0) return url;
 
-	let idx = url.indexOf('?', 1);
-	if (idx !== -1) {
-		obj.search = url.substring(idx);
-		obj.query = obj.search.substring(1);
-		obj.pathname = url.substring(0, idx);
-	}
+		let obj = req._parsedUrl;
+		if (obj && obj._raw === url) return obj;
 
-	obj._raw = url;
-
-	return (req._parsedUrl = obj);
-};
+		obj = {};
+		obj.query = obj.search = null;
+		obj.href = obj.path = obj.pathname = url;
 
-const http = require$$1$3;
-const Router = trouter;
-const { parse } = require$$8;
-const parser = url;
+		let idx = url.indexOf('?', 1);
+		if (idx !== -1) {
+			obj.search = url.substring(idx);
+			obj.query = obj.search.substring(1);
+			obj.pathname = url.substring(0, idx);
+		}
 
-function lead(x) {
-	return x.charCodeAt(0) === 47 ? x : ('/' + x);
-}
+		obj._raw = url;
 
-function value(x) {
-  let y = x.indexOf('/', 1);
-  return y > 1 ? x.substring(0, y) : x;
+		return (req._parsedUrl = obj);
+	};
+	return url;
 }
 
-function mutate(str, req) {
-	req.url = req.url.substring(str.length) || '/';
-	req.path = req.path.substring(str.length) || '/';
-}
+var polka$1;
+var hasRequiredPolka;
 
-function onError(err, req, res, next) {
-	let code = (res.statusCode = err.code || err.status || 500);
-	res.end(err.length && err || err.message || http.STATUS_CODES[code]);
-}
+function requirePolka () {
+	if (hasRequiredPolka) return polka$1;
+	hasRequiredPolka = 1;
+	const http = require$$1$3;
+	const Router = requireTrouter();
+	const { parse } = require$$8;
+	const parser = requireUrl();
 
-class Polka extends Router {
-	constructor(opts={}) {
-		super(opts);
-		this.apps = {};
-		this.wares = [];
-		this.bwares = {};
-		this.parse = parser;
-		this.server = opts.server;
-		this.handler = this.handler.bind(this);
-		this.onError = opts.onError || onError; // catch-all handler
-		this.onNoMatch = opts.onNoMatch || this.onError.bind(null, { code:404 });
+	function lead(x) {
+		return x.charCodeAt(0) === 47 ? x : ('/' + x);
 	}
 
-	add(method, pattern, ...fns) {
-		let base = lead(value(pattern));
-		if (this.apps[base] !== void 0) throw new Error(`Cannot mount ".${method.toLowerCase()}('${lead(pattern)}')" because a Polka application at ".use('${base}')" already exists! You should move this handler into your Polka application instead.`);
-		return super.add(method, pattern, ...fns);
+	function value(x) {
+	  let y = x.indexOf('/', 1);
+	  return y > 1 ? x.substring(0, y) : x;
 	}
 
-	use(base, ...fns) {
-		if (typeof base === 'function') {
-			this.wares = this.wares.concat(base, fns);
-		} else if (base === '/') {
-			this.wares = this.wares.concat(fns);
-		} else {
-			base = lead(base);
-			fns.forEach(fn => {
-				if (fn instanceof Polka) {
-					this.apps[base] = fn;
-				} else {
-					let arr = this.bwares[base] || [];
-					arr.length > 0 || arr.push((r, _, nxt) => (mutate(base, r),nxt()));
-					this.bwares[base] = arr.concat(fn);
-				}
-			});
-		}
-		return this; // chainable
+	function mutate(str, req) {
+		req.url = req.url.substring(str.length) || '/';
+		req.path = req.path.substring(str.length) || '/';
 	}
 
-	listen() {
-		(this.server = this.server || http.createServer()).on('request', this.handler);
-		this.server.listen.apply(this.server, arguments);
-		return this;
+	function onError(err, req, res, next) {
+		let code = (res.statusCode = err.code || err.status || 500);
+		res.end(err.length && err || err.message || http.STATUS_CODES[code]);
 	}
 
-	handler(req, res, info) {
-		info = info || this.parse(req);
-		let fns=[], arr=this.wares, obj=this.find(req.method, info.pathname);
-		req.originalUrl = req.originalUrl || req.url;
-		let base = value(req.path = info.pathname);
-		if (this.bwares[base] !== void 0) {
-			arr = arr.concat(this.bwares[base]);
+	class Polka extends Router {
+		constructor(opts={}) {
+			super(opts);
+			this.apps = {};
+			this.wares = [];
+			this.bwares = {};
+			this.parse = parser;
+			this.server = opts.server;
+			this.handler = this.handler.bind(this);
+			this.onError = opts.onError || onError; // catch-all handler
+			this.onNoMatch = opts.onNoMatch || this.onError.bind(null, { code:404 });
 		}
-		if (obj) {
-			fns = obj.handlers;
-			req.params = obj.params;
-		} else if (this.apps[base] !== void 0) {
-			mutate(base, req); info.pathname=req.path; //=> updates
-			fns.push(this.apps[base].handler.bind(null, req, res, info));
-		} else if (fns.length === 0) {
-			fns.push(this.onNoMatch);
+
+		add(method, pattern, ...fns) {
+			let base = lead(value(pattern));
+			if (this.apps[base] !== void 0) throw new Error(`Cannot mount ".${method.toLowerCase()}('${lead(pattern)}')" because a Polka application at ".use('${base}')" already exists! You should move this handler into your Polka application instead.`);
+			return super.add(method, pattern, ...fns);
+		}
+
+		use(base, ...fns) {
+			if (typeof base === 'function') {
+				this.wares = this.wares.concat(base, fns);
+			} else if (base === '/') {
+				this.wares = this.wares.concat(fns);
+			} else {
+				base = lead(base);
+				fns.forEach(fn => {
+					if (fn instanceof Polka) {
+						this.apps[base] = fn;
+					} else {
+						let arr = this.bwares[base] || [];
+						arr.length > 0 || arr.push((r, _, nxt) => (mutate(base, r),nxt()));
+						this.bwares[base] = arr.concat(fn);
+					}
+				});
+			}
+			return this; // chainable
+		}
+
+		listen() {
+			(this.server = this.server || http.createServer()).on('request', this.handler);
+			this.server.listen.apply(this.server, arguments);
+			return this;
+		}
+
+		handler(req, res, info) {
+			info = info || this.parse(req);
+			let fns=[], arr=this.wares, obj=this.find(req.method, info.pathname);
+			req.originalUrl = req.originalUrl || req.url;
+			let base = value(req.path = info.pathname);
+			if (this.bwares[base] !== void 0) {
+				arr = arr.concat(this.bwares[base]);
+			}
+			if (obj) {
+				fns = obj.handlers;
+				req.params = obj.params;
+			} else if (this.apps[base] !== void 0) {
+				mutate(base, req); info.pathname=req.path; //=> updates
+				fns.push(this.apps[base].handler.bind(null, req, res, info));
+			} else if (fns.length === 0) {
+				fns.push(this.onNoMatch);
+			}
+			// Grab addl values from `info`
+			req.search = info.search;
+			req.query = parse(info.query);
+			// Exit if only a single function
+			let i=0, len=arr.length, num=fns.length;
+			if (len === i && num === 1) return fns[0](req, res);
+			// Otherwise loop thru all middlware
+			let next = err => err ? this.onError(err, req, res, next) : loop();
+			let loop = _ => res.finished || (i < len) && arr[i++](req, res, next);
+			arr = arr.concat(fns);
+			len += num;
+			loop(); // init
 		}
-		// Grab addl values from `info`
-		req.search = info.search;
-		req.query = parse(info.query);
-		// Exit if only a single function
-		let i=0, len=arr.length, num=fns.length;
-		if (len === i && num === 1) return fns[0](req, res);
-		// Otherwise loop thru all middlware
-		let next = err => err ? this.onError(err, req, res, next) : loop();
-		let loop = _ => res.finished || (i < len) && arr[i++](req, res, next);
-		arr = arr.concat(fns);
-		len += num;
-		loop(); // init
 	}
-}
 
-var polka = opts => new Polka(opts);
+	polka$1 = opts => new Polka(opts);
+	return polka$1;
+}
 
-var polka$1 = /*@__PURE__*/getDefaultExportFromCjs(polka);
+var polkaExports = requirePolka();
+var polka = /*@__PURE__*/getDefaultExportFromCjs(polkaExports);
 
 /**
  * Abstract class representing a ProviderClass.
@@ -35066,7 +35154,7 @@ class ProviderClass extends EventEmitterClass {
      * @returns {Polka} Polka instance.
      */
     buildHTTPServer() {
-        return polka$1()
+        return polka()
             .use(cors())
             .use(bodyParserExports.urlencoded({ extended: true }))
             .use(bodyParserExports.json());