@wix/dev-machine-monitor 1.0.5 → 1.0.6

package/build/run.cjs

@@ -3459,342 +3459,6 @@ var require_commander = __commonJS({
   }
 });
 
-// node_modules/http-proxy-3/dist/lib/http-proxy/common.js
-var require_common = __commonJS({
-  "node_modules/http-proxy-3/dist/lib/http-proxy/common.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.isSSL = void 0;
-    exports2.setupOutgoing = setupOutgoing;
-    exports2.setupSocket = setupSocket;
-    exports2.getPort = getPort;
-    exports2.hasEncryptedConnection = hasEncryptedConnection;
-    exports2.urlJoin = urlJoin;
-    exports2.rewriteCookieProperty = rewriteCookieProperty;
-    exports2.toURL = toURL;
-    var node_tls_1 = require("node:tls");
-    var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
-    exports2.isSSL = /^https|wss/;
-    var HEADER_BLACKLIST = "trailer";
-    var HTTP2_HEADER_BLACKLIST = [
-      ":method",
-      ":path",
-      ":scheme",
-      ":authority"
-    ];
-    function setupOutgoing(outgoing, options, req, forward) {
-      const target = options[forward || "target"];
-      outgoing.port = +(target.port ?? (target.protocol !== void 0 && exports2.isSSL.test(target.protocol) ? 443 : 80));
-      for (const e of [
-        "host",
-        "hostname",
-        "socketPath",
-        "pfx",
-        "key",
-        "passphrase",
-        "cert",
-        "ca",
-        "ciphers",
-        "secureProtocol"
-      ]) {
-        outgoing[e] = target[e];
-      }
-      outgoing.method = options.method || req.method;
-      outgoing.headers = { ...req.headers };
-      if (options.headers) {
-        outgoing.headers = { ...outgoing.headers, ...options.headers };
-      }
-      for (const header in outgoing.headers) {
-        if (HEADER_BLACKLIST == header.toLowerCase()) {
-          delete outgoing.headers[header];
-          break;
-        }
-      }
-      if (req.httpVersionMajor > 1) {
-        for (const header of HTTP2_HEADER_BLACKLIST) {
-          delete outgoing.headers[header];
-        }
-      }
-      if (options.auth) {
-        delete outgoing.headers.authorization;
-        outgoing.auth = options.auth;
-      }
-      if (options.ca) {
-        outgoing.ca = options.ca;
-      }
-      if (target.protocol !== void 0 && exports2.isSSL.test(target.protocol)) {
-        outgoing.rejectUnauthorized = typeof options.secure === "undefined" ? true : options.secure;
-      }
-      outgoing.agent = options.agent || false;
-      outgoing.localAddress = options.localAddress;
-      if (!outgoing.agent) {
-        outgoing.headers = outgoing.headers || {};
-        if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) {
-          outgoing.headers.connection = "close";
-        }
-      }
-      const targetPath = target && options.prependPath !== false && "pathname" in target ? getPath(`${target.pathname}${target.search ?? ""}`) : "/";
-      let outgoingPath = options.toProxy ? req.url : getPath(req.url);
-      outgoingPath = !options.ignorePath ? outgoingPath : "";
-      outgoing.path = urlJoin(targetPath, outgoingPath ?? "");
-      if (options.changeOrigin) {
-        outgoing.headers.host = target.protocol !== void 0 && required(outgoing.port, target.protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host;
-      }
-      return outgoing;
-    }
-    function setupSocket(socket) {
-      socket.setTimeout(0);
-      socket.setNoDelay(true);
-      socket.setKeepAlive(true, 0);
-      return socket;
-    }
-    function getPort(req) {
-      const res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
-      return res ? res[1] : hasEncryptedConnection(req) ? "443" : "80";
-    }
-    function hasEncryptedConnection(req) {
-      const conn = req.connection;
-      return conn instanceof node_tls_1.TLSSocket && conn.encrypted || Boolean(conn.pair);
-    }
-    function urlJoin(...args) {
-      const queryParams = [];
-      let queryParamRaw = "";
-      args.forEach((url, index) => {
-        const qpStart = url.indexOf("?");
-        if (qpStart !== -1) {
-          queryParams.push(url.substring(qpStart + 1));
-          args[index] = url.substring(0, qpStart);
-        }
-      });
-      queryParamRaw = queryParams.filter(Boolean).join("&");
-      let retSegs = "";
-      for (const seg of args) {
-        if (!seg) {
-          continue;
-        }
-        if (retSegs.endsWith("/")) {
-          if (seg.startsWith("/")) {
-            retSegs += seg.slice(1);
-          } else {
-            retSegs += seg;
-          }
-        } else {
-          if (seg.startsWith("/")) {
-            retSegs += seg;
-          } else {
-            retSegs += "/" + seg;
-          }
-        }
-      }
-      return queryParamRaw ? retSegs + "?" + queryParamRaw : retSegs;
-    }
-    function rewriteCookieProperty(header, config, property) {
-      if (Array.isArray(header)) {
-        return header.map((headerElement) => {
-          return rewriteCookieProperty(headerElement, config, property);
-        });
-      }
-      return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), (match, prefix, previousValue) => {
-        let newValue;
-        if (previousValue in config) {
-          newValue = config[previousValue];
-        } else if ("*" in config) {
-          newValue = config["*"];
-        } else {
-          return match;
-        }
-        if (newValue) {
-          return prefix + newValue;
-        } else {
-          return "";
-        }
-      });
-    }
-    function hasPort(host) {
-      return !!~host.indexOf(":");
-    }
-    function getPath(url) {
-      if (url === "" || url?.startsWith("?")) {
-        return url;
-      }
-      const u2 = toURL(url);
-      return `${u2.pathname ?? ""}${u2.search ?? ""}`;
-    }
-    function toURL(url) {
-      if (url instanceof URL) {
-        return url;
-      } else if (typeof url === "object" && "href" in url && typeof url.href === "string") {
-        url = url.href;
-      }
-      if (!url) {
-        url = "";
-      }
-      if (typeof url != "string") {
-        url = `${url}`;
-      }
-      if (url.startsWith("//")) {
-        url = `http://base.invalid${url}`;
-      }
-      return new URL(url, "http://base.invalid");
-    }
-    function required(port, protocol) {
-      protocol = protocol.split(":")[0];
-      port = +port;
-      if (!port)
-        return false;
-      switch (protocol) {
-        case "http":
-        case "ws":
-          return port !== 80;
-        case "https":
-        case "wss":
-          return port !== 443;
-      }
-      return port !== 0;
-    }
-  }
-});
-
-// node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js
-var require_web_outgoing = __commonJS({
-  "node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o2, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o2, k2, desc);
-    }) : (function(o2, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o2[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o2, v) {
-      Object.defineProperty(o2, "default", { enumerable: true, value: v });
-    }) : function(o2, v) {
-      o2["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o2) {
-        ownKeys = Object.getOwnPropertyNames || function(o3) {
-          var ar = [];
-          for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o2);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.OUTGOING_PASSES = void 0;
-    exports2.removeChunked = removeChunked;
-    exports2.setConnection = setConnection;
-    exports2.setRedirectHostRewrite = setRedirectHostRewrite;
-    exports2.writeHeaders = writeHeaders;
-    exports2.writeStatusCode = writeStatusCode;
-    var common2 = __importStar(require_common());
-    var redirectRegex = /^201|30(1|2|7|8)$/;
-    function removeChunked(_req, _res, proxyRes) {
-      delete proxyRes.headers["transfer-encoding"];
-    }
-    function setConnection(req, _res, proxyRes) {
-      if (req.httpVersion === "1.0") {
-        proxyRes.headers["connection"] = req.headers["connection"] || "close";
-      } else if (req.httpVersion !== "2.0" && !proxyRes.headers["connection"]) {
-        proxyRes.headers["connection"] = req.headers["connection"] || "keep-alive";
-      }
-    }
-    function setRedirectHostRewrite(req, _res, proxyRes, options) {
-      if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers["location"] && redirectRegex.test(`${proxyRes.statusCode}`)) {
-        const target = common2.toURL(options.target);
-        const location = proxyRes.headers["location"];
-        if (typeof location != "string") {
-          return;
-        }
-        const u2 = common2.toURL(location);
-        if (target.host != u2.host) {
-          return;
-        }
-        if (options.hostRewrite) {
-          u2.host = options.hostRewrite;
-        } else if (options.autoRewrite) {
-          u2.host = req.headers["host"] ?? "";
-        }
-        if (options.protocolRewrite) {
-          u2.protocol = options.protocolRewrite;
-        }
-        proxyRes.headers["location"] = u2.toString();
-      }
-    }
-    function writeHeaders(_req, res, proxyRes, options) {
-      const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? (
-        // also test for ''
-        { "*": options.cookieDomainRewrite }
-      ) : options.cookieDomainRewrite;
-      const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? (
-        // also test for ''
-        { "*": options.cookiePathRewrite }
-      ) : options.cookiePathRewrite;
-      const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
-      const setHeader = (key, header) => {
-        if (header == void 0) {
-          return;
-        }
-        if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") {
-          header = common2.rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
-        }
-        if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") {
-          header = common2.rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
-        }
-        res.setHeader(String(key).trim(), header);
-      };
-      let rawHeaderKeyMap;
-      if (preserveHeaderKeyCase && proxyRes.rawHeaders != void 0) {
-        rawHeaderKeyMap = {};
-        for (let i2 = 0; i2 < proxyRes.rawHeaders.length; i2 += 2) {
-          const key = proxyRes.rawHeaders[i2];
-          rawHeaderKeyMap[key.toLowerCase()] = key;
-        }
-      }
-      for (const key0 in proxyRes.headers) {
-        let key = key0;
-        if (_req.httpVersionMajor > 1 && key === "connection") {
-          continue;
-        }
-        const header = proxyRes.headers[key];
-        if (preserveHeaderKeyCase && rawHeaderKeyMap) {
-          key = rawHeaderKeyMap[key] ?? key;
-        }
-        setHeader(key, header);
-      }
-    }
-    function writeStatusCode(_req, res, proxyRes) {
-      res.statusCode = proxyRes.statusCode;
-      if (proxyRes.statusMessage && _req.httpVersionMajor === 1) {
-        res.statusMessage = proxyRes.statusMessage;
-      }
-    }
-    exports2.OUTGOING_PASSES = {
-      removeChunked,
-      setConnection,
-      setRedirectHostRewrite,
-      writeHeaders,
-      writeStatusCode
-    };
-  }
-});
-
 // node_modules/ms/index.js
 var require_ms = __commonJS({
   "node_modules/ms/index.js"(exports2, module2) {
@@ -3913,7 +3577,7 @@ var require_ms = __commonJS({
 });
 
 // node_modules/debug/src/common.js
-var require_common2 = __commonJS({
+var require_common = __commonJS({
   "node_modules/debug/src/common.js"(exports2, module2) {
     "use strict";
     function setup(env2) {
@@ -4249,7 +3913,7 @@ var require_browser = __commonJS({
       } catch (error) {
       }
     }
-    module2.exports = require_common2()(exports2);
+    module2.exports = require_common()(exports2);
     var { formatters } = module2.exports;
     formatters.j = function(v) {
       try {
@@ -4423,7 +4087,7 @@ var require_node = __commonJS({
         debug.inspectOpts[keys[i2]] = exports2.inspectOpts[keys[i2]];
       }
     }
-    module2.exports = require_common2()(exports2);
+    module2.exports = require_common()(exports2);
     var { formatters } = module2.exports;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
@@ -4615,354 +4279,698 @@ var require_follow_redirects = __commonJS({
           self._ended = true;
           currentRequest.end(null, null, callback);
         });
-        this._ending = true;
+        this._ending = true;
+      }
+    };
+    RedirectableRequest.prototype.setHeader = function(name, value) {
+      this._options.headers[name] = value;
+      this._currentRequest.setHeader(name, value);
+    };
+    RedirectableRequest.prototype.removeHeader = function(name) {
+      delete this._options.headers[name];
+      this._currentRequest.removeHeader(name);
+    };
+    RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+      var self = this;
+      function destroyOnTimeout(socket) {
+        socket.setTimeout(msecs);
+        socket.removeListener("timeout", socket.destroy);
+        socket.addListener("timeout", socket.destroy);
+      }
+      function startTimer(socket) {
+        if (self._timeout) {
+          clearTimeout(self._timeout);
+        }
+        self._timeout = setTimeout(function() {
+          self.emit("timeout");
+          clearTimer();
+        }, msecs);
+        destroyOnTimeout(socket);
+      }
+      function clearTimer() {
+        if (self._timeout) {
+          clearTimeout(self._timeout);
+          self._timeout = null;
+        }
+        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);
+        }
+      }
+      if (callback) {
+        this.on("timeout", callback);
+      }
+      if (this.socket) {
+        startTimer(this.socket);
+      } else {
+        this._currentRequest.once("socket", startTimer);
+      }
+      this.on("socket", destroyOnTimeout);
+      this.on("abort", clearTimer);
+      this.on("error", clearTimer);
+      this.on("response", clearTimer);
+      this.on("close", clearTimer);
+      return this;
+    };
+    [
+      "flushHeaders",
+      "getHeader",
+      "setNoDelay",
+      "setSocketKeepAlive"
+    ].forEach(function(method) {
+      RedirectableRequest.prototype[method] = function(a2, b) {
+        return this._currentRequest[method](a2, b);
+      };
+    });
+    ["aborted", "connection", "socket"].forEach(function(property) {
+      Object.defineProperty(RedirectableRequest.prototype, property, {
+        get: function() {
+          return this._currentRequest[property];
+        }
+      });
+    });
+    RedirectableRequest.prototype._sanitizeOptions = function(options) {
+      if (!options.headers) {
+        options.headers = {};
+      }
+      if (options.host) {
+        if (!options.hostname) {
+          options.hostname = options.host;
+        }
+        delete options.host;
+      }
+      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);
+        }
+      }
+    };
+    RedirectableRequest.prototype._performRequest = function() {
+      var protocol = this._options.protocol;
+      var nativeProtocol = this._options.nativeProtocols[protocol];
+      if (!nativeProtocol) {
+        throw new TypeError("Unsupported protocol " + protocol);
+      }
+      if (this._options.agents) {
+        var scheme = protocol.slice(0, -1);
+        this._options.agent = this._options.agents[scheme];
+      }
+      var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+      request._redirectable = this;
+      for (var event of events) {
+        request.on(event, eventHandlers[event]);
+      }
+      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
+      );
+      if (this._isRedirect) {
+        var i2 = 0;
+        var self = this;
+        var buffers = this._requestBodyBuffers;
+        (function writeNext(error) {
+          if (request === self._currentRequest) {
+            if (error) {
+              self.emit("error", error);
+            } else if (i2 < buffers.length) {
+              var buffer = buffers[i2++];
+              if (!request.finished) {
+                request.write(buffer.data, buffer.encoding, writeNext);
+              }
+            } else if (self._ended) {
+              request.end();
+            }
+          }
+        })();
+      }
+    };
+    RedirectableRequest.prototype._processResponse = function(response) {
+      var statusCode = response.statusCode;
+      if (this._options.trackRedirects) {
+        this._redirects.push({
+          url: this._currentUrl,
+          headers: response.headers,
+          statusCode
+        });
+      }
+      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);
+        this._requestBodyBuffers = [];
+        return;
+      }
+      destroyRequest(this._currentRequest);
+      response.destroy();
+      if (++this._redirectCount > this._options.maxRedirects) {
+        throw new TooManyRedirectsError();
+      }
+      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);
+      }
+      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";
+        this._requestBodyBuffers = [];
+        removeMatchingHeaders(/^content-/i, this._options.headers);
+      }
+      var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+      var currentUrlParts = parseUrl(this._currentUrl);
+      var currentHost = currentHostHeader || currentUrlParts.host;
+      var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url.format(Object.assign(currentUrlParts, { host: currentHost }));
+      var redirectUrl = resolveUrl(location, currentUrl);
+      debug("redirecting to", redirectUrl.href);
+      this._isRedirect = true;
+      spreadUrlObject(redirectUrl, this._options);
+      if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
+        removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+      }
+      if (isFunction(beforeRedirect)) {
+        var responseDetails = {
+          headers: response.headers,
+          statusCode
+        };
+        var requestDetails = {
+          url: currentUrl,
+          method,
+          headers: requestHeaders
+        };
+        beforeRedirect(this._options, responseDetails, requestDetails);
+        this._sanitizeOptions(this._options);
+      }
+      this._performRequest();
+    };
+    function wrap(protocols) {
+      var exports3 = {
+        maxRedirects: 21,
+        maxBodyLength: 10 * 1024 * 1024
+      };
+      var nativeProtocols = {};
+      Object.keys(protocols).forEach(function(scheme) {
+        var protocol = scheme + ":";
+        var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+        var wrappedProtocol = exports3[scheme] = Object.create(nativeProtocol);
+        function request(input, options, callback) {
+          if (isURL(input)) {
+            input = spreadUrlObject(input);
+          } else if (isString(input)) {
+            input = spreadUrlObject(parseUrl(input));
+          } else {
+            callback = options;
+            options = validateUrl(input);
+            input = { protocol };
+          }
+          if (isFunction(options)) {
+            callback = options;
+            options = null;
+          }
+          options = Object.assign({
+            maxRedirects: exports3.maxRedirects,
+            maxBodyLength: exports3.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);
+        }
+        function get(input, options, callback) {
+          var wrappedRequest = wrappedProtocol.request(input, options, callback);
+          wrappedRequest.end();
+          return wrappedRequest;
+        }
+        Object.defineProperties(wrappedProtocol, {
+          request: { value: request, configurable: true, enumerable: true, writable: true },
+          get: { value: get, configurable: true, enumerable: true, writable: true }
+        });
+      });
+      return exports3;
+    }
+    function noop3() {
+    }
+    function parseUrl(input) {
+      var parsed;
+      if (useNativeURL) {
+        parsed = new URL2(input);
+      } else {
+        parsed = validateUrl(url.parse(input));
+        if (!isString(parsed.protocol)) {
+          throw new InvalidUrlError({ input });
+        }
       }
-    };
-    RedirectableRequest.prototype.setHeader = function(name, value) {
-      this._options.headers[name] = value;
-      this._currentRequest.setHeader(name, value);
-    };
-    RedirectableRequest.prototype.removeHeader = function(name) {
-      delete this._options.headers[name];
-      this._currentRequest.removeHeader(name);
-    };
-    RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
-      var self = this;
-      function destroyOnTimeout(socket) {
-        socket.setTimeout(msecs);
-        socket.removeListener("timeout", socket.destroy);
-        socket.addListener("timeout", socket.destroy);
+      return parsed;
+    }
+    function resolveUrl(relative, base) {
+      return useNativeURL ? new URL2(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 });
       }
-      function startTimer(socket) {
-        if (self._timeout) {
-          clearTimeout(self._timeout);
-        }
-        self._timeout = setTimeout(function() {
-          self.emit("timeout");
-          clearTimer();
-        }, msecs);
-        destroyOnTimeout(socket);
+      if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+        throw new InvalidUrlError({ input: input.href || input });
       }
-      function clearTimer() {
-        if (self._timeout) {
-          clearTimeout(self._timeout);
-          self._timeout = null;
-        }
-        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);
-        }
+      return input;
+    }
+    function spreadUrlObject(urlObject, target) {
+      var spread = target || {};
+      for (var key of preservedUrlFields) {
+        spread[key] = urlObject[key];
       }
-      if (callback) {
-        this.on("timeout", callback);
+      if (spread.hostname.startsWith("[")) {
+        spread.hostname = spread.hostname.slice(1, -1);
       }
-      if (this.socket) {
-        startTimer(this.socket);
-      } else {
-        this._currentRequest.once("socket", startTimer);
+      if (spread.port !== "") {
+        spread.port = Number(spread.port);
       }
-      this.on("socket", destroyOnTimeout);
-      this.on("abort", clearTimer);
-      this.on("error", clearTimer);
-      this.on("response", clearTimer);
-      this.on("close", clearTimer);
-      return this;
-    };
-    [
-      "flushHeaders",
-      "getHeader",
-      "setNoDelay",
-      "setSocketKeepAlive"
-    ].forEach(function(method) {
-      RedirectableRequest.prototype[method] = function(a2, b) {
-        return this._currentRequest[method](a2, b);
-      };
-    });
-    ["aborted", "connection", "socket"].forEach(function(property) {
-      Object.defineProperty(RedirectableRequest.prototype, property, {
-        get: function() {
-          return this._currentRequest[property];
+      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];
         }
-      });
-    });
-    RedirectableRequest.prototype._sanitizeOptions = function(options) {
-      if (!options.headers) {
-        options.headers = {};
       }
-      if (options.host) {
-        if (!options.hostname) {
-          options.hostname = options.host;
+      return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
+    }
+    function createErrorType(code, message, baseClass) {
+      function CustomError(properties) {
+        if (isFunction(Error.captureStackTrace)) {
+          Error.captureStackTrace(this, this.constructor);
         }
-        delete options.host;
+        Object.assign(this, properties || {});
+        this.code = code;
+        this.message = this.cause ? message + ": " + this.cause.message : message;
       }
-      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);
+      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]);
       }
-    };
-    RedirectableRequest.prototype._performRequest = function() {
-      var protocol = this._options.protocol;
-      var nativeProtocol = this._options.nativeProtocols[protocol];
-      if (!nativeProtocol) {
-        throw new TypeError("Unsupported protocol " + protocol);
-      }
-      if (this._options.agents) {
-        var scheme = protocol.slice(0, -1);
-        this._options.agent = this._options.agents[scheme];
+      request.on("error", noop3);
+      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 URL2 && value instanceof URL2;
+    }
+    module2.exports = wrap({ http: http2, https });
+    module2.exports.wrap = wrap;
+  }
+});
+
+// node_modules/http-proxy-3/dist/lib/http-proxy/common.js
+var require_common2 = __commonJS({
+  "node_modules/http-proxy-3/dist/lib/http-proxy/common.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isSSL = void 0;
+    exports2.setupOutgoing = setupOutgoing;
+    exports2.setupSocket = setupSocket;
+    exports2.getPort = getPort;
+    exports2.hasEncryptedConnection = hasEncryptedConnection;
+    exports2.urlJoin = urlJoin;
+    exports2.rewriteCookieProperty = rewriteCookieProperty;
+    exports2.toURL = toURL;
+    var node_tls_1 = require("node:tls");
+    var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+    exports2.isSSL = /^https|wss/;
+    var HEADER_BLACKLIST = "trailer";
+    var HTTP2_HEADER_BLACKLIST = [
+      ":method",
+      ":path",
+      ":scheme",
+      ":authority",
+      "connection",
+      "keep-alive"
+    ];
+    function setupOutgoing(outgoing, options, req, forward) {
+      const target = options[forward || "target"];
+      outgoing.port = +(target.port ?? (target.protocol !== void 0 && exports2.isSSL.test(target.protocol) ? 443 : 80));
+      for (const e of [
+        "host",
+        "hostname",
+        "socketPath",
+        "pfx",
+        "key",
+        "passphrase",
+        "cert",
+        "ca",
+        "ciphers",
+        "secureProtocol"
+      ]) {
+        outgoing[e] = target[e];
       }
-      var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
-      request._redirectable = this;
-      for (var event of events) {
-        request.on(event, eventHandlers[event]);
+      outgoing.method = options.method || req.method;
+      outgoing.headers = { ...req.headers };
+      if (options.headers) {
+        outgoing.headers = { ...outgoing.headers, ...options.headers };
       }
-      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
-      );
-      if (this._isRedirect) {
-        var i2 = 0;
-        var self = this;
-        var buffers = this._requestBodyBuffers;
-        (function writeNext(error) {
-          if (request === self._currentRequest) {
-            if (error) {
-              self.emit("error", error);
-            } else if (i2 < buffers.length) {
-              var buffer = buffers[i2++];
-              if (!request.finished) {
-                request.write(buffer.data, buffer.encoding, writeNext);
-              }
-            } else if (self._ended) {
-              request.end();
-            }
-          }
-        })();
+      for (const header in outgoing.headers) {
+        if (HEADER_BLACKLIST == header.toLowerCase()) {
+          delete outgoing.headers[header];
+          break;
+        }
       }
-    };
-    RedirectableRequest.prototype._processResponse = function(response) {
-      var statusCode = response.statusCode;
-      if (this._options.trackRedirects) {
-        this._redirects.push({
-          url: this._currentUrl,
-          headers: response.headers,
-          statusCode
-        });
+      if (req.httpVersionMajor > 1) {
+        for (const header of HTTP2_HEADER_BLACKLIST) {
+          delete outgoing.headers[header];
+        }
       }
-      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);
-        this._requestBodyBuffers = [];
-        return;
+      if (options.auth) {
+        delete outgoing.headers.authorization;
+        outgoing.auth = options.auth;
       }
-      destroyRequest(this._currentRequest);
-      response.destroy();
-      if (++this._redirectCount > this._options.maxRedirects) {
-        throw new TooManyRedirectsError();
+      if (options.ca) {
+        outgoing.ca = options.ca;
       }
-      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);
+      if (target.protocol !== void 0 && exports2.isSSL.test(target.protocol)) {
+        outgoing.rejectUnauthorized = typeof options.secure === "undefined" ? true : options.secure;
       }
-      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";
-        this._requestBodyBuffers = [];
-        removeMatchingHeaders(/^content-/i, this._options.headers);
+      outgoing.agent = options.agent || false;
+      outgoing.localAddress = options.localAddress;
+      if (!outgoing.agent) {
+        outgoing.headers = outgoing.headers || {};
+        if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) {
+          outgoing.headers.connection = "close";
+        }
       }
-      var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
-      var currentUrlParts = parseUrl(this._currentUrl);
-      var currentHost = currentHostHeader || currentUrlParts.host;
-      var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url.format(Object.assign(currentUrlParts, { host: currentHost }));
-      var redirectUrl = resolveUrl(location, currentUrl);
-      debug("redirecting to", redirectUrl.href);
-      this._isRedirect = true;
-      spreadUrlObject(redirectUrl, this._options);
-      if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
-        removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+      const targetPath = target && options.prependPath !== false && "pathname" in target ? getPath(`${target.pathname}${target.search ?? ""}`) : "/";
+      let outgoingPath = options.toProxy ? req.url : getPath(req.url);
+      outgoingPath = !options.ignorePath ? outgoingPath : "";
+      outgoing.path = urlJoin(targetPath, outgoingPath ?? "");
+      if (options.changeOrigin) {
+        outgoing.headers.host = target.protocol !== void 0 && required(outgoing.port, target.protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host;
       }
-      if (isFunction(beforeRedirect)) {
-        var responseDetails = {
-          headers: response.headers,
-          statusCode
-        };
-        var requestDetails = {
-          url: currentUrl,
-          method,
-          headers: requestHeaders
-        };
-        beforeRedirect(this._options, responseDetails, requestDetails);
-        this._sanitizeOptions(this._options);
+      outgoing.url = "href" in target && target.href || (target.protocol === "https" ? "https" : "http") + "://" + outgoing.host + (outgoing.port ? ":" + outgoing.port : "");
+      if (req.httpVersionMajor > 1) {
+        for (const header of HTTP2_HEADER_BLACKLIST) {
+          delete outgoing.headers[header];
+        }
       }
-      this._performRequest();
-    };
-    function wrap(protocols) {
-      var exports3 = {
-        maxRedirects: 21,
-        maxBodyLength: 10 * 1024 * 1024
-      };
-      var nativeProtocols = {};
-      Object.keys(protocols).forEach(function(scheme) {
-        var protocol = scheme + ":";
-        var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
-        var wrappedProtocol = exports3[scheme] = Object.create(nativeProtocol);
-        function request(input, options, callback) {
-          if (isURL(input)) {
-            input = spreadUrlObject(input);
-          } else if (isString(input)) {
-            input = spreadUrlObject(parseUrl(input));
+      return outgoing;
+    }
+    function setupSocket(socket) {
+      socket.setTimeout(0);
+      socket.setNoDelay(true);
+      socket.setKeepAlive(true, 0);
+      return socket;
+    }
+    function getPort(req) {
+      const res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
+      return res ? res[1] : hasEncryptedConnection(req) ? "443" : "80";
+    }
+    function hasEncryptedConnection(req) {
+      const conn = req.connection;
+      return conn instanceof node_tls_1.TLSSocket && conn.encrypted || Boolean(conn.pair);
+    }
+    function urlJoin(...args) {
+      const queryParams = [];
+      let queryParamRaw = "";
+      args.forEach((url, index) => {
+        const qpStart = url.indexOf("?");
+        if (qpStart !== -1) {
+          queryParams.push(url.substring(qpStart + 1));
+          args[index] = url.substring(0, qpStart);
+        }
+      });
+      queryParamRaw = queryParams.filter(Boolean).join("&");
+      let retSegs = "";
+      for (const seg of args) {
+        if (!seg) {
+          continue;
+        }
+        if (retSegs.endsWith("/")) {
+          if (seg.startsWith("/")) {
+            retSegs += seg.slice(1);
           } else {
-            callback = options;
-            options = validateUrl(input);
-            input = { protocol };
-          }
-          if (isFunction(options)) {
-            callback = options;
-            options = null;
+            retSegs += seg;
           }
-          options = Object.assign({
-            maxRedirects: exports3.maxRedirects,
-            maxBodyLength: exports3.maxBodyLength
-          }, input, options);
-          options.nativeProtocols = nativeProtocols;
-          if (!isString(options.host) && !isString(options.hostname)) {
-            options.hostname = "::1";
+        } else {
+          if (seg.startsWith("/")) {
+            retSegs += seg;
+          } else {
+            retSegs += "/" + seg;
           }
-          assert.equal(options.protocol, protocol, "protocol mismatch");
-          debug("options", options);
-          return new RedirectableRequest(options, callback);
-        }
-        function get(input, options, callback) {
-          var wrappedRequest = wrappedProtocol.request(input, options, callback);
-          wrappedRequest.end();
-          return wrappedRequest;
         }
-        Object.defineProperties(wrappedProtocol, {
-          request: { value: request, configurable: true, enumerable: true, writable: true },
-          get: { value: get, configurable: true, enumerable: true, writable: true }
+      }
+      return queryParamRaw ? retSegs + "?" + queryParamRaw : retSegs;
+    }
+    function rewriteCookieProperty(header, config, property) {
+      if (Array.isArray(header)) {
+        return header.map((headerElement) => {
+          return rewriteCookieProperty(headerElement, config, property);
         });
+      }
+      return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", "i"), (match, prefix, previousValue) => {
+        let newValue;
+        if (previousValue in config) {
+          newValue = config[previousValue];
+        } else if ("*" in config) {
+          newValue = config["*"];
+        } else {
+          return match;
+        }
+        if (newValue) {
+          return prefix + newValue;
+        } else {
+          return "";
+        }
       });
-      return exports3;
     }
-    function noop3() {
+    function hasPort(host) {
+      return !!~host.indexOf(":");
     }
-    function parseUrl(input) {
-      var parsed;
-      if (useNativeURL) {
-        parsed = new URL2(input);
-      } else {
-        parsed = validateUrl(url.parse(input));
-        if (!isString(parsed.protocol)) {
-          throw new InvalidUrlError({ input });
-        }
+    function getPath(url) {
+      if (url === "" || url?.startsWith("?")) {
+        return url;
       }
-      return parsed;
+      const u2 = toURL(url);
+      return `${u2.pathname ?? ""}${u2.search ?? ""}`;
     }
-    function resolveUrl(relative, base) {
-      return useNativeURL ? new URL2(relative, base) : parseUrl(url.resolve(base, relative));
+    function toURL(url) {
+      if (url instanceof URL) {
+        return url;
+      } else if (typeof url === "object" && "href" in url && typeof url.href === "string") {
+        url = url.href;
+      }
+      if (!url) {
+        url = "";
+      }
+      if (typeof url != "string") {
+        url = `${url}`;
+      }
+      if (url.startsWith("//")) {
+        url = `http://base.invalid${url}`;
+      }
+      return new URL(url, "http://base.invalid");
     }
-    function validateUrl(input) {
-      if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
-        throw new InvalidUrlError({ input: input.href || input });
+    function required(port, protocol) {
+      protocol = protocol.split(":")[0];
+      port = +port;
+      if (!port)
+        return false;
+      switch (protocol) {
+        case "http":
+        case "ws":
+          return port !== 80;
+        case "https":
+        case "wss":
+          return port !== 443;
       }
-      if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
-        throw new InvalidUrlError({ input: input.href || input });
+      return port !== 0;
+    }
+  }
+});
+
+// node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js
+var require_web_outgoing = __commonJS({
+  "node_modules/http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o2, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
       }
-      return input;
+      Object.defineProperty(o2, k2, desc);
+    }) : (function(o2, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o2[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o2, v) {
+      Object.defineProperty(o2, "default", { enumerable: true, value: v });
+    }) : function(o2, v) {
+      o2["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o2) {
+        ownKeys = Object.getOwnPropertyNames || function(o3) {
+          var ar = [];
+          for (var k in o3) if (Object.prototype.hasOwnProperty.call(o3, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o2);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++) if (k[i2] !== "default") __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OUTGOING_PASSES = void 0;
+    exports2.removeChunked = removeChunked;
+    exports2.setConnection = setConnection;
+    exports2.setRedirectHostRewrite = setRedirectHostRewrite;
+    exports2.writeHeaders = writeHeaders;
+    exports2.writeStatusCode = writeStatusCode;
+    var common2 = __importStar(require_common2());
+    var redirectRegex = /^201|30(1|2|7|8)$/;
+    function removeChunked(_req, _res, proxyRes) {
+      delete proxyRes.headers["transfer-encoding"];
     }
-    function spreadUrlObject(urlObject, target) {
-      var spread = target || {};
-      for (var key of preservedUrlFields) {
-        spread[key] = urlObject[key];
-      }
-      if (spread.hostname.startsWith("[")) {
-        spread.hostname = spread.hostname.slice(1, -1);
-      }
-      if (spread.port !== "") {
-        spread.port = Number(spread.port);
+    function setConnection(req, _res, proxyRes) {
+      if (req.httpVersion === "1.0") {
+        proxyRes.headers["connection"] = req.headers["connection"] || "close";
+      } else if (req.httpVersion !== "2.0" && !proxyRes.headers["connection"]) {
+        proxyRes.headers["connection"] = req.headers["connection"] || "keep-alive";
       }
-      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];
+    function setRedirectHostRewrite(req, _res, proxyRes, options) {
+      if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers["location"] && redirectRegex.test(`${proxyRes.statusCode}`)) {
+        const target = common2.toURL(options.target);
+        const location = proxyRes.headers["location"];
+        if (typeof location != "string") {
+          return;
+        }
+        const u2 = common2.toURL(location);
+        if (target.host != u2.host) {
+          return;
+        }
+        if (options.hostRewrite) {
+          u2.host = options.hostRewrite;
+        } else if (options.autoRewrite) {
+          u2.host = req.headers["host"] ?? "";
+        }
+        if (options.protocolRewrite) {
+          u2.protocol = options.protocolRewrite;
         }
+        proxyRes.headers["location"] = u2.toString();
       }
-      return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
     }
-    function createErrorType(code, message, baseClass) {
-      function CustomError(properties) {
-        if (isFunction(Error.captureStackTrace)) {
-          Error.captureStackTrace(this, this.constructor);
+    function writeHeaders(_req, res, proxyRes, options) {
+      const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? (
+        // also test for ''
+        { "*": options.cookieDomainRewrite }
+      ) : options.cookieDomainRewrite;
+      const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? (
+        // also test for ''
+        { "*": options.cookiePathRewrite }
+      ) : options.cookiePathRewrite;
+      const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+      const setHeader = (key, header) => {
+        if (header == void 0) {
+          return;
+        }
+        if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") {
+          header = common2.rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
+        }
+        if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") {
+          header = common2.rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
+        }
+        res.setHeader(String(key).trim(), header);
+      };
+      let rawHeaderKeyMap;
+      if (preserveHeaderKeyCase && proxyRes.rawHeaders != void 0) {
+        rawHeaderKeyMap = {};
+        for (let i2 = 0; i2 < proxyRes.rawHeaders.length; i2 += 2) {
+          const key = proxyRes.rawHeaders[i2];
+          rawHeaderKeyMap[key.toLowerCase()] = key;
         }
-        Object.assign(this, properties || {});
-        this.code = code;
-        this.message = this.cause ? message + ": " + this.cause.message : message;
       }
-      CustomError.prototype = new (baseClass || Error)();
-      Object.defineProperties(CustomError.prototype, {
-        constructor: {
-          value: CustomError,
-          enumerable: false
-        },
-        name: {
-          value: "Error [" + code + "]",
-          enumerable: false
+      for (const key0 in proxyRes.headers) {
+        let key = key0;
+        if (_req.httpVersionMajor > 1 && (key === "connection" || key === "keep-alive")) {
+          continue;
         }
-      });
-      return CustomError;
-    }
-    function destroyRequest(request, error) {
-      for (var event of events) {
-        request.removeListener(event, eventHandlers[event]);
+        const header = proxyRes.headers[key];
+        if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+          key = rawHeaderKeyMap[key] ?? key;
+        }
+        setHeader(key, header);
       }
-      request.on("error", noop3);
-      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 URL2 && value instanceof URL2;
+    function writeStatusCode(_req, res, proxyRes) {
+      res.statusCode = proxyRes.statusCode;
+      if (proxyRes.statusMessage && _req.httpVersionMajor === 1) {
+        res.statusMessage = proxyRes.statusMessage;
+      }
     }
-    module2.exports = wrap({ http: http2, https });
-    module2.exports.wrap = wrap;
+    exports2.OUTGOING_PASSES = {
+      removeChunked,
+      setConnection,
+      setRedirectHostRewrite,
+      writeHeaders,
+      writeStatusCode
+    };
   }
 });
 
@@ -5015,9 +5023,10 @@ var require_web_incoming = __commonJS({
     exports2.stream = stream;
     var http2 = __importStar(require("node:http"));
     var https = __importStar(require("node:https"));
-    var web_outgoing_1 = require_web_outgoing();
-    var common2 = __importStar(require_common());
     var followRedirects = __importStar(require_follow_redirects());
+    var common2 = __importStar(require_common2());
+    var web_outgoing_1 = require_web_outgoing();
+    var node_stream_1 = require("node:stream");
     var web_o = Object.values(web_outgoing_1.OUTGOING_PASSES);
     var nativeAgents = { http: http2, https };
     function deleteLength(req) {
@@ -5048,6 +5057,9 @@ var require_web_incoming = __commonJS({
     }
     function stream(req, res, options, _, server, cb) {
       server.emit("start", req, res, options.target || options.forward);
+      if (options.fetch || process.env.FORCE_FETCH_PATH === "true") {
+        return stream2(req, res, options, _, server, cb);
+      }
       const agents = options.followRedirects ? followRedirects : nativeAgents;
       const http3 = agents.http;
       const https2 = agents.https;
@@ -5119,6 +5131,149 @@ var require_web_incoming = __commonJS({
         }
       });
     }
+    async function stream2(req, res, options, _, server, cb) {
+      const handleError = (err, target) => {
+        if (cb) {
+          cb(err, req, res, target);
+        } else {
+          server.emit("error", err, req, res, target);
+        }
+      };
+      req.on("error", (err) => {
+        if (req.socket.destroyed && err.code === "ECONNRESET") {
+          const target = options.target || options.forward;
+          if (target) {
+            server.emit("econnreset", err, req, res, target);
+          }
+          return;
+        }
+        handleError(err);
+      });
+      const fetchOptions = options.fetch === true ? {} : options.fetch;
+      if (!fetchOptions) {
+        throw new Error("stream2 called without fetch options");
+      }
+      if (options.forward) {
+        const outgoingOptions2 = common2.setupOutgoing(options.ssl || {}, options, req, "forward");
+        const requestOptions2 = {
+          method: outgoingOptions2.method
+        };
+        if (fetchOptions.dispatcher) {
+          requestOptions2.dispatcher = fetchOptions.dispatcher;
+        }
+        if (options.buffer) {
+          requestOptions2.body = options.buffer;
+        } else if (req.method !== "GET" && req.method !== "HEAD") {
+          requestOptions2.body = req;
+          requestOptions2.duplex = "half";
+        }
+        if (fetchOptions.onBeforeRequest) {
+          try {
+            await fetchOptions.onBeforeRequest(requestOptions2, req, res, options);
+          } catch (err) {
+            handleError(err, options.forward);
+            return;
+          }
+        }
+        try {
+          const result = await fetch(new URL(outgoingOptions2.url).origin + outgoingOptions2.path, requestOptions2);
+          if (fetchOptions.onAfterResponse) {
+            try {
+              await fetchOptions.onAfterResponse(result, req, res, options);
+            } catch (err) {
+              handleError(err, options.forward);
+              return;
+            }
+          }
+        } catch (err) {
+          handleError(err, options.forward);
+        }
+        if (!options.target) {
+          return res.end();
+        }
+      }
+      const outgoingOptions = common2.setupOutgoing(options.ssl || {}, options, req);
+      const requestOptions = {
+        method: outgoingOptions.method,
+        headers: Object.fromEntries(Object.entries(outgoingOptions.headers || {}).filter(([key, _value]) => {
+          return typeof key === "string";
+        })),
+        ...fetchOptions.requestOptions
+      };
+      if (fetchOptions.dispatcher) {
+        requestOptions.dispatcher = fetchOptions.dispatcher;
+      }
+      if (options.auth) {
+        requestOptions.headers = {
+          ...requestOptions.headers,
+          authorization: `Basic ${Buffer.from(options.auth).toString("base64")}`
+        };
+      }
+      if (options.buffer) {
+        requestOptions.body = options.buffer;
+      } else if (req.method !== "GET" && req.method !== "HEAD") {
+        requestOptions.body = req;
+        requestOptions.duplex = "half";
+      }
+      if (fetchOptions.onBeforeRequest) {
+        try {
+          await fetchOptions.onBeforeRequest(requestOptions, req, res, options);
+        } catch (err) {
+          handleError(err, options.target);
+          return;
+        }
+      }
+      try {
+        const response = await fetch(new URL(outgoingOptions.url).origin + outgoingOptions.path, requestOptions);
+        if (fetchOptions.onAfterResponse) {
+          try {
+            await fetchOptions.onAfterResponse(response, req, res, options);
+          } catch (err) {
+            handleError(err, options.target);
+            return;
+          }
+        }
+        const fakeProxyRes = {
+          statusCode: response.status,
+          statusMessage: response.statusText,
+          headers: Object.fromEntries(response.headers.entries()),
+          rawHeaders: Object.entries(response.headers).flatMap(([key, value]) => {
+            if (Array.isArray(value)) {
+              return value.flatMap((v) => v != null ? [key, v] : []);
+            }
+            return value != null ? [key, value] : [];
+          })
+        };
+        server?.emit("proxyRes", fakeProxyRes, req, res);
+        if (!res.headersSent && !options.selfHandleResponse) {
+          for (const pass of web_o) {
+            pass(req, res, fakeProxyRes, options);
+          }
+        }
+        if (!res.writableEnded) {
+          const nodeStream = response.body ? node_stream_1.Readable.from(response.body) : null;
+          if (nodeStream) {
+            nodeStream.on("error", (err) => {
+              handleError(err, options.target);
+            });
+            nodeStream.on("end", () => {
+              server?.emit("end", req, res, fakeProxyRes);
+            });
+            if (!options.selfHandleResponse) {
+              nodeStream.pipe(res, { end: true });
+            } else {
+              nodeStream.resume();
+            }
+          } else {
+            server?.emit("end", req, res, fakeProxyRes);
+          }
+        } else {
+          server?.emit("end", req, res, fakeProxyRes);
+        }
+      } catch (err) {
+        handleError(err, options.target);
+      }
+    }
     exports2.WEB_PASSES = { deleteLength, timeout, XHeaders, stream };
   }
 });
@@ -5175,7 +5330,7 @@ var require_ws_incoming = __commonJS({
     exports2.stream = stream;
     var http2 = __importStar(require("node:http"));
     var https = __importStar(require("node:https"));
-    var common2 = __importStar(require_common());
+    var common2 = __importStar(require_common2());
     var web_outgoing_1 = require_web_outgoing();
     var debug_1 = __importDefault(require_src());
     var log = (0, debug_1.default)("http-proxy-3:ws-incoming");
@@ -5404,7 +5559,7 @@ var require_http_proxy = __commonJS({
     var ws_incoming_1 = require_ws_incoming();
     var node_events_1 = require("node:events");
     var debug_1 = __importDefault(require_src());
-    var common_1 = require_common();
+    var common_1 = require_common2();
     var log = (0, debug_1.default)("http-proxy-3");
     var ProxyServer = class _ProxyServer extends node_events_1.EventEmitter {
       /**
@@ -5525,7 +5680,7 @@ var require_http_proxy = __commonJS({
           passes.splice(i2++, 0, cb);
         };
         log("creating a ProxyServer", options);
-        options.prependPath = options.prependPath === false ? false : true;
+        options.prependPath = options.prependPath !== false;
         this.options = options;
         this.web = this.createRightProxy("web")(options);
         this.ws = this.createRightProxy("ws")(options);
@@ -6618,7 +6773,7 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
   const httpServer = http.createServer((req, res) => {
     if (req.url?.startsWith(RESTART_URL) && req.method === "POST") {
       onRestart();
-      res.writeHead(200, {
+      res.writeHead(500, {
         "Content-Type": "text/html"
       }).end(`
             <!doctype html>
@@ -6714,8 +6869,29 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
                 <section>
                   <span class="code" id="err-code">Restarting the services...</span>
                   <h1 id="err-title">Please wait...</h1>
-                  <p class="lead">Will reload in 5 seconds</p>
-                  <script>setTimeout(() => window.location.href = "/", 5_000);</script>
+                  <script>
+                    function checkIfSiteIsAlive(counter = 0) {
+                      if (counter === 10) {
+                        window.location.href = "/";
+                        return;
+                      }
+
+                      fetch('/')
+                        .then((response) => {
+                          if (response.ok) {
+                            window.location.href = "/";
+                            return;
+                          }
+                          return Promise.reject();
+                        })
+                        .catch((error) => {
+                          console.error('monitor:error', 'server is not yet reachable', error);
+                          setTimeout(() => checkIfSiteIsAlive(counter + 1), 2_000);
+                        });
+                    }
+                    checkIfSiteIsAlive();
+                  </script>
+                  <p class="lead">Waiting for server to restart</p>
                 </section>
               </main>
             </body>
@@ -6736,7 +6912,7 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
   proxy.on("error", (_err, _req, res) => {
     if ("req" in res) {
       if (!res.headersSent && !res.writableEnded) {
-        res.writeHead(200, {
+        res.writeHead(500, {
           "Content-Type": "text/html"
         }).end(`
             <!doctype html>
@@ -6744,8 +6920,7 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
             <head>
               <meta charset="utf-8" />
               <meta name="viewport" content="width=device-width,initial-scale=1" />
-              <title>Something went wrong \u2014 Error</title>
-              <meta name="description" content="Friendly error page with suggestions and retry button." />
+              <title>Development Server Crashed</title>
               <style>
                 :root{
                   --bg:#0f1724; /* deep navy */
@@ -6815,11 +6990,10 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
               </style>
             </head>
             <body>
-              <main class="card" role="main" aria-labelledby="err-title">
+              <main class="card">
                 <div class="illustration">
-                  <div class="badge" aria-hidden="true">
-                    <!-- friendly robot / broken plug SVG -->
-                    <svg width="160" height="160" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg" class="wobble" role="img" aria-hidden="true">
+                  <div class="badge">
+                    <svg width="160" height="160" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg" class="wobble">
                       <rect x="6" y="10" width="52" height="36" rx="6" fill="rgba(125,211,252,0.06)" stroke="rgba(125,211,252,0.12)"/>
                       <circle cx="20" cy="28" r="4" fill="rgba(125,211,252,0.18)"/>
                       <rect x="32" y="24" width="16" height="6" rx="2" fill="rgba(125,211,252,0.22)"/>
@@ -6830,13 +7004,14 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
                 </div>
 
                 <section>
-                  <span class="code" id="err-code">500</span>
-                  <h1 id="err-title">Uh-oh \u2014 something went wrong.</h1>
+                  <span class="code" id="err-code">Development Server Down</span>
+                  <h1 id="err-title">For unknown reasons development server has crashed and is not reachable.</h1>
                   <p class="lead">We hit an unexpected error while trying to load the page. This usually clears up quickly \u2014 here are a few options.</p>
 
-                  <div class="actions" role="group" aria-label="error actions">
+                  <div class="actions">
                     <form action=${RESTART_URL} method="POST">
                       <button class="btn primary" id="retryBtn" type="submit">Retry</button>
+                      <a class="btn" id="homeBtn" onClick="fixWithAI()">Fix with AI</a>
                     </form>
                     <script type="text/javascript">
                       function fixWithAI() {
@@ -6850,15 +7025,9 @@ async function runProxy(proxyFrom, proxyTo, stdio) {
                         }, '*');
                       }
                     </script>
-                    <a class="btn" id="homeBtn" onClick="fixWithAI()">Fix with AI</a>
-                  </div>
-
-                  <div class="details" id="details" hidden>
-                    <strong>Technical details</strong>
-                    <div id="debugText" style="margin-top:8px;color:var(--muted);">No additional information available.</div>
                   </div>
 
-                  <div class="suggestions" aria-hidden="false">
+                  <div class="suggestions">
                     <div class="suggestion"><span class="dot"></span><div>Try refreshing the page or press <kbd>Ctrl</kbd> + <kbd>R</kbd>.</div></div>
                     <div class="suggestion"><span class="dot"></span><div>Check your connection or try again in a few minutes.</div></div>
                     <div class="suggestion"><span class="dot"></span><div>If the problem persists, open an issue or contact support.</div></div>