@rsbuild/core 2.0.0-alpha.4 → 2.0.0-beta.1

package/compiled/http-proxy-middleware/index.js

@@ -622,6 +622,513 @@
         return result;
       };
     },
+    471: (module, exports, __nccwpck_require__) => {
+      exports.formatArgs = formatArgs;
+      exports.save = save;
+      exports.load = load;
+      exports.useColors = useColors;
+      exports.storage = localstorage();
+      exports.destroy = (() => {
+        let warned = false;
+        return () => {
+          if (!warned) {
+            warned = true;
+            console.warn(
+              "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+            );
+          }
+        };
+      })();
+      exports.colors = [
+        "#0000CC",
+        "#0000FF",
+        "#0033CC",
+        "#0033FF",
+        "#0066CC",
+        "#0066FF",
+        "#0099CC",
+        "#0099FF",
+        "#00CC00",
+        "#00CC33",
+        "#00CC66",
+        "#00CC99",
+        "#00CCCC",
+        "#00CCFF",
+        "#3300CC",
+        "#3300FF",
+        "#3333CC",
+        "#3333FF",
+        "#3366CC",
+        "#3366FF",
+        "#3399CC",
+        "#3399FF",
+        "#33CC00",
+        "#33CC33",
+        "#33CC66",
+        "#33CC99",
+        "#33CCCC",
+        "#33CCFF",
+        "#6600CC",
+        "#6600FF",
+        "#6633CC",
+        "#6633FF",
+        "#66CC00",
+        "#66CC33",
+        "#9900CC",
+        "#9900FF",
+        "#9933CC",
+        "#9933FF",
+        "#99CC00",
+        "#99CC33",
+        "#CC0000",
+        "#CC0033",
+        "#CC0066",
+        "#CC0099",
+        "#CC00CC",
+        "#CC00FF",
+        "#CC3300",
+        "#CC3333",
+        "#CC3366",
+        "#CC3399",
+        "#CC33CC",
+        "#CC33FF",
+        "#CC6600",
+        "#CC6633",
+        "#CC9900",
+        "#CC9933",
+        "#CCCC00",
+        "#CCCC33",
+        "#FF0000",
+        "#FF0033",
+        "#FF0066",
+        "#FF0099",
+        "#FF00CC",
+        "#FF00FF",
+        "#FF3300",
+        "#FF3333",
+        "#FF3366",
+        "#FF3399",
+        "#FF33CC",
+        "#FF33FF",
+        "#FF6600",
+        "#FF6633",
+        "#FF9900",
+        "#FF9933",
+        "#FFCC00",
+        "#FFCC33",
+      ];
+      function useColors() {
+        if (
+          typeof window !== "undefined" &&
+          window.process &&
+          (window.process.type === "renderer" || window.process.__nwjs)
+        ) {
+          return true;
+        }
+        if (
+          typeof navigator !== "undefined" &&
+          navigator.userAgent &&
+          navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)
+        ) {
+          return false;
+        }
+        let m;
+        return (
+          (typeof document !== "undefined" &&
+            document.documentElement &&
+            document.documentElement.style &&
+            document.documentElement.style.WebkitAppearance) ||
+          (typeof window !== "undefined" &&
+            window.console &&
+            (window.console.firebug ||
+              (window.console.exception && window.console.table))) ||
+          (typeof navigator !== "undefined" &&
+            navigator.userAgent &&
+            (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) &&
+            parseInt(m[1], 10) >= 31) ||
+          (typeof navigator !== "undefined" &&
+            navigator.userAgent &&
+            navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))
+        );
+      }
+      function formatArgs(args) {
+        args[0] =
+          (this.useColors ? "%c" : "") +
+          this.namespace +
+          (this.useColors ? " %c" : " ") +
+          args[0] +
+          (this.useColors ? "%c " : " ") +
+          "+" +
+          module.exports.humanize(this.diff);
+        if (!this.useColors) {
+          return;
+        }
+        const c = "color: " + this.color;
+        args.splice(1, 0, c, "color: inherit");
+        let index = 0;
+        let lastC = 0;
+        args[0].replace(/%[a-zA-Z%]/g, (match) => {
+          if (match === "%%") {
+            return;
+          }
+          index++;
+          if (match === "%c") {
+            lastC = index;
+          }
+        });
+        args.splice(lastC, 0, c);
+      }
+      exports.log = console.debug || console.log || (() => {});
+      function save(namespaces) {
+        try {
+          if (namespaces) {
+            exports.storage.setItem("debug", namespaces);
+          } else {
+            exports.storage.removeItem("debug");
+          }
+        } catch (error) {}
+      }
+      function load() {
+        let r;
+        try {
+          r =
+            exports.storage.getItem("debug") ||
+            exports.storage.getItem("DEBUG");
+        } catch (error) {}
+        if (!r && typeof process !== "undefined" && "env" in process) {
+          r = process.env.DEBUG;
+        }
+        return r;
+      }
+      function localstorage() {
+        try {
+          return localStorage;
+        } catch (error) {}
+      }
+      module.exports = __nccwpck_require__(1210)(exports);
+      const { formatters } = module.exports;
+      formatters.j = function (v) {
+        try {
+          return JSON.stringify(v);
+        } catch (error) {
+          return "[UnexpectedJSONParseError]: " + error.message;
+        }
+      };
+    },
+    1210: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      function setup(env) {
+        createDebug.debug = createDebug;
+        createDebug.default = createDebug;
+        createDebug.coerce = coerce;
+        createDebug.disable = disable;
+        createDebug.enable = enable;
+        createDebug.enabled = enabled;
+        createDebug.humanize = __nccwpck_require__(6987);
+        createDebug.destroy = destroy;
+        Object.keys(env).forEach((key) => {
+          createDebug[key] = env[key];
+        });
+        createDebug.names = [];
+        createDebug.skips = [];
+        createDebug.formatters = {};
+        function selectColor(namespace) {
+          let hash = 0;
+          for (let i = 0; i < namespace.length; i++) {
+            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+            hash |= 0;
+          }
+          return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+        }
+        createDebug.selectColor = selectColor;
+        function createDebug(namespace) {
+          let prevTime;
+          let enableOverride = null;
+          let namespacesCache;
+          let enabledCache;
+          function debug(...args) {
+            if (!debug.enabled) {
+              return;
+            }
+            const self = debug;
+            const curr = Number(new Date());
+            const ms = curr - (prevTime || curr);
+            self.diff = ms;
+            self.prev = prevTime;
+            self.curr = curr;
+            prevTime = curr;
+            args[0] = createDebug.coerce(args[0]);
+            if (typeof args[0] !== "string") {
+              args.unshift("%O");
+            }
+            let index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+              if (match === "%%") {
+                return "%";
+              }
+              index++;
+              const formatter = createDebug.formatters[format];
+              if (typeof formatter === "function") {
+                const val = args[index];
+                match = formatter.call(self, val);
+                args.splice(index, 1);
+                index--;
+              }
+              return match;
+            });
+            createDebug.formatArgs.call(self, args);
+            const logFn = self.log || createDebug.log;
+            logFn.apply(self, args);
+          }
+          debug.namespace = namespace;
+          debug.useColors = createDebug.useColors();
+          debug.color = createDebug.selectColor(namespace);
+          debug.extend = extend;
+          debug.destroy = createDebug.destroy;
+          Object.defineProperty(debug, "enabled", {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              if (enableOverride !== null) {
+                return enableOverride;
+              }
+              if (namespacesCache !== createDebug.namespaces) {
+                namespacesCache = createDebug.namespaces;
+                enabledCache = createDebug.enabled(namespace);
+              }
+              return enabledCache;
+            },
+            set: (v) => {
+              enableOverride = v;
+            },
+          });
+          if (typeof createDebug.init === "function") {
+            createDebug.init(debug);
+          }
+          return debug;
+        }
+        function extend(namespace, delimiter) {
+          const newDebug = createDebug(
+            this.namespace +
+              (typeof delimiter === "undefined" ? ":" : delimiter) +
+              namespace,
+          );
+          newDebug.log = this.log;
+          return newDebug;
+        }
+        function enable(namespaces) {
+          createDebug.save(namespaces);
+          createDebug.namespaces = namespaces;
+          createDebug.names = [];
+          createDebug.skips = [];
+          const split = (typeof namespaces === "string" ? namespaces : "")
+            .trim()
+            .replace(/\s+/g, ",")
+            .split(",")
+            .filter(Boolean);
+          for (const ns of split) {
+            if (ns[0] === "-") {
+              createDebug.skips.push(ns.slice(1));
+            } else {
+              createDebug.names.push(ns);
+            }
+          }
+        }
+        function matchesTemplate(search, template) {
+          let searchIndex = 0;
+          let templateIndex = 0;
+          let starIndex = -1;
+          let matchIndex = 0;
+          while (searchIndex < search.length) {
+            if (
+              templateIndex < template.length &&
+              (template[templateIndex] === search[searchIndex] ||
+                template[templateIndex] === "*")
+            ) {
+              if (template[templateIndex] === "*") {
+                starIndex = templateIndex;
+                matchIndex = searchIndex;
+                templateIndex++;
+              } else {
+                searchIndex++;
+                templateIndex++;
+              }
+            } else if (starIndex !== -1) {
+              templateIndex = starIndex + 1;
+              matchIndex++;
+              searchIndex = matchIndex;
+            } else {
+              return false;
+            }
+          }
+          while (
+            templateIndex < template.length &&
+            template[templateIndex] === "*"
+          ) {
+            templateIndex++;
+          }
+          return templateIndex === template.length;
+        }
+        function disable() {
+          const namespaces = [
+            ...createDebug.names,
+            ...createDebug.skips.map((namespace) => "-" + namespace),
+          ].join(",");
+          createDebug.enable("");
+          return namespaces;
+        }
+        function enabled(name) {
+          for (const skip of createDebug.skips) {
+            if (matchesTemplate(name, skip)) {
+              return false;
+            }
+          }
+          for (const ns of createDebug.names) {
+            if (matchesTemplate(name, ns)) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function coerce(val) {
+          if (val instanceof Error) {
+            return val.stack || val.message;
+          }
+          return val;
+        }
+        function destroy() {
+          console.warn(
+            "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+          );
+        }
+        createDebug.enable(createDebug.load());
+        return createDebug;
+      }
+      module.exports = setup;
+    },
+    6675: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      if (
+        typeof process === "undefined" ||
+        process.type === "renderer" ||
+        process.browser === true ||
+        process.__nwjs
+      ) {
+        module.exports = __nccwpck_require__(471);
+      } else {
+        module.exports = __nccwpck_require__(7443);
+      }
+    },
+    7443: (module, exports, __nccwpck_require__) => {
+      const tty = __nccwpck_require__(2018);
+      const util = __nccwpck_require__(9023);
+      exports.init = init;
+      exports.log = log;
+      exports.formatArgs = formatArgs;
+      exports.save = save;
+      exports.load = load;
+      exports.useColors = useColors;
+      exports.destroy = util.deprecate(
+        () => {},
+        "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+      );
+      exports.colors = [6, 2, 3, 4, 5, 1];
+      try {
+        const supportsColor = __nccwpck_require__(115);
+        if (
+          supportsColor &&
+          (supportsColor.stderr || supportsColor).level >= 2
+        ) {
+          exports.colors = [
+            20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62,
+            63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112,
+            113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165,
+            166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196,
+            197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
+            214, 215, 220, 221,
+          ];
+        }
+      } catch (error) {}
+      exports.inspectOpts = Object.keys(process.env)
+        .filter((key) => /^debug_/i.test(key))
+        .reduce((obj, key) => {
+          const prop = key
+            .substring(6)
+            .toLowerCase()
+            .replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+          let val = process.env[key];
+          if (/^(yes|on|true|enabled)$/i.test(val)) {
+            val = true;
+          } else if (/^(no|off|false|disabled)$/i.test(val)) {
+            val = false;
+          } else if (val === "null") {
+            val = null;
+          } else {
+            val = Number(val);
+          }
+          obj[prop] = val;
+          return obj;
+        }, {});
+      function useColors() {
+        return "colors" in exports.inspectOpts
+          ? Boolean(exports.inspectOpts.colors)
+          : tty.isatty(process.stderr.fd);
+      }
+      function formatArgs(args) {
+        const { namespace: name, useColors } = this;
+        if (useColors) {
+          const c = this.color;
+          const colorCode = "[3" + (c < 8 ? c : "8;5;" + c);
+          const prefix = `  ${colorCode};1m${name} `;
+          args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+          args.push(
+            colorCode + "m+" + module.exports.humanize(this.diff) + "",
+          );
+        } else {
+          args[0] = getDate() + name + " " + args[0];
+        }
+      }
+      function getDate() {
+        if (exports.inspectOpts.hideDate) {
+          return "";
+        }
+        return new Date().toISOString() + " ";
+      }
+      function log(...args) {
+        return process.stderr.write(
+          util.formatWithOptions(exports.inspectOpts, ...args) + "\n",
+        );
+      }
+      function save(namespaces) {
+        if (namespaces) {
+          process.env.DEBUG = namespaces;
+        } else {
+          delete process.env.DEBUG;
+        }
+      }
+      function load() {
+        return process.env.DEBUG;
+      }
+      function init(debug) {
+        debug.inspectOpts = {};
+        const keys = Object.keys(exports.inspectOpts);
+        for (let i = 0; i < keys.length; i++) {
+          debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+        }
+      }
+      module.exports = __nccwpck_require__(1210)(exports);
+      const { formatters } = module.exports;
+      formatters.o = function (v) {
+        this.inspectOpts.colors = this.useColors;
+        return util
+          .inspect(v, this.inspectOpts)
+          .split("\n")
+          .map((str) => str.trim())
+          .join(" ");
+      };
+      formatters.O = function (v) {
+        this.inspectOpts.colors = this.useColors;
+        return util.inspect(v, this.inspectOpts);
+      };
+    },
     6234: (module) => {
       "use strict";
       var has = Object.prototype.hasOwnProperty,
@@ -1029,12 +1536,12 @@
       };
       module.exports = fill;
     },
-    9679: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    4382: (module, __unused_webpack_exports, __nccwpck_require__) => {
       var debug;
       module.exports = function () {
         if (!debug) {
           try {
-            debug = __nccwpck_require__(2814)("follow-redirects");
+            debug = __nccwpck_require__(6675)("follow-redirects");
           } catch (error) {}
           if (typeof debug !== "function") {
             debug = function () {};
@@ -1043,14 +1550,14 @@
         debug.apply(null, arguments);
       };
     },
-    1584: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    8977: (module, __unused_webpack_exports, __nccwpck_require__) => {
       var url = __nccwpck_require__(7016);
       var URL = url.URL;
       var http = __nccwpck_require__(8611);
       var https = __nccwpck_require__(5692);
       var Writable = __nccwpck_require__(2203).Writable;
       var assert = __nccwpck_require__(2613);
-      var debug = __nccwpck_require__(9679);
+      var debug = __nccwpck_require__(4382);
       (function detectUnsupportedEnvironment() {
         var looksLikeNode = typeof process !== "undefined";
         var looksLikeBrowser =
@@ -1593,1333 +2100,543 @@
       module.exports = wrap({ http, https });
       module.exports.wrap = wrap;
     },
-    501: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getHandlers = exports.init = void 0;
-      const logger_1 = __nccwpck_require__(8045);
-      const logger = (0, logger_1.getInstance)();
-      function init(proxy, option) {
-        const handlers = getHandlers(option);
-        for (const eventName of Object.keys(handlers)) {
-          proxy.on(eventName, handlers[eventName]);
-        }
-        proxy.on("econnreset", (error, req, res, target) => {
-          logger.error(`[HPM] ECONNRESET: %O`, error);
-        });
-        proxy.on("proxyReqWs", (proxyReq, req, socket, options, head) => {
-          socket.on("error", (error) => {
-            logger.error(`[HPM] WebSocket error: %O`, error);
-          });
-        });
-        logger.debug(
-          "[HPM] Subscribed to http-proxy events:",
-          Object.keys(handlers),
-        );
-      }
-      exports.init = init;
-      function getHandlers(options) {
-        const proxyEventsMap = {
-          error: "onError",
-          proxyReq: "onProxyReq",
-          proxyReqWs: "onProxyReqWs",
-          proxyRes: "onProxyRes",
-          open: "onOpen",
-          close: "onClose",
-        };
-        const handlers = {};
-        for (const [eventName, onEventName] of Object.entries(proxyEventsMap)) {
-          const fnHandler = options ? options[onEventName] : null;
-          if (typeof fnHandler === "function") {
-            handlers[eventName] = fnHandler;
-          }
-        }
-        if (typeof handlers.error !== "function") {
-          handlers.error = defaultErrorHandler;
-        }
-        if (typeof handlers.close !== "function") {
-          handlers.close = logClose;
-        }
-        return handlers;
-      }
-      exports.getHandlers = getHandlers;
-      function defaultErrorHandler(err, req, res) {
-        if (!req && !res) {
-          throw err;
-        }
-        const host = req.headers && req.headers.host;
-        const code = err.code;
-        if (res.writeHead && !res.headersSent) {
-          if (/HPE_INVALID/.test(code)) {
-            res.writeHead(502);
-          } else {
-            switch (code) {
-              case "ECONNRESET":
-              case "ENOTFOUND":
-              case "ECONNREFUSED":
-              case "ETIMEDOUT":
-                res.writeHead(504);
-                break;
-              default:
-                res.writeHead(500);
-            }
-          }
-        }
-        res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
-      }
-      function logClose(req, socket, head) {
-        logger.info("[HPM] Client disconnected");
-      }
+    1929: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      /*!
+       * Caron dimonio, con occhi di bragia
+       * loro accennando, tutte le raccoglie;
+       * batte col remo qualunque s’adagia
+       *
+       * Charon the demon, with the eyes of glede,
+       * Beckoning to them, collects them all together,
+       * Beats with his oar whoever lags behind
+       *
+       *          Dante - The Divine Comedy (Canto III)
+       */
+      module.exports = __nccwpck_require__(8944);
     },
-    2304: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createConfig = void 0;
-      const isPlainObj = __nccwpck_require__(3458);
-      const url = __nccwpck_require__(7016);
-      const errors_1 = __nccwpck_require__(4618);
-      const logger_1 = __nccwpck_require__(8045);
-      const logger = (0, logger_1.getInstance)();
-      function createConfig(context, opts) {
-        const config = { context: undefined, options: {} };
-        if (isContextless(context, opts)) {
-          config.context = "/";
-          config.options = Object.assign(config.options, context);
-        } else if (isStringShortHand(context)) {
-          const oUrl = url.parse(context);
-          const target = [oUrl.protocol, "//", oUrl.host].join("");
-          config.context = oUrl.pathname || "/";
-          config.options = Object.assign(config.options, { target }, opts);
-          if (oUrl.protocol === "ws:" || oUrl.protocol === "wss:") {
-            config.options.ws = true;
-          }
-        } else {
-          config.context = context;
-          config.options = Object.assign(config.options, opts);
-        }
-        configureLogger(config.options);
-        if (!config.options.target && !config.options.router) {
-          throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
-        }
-        return config;
-      }
-      exports.createConfig = createConfig;
-      function isStringShortHand(context) {
-        if (typeof context === "string") {
-          return !!url.parse(context).host;
-        }
-      }
-      function isContextless(context, opts) {
-        return (
-          isPlainObj(context) &&
-          (opts == null || Object.keys(opts).length === 0)
-        );
-      }
-      function configureLogger(options) {
-        if (options.logLevel) {
-          logger.setLevel(options.logLevel);
-        }
-        if (options.logProvider) {
-          logger.setProvider(options.logProvider);
-        }
+    8944: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var ProxyServer = __nccwpck_require__(9815).Server;
+      function createProxyServer(options) {
+        return new ProxyServer(options);
       }
+      ProxyServer.createProxyServer = createProxyServer;
+      ProxyServer.createServer = createProxyServer;
+      ProxyServer.createProxy = createProxyServer;
+      module.exports = ProxyServer;
     },
-    1345: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.match = void 0;
-      const isGlob = __nccwpck_require__(686);
-      const micromatch = __nccwpck_require__(9555);
-      const url = __nccwpck_require__(7016);
-      const errors_1 = __nccwpck_require__(4618);
-      function match(context, uri, req) {
-        if (isStringPath(context)) {
-          return matchSingleStringPath(context, uri);
+    6758: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      var common = exports,
+        url = __nccwpck_require__(7016),
+        required = __nccwpck_require__(7866);
+      var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i,
+        isSSL = /^https|wss/;
+      common.isSSL = isSSL;
+      common.setupOutgoing = function (outgoing, options, req, forward) {
+        outgoing.port =
+          options[forward || "target"].port ||
+          (isSSL.test(options[forward || "target"].protocol) ? 443 : 80);
+        [
+          "host",
+          "hostname",
+          "socketPath",
+          "pfx",
+          "key",
+          "passphrase",
+          "cert",
+          "ca",
+          "ciphers",
+          "secureProtocol",
+        ].forEach(function (e) {
+          outgoing[e] = options[forward || "target"][e];
+        });
+        outgoing.method = options.method || req.method;
+        outgoing.headers = Object.assign({}, req.headers);
+        if (options.headers) {
+          Object.assign(outgoing.headers, options.headers);
         }
-        if (isGlobPath(context)) {
-          return matchSingleGlobPath(context, uri);
+        if (options.auth) {
+          outgoing.auth = options.auth;
         }
-        if (Array.isArray(context)) {
-          if (context.every(isStringPath)) {
-            return matchMultiPath(context, uri);
-          }
-          if (context.every(isGlobPath)) {
-            return matchMultiGlobPath(context, uri);
-          }
-          throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+        if (options.ca) {
+          outgoing.ca = options.ca;
         }
-        if (typeof context === "function") {
-          const pathname = getUrlPathName(uri);
-          return context(pathname, req);
+        if (isSSL.test(options[forward || "target"].protocol)) {
+          outgoing.rejectUnauthorized =
+            typeof options.secure === "undefined" ? true : options.secure;
         }
-        throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
-      }
-      exports.match = match;
-      function matchSingleStringPath(context, uri) {
-        const pathname = getUrlPathName(uri);
-        return pathname.indexOf(context) === 0;
-      }
-      function matchSingleGlobPath(pattern, uri) {
-        const pathname = getUrlPathName(uri);
-        const matches = micromatch([pathname], pattern);
-        return matches && matches.length > 0;
-      }
-      function matchMultiGlobPath(patternList, uri) {
-        return matchSingleGlobPath(patternList, uri);
-      }
-      function matchMultiPath(contextList, uri) {
-        let isMultiPath = false;
-        for (const context of contextList) {
-          if (matchSingleStringPath(context, uri)) {
-            isMultiPath = true;
-            break;
+        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";
           }
         }
-        return isMultiPath;
-      }
-      function getUrlPathName(uri) {
-        return uri && url.parse(uri).pathname;
-      }
-      function isStringPath(context) {
-        return typeof context === "string" && !isGlob(context);
-      }
-      function isGlobPath(context) {
-        return isGlob(context);
-      }
-    },
-    4618: (__unused_webpack_module, exports) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.ERRORS = void 0;
-      var ERRORS;
-      (function (ERRORS) {
-        ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] =
-          '[HPM] Missing "target" option. Example: {target: "http://www.example.org"}';
-        ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] =
-          '[HPM] Invalid context. Expecting something like: "/api" or ["/api", "/ajax"]';
-        ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] =
-          '[HPM] Invalid context. Expecting something like: ["/api", "/ajax"] or ["/api/**", "!**.html"]';
-        ERRORS["ERR_PATH_REWRITER_CONFIG"] =
-          "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
-      })((ERRORS = exports.ERRORS || (exports.ERRORS = {})));
-    },
-    6861: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.fixRequestBody = void 0;
-      const querystring = __nccwpck_require__(3480);
-      function fixRequestBody(proxyReq, req) {
-        if (req.readableLength !== 0) {
-          return;
-        }
-        const requestBody = req.body;
-        if (!requestBody) {
-          return;
-        }
-        const contentType = proxyReq.getHeader("Content-Type");
-        if (!contentType) {
-          return;
+        var target = options[forward || "target"];
+        var targetPath =
+          target && options.prependPath !== false ? target.path || "" : "";
+        var outgoingPath = !options.toProxy
+          ? url.parse(req.url).path || ""
+          : req.url;
+        outgoingPath = !options.ignorePath ? outgoingPath : "";
+        outgoing.path = common.urlJoin(targetPath, outgoingPath);
+        if (options.changeOrigin) {
+          outgoing.headers.host =
+            required(outgoing.port, options[forward || "target"].protocol) &&
+            !hasPort(outgoing.host)
+              ? outgoing.host + ":" + outgoing.port
+              : outgoing.host;
         }
-        const writeBody = (bodyData) => {
-          proxyReq.setHeader("Content-Length", Buffer.byteLength(bodyData));
-          proxyReq.write(bodyData);
-        };
-        if (contentType.includes("application/json")) {
-          writeBody(JSON.stringify(requestBody));
-        } else if (contentType.includes("application/x-www-form-urlencoded")) {
-          writeBody(querystring.stringify(requestBody));
+        return outgoing;
+      };
+      common.setupSocket = function (socket) {
+        socket.setTimeout(0);
+        socket.setNoDelay(true);
+        socket.setKeepAlive(true, 0);
+        return socket;
+      };
+      common.getPort = function (req) {
+        var res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
+        return res ? res[1] : common.hasEncryptedConnection(req) ? "443" : "80";
+      };
+      common.hasEncryptedConnection = function (req) {
+        return Boolean(req.connection.encrypted || req.connection.pair);
+      };
+      common.urlJoin = function () {
+        var args = Array.prototype.slice.call(arguments),
+          lastIndex = args.length - 1,
+          last = args[lastIndex],
+          lastSegs = last.split("?"),
+          retSegs;
+        args[lastIndex] = lastSegs.shift();
+        retSegs = [
+          args
+            .filter(Boolean)
+            .join("/")
+            .replace(/\/+/g, "/")
+            .replace("http:/", "http://")
+            .replace("https:/", "https://"),
+        ];
+        retSegs.push.apply(retSegs, lastSegs);
+        return retSegs.join("?");
+      };
+      common.rewriteCookieProperty = function rewriteCookieProperty(
+        header,
+        config,
+        property,
+      ) {
+        if (Array.isArray(header)) {
+          return header.map(function (headerElement) {
+            return rewriteCookieProperty(headerElement, config, property);
+          });
         }
+        return header.replace(
+          new RegExp("(;\\s*" + property + "=)([^;]+)", "i"),
+          function (match, prefix, previousValue) {
+            var 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(":");
       }
-      exports.fixRequestBody = fixRequestBody;
     },
-    5611: function (__unused_webpack_module, exports, __nccwpck_require__) {
-      "use strict";
-      var __createBinding =
-        (this && this.__createBinding) ||
-        (Object.create
-          ? function (o, m, k, k2) {
-              if (k2 === undefined) k2 = k;
-              Object.defineProperty(o, k2, {
-                enumerable: true,
-                get: function () {
-                  return m[k];
-                },
-              });
+    9815: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var httpProxy = module.exports,
+        parse_url = __nccwpck_require__(7016).parse,
+        EE3 = __nccwpck_require__(6234),
+        http = __nccwpck_require__(8611),
+        https = __nccwpck_require__(5692),
+        web = __nccwpck_require__(7640),
+        ws = __nccwpck_require__(2264);
+      httpProxy.Server = ProxyServer;
+      function createRightProxy(type) {
+        return function (options) {
+          return function (req, res) {
+            var passes = type === "ws" ? this.wsPasses : this.webPasses,
+              args = [].slice.call(arguments),
+              cntr = args.length - 1,
+              head,
+              cbl;
+            if (typeof args[cntr] === "function") {
+              cbl = args[cntr];
+              cntr--;
             }
-          : function (o, m, k, k2) {
-              if (k2 === undefined) k2 = k;
-              o[k2] = m[k];
+            var requestOptions = options;
+            if (!(args[cntr] instanceof Buffer) && args[cntr] !== res) {
+              requestOptions = Object.assign({}, options);
+              Object.assign(requestOptions, args[cntr]);
+              cntr--;
+            }
+            if (args[cntr] instanceof Buffer) {
+              head = args[cntr];
+            }
+            ["target", "forward"].forEach(function (e) {
+              if (typeof requestOptions[e] === "string")
+                requestOptions[e] = parse_url(requestOptions[e]);
             });
-      var __exportStar =
-        (this && this.__exportStar) ||
-        function (m, exports) {
-          for (var p in m)
-            if (
-              p !== "default" &&
-              !Object.prototype.hasOwnProperty.call(exports, p)
-            )
-              __createBinding(exports, m, p);
-        };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      __exportStar(__nccwpck_require__(9602), exports);
-    },
-    9602: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.fixRequestBody = exports.responseInterceptor = void 0;
-      var response_interceptor_1 = __nccwpck_require__(5938);
-      Object.defineProperty(exports, "responseInterceptor", {
-        enumerable: true,
-        get: function () {
-          return response_interceptor_1.responseInterceptor;
-        },
-      });
-      var fix_request_body_1 = __nccwpck_require__(6861);
-      Object.defineProperty(exports, "fixRequestBody", {
-        enumerable: true,
-        get: function () {
-          return fix_request_body_1.fixRequestBody;
-        },
-      });
-    },
-    5938: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.responseInterceptor = void 0;
-      const zlib = __nccwpck_require__(3106);
-      function responseInterceptor(interceptor) {
-        return async function proxyRes(proxyRes, req, res) {
-          const originalProxyRes = proxyRes;
-          let buffer = Buffer.from("", "utf8");
-          const _proxyRes = decompress(
-            proxyRes,
-            proxyRes.headers["content-encoding"],
-          );
-          _proxyRes.on(
-            "data",
-            (chunk) => (buffer = Buffer.concat([buffer, chunk])),
-          );
-          _proxyRes.on("end", async () => {
-            copyHeaders(proxyRes, res);
-            const interceptedBuffer = Buffer.from(
-              await interceptor(buffer, originalProxyRes, req, res),
-            );
-            res.setHeader(
-              "content-length",
-              Buffer.byteLength(interceptedBuffer, "utf8"),
-            );
-            res.write(interceptedBuffer);
-            res.end();
-          });
-          _proxyRes.on("error", (error) => {
-            res.end(`Error fetching proxied request: ${error.message}`);
-          });
+            if (!requestOptions.target && !requestOptions.forward) {
+              return this.emit(
+                "error",
+                new Error("Must provide a proper URL as target"),
+              );
+            }
+            for (var i = 0; i < passes.length; i++) {
+              if (passes[i](req, res, requestOptions, head, this, cbl)) {
+                break;
+              }
+            }
+          };
         };
       }
-      exports.responseInterceptor = responseInterceptor;
-      function decompress(proxyRes, contentEncoding) {
-        let _proxyRes = proxyRes;
-        let decompress;
-        switch (contentEncoding) {
-          case "gzip":
-            decompress = zlib.createGunzip();
-            break;
-          case "br":
-            decompress = zlib.createBrotliDecompress();
-            break;
-          case "deflate":
-            decompress = zlib.createInflate();
-            break;
-          default:
-            break;
-        }
-        if (decompress) {
-          _proxyRes.pipe(decompress);
-          _proxyRes = decompress;
-        }
-        return _proxyRes;
+      httpProxy.createRightProxy = createRightProxy;
+      function ProxyServer(options) {
+        EE3.call(this);
+        options = options || {};
+        options.prependPath = options.prependPath === false ? false : true;
+        this.web = this.proxyRequest = createRightProxy("web")(options);
+        this.ws = this.proxyWebsocketRequest = createRightProxy("ws")(options);
+        this.options = options;
+        this.webPasses = Object.keys(web).map(function (pass) {
+          return web[pass];
+        });
+        this.wsPasses = Object.keys(ws).map(function (pass) {
+          return ws[pass];
+        });
+        this.on("error", this.onError, this);
       }
-      function copyHeaders(originalResponse, response) {
-        response.statusCode = originalResponse.statusCode;
-        response.statusMessage = originalResponse.statusMessage;
-        if (response.setHeader) {
-          let keys = Object.keys(originalResponse.headers);
-          keys = keys.filter(
-            (key) => !["content-encoding", "transfer-encoding"].includes(key),
-          );
-          keys.forEach((key) => {
-            let value = originalResponse.headers[key];
-            if (key === "set-cookie") {
-              value = Array.isArray(value) ? value : [value];
-              value = value.map((x) => x.replace(/Domain=[^;]+?/i, ""));
-            }
-            response.setHeader(key, value);
-          });
-        } else {
-          response.headers = originalResponse.headers;
+      __nccwpck_require__(9023).inherits(ProxyServer, EE3);
+      ProxyServer.prototype.onError = function (err) {
+        if (this.listeners("error").length === 1) {
+          throw err;
         }
-      }
-    },
-    6953: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.HttpProxyMiddleware = void 0;
-      const httpProxy = __nccwpck_require__(4484);
-      const config_factory_1 = __nccwpck_require__(2304);
-      const contextMatcher = __nccwpck_require__(1345);
-      const handlers = __nccwpck_require__(501);
-      const logger_1 = __nccwpck_require__(8045);
-      const PathRewriter = __nccwpck_require__(6241);
-      const Router = __nccwpck_require__(604);
-      class HttpProxyMiddleware {
-        constructor(context, opts) {
-          this.logger = (0, logger_1.getInstance)();
-          this.wsInternalSubscribed = false;
-          this.serverOnCloseSubscribed = false;
-          this.middleware = async (req, res, next) => {
-            var _a, _b;
-            if (this.shouldProxy(this.config.context, req)) {
-              try {
-                const activeProxyOptions = await this.prepareProxyRequest(req);
-                this.proxy.web(req, res, activeProxyOptions);
-              } catch (err) {
-                next(err);
-              }
-            } else {
-              next();
-            }
-            const server =
-              (_b =
-                (_a = req.socket) !== null && _a !== void 0
-                  ? _a
-                  : req.connection) === null || _b === void 0
-                ? void 0
-                : _b.server;
-            if (server && !this.serverOnCloseSubscribed) {
-              server.on("close", () => {
-                this.logger.info(
-                  "[HPM] server close signal received: closing proxy server",
-                );
-                this.proxy.close();
-              });
-              this.serverOnCloseSubscribed = true;
-            }
-            if (this.proxyOptions.ws === true) {
-              this.catchUpgradeRequest(server);
-            }
-          };
-          this.catchUpgradeRequest = (server) => {
-            if (!this.wsInternalSubscribed) {
-              server.on("upgrade", this.handleUpgrade);
-              this.wsInternalSubscribed = true;
-            }
-          };
-          this.handleUpgrade = async (req, socket, head) => {
-            if (this.shouldProxy(this.config.context, req)) {
-              const activeProxyOptions = await this.prepareProxyRequest(req);
-              this.proxy.ws(req, socket, head, activeProxyOptions);
-              this.logger.info("[HPM] Upgrading to WebSocket");
-            }
-          };
-          this.shouldProxy = (context, req) => {
-            try {
-              const path = req.originalUrl || req.url;
-              return contextMatcher.match(context, path, req);
-            } catch (error) {
-              this.logger.error(error);
-              return false;
-            }
-          };
-          this.prepareProxyRequest = async (req) => {
-            req.url = req.originalUrl || req.url;
-            const originalPath = req.url;
-            const newProxyOptions = Object.assign({}, this.proxyOptions);
-            await this.applyRouter(req, newProxyOptions);
-            await this.applyPathRewrite(req, this.pathRewriter);
-            if (this.proxyOptions.logLevel === "debug") {
-              const arrow = (0, logger_1.getArrow)(
-                originalPath,
-                req.url,
-                this.proxyOptions.target,
-                newProxyOptions.target,
-              );
-              this.logger.debug(
-                "[HPM] %s %s %s %s",
-                req.method,
-                originalPath,
-                arrow,
-                newProxyOptions.target,
-              );
-            }
-            return newProxyOptions;
-          };
-          this.applyRouter = async (req, options) => {
-            let newTarget;
-            if (options.router) {
-              newTarget = await Router.getTarget(req, options);
-              if (newTarget) {
-                this.logger.debug(
-                  '[HPM] Router new target: %s -> "%s"',
-                  options.target,
-                  newTarget,
-                );
-                options.target = newTarget;
-              }
-            }
-          };
-          this.applyPathRewrite = async (req, pathRewriter) => {
-            if (pathRewriter) {
-              const path = await pathRewriter(req.url, req);
-              if (typeof path === "string") {
-                req.url = path;
-              } else {
-                this.logger.info(
-                  "[HPM] pathRewrite: No rewritten path found. (%s)",
-                  req.url,
-                );
-              }
-            }
-          };
-          this.logError = (err, req, res, target) => {
-            var _a;
-            const hostname =
-              ((_a = req.headers) === null || _a === void 0
-                ? void 0
-                : _a.host) ||
-              req.hostname ||
-              req.host;
-            const requestHref = `${hostname}${req.url}`;
-            const targetHref = `${target === null || target === void 0 ? void 0 : target.href}`;
-            const errorMessage =
-              "[HPM] Error occurred while proxying request %s to %s [%s] (%s)";
-            const errReference =
-              "https://nodejs.org/api/errors.html#errors_common_system_errors";
-            this.logger.error(
-              errorMessage,
-              requestHref,
-              targetHref,
-              err.code || err,
-              errReference,
-            );
-          };
-          this.config = (0, config_factory_1.createConfig)(context, opts);
-          this.proxyOptions = this.config.options;
-          this.proxy = httpProxy.createProxyServer({});
-          this.logger.info(
-            `[HPM] Proxy created: ${this.config.context}  -> ${this.proxyOptions.target}`,
-          );
-          this.pathRewriter = PathRewriter.createPathRewriter(
-            this.proxyOptions.pathRewrite,
-          );
-          handlers.init(this.proxy, this.proxyOptions);
-          this.proxy.on("error", this.logError);
-          this.middleware.upgrade = (req, socket, head) => {
-            if (!this.wsInternalSubscribed) {
-              this.handleUpgrade(req, socket, head);
-            }
+      };
+      ProxyServer.prototype.listen = function (port, hostname) {
+        var self = this,
+          closure = function (req, res) {
+            self.web(req, res);
           };
+        this._server = this.options.ssl
+          ? https.createServer(this.options.ssl, closure)
+          : http.createServer(closure);
+        if (this.options.ws) {
+          this._server.on("upgrade", function (req, socket, head) {
+            self.ws(req, socket, head);
+          });
         }
-      }
-      exports.HttpProxyMiddleware = HttpProxyMiddleware;
-    },
-    7861: function (__unused_webpack_module, exports, __nccwpck_require__) {
-      "use strict";
-      var __createBinding =
-        (this && this.__createBinding) ||
-        (Object.create
-          ? function (o, m, k, k2) {
-              if (k2 === undefined) k2 = k;
-              Object.defineProperty(o, k2, {
-                enumerable: true,
-                get: function () {
-                  return m[k];
-                },
-              });
-            }
-          : function (o, m, k, k2) {
-              if (k2 === undefined) k2 = k;
-              o[k2] = m[k];
-            });
-      var __exportStar =
-        (this && this.__exportStar) ||
-        function (m, exports) {
-          for (var p in m)
-            if (
-              p !== "default" &&
-              !Object.prototype.hasOwnProperty.call(exports, p)
-            )
-              __createBinding(exports, m, p);
-        };
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createProxyMiddleware = void 0;
-      const http_proxy_middleware_1 = __nccwpck_require__(6953);
-      function createProxyMiddleware(context, options) {
-        const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(
-          context,
-          options,
-        );
-        return middleware;
-      }
-      exports.createProxyMiddleware = createProxyMiddleware;
-      __exportStar(__nccwpck_require__(5611), exports);
-    },
-    8045: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getArrow = exports.getInstance = void 0;
-      const util = __nccwpck_require__(9023);
-      let loggerInstance;
-      const defaultProvider = {
-        log: console.log,
-        debug: console.log,
-        info: console.info,
-        warn: console.warn,
-        error: console.error,
+        this._server.listen(port, hostname);
+        return this;
       };
-      var LEVELS;
-      (function (LEVELS) {
-        LEVELS[(LEVELS["debug"] = 10)] = "debug";
-        LEVELS[(LEVELS["info"] = 20)] = "info";
-        LEVELS[(LEVELS["warn"] = 30)] = "warn";
-        LEVELS[(LEVELS["error"] = 50)] = "error";
-        LEVELS[(LEVELS["silent"] = 80)] = "silent";
-      })(LEVELS || (LEVELS = {}));
-      function getInstance() {
-        if (!loggerInstance) {
-          loggerInstance = new Logger();
-        }
-        return loggerInstance;
-      }
-      exports.getInstance = getInstance;
-      class Logger {
-        constructor() {
-          this.setLevel("info");
-          this.setProvider(() => defaultProvider);
-        }
-        log() {
-          this.provider.log(this._interpolate.apply(null, arguments));
-        }
-        debug() {
-          if (this._showLevel("debug")) {
-            this.provider.debug(this._interpolate.apply(null, arguments));
-          }
+      ProxyServer.prototype.close = function (callback) {
+        var self = this;
+        if (this._server) {
+          this._server.close(done);
         }
-        info() {
-          if (this._showLevel("info")) {
-            this.provider.info(this._interpolate.apply(null, arguments));
+        function done() {
+          self._server = null;
+          if (callback) {
+            callback.apply(null, arguments);
           }
         }
-        warn() {
-          if (this._showLevel("warn")) {
-            this.provider.warn(this._interpolate.apply(null, arguments));
-          }
+      };
+      ProxyServer.prototype.before = function (type, passName, callback) {
+        if (type !== "ws" && type !== "web") {
+          throw new Error("type must be `web` or `ws`");
         }
-        error() {
-          if (this._showLevel("error")) {
-            this.provider.error(this._interpolate.apply(null, arguments));
-          }
+        var passes = type === "ws" ? this.wsPasses : this.webPasses,
+          i = false;
+        passes.forEach(function (v, idx) {
+          if (v.name === passName) i = idx;
+        });
+        if (i === false) throw new Error("No such pass");
+        passes.splice(i, 0, callback);
+      };
+      ProxyServer.prototype.after = function (type, passName, callback) {
+        if (type !== "ws" && type !== "web") {
+          throw new Error("type must be `web` or `ws`");
         }
-        setLevel(v) {
-          if (this.isValidLevel(v)) {
-            this.logLevel = v;
+        var passes = type === "ws" ? this.wsPasses : this.webPasses,
+          i = false;
+        passes.forEach(function (v, idx) {
+          if (v.name === passName) i = idx;
+        });
+        if (i === false) throw new Error("No such pass");
+        passes.splice(i++, 0, callback);
+      };
+    },
+    7640: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var httpNative = __nccwpck_require__(8611),
+        httpsNative = __nccwpck_require__(5692),
+        web_o = __nccwpck_require__(382),
+        common = __nccwpck_require__(6758),
+        followRedirects = __nccwpck_require__(8977);
+      web_o = Object.keys(web_o).map(function (pass) {
+        return web_o[pass];
+      });
+      var nativeAgents = { http: httpNative, https: httpsNative };
+      /*!
+       * Array of passes.
+       *
+       * A `pass` is just a function that is executed on `req, res, options`
+       * so that you can easily add new checks while still keeping the base
+       * flexible.
+       */ module.exports = {
+        deleteLength: function deleteLength(req, res, options) {
+          if (
+            (req.method === "DELETE" || req.method === "OPTIONS") &&
+            !req.headers["content-length"]
+          ) {
+            req.headers["content-length"] = "0";
+            delete req.headers["transfer-encoding"];
           }
-        }
-        setProvider(fn) {
-          if (fn && this.isValidProvider(fn)) {
-            this.provider = fn(defaultProvider);
+        },
+        timeout: function timeout(req, res, options) {
+          if (options.timeout) {
+            req.socket.setTimeout(options.timeout);
           }
-        }
-        isValidProvider(fnProvider) {
-          const result = true;
-          if (fnProvider && typeof fnProvider !== "function") {
-            throw new Error(
-              "[HPM] Log provider config error. Expecting a function.",
+        },
+        XHeaders: function XHeaders(req, res, options) {
+          if (!options.xfwd) return;
+          var encrypted = req.isSpdy || common.hasEncryptedConnection(req);
+          var values = {
+            for: req.connection.remoteAddress || req.socket.remoteAddress,
+            port: common.getPort(req),
+            proto: encrypted ? "https" : "http",
+          };
+          ["for", "port", "proto"].forEach(function (header) {
+            req.headers["x-forwarded-" + header] =
+              (req.headers["x-forwarded-" + header] || "") +
+              (req.headers["x-forwarded-" + header] ? "," : "") +
+              values[header];
+          });
+          req.headers["x-forwarded-host"] =
+            req.headers["x-forwarded-host"] || req.headers["host"] || "";
+        },
+        stream: function stream(req, res, options, _, server, clb) {
+          server.emit("start", req, res, options.target || options.forward);
+          var agents = options.followRedirects ? followRedirects : nativeAgents;
+          var http = agents.http;
+          var https = agents.https;
+          if (options.forward) {
+            var forwardReq = (
+              options.forward.protocol === "https:" ? https : http
+            ).request(
+              common.setupOutgoing(options.ssl || {}, options, req, "forward"),
             );
+            var forwardError = createErrorHandler(forwardReq, options.forward);
+            req.on("error", forwardError);
+            forwardReq.on("error", forwardError);
+            (options.buffer || req).pipe(forwardReq);
+            if (!options.target) {
+              return res.end();
+            }
           }
-          return result;
-        }
-        isValidLevel(levelName) {
-          const validLevels = Object.keys(LEVELS);
-          const isValid = validLevels.includes(levelName);
-          if (!isValid) {
-            throw new Error("[HPM] Log level error. Invalid logLevel.");
-          }
-          return isValid;
-        }
-        _showLevel(showLevel) {
-          let result = false;
-          const currentLogLevel = LEVELS[this.logLevel];
-          if (currentLogLevel && currentLogLevel <= LEVELS[showLevel]) {
-            result = true;
-          }
-          return result;
-        }
-        _interpolate(format, ...args) {
-          const result = util.format(format, ...args);
-          return result;
-        }
-      }
-      function getArrow(originalPath, newPath, originalTarget, newTarget) {
-        const arrow = [">"];
-        const isNewTarget = originalTarget !== newTarget;
-        const isNewPath = originalPath !== newPath;
-        if (isNewPath && !isNewTarget) {
-          arrow.unshift("~");
-        } else if (!isNewPath && isNewTarget) {
-          arrow.unshift("=");
-        } else if (isNewPath && isNewTarget) {
-          arrow.unshift("≈");
-        } else {
-          arrow.unshift("-");
-        }
-        return arrow.join("");
-      }
-      exports.getArrow = getArrow;
-    },
-    6241: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.createPathRewriter = void 0;
-      const isPlainObj = __nccwpck_require__(3458);
-      const errors_1 = __nccwpck_require__(4618);
-      const logger_1 = __nccwpck_require__(8045);
-      const logger = (0, logger_1.getInstance)();
-      function createPathRewriter(rewriteConfig) {
-        let rulesCache;
-        if (!isValidRewriteConfig(rewriteConfig)) {
-          return;
-        }
-        if (typeof rewriteConfig === "function") {
-          const customRewriteFn = rewriteConfig;
-          return customRewriteFn;
-        } else {
-          rulesCache = parsePathRewriteRules(rewriteConfig);
-          return rewritePath;
-        }
-        function rewritePath(path) {
-          let result = path;
-          for (const rule of rulesCache) {
-            if (rule.regex.test(path)) {
-              result = result.replace(rule.regex, rule.value);
-              logger.debug(
-                '[HPM] Rewriting path from "%s" to "%s"',
-                path,
-                result,
-              );
-              break;
+          var proxyReq = (
+            options.target.protocol === "https:" ? https : http
+          ).request(common.setupOutgoing(options.ssl || {}, options, req));
+          proxyReq.on("socket", function (socket) {
+            if (server && !proxyReq.getHeader("expect")) {
+              server.emit("proxyReq", proxyReq, req, res, options);
             }
+          });
+          if (options.proxyTimeout) {
+            proxyReq.setTimeout(options.proxyTimeout, function () {
+              proxyReq.abort();
+            });
           }
-          return result;
-        }
-      }
-      exports.createPathRewriter = createPathRewriter;
-      function isValidRewriteConfig(rewriteConfig) {
-        if (typeof rewriteConfig === "function") {
-          return true;
-        } else if (isPlainObj(rewriteConfig)) {
-          return Object.keys(rewriteConfig).length !== 0;
-        } else if (rewriteConfig === undefined || rewriteConfig === null) {
-          return false;
-        } else {
-          throw new Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
-        }
-      }
-      function parsePathRewriteRules(rewriteConfig) {
-        const rules = [];
-        if (isPlainObj(rewriteConfig)) {
-          for (const [key] of Object.entries(rewriteConfig)) {
-            rules.push({ regex: new RegExp(key), value: rewriteConfig[key] });
-            logger.info(
-              '[HPM] Proxy rewrite rule created: "%s" ~> "%s"',
-              key,
-              rewriteConfig[key],
-            );
+          req.on("aborted", function () {
+            proxyReq.abort();
+          });
+          var proxyError = createErrorHandler(proxyReq, options.target);
+          req.on("error", proxyError);
+          proxyReq.on("error", proxyError);
+          function createErrorHandler(proxyReq, url) {
+            return function proxyError(err) {
+              if (req.socket.destroyed && err.code === "ECONNRESET") {
+                server.emit("econnreset", err, req, res, url);
+                return proxyReq.abort();
+              }
+              if (clb) {
+                clb(err, req, res, url);
+              } else {
+                server.emit("error", err, req, res, url);
+              }
+            };
           }
-        }
-        return rules;
-      }
-    },
-    604: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.getTarget = void 0;
-      const isPlainObj = __nccwpck_require__(3458);
-      const logger_1 = __nccwpck_require__(8045);
-      const logger = (0, logger_1.getInstance)();
-      async function getTarget(req, config) {
-        let newTarget;
-        const router = config.router;
-        if (isPlainObj(router)) {
-          newTarget = getTargetFromProxyTable(req, router);
-        } else if (typeof router === "function") {
-          newTarget = await router(req);
-        }
-        return newTarget;
-      }
-      exports.getTarget = getTarget;
-      function getTargetFromProxyTable(req, table) {
-        let result;
-        const host = req.headers.host;
-        const path = req.url;
-        const hostAndPath = host + path;
-        for (const [key] of Object.entries(table)) {
-          if (containsPath(key)) {
-            if (hostAndPath.indexOf(key) > -1) {
-              result = table[key];
-              logger.debug('[HPM] Router table match: "%s"', key);
-              break;
+          (options.buffer || req).pipe(proxyReq);
+          proxyReq.on("response", function (proxyRes) {
+            if (server) {
+              server.emit("proxyRes", proxyRes, req, res);
             }
-          } else {
-            if (key === host) {
-              result = table[key];
-              logger.debug('[HPM] Router table match: "%s"', host);
-              break;
+            if (!res.headersSent && !options.selfHandleResponse) {
+              for (var i = 0; i < web_o.length; i++) {
+                if (web_o[i](req, res, proxyRes, options)) {
+                  break;
+                }
+              }
             }
-          }
-        }
-        return result;
-      }
-      function containsPath(v) {
-        return v.indexOf("/") > -1;
-      }
+            if (!res.finished) {
+              proxyRes.on("end", function () {
+                if (server) server.emit("end", req, res, proxyRes);
+              });
+              if (!options.selfHandleResponse) proxyRes.pipe(res);
+            } else {
+              if (server) server.emit("end", req, res, proxyRes);
+            }
+          });
+        },
+      };
     },
-    4484: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    382: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var url = __nccwpck_require__(7016),
+        common = __nccwpck_require__(6758);
+      var redirectRegex = /^201|30(1|2|7|8)$/;
       /*!
-       * Caron dimonio, con occhi di bragia
-       * loro accennando, tutte le raccoglie;
-       * batte col remo qualunque s’adagia
-       *
-       * Charon the demon, with the eyes of glede,
-       * Beckoning to them, collects them all together,
-       * Beats with his oar whoever lags behind
+       * Array of passes.
        *
-       *          Dante - The Divine Comedy (Canto III)
-       */
-      module.exports = __nccwpck_require__(5175);
-    },
-    5175: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      var ProxyServer = __nccwpck_require__(1152).Server;
-      function createProxyServer(options) {
-        return new ProxyServer(options);
-      }
-      ProxyServer.createProxyServer = createProxyServer;
-      ProxyServer.createServer = createProxyServer;
-      ProxyServer.createProxy = createProxyServer;
-      module.exports = ProxyServer;
-    },
-    2915: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      var common = exports,
-        url = __nccwpck_require__(7016),
-        required = __nccwpck_require__(7866);
-      var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i,
-        isSSL = /^https|wss/;
-      common.isSSL = isSSL;
-      common.setupOutgoing = function (outgoing, options, req, forward) {
-        outgoing.port =
-          options[forward || "target"].port ||
-          (isSSL.test(options[forward || "target"].protocol) ? 443 : 80);
-        [
-          "host",
-          "hostname",
-          "socketPath",
-          "pfx",
-          "key",
-          "passphrase",
-          "cert",
-          "ca",
-          "ciphers",
-          "secureProtocol",
-        ].forEach(function (e) {
-          outgoing[e] = options[forward || "target"][e];
-        });
-        outgoing.method = options.method || req.method;
-        outgoing.headers = Object.assign({}, req.headers);
-        if (options.headers) {
-          Object.assign(outgoing.headers, options.headers);
-        }
-        if (options.auth) {
-          outgoing.auth = options.auth;
-        }
-        if (options.ca) {
-          outgoing.ca = options.ca;
-        }
-        if (isSSL.test(options[forward || "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 || {};
+       * A `pass` is just a function that is executed on `req, res, options`
+       * so that you can easily add new checks while still keeping the base
+       * flexible.
+       */ module.exports = {
+        removeChunked: function removeChunked(req, res, proxyRes) {
+          if (req.httpVersion === "1.0") {
+            delete proxyRes.headers["transfer-encoding"];
+          }
+        },
+        setConnection: 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";
+          }
+        },
+        setRedirectHostRewrite: function setRedirectHostRewrite(
+          req,
+          res,
+          proxyRes,
+          options,
+        ) {
           if (
-            typeof outgoing.headers.connection !== "string" ||
-            !upgradeHeader.test(outgoing.headers.connection)
+            (options.hostRewrite ||
+              options.autoRewrite ||
+              options.protocolRewrite) &&
+            proxyRes.headers["location"] &&
+            redirectRegex.test(proxyRes.statusCode)
           ) {
-            outgoing.headers.connection = "close";
+            var target = url.parse(options.target);
+            var u = url.parse(proxyRes.headers["location"]);
+            if (target.host != u.host) {
+              return;
+            }
+            if (options.hostRewrite) {
+              u.host = options.hostRewrite;
+            } else if (options.autoRewrite) {
+              u.host = req.headers["host"];
+            }
+            if (options.protocolRewrite) {
+              u.protocol = options.protocolRewrite;
+            }
+            proxyRes.headers["location"] = u.format();
           }
-        }
-        var target = options[forward || "target"];
-        var targetPath =
-          target && options.prependPath !== false ? target.path || "" : "";
-        var outgoingPath = !options.toProxy
-          ? url.parse(req.url).path || ""
-          : req.url;
-        outgoingPath = !options.ignorePath ? outgoingPath : "";
-        outgoing.path = common.urlJoin(targetPath, outgoingPath);
-        if (options.changeOrigin) {
-          outgoing.headers.host =
-            required(outgoing.port, options[forward || "target"].protocol) &&
-            !hasPort(outgoing.host)
-              ? outgoing.host + ":" + outgoing.port
-              : outgoing.host;
-        }
-        return outgoing;
-      };
-      common.setupSocket = function (socket) {
-        socket.setTimeout(0);
-        socket.setNoDelay(true);
-        socket.setKeepAlive(true, 0);
-        return socket;
-      };
-      common.getPort = function (req) {
-        var res = req.headers.host ? req.headers.host.match(/:(\d+)/) : "";
-        return res ? res[1] : common.hasEncryptedConnection(req) ? "443" : "80";
-      };
-      common.hasEncryptedConnection = function (req) {
-        return Boolean(req.connection.encrypted || req.connection.pair);
-      };
-      common.urlJoin = function () {
-        var args = Array.prototype.slice.call(arguments),
-          lastIndex = args.length - 1,
-          last = args[lastIndex],
-          lastSegs = last.split("?"),
-          retSegs;
-        args[lastIndex] = lastSegs.shift();
-        retSegs = [
-          args
-            .filter(Boolean)
-            .join("/")
-            .replace(/\/+/g, "/")
-            .replace("http:/", "http://")
-            .replace("https:/", "https://"),
-        ];
-        retSegs.push.apply(retSegs, lastSegs);
-        return retSegs.join("?");
-      };
-      common.rewriteCookieProperty = function rewriteCookieProperty(
-        header,
-        config,
-        property,
-      ) {
-        if (Array.isArray(header)) {
-          return header.map(function (headerElement) {
-            return rewriteCookieProperty(headerElement, config, property);
-          });
-        }
-        return header.replace(
-          new RegExp("(;\\s*" + property + "=)([^;]+)", "i"),
-          function (match, prefix, previousValue) {
-            var 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(":");
-      }
-    },
-    1152: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      var httpProxy = module.exports,
-        parse_url = __nccwpck_require__(7016).parse,
-        EE3 = __nccwpck_require__(6234),
-        http = __nccwpck_require__(8611),
-        https = __nccwpck_require__(5692),
-        web = __nccwpck_require__(9043),
-        ws = __nccwpck_require__(2725);
-      httpProxy.Server = ProxyServer;
-      function createRightProxy(type) {
-        return function (options) {
-          return function (req, res) {
-            var passes = type === "ws" ? this.wsPasses : this.webPasses,
-              args = [].slice.call(arguments),
-              cntr = args.length - 1,
-              head,
-              cbl;
-            if (typeof args[cntr] === "function") {
-              cbl = args[cntr];
-              cntr--;
-            }
-            var requestOptions = options;
-            if (!(args[cntr] instanceof Buffer) && args[cntr] !== res) {
-              requestOptions = Object.assign({}, options);
-              Object.assign(requestOptions, args[cntr]);
-              cntr--;
-            }
-            if (args[cntr] instanceof Buffer) {
-              head = args[cntr];
-            }
-            ["target", "forward"].forEach(function (e) {
-              if (typeof requestOptions[e] === "string")
-                requestOptions[e] = parse_url(requestOptions[e]);
-            });
-            if (!requestOptions.target && !requestOptions.forward) {
-              return this.emit(
-                "error",
-                new Error("Must provide a proper URL as target"),
-              );
-            }
-            for (var i = 0; i < passes.length; i++) {
-              if (passes[i](req, res, requestOptions, head, this, cbl)) {
-                break;
+        },
+        writeHeaders: function writeHeaders(req, res, proxyRes, options) {
+          var rewriteCookieDomainConfig = options.cookieDomainRewrite,
+            rewriteCookiePathConfig = options.cookiePathRewrite,
+            preserveHeaderKeyCase = options.preserveHeaderKeyCase,
+            rawHeaderKeyMap,
+            setHeader = function (key, header) {
+              if (header == undefined) return;
+              if (
+                rewriteCookieDomainConfig &&
+                key.toLowerCase() === "set-cookie"
+              ) {
+                header = common.rewriteCookieProperty(
+                  header,
+                  rewriteCookieDomainConfig,
+                  "domain",
+                );
+              }
+              if (
+                rewriteCookiePathConfig &&
+                key.toLowerCase() === "set-cookie"
+              ) {
+                header = common.rewriteCookieProperty(
+                  header,
+                  rewriteCookiePathConfig,
+                  "path",
+                );
               }
+              res.setHeader(String(key).trim(), header);
+            };
+          if (typeof rewriteCookieDomainConfig === "string") {
+            rewriteCookieDomainConfig = { "*": rewriteCookieDomainConfig };
+          }
+          if (typeof rewriteCookiePathConfig === "string") {
+            rewriteCookiePathConfig = { "*": rewriteCookiePathConfig };
+          }
+          if (preserveHeaderKeyCase && proxyRes.rawHeaders != undefined) {
+            rawHeaderKeyMap = {};
+            for (var i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+              var key = proxyRes.rawHeaders[i];
+              rawHeaderKeyMap[key.toLowerCase()] = key;
             }
-          };
-        };
-      }
-      httpProxy.createRightProxy = createRightProxy;
-      function ProxyServer(options) {
-        EE3.call(this);
-        options = options || {};
-        options.prependPath = options.prependPath === false ? false : true;
-        this.web = this.proxyRequest = createRightProxy("web")(options);
-        this.ws = this.proxyWebsocketRequest = createRightProxy("ws")(options);
-        this.options = options;
-        this.webPasses = Object.keys(web).map(function (pass) {
-          return web[pass];
-        });
-        this.wsPasses = Object.keys(ws).map(function (pass) {
-          return ws[pass];
-        });
-        this.on("error", this.onError, this);
-      }
-      __nccwpck_require__(9023).inherits(ProxyServer, EE3);
-      ProxyServer.prototype.onError = function (err) {
-        if (this.listeners("error").length === 1) {
-          throw err;
-        }
-      };
-      ProxyServer.prototype.listen = function (port, hostname) {
-        var self = this,
-          closure = function (req, res) {
-            self.web(req, res);
-          };
-        this._server = this.options.ssl
-          ? https.createServer(this.options.ssl, closure)
-          : http.createServer(closure);
-        if (this.options.ws) {
-          this._server.on("upgrade", function (req, socket, head) {
-            self.ws(req, socket, head);
+          }
+          Object.keys(proxyRes.headers).forEach(function (key) {
+            var header = proxyRes.headers[key];
+            if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+              key = rawHeaderKeyMap[key] || key;
+            }
+            setHeader(key, header);
           });
-        }
-        this._server.listen(port, hostname);
-        return this;
-      };
-      ProxyServer.prototype.close = function (callback) {
-        var self = this;
-        if (this._server) {
-          this._server.close(done);
-        }
-        function done() {
-          self._server = null;
-          if (callback) {
-            callback.apply(null, arguments);
+        },
+        writeStatusCode: function writeStatusCode(req, res, proxyRes) {
+          if (proxyRes.statusMessage) {
+            res.statusCode = proxyRes.statusCode;
+            res.statusMessage = proxyRes.statusMessage;
+          } else {
+            res.statusCode = proxyRes.statusCode;
           }
-        }
-      };
-      ProxyServer.prototype.before = function (type, passName, callback) {
-        if (type !== "ws" && type !== "web") {
-          throw new Error("type must be `web` or `ws`");
-        }
-        var passes = type === "ws" ? this.wsPasses : this.webPasses,
-          i = false;
-        passes.forEach(function (v, idx) {
-          if (v.name === passName) i = idx;
-        });
-        if (i === false) throw new Error("No such pass");
-        passes.splice(i, 0, callback);
-      };
-      ProxyServer.prototype.after = function (type, passName, callback) {
-        if (type !== "ws" && type !== "web") {
-          throw new Error("type must be `web` or `ws`");
-        }
-        var passes = type === "ws" ? this.wsPasses : this.webPasses,
-          i = false;
-        passes.forEach(function (v, idx) {
-          if (v.name === passName) i = idx;
-        });
-        if (i === false) throw new Error("No such pass");
-        passes.splice(i++, 0, callback);
+        },
       };
     },
-    9043: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      var httpNative = __nccwpck_require__(8611),
-        httpsNative = __nccwpck_require__(5692),
-        web_o = __nccwpck_require__(9905),
-        common = __nccwpck_require__(2915),
-        followRedirects = __nccwpck_require__(1584);
-      web_o = Object.keys(web_o).map(function (pass) {
-        return web_o[pass];
-      });
-      var nativeAgents = { http: httpNative, https: httpsNative };
+    2264: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var http = __nccwpck_require__(8611),
+        https = __nccwpck_require__(5692),
+        common = __nccwpck_require__(6758);
       /*!
        * Array of passes.
        *
-       * A `pass` is just a function that is executed on `req, res, options`
+       * A `pass` is just a function that is executed on `req, socket, options`
        * so that you can easily add new checks while still keeping the base
        * flexible.
        */ module.exports = {
-        deleteLength: function deleteLength(req, res, options) {
-          if (
-            (req.method === "DELETE" || req.method === "OPTIONS") &&
-            !req.headers["content-length"]
-          ) {
-            req.headers["content-length"] = "0";
-            delete req.headers["transfer-encoding"];
-          }
-        },
-        timeout: function timeout(req, res, options) {
-          if (options.timeout) {
-            req.socket.setTimeout(options.timeout);
-          }
-        },
-        XHeaders: function XHeaders(req, res, options) {
-          if (!options.xfwd) return;
-          var encrypted = req.isSpdy || common.hasEncryptedConnection(req);
-          var values = {
-            for: req.connection.remoteAddress || req.socket.remoteAddress,
-            port: common.getPort(req),
-            proto: encrypted ? "https" : "http",
-          };
-          ["for", "port", "proto"].forEach(function (header) {
-            req.headers["x-forwarded-" + header] =
-              (req.headers["x-forwarded-" + header] || "") +
-              (req.headers["x-forwarded-" + header] ? "," : "") +
-              values[header];
-          });
-          req.headers["x-forwarded-host"] =
-            req.headers["x-forwarded-host"] || req.headers["host"] || "";
-        },
-        stream: function stream(req, res, options, _, server, clb) {
-          server.emit("start", req, res, options.target || options.forward);
-          var agents = options.followRedirects ? followRedirects : nativeAgents;
-          var http = agents.http;
-          var https = agents.https;
-          if (options.forward) {
-            var forwardReq = (
-              options.forward.protocol === "https:" ? https : http
-            ).request(
-              common.setupOutgoing(options.ssl || {}, options, req, "forward"),
-            );
-            var forwardError = createErrorHandler(forwardReq, options.forward);
-            req.on("error", forwardError);
-            forwardReq.on("error", forwardError);
-            (options.buffer || req).pipe(forwardReq);
-            if (!options.target) {
-              return res.end();
-            }
-          }
-          var proxyReq = (
-            options.target.protocol === "https:" ? https : http
-          ).request(common.setupOutgoing(options.ssl || {}, options, req));
-          proxyReq.on("socket", function (socket) {
-            if (server && !proxyReq.getHeader("expect")) {
-              server.emit("proxyReq", proxyReq, req, res, options);
-            }
-          });
-          if (options.proxyTimeout) {
-            proxyReq.setTimeout(options.proxyTimeout, function () {
-              proxyReq.abort();
-            });
-          }
-          req.on("aborted", function () {
-            proxyReq.abort();
-          });
-          var proxyError = createErrorHandler(proxyReq, options.target);
-          req.on("error", proxyError);
-          proxyReq.on("error", proxyError);
-          function createErrorHandler(proxyReq, url) {
-            return function proxyError(err) {
-              if (req.socket.destroyed && err.code === "ECONNRESET") {
-                server.emit("econnreset", err, req, res, url);
-                return proxyReq.abort();
-              }
-              if (clb) {
-                clb(err, req, res, url);
-              } else {
-                server.emit("error", err, req, res, url);
-              }
-            };
-          }
-          (options.buffer || req).pipe(proxyReq);
-          proxyReq.on("response", function (proxyRes) {
-            if (server) {
-              server.emit("proxyRes", proxyRes, req, res);
-            }
-            if (!res.headersSent && !options.selfHandleResponse) {
-              for (var i = 0; i < web_o.length; i++) {
-                if (web_o[i](req, res, proxyRes, options)) {
-                  break;
-                }
-              }
-            }
-            if (!res.finished) {
-              proxyRes.on("end", function () {
-                if (server) server.emit("end", req, res, proxyRes);
-              });
-              if (!options.selfHandleResponse) proxyRes.pipe(res);
-            } else {
-              if (server) server.emit("end", req, res, proxyRes);
-            }
-          });
-        },
-      };
-    },
-    9905: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      var url = __nccwpck_require__(7016),
-        common = __nccwpck_require__(2915);
-      var redirectRegex = /^201|30(1|2|7|8)$/;
-      /*!
-       * Array of passes.
-       *
-       * A `pass` is just a function that is executed on `req, res, options`
-       * so that you can easily add new checks while still keeping the base
-       * flexible.
-       */ module.exports = {
-        removeChunked: function removeChunked(req, res, proxyRes) {
-          if (req.httpVersion === "1.0") {
-            delete proxyRes.headers["transfer-encoding"];
-          }
-        },
-        setConnection: 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";
-          }
-        },
-        setRedirectHostRewrite: function setRedirectHostRewrite(
-          req,
-          res,
-          proxyRes,
-          options,
-        ) {
-          if (
-            (options.hostRewrite ||
-              options.autoRewrite ||
-              options.protocolRewrite) &&
-            proxyRes.headers["location"] &&
-            redirectRegex.test(proxyRes.statusCode)
-          ) {
-            var target = url.parse(options.target);
-            var u = url.parse(proxyRes.headers["location"]);
-            if (target.host != u.host) {
-              return;
-            }
-            if (options.hostRewrite) {
-              u.host = options.hostRewrite;
-            } else if (options.autoRewrite) {
-              u.host = req.headers["host"];
-            }
-            if (options.protocolRewrite) {
-              u.protocol = options.protocolRewrite;
-            }
-            proxyRes.headers["location"] = u.format();
-          }
-        },
-        writeHeaders: function writeHeaders(req, res, proxyRes, options) {
-          var rewriteCookieDomainConfig = options.cookieDomainRewrite,
-            rewriteCookiePathConfig = options.cookiePathRewrite,
-            preserveHeaderKeyCase = options.preserveHeaderKeyCase,
-            rawHeaderKeyMap,
-            setHeader = function (key, header) {
-              if (header == undefined) return;
-              if (
-                rewriteCookieDomainConfig &&
-                key.toLowerCase() === "set-cookie"
-              ) {
-                header = common.rewriteCookieProperty(
-                  header,
-                  rewriteCookieDomainConfig,
-                  "domain",
-                );
-              }
-              if (
-                rewriteCookiePathConfig &&
-                key.toLowerCase() === "set-cookie"
-              ) {
-                header = common.rewriteCookieProperty(
-                  header,
-                  rewriteCookiePathConfig,
-                  "path",
-                );
-              }
-              res.setHeader(String(key).trim(), header);
-            };
-          if (typeof rewriteCookieDomainConfig === "string") {
-            rewriteCookieDomainConfig = { "*": rewriteCookieDomainConfig };
-          }
-          if (typeof rewriteCookiePathConfig === "string") {
-            rewriteCookiePathConfig = { "*": rewriteCookiePathConfig };
-          }
-          if (preserveHeaderKeyCase && proxyRes.rawHeaders != undefined) {
-            rawHeaderKeyMap = {};
-            for (var i = 0; i < proxyRes.rawHeaders.length; i += 2) {
-              var key = proxyRes.rawHeaders[i];
-              rawHeaderKeyMap[key.toLowerCase()] = key;
-            }
-          }
-          Object.keys(proxyRes.headers).forEach(function (key) {
-            var header = proxyRes.headers[key];
-            if (preserveHeaderKeyCase && rawHeaderKeyMap) {
-              key = rawHeaderKeyMap[key] || key;
-            }
-            setHeader(key, header);
-          });
-        },
-        writeStatusCode: function writeStatusCode(req, res, proxyRes) {
-          if (proxyRes.statusMessage) {
-            res.statusCode = proxyRes.statusCode;
-            res.statusMessage = proxyRes.statusMessage;
-          } else {
-            res.statusCode = proxyRes.statusCode;
-          }
-        },
-      };
-    },
-    2725: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      var http = __nccwpck_require__(8611),
-        https = __nccwpck_require__(5692),
-        common = __nccwpck_require__(2915);
-      /*!
-       * Array of passes.
-       *
-       * A `pass` is just a function that is executed on `req, socket, options`
-       * so that you can easily add new checks while still keeping the base
-       * flexible.
-       */ module.exports = {
-        checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
-          if (req.method !== "GET" || !req.headers.upgrade) {
-            socket.destroy();
-            return true;
-          }
-          if (req.headers.upgrade.toLowerCase() !== "websocket") {
-            socket.destroy();
-            return true;
+        checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
+          if (req.method !== "GET" || !req.headers.upgrade) {
+            socket.destroy();
+            return true;
+          }
+          if (req.headers.upgrade.toLowerCase() !== "websocket") {
+            socket.destroy();
+            return true;
           }
         },
         XHeaders: function XHeaders(req, socket, options) {
@@ -3201,15 +2918,30 @@
         return false;
       };
     },
-    3458: (module) => {
+    634: (__unused_webpack_module, exports) => {
       "use strict";
-      module.exports = (value) => {
-        if (Object.prototype.toString.call(value) !== "[object Object]") {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      /*!
+       * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+       *
+       * Copyright (c) 2014-2017, Jon Schlinkert.
+       * Released under the MIT License.
+       */ function isObject(o) {
+        return Object.prototype.toString.call(o) === "[object Object]";
+      }
+      function isPlainObject(o) {
+        var ctor, prot;
+        if (isObject(o) === false) return false;
+        ctor = o.constructor;
+        if (ctor === undefined) return true;
+        prot = ctor.prototype;
+        if (isObject(prot) === false) return false;
+        if (prot.hasOwnProperty("isPrototypeOf") === false) {
           return false;
         }
-        const prototype = Object.getPrototypeOf(value);
-        return prototype === null || prototype === Object.prototype;
-      };
+        return true;
+      }
+      exports.isPlainObject = isPlainObject;
     },
     9555: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
@@ -3385,24 +3117,138 @@
       micromatch.hasBraces = hasBraces;
       module.exports = micromatch;
     },
-    5675: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      "use strict";
-      module.exports = __nccwpck_require__(3193);
-    },
-    7054: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      "use strict";
-      const path = __nccwpck_require__(6928);
-      const WIN_SLASH = "\\\\/";
-      const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-      const DOT_LITERAL = "\\.";
-      const PLUS_LITERAL = "\\+";
-      const QMARK_LITERAL = "\\?";
-      const SLASH_LITERAL = "\\/";
-      const ONE_CHAR = "(?=.)";
-      const QMARK = "[^/]";
-      const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-      const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-      const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    6987: (module) => {
+      var s = 1e3;
+      var m = s * 60;
+      var h = m * 60;
+      var d = h * 24;
+      var w = d * 7;
+      var y = d * 365.25;
+      module.exports = function (val, options) {
+        options = options || {};
+        var type = typeof val;
+        if (type === "string" && val.length > 0) {
+          return parse(val);
+        } else if (type === "number" && isFinite(val)) {
+          return options.long ? fmtLong(val) : fmtShort(val);
+        }
+        throw new Error(
+          "val is not a non-empty string or a valid number. val=" +
+            JSON.stringify(val),
+        );
+      };
+      function parse(str) {
+        str = String(str);
+        if (str.length > 100) {
+          return;
+        }
+        var match =
+          /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+            str,
+          );
+        if (!match) {
+          return;
+        }
+        var n = parseFloat(match[1]);
+        var type = (match[2] || "ms").toLowerCase();
+        switch (type) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return n * y;
+          case "weeks":
+          case "week":
+          case "w":
+            return n * w;
+          case "days":
+          case "day":
+          case "d":
+            return n * d;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return n * h;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return n * m;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return n * s;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return n;
+          default:
+            return undefined;
+        }
+      }
+      function fmtShort(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return Math.round(ms / d) + "d";
+        }
+        if (msAbs >= h) {
+          return Math.round(ms / h) + "h";
+        }
+        if (msAbs >= m) {
+          return Math.round(ms / m) + "m";
+        }
+        if (msAbs >= s) {
+          return Math.round(ms / s) + "s";
+        }
+        return ms + "ms";
+      }
+      function fmtLong(ms) {
+        var msAbs = Math.abs(ms);
+        if (msAbs >= d) {
+          return plural(ms, msAbs, d, "day");
+        }
+        if (msAbs >= h) {
+          return plural(ms, msAbs, h, "hour");
+        }
+        if (msAbs >= m) {
+          return plural(ms, msAbs, m, "minute");
+        }
+        if (msAbs >= s) {
+          return plural(ms, msAbs, s, "second");
+        }
+        return ms + " ms";
+      }
+      function plural(ms, msAbs, n, name) {
+        var isPlural = msAbs >= n * 1.5;
+        return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+      }
+    },
+    5675: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      module.exports = __nccwpck_require__(3193);
+    },
+    7054: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      const path = __nccwpck_require__(6928);
+      const WIN_SLASH = "\\\\/";
+      const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+      const DOT_LITERAL = "\\.";
+      const PLUS_LITERAL = "\\+";
+      const QMARK_LITERAL = "\\?";
+      const SLASH_LITERAL = "\\/";
+      const ONE_CHAR = "(?=.)";
+      const QMARK = "[^/]";
+      const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+      const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+      const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
       const NO_DOT = `(?!${DOT_LITERAL})`;
       const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
       const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
@@ -4746,514 +4592,1516 @@
                 }
                 continue;
               }
-              break;
+              break;
+            }
+          }
+          if (code === CHAR_ASTERISK) {
+            if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (code === CHAR_QUESTION_MARK) {
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (code === CHAR_LEFT_SQUARE_BRACKET) {
+            while (eos() !== true && (next = advance())) {
+              if (next === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = true;
+                advance();
+                continue;
+              }
+              if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                isBracket = token.isBracket = true;
+                isGlob = token.isGlob = true;
+                finished = true;
+                break;
+              }
+            }
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (
+            opts.nonegate !== true &&
+            code === CHAR_EXCLAMATION_MARK &&
+            index === start
+          ) {
+            negated = token.negated = true;
+            start++;
+            continue;
+          }
+          if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+            isGlob = token.isGlob = true;
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_LEFT_PARENTHESES) {
+                  backslashes = token.backslashes = true;
+                  code = advance();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+          if (isGlob === true) {
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+        }
+        if (opts.noext === true) {
+          isExtglob = false;
+          isGlob = false;
+        }
+        let base = str;
+        let prefix = "";
+        let glob = "";
+        if (start > 0) {
+          prefix = str.slice(0, start);
+          str = str.slice(start);
+          lastIndex -= start;
+        }
+        if (base && isGlob === true && lastIndex > 0) {
+          base = str.slice(0, lastIndex);
+          glob = str.slice(lastIndex);
+        } else if (isGlob === true) {
+          base = "";
+          glob = str;
+        } else {
+          base = str;
+        }
+        if (base && base !== "" && base !== "/" && base !== str) {
+          if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+            base = base.slice(0, -1);
+          }
+        }
+        if (opts.unescape === true) {
+          if (glob) glob = utils.removeBackslashes(glob);
+          if (base && backslashes === true) {
+            base = utils.removeBackslashes(base);
+          }
+        }
+        const state = {
+          prefix,
+          input,
+          start,
+          base,
+          glob,
+          isBrace,
+          isBracket,
+          isGlob,
+          isExtglob,
+          isGlobstar,
+          negated,
+          negatedExtglob,
+        };
+        if (opts.tokens === true) {
+          state.maxDepth = 0;
+          if (!isPathSeparator(code)) {
+            tokens.push(token);
+          }
+          state.tokens = tokens;
+        }
+        if (opts.parts === true || opts.tokens === true) {
+          let prevIndex;
+          for (let idx = 0; idx < slashes.length; idx++) {
+            const n = prevIndex ? prevIndex + 1 : start;
+            const i = slashes[idx];
+            const value = input.slice(n, i);
+            if (opts.tokens) {
+              if (idx === 0 && start !== 0) {
+                tokens[idx].isPrefix = true;
+                tokens[idx].value = prefix;
+              } else {
+                tokens[idx].value = value;
+              }
+              depth(tokens[idx]);
+              state.maxDepth += tokens[idx].depth;
+            }
+            if (idx !== 0 || value !== "") {
+              parts.push(value);
+            }
+            prevIndex = i;
+          }
+          if (prevIndex && prevIndex + 1 < input.length) {
+            const value = input.slice(prevIndex + 1);
+            parts.push(value);
+            if (opts.tokens) {
+              tokens[tokens.length - 1].value = value;
+              depth(tokens[tokens.length - 1]);
+              state.maxDepth += tokens[tokens.length - 1].depth;
+            }
+          }
+          state.slashes = slashes;
+          state.parts = parts;
+        }
+        return state;
+      };
+      module.exports = scan;
+    },
+    7910: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      const path = __nccwpck_require__(6928);
+      const win32 = process.platform === "win32";
+      const {
+        REGEX_BACKSLASH,
+        REGEX_REMOVE_BACKSLASH,
+        REGEX_SPECIAL_CHARS,
+        REGEX_SPECIAL_CHARS_GLOBAL,
+      } = __nccwpck_require__(7054);
+      exports.isObject = (val) =>
+        val !== null && typeof val === "object" && !Array.isArray(val);
+      exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+      exports.isRegexChar = (str) =>
+        str.length === 1 && exports.hasRegexChars(str);
+      exports.escapeRegex = (str) =>
+        str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+      exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+      exports.removeBackslashes = (str) =>
+        str.replace(REGEX_REMOVE_BACKSLASH, (match) =>
+          match === "\\" ? "" : match,
+        );
+      exports.supportsLookbehinds = () => {
+        const segs = process.version.slice(1).split(".").map(Number);
+        if (
+          (segs.length === 3 && segs[0] >= 9) ||
+          (segs[0] === 8 && segs[1] >= 10)
+        ) {
+          return true;
+        }
+        return false;
+      };
+      exports.isWindows = (options) => {
+        if (options && typeof options.windows === "boolean") {
+          return options.windows;
+        }
+        return win32 === true || path.sep === "\\";
+      };
+      exports.escapeLast = (input, char, lastIdx) => {
+        const idx = input.lastIndexOf(char, lastIdx);
+        if (idx === -1) return input;
+        if (input[idx - 1] === "\\")
+          return exports.escapeLast(input, char, idx - 1);
+        return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+      };
+      exports.removePrefix = (input, state = {}) => {
+        let output = input;
+        if (output.startsWith("./")) {
+          output = output.slice(2);
+          state.prefix = "./";
+        }
+        return output;
+      };
+      exports.wrapOutput = (input, state = {}, options = {}) => {
+        const prepend = options.contains ? "" : "^";
+        const append = options.contains ? "" : "$";
+        let output = `${prepend}(?:${input})${append}`;
+        if (state.negated === true) {
+          output = `(?:^(?!${output}).*$)`;
+        }
+        return output;
+      };
+    },
+    7866: (module) => {
+      "use strict";
+      module.exports = 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;
+          case "ftp":
+            return port !== 21;
+          case "gopher":
+            return port !== 70;
+          case "file":
+            return false;
+        }
+        return port !== 0;
+      };
+    },
+    743: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      "use strict";
+      /*!
+       * to-regex-range <https://github.com/micromatch/to-regex-range>
+       *
+       * Copyright (c) 2015-present, Jon Schlinkert.
+       * Released under the MIT License.
+       */ const isNumber = __nccwpck_require__(952);
+      const toRegexRange = (min, max, options) => {
+        if (isNumber(min) === false) {
+          throw new TypeError(
+            "toRegexRange: expected the first argument to be a number",
+          );
+        }
+        if (max === void 0 || min === max) {
+          return String(min);
+        }
+        if (isNumber(max) === false) {
+          throw new TypeError(
+            "toRegexRange: expected the second argument to be a number.",
+          );
+        }
+        let opts = { relaxZeros: true, ...options };
+        if (typeof opts.strictZeros === "boolean") {
+          opts.relaxZeros = opts.strictZeros === false;
+        }
+        let relax = String(opts.relaxZeros);
+        let shorthand = String(opts.shorthand);
+        let capture = String(opts.capture);
+        let wrap = String(opts.wrap);
+        let cacheKey =
+          min + ":" + max + "=" + relax + shorthand + capture + wrap;
+        if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+          return toRegexRange.cache[cacheKey].result;
+        }
+        let a = Math.min(min, max);
+        let b = Math.max(min, max);
+        if (Math.abs(a - b) === 1) {
+          let result = min + "|" + max;
+          if (opts.capture) {
+            return `(${result})`;
+          }
+          if (opts.wrap === false) {
+            return result;
+          }
+          return `(?:${result})`;
+        }
+        let isPadded = hasPadding(min) || hasPadding(max);
+        let state = { min, max, a, b };
+        let positives = [];
+        let negatives = [];
+        if (isPadded) {
+          state.isPadded = isPadded;
+          state.maxLen = String(state.max).length;
+        }
+        if (a < 0) {
+          let newMin = b < 0 ? Math.abs(b) : 1;
+          negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+          a = state.a = 0;
+        }
+        if (b >= 0) {
+          positives = splitToPatterns(a, b, state, opts);
+        }
+        state.negatives = negatives;
+        state.positives = positives;
+        state.result = collatePatterns(negatives, positives, opts);
+        if (opts.capture === true) {
+          state.result = `(${state.result})`;
+        } else if (
+          opts.wrap !== false &&
+          positives.length + negatives.length > 1
+        ) {
+          state.result = `(?:${state.result})`;
+        }
+        toRegexRange.cache[cacheKey] = state;
+        return state.result;
+      };
+      function collatePatterns(neg, pos, options) {
+        let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
+        let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
+        let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
+        let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+        return subpatterns.join("|");
+      }
+      function splitToRanges(min, max) {
+        let nines = 1;
+        let zeros = 1;
+        let stop = countNines(min, nines);
+        let stops = new Set([max]);
+        while (min <= stop && stop <= max) {
+          stops.add(stop);
+          nines += 1;
+          stop = countNines(min, nines);
+        }
+        stop = countZeros(max + 1, zeros) - 1;
+        while (min < stop && stop <= max) {
+          stops.add(stop);
+          zeros += 1;
+          stop = countZeros(max + 1, zeros) - 1;
+        }
+        stops = [...stops];
+        stops.sort(compare);
+        return stops;
+      }
+      function rangeToPattern(start, stop, options) {
+        if (start === stop) {
+          return { pattern: start, count: [], digits: 0 };
+        }
+        let zipped = zip(start, stop);
+        let digits = zipped.length;
+        let pattern = "";
+        let count = 0;
+        for (let i = 0; i < digits; i++) {
+          let [startDigit, stopDigit] = zipped[i];
+          if (startDigit === stopDigit) {
+            pattern += startDigit;
+          } else if (startDigit !== "0" || stopDigit !== "9") {
+            pattern += toCharacterClass(startDigit, stopDigit, options);
+          } else {
+            count++;
+          }
+        }
+        if (count) {
+          pattern += options.shorthand === true ? "\\d" : "[0-9]";
+        }
+        return { pattern, count: [count], digits };
+      }
+      function splitToPatterns(min, max, tok, options) {
+        let ranges = splitToRanges(min, max);
+        let tokens = [];
+        let start = min;
+        let prev;
+        for (let i = 0; i < ranges.length; i++) {
+          let max = ranges[i];
+          let obj = rangeToPattern(String(start), String(max), options);
+          let zeros = "";
+          if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+            if (prev.count.length > 1) {
+              prev.count.pop();
+            }
+            prev.count.push(obj.count[0]);
+            prev.string = prev.pattern + toQuantifier(prev.count);
+            start = max + 1;
+            continue;
+          }
+          if (tok.isPadded) {
+            zeros = padZeros(max, tok, options);
+          }
+          obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+          tokens.push(obj);
+          start = max + 1;
+          prev = obj;
+        }
+        return tokens;
+      }
+      function filterPatterns(arr, comparison, prefix, intersection, options) {
+        let result = [];
+        for (let ele of arr) {
+          let { string } = ele;
+          if (!intersection && !contains(comparison, "string", string)) {
+            result.push(prefix + string);
+          }
+          if (intersection && contains(comparison, "string", string)) {
+            result.push(prefix + string);
+          }
+        }
+        return result;
+      }
+      function zip(a, b) {
+        let arr = [];
+        for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+        return arr;
+      }
+      function compare(a, b) {
+        return a > b ? 1 : b > a ? -1 : 0;
+      }
+      function contains(arr, key, val) {
+        return arr.some((ele) => ele[key] === val);
+      }
+      function countNines(min, len) {
+        return Number(String(min).slice(0, -len) + "9".repeat(len));
+      }
+      function countZeros(integer, zeros) {
+        return integer - (integer % Math.pow(10, zeros));
+      }
+      function toQuantifier(digits) {
+        let [start = 0, stop = ""] = digits;
+        if (stop || start > 1) {
+          return `{${start + (stop ? "," + stop : "")}}`;
+        }
+        return "";
+      }
+      function toCharacterClass(a, b, options) {
+        return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
+      }
+      function hasPadding(str) {
+        return /^-?(0+)\d/.test(str);
+      }
+      function padZeros(value, tok, options) {
+        if (!tok.isPadded) {
+          return value;
+        }
+        let diff = Math.abs(tok.maxLen - String(value).length);
+        let relax = options.relaxZeros !== false;
+        switch (diff) {
+          case 0:
+            return "";
+          case 1:
+            return relax ? "0?" : "0";
+          case 2:
+            return relax ? "0{0,2}" : "00";
+          default: {
+            return relax ? `0{0,${diff}}` : `0{${diff}}`;
+          }
+        }
+      }
+      toRegexRange.cache = {};
+      toRegexRange.clearCache = () => (toRegexRange.cache = {});
+      module.exports = toRegexRange;
+    },
+    115: (module) => {
+      module.exports = eval("require")("supports-color");
+    },
+    2613: (module) => {
+      "use strict";
+      module.exports = require("assert");
+    },
+    8611: (module) => {
+      "use strict";
+      module.exports = require("http");
+    },
+    5692: (module) => {
+      "use strict";
+      module.exports = require("https");
+    },
+    6928: (module) => {
+      "use strict";
+      module.exports = require("path");
+    },
+    3480: (module) => {
+      "use strict";
+      module.exports = require("querystring");
+    },
+    2203: (module) => {
+      "use strict";
+      module.exports = require("stream");
+    },
+    2018: (module) => {
+      "use strict";
+      module.exports = require("tty");
+    },
+    7016: (module) => {
+      "use strict";
+      module.exports = require("url");
+    },
+    9023: (module) => {
+      "use strict";
+      module.exports = require("util");
+    },
+    3106: (module) => {
+      "use strict";
+      module.exports = require("zlib");
+    },
+    1783: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.verifyConfig = verifyConfig;
+      const errors_1 = __nccwpck_require__(4006);
+      function verifyConfig(options) {
+        if (!options.target && !options.router) {
+          throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+        }
+      }
+    },
+    5342: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.Debug = void 0;
+      const createDebug = __nccwpck_require__(6675);
+      exports.Debug = createDebug("http-proxy-middleware");
+    },
+    4006: (__unused_webpack_module, exports) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ERRORS = void 0;
+      var ERRORS;
+      (function (ERRORS) {
+        ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] =
+          '[HPM] Missing "target" option. Example: {target: "http://www.example.org"}';
+        ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] =
+          '[HPM] Invalid pathFilter. Expecting something like: "/api" or ["/api", "/ajax"]';
+        ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] =
+          '[HPM] Invalid pathFilter. Plain paths (e.g. "/api") can not be mixed with globs (e.g. "/api/**"). Expecting something like: ["/api", "/ajax"] or ["/api/**", "!**.html"].';
+        ERRORS["ERR_PATH_REWRITER_CONFIG"] =
+          "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
+      })(ERRORS || (exports.ERRORS = ERRORS = {}));
+    },
+    1179: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.createProxyMiddleware = createProxyMiddleware;
+      const http_proxy_middleware_1 = __nccwpck_require__(3501);
+      function createProxyMiddleware(options) {
+        const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(
+          options,
+        );
+        return middleware;
+      }
+    },
+    4828: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getPlugins = getPlugins;
+      const default_1 = __nccwpck_require__(3024);
+      function getPlugins(options) {
+        const maybeErrorResponsePlugin = options.on?.error
+          ? []
+          : [default_1.errorResponsePlugin];
+        const defaultPlugins = options.ejectPlugins
+          ? []
+          : [
+              default_1.debugProxyErrorsPlugin,
+              default_1.proxyEventsPlugin,
+              default_1.loggerPlugin,
+              ...maybeErrorResponsePlugin,
+            ];
+        const userPlugins = options.plugins ?? [];
+        return [...defaultPlugins, ...userPlugins];
+      }
+    },
+    2609: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.fixRequestBody = fixRequestBody;
+      const querystring = __nccwpck_require__(3480);
+      function fixRequestBody(proxyReq, req) {
+        if (req.readableLength !== 0) {
+          return;
+        }
+        const requestBody = req.body;
+        if (!requestBody) {
+          return;
+        }
+        const contentType = proxyReq.getHeader("Content-Type");
+        if (!contentType) {
+          return;
+        }
+        const writeBody = (bodyData) => {
+          proxyReq.setHeader("Content-Length", Buffer.byteLength(bodyData));
+          proxyReq.write(bodyData);
+        };
+        if (
+          contentType.includes("application/json") ||
+          contentType.includes("+json")
+        ) {
+          writeBody(JSON.stringify(requestBody));
+        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          writeBody(querystring.stringify(requestBody));
+        } else if (contentType.includes("multipart/form-data")) {
+          writeBody(handlerFormDataBodyData(contentType, requestBody));
+        }
+      }
+      function handlerFormDataBodyData(contentType, data) {
+        const boundary = contentType.replace(/^.*boundary=(.*)$/, "$1");
+        let str = "";
+        for (const [key, value] of Object.entries(data)) {
+          str += `--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`;
+        }
+        return str;
+      }
+    },
+    3623: function (__unused_webpack_module, exports, __nccwpck_require__) {
+      "use strict";
+      var __createBinding =
+        (this && this.__createBinding) ||
+        (Object.create
+          ? function (o, m, k, k2) {
+              if (k2 === undefined) 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(o, k2, desc);
+            }
+          : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+            });
+      var __exportStar =
+        (this && this.__exportStar) ||
+        function (m, exports) {
+          for (var p in m)
+            if (
+              p !== "default" &&
+              !Object.prototype.hasOwnProperty.call(exports, p)
+            )
+              __createBinding(exports, m, p);
+        };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(__nccwpck_require__(1310), exports);
+    },
+    1310: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.fixRequestBody = exports.responseInterceptor = void 0;
+      var response_interceptor_1 = __nccwpck_require__(4566);
+      Object.defineProperty(exports, "responseInterceptor", {
+        enumerable: true,
+        get: function () {
+          return response_interceptor_1.responseInterceptor;
+        },
+      });
+      var fix_request_body_1 = __nccwpck_require__(2609);
+      Object.defineProperty(exports, "fixRequestBody", {
+        enumerable: true,
+        get: function () {
+          return fix_request_body_1.fixRequestBody;
+        },
+      });
+    },
+    4566: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.responseInterceptor = responseInterceptor;
+      const zlib = __nccwpck_require__(3106);
+      const debug_1 = __nccwpck_require__(5342);
+      const function_1 = __nccwpck_require__(7);
+      const debug = debug_1.Debug.extend("response-interceptor");
+      function responseInterceptor(interceptor) {
+        return async function proxyResResponseInterceptor(proxyRes, req, res) {
+          debug("intercept proxy response");
+          const originalProxyRes = proxyRes;
+          let buffer = Buffer.from("", "utf8");
+          const _proxyRes = decompress(
+            proxyRes,
+            proxyRes.headers["content-encoding"],
+          );
+          _proxyRes.on(
+            "data",
+            (chunk) => (buffer = Buffer.concat([buffer, chunk])),
+          );
+          _proxyRes.on("end", async () => {
+            copyHeaders(proxyRes, res);
+            debug(
+              "call interceptor function: %s",
+              (0, function_1.getFunctionName)(interceptor),
+            );
+            const interceptedBuffer = Buffer.from(
+              await interceptor(buffer, originalProxyRes, req, res),
+            );
+            debug(
+              "set content-length: %s",
+              Buffer.byteLength(interceptedBuffer, "utf8"),
+            );
+            res.setHeader(
+              "content-length",
+              Buffer.byteLength(interceptedBuffer, "utf8"),
+            );
+            debug("write intercepted response");
+            res.write(interceptedBuffer);
+            res.end();
+          });
+          _proxyRes.on("error", (error) => {
+            res.end(`Error fetching proxied request: ${error.message}`);
+          });
+        };
+      }
+      function decompress(proxyRes, contentEncoding) {
+        let _proxyRes = proxyRes;
+        let decompress;
+        switch (contentEncoding) {
+          case "gzip":
+            decompress = zlib.createGunzip();
+            break;
+          case "br":
+            decompress = zlib.createBrotliDecompress();
+            break;
+          case "deflate":
+            decompress = zlib.createInflate();
+            break;
+          default:
+            break;
+        }
+        if (decompress) {
+          debug(
+            `decompress proxy response with 'content-encoding': %s`,
+            contentEncoding,
+          );
+          _proxyRes.pipe(decompress);
+          _proxyRes = decompress;
+        }
+        return _proxyRes;
+      }
+      function copyHeaders(originalResponse, response) {
+        debug("copy original response headers");
+        response.statusCode = originalResponse.statusCode;
+        response.statusMessage = originalResponse.statusMessage;
+        if (response.setHeader) {
+          let keys = Object.keys(originalResponse.headers);
+          keys = keys.filter(
+            (key) => !["content-encoding", "transfer-encoding"].includes(key),
+          );
+          keys.forEach((key) => {
+            let value = originalResponse.headers[key];
+            if (key === "set-cookie") {
+              value = Array.isArray(value) ? value : [value];
+              value = value.map((x) => x.replace(/Domain=[^;]+?/i, ""));
+            }
+            response.setHeader(key, value);
+          });
+        } else {
+          response.headers = originalResponse.headers;
+        }
+      }
+    },
+    3501: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.HttpProxyMiddleware = void 0;
+      const httpProxy = __nccwpck_require__(1929);
+      const configuration_1 = __nccwpck_require__(1783);
+      const get_plugins_1 = __nccwpck_require__(4828);
+      const path_filter_1 = __nccwpck_require__(3833);
+      const PathRewriter = __nccwpck_require__(3461);
+      const Router = __nccwpck_require__(1976);
+      const debug_1 = __nccwpck_require__(5342);
+      const function_1 = __nccwpck_require__(7);
+      const logger_1 = __nccwpck_require__(2001);
+      class HttpProxyMiddleware {
+        constructor(options) {
+          this.wsInternalSubscribed = false;
+          this.serverOnCloseSubscribed = false;
+          this.middleware = async (req, res, next) => {
+            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+              try {
+                const activeProxyOptions = await this.prepareProxyRequest(req);
+                (0, debug_1.Debug)(
+                  `proxy request to target: %O`,
+                  activeProxyOptions.target,
+                );
+                this.proxy.web(req, res, activeProxyOptions);
+              } catch (err) {
+                next?.(err);
+              }
+            } else {
+              next?.();
             }
-          }
-          if (code === CHAR_ASTERISK) {
-            if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-            isGlob = token.isGlob = true;
-            finished = true;
-            if (scanToEnd === true) {
-              continue;
+            const server = (req.socket ?? req.connection)?.server;
+            if (server && !this.serverOnCloseSubscribed) {
+              server.on("close", () => {
+                (0, debug_1.Debug)(
+                  "server close signal received: closing proxy server",
+                );
+                this.proxy.close();
+              });
+              this.serverOnCloseSubscribed = true;
             }
-            break;
-          }
-          if (code === CHAR_QUESTION_MARK) {
-            isGlob = token.isGlob = true;
-            finished = true;
-            if (scanToEnd === true) {
-              continue;
+            if (this.proxyOptions.ws === true) {
+              this.catchUpgradeRequest(server);
             }
-            break;
-          }
-          if (code === CHAR_LEFT_SQUARE_BRACKET) {
-            while (eos() !== true && (next = advance())) {
-              if (next === CHAR_BACKWARD_SLASH) {
-                backslashes = token.backslashes = true;
-                advance();
-                continue;
-              }
-              if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-                isBracket = token.isBracket = true;
-                isGlob = token.isGlob = true;
-                finished = true;
-                break;
+          };
+          this.catchUpgradeRequest = (server) => {
+            if (!this.wsInternalSubscribed) {
+              (0, debug_1.Debug)("subscribing to server upgrade event");
+              server.on("upgrade", this.handleUpgrade);
+              this.wsInternalSubscribed = true;
+            }
+          };
+          this.handleUpgrade = async (req, socket, head) => {
+            try {
+              if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+                const activeProxyOptions = await this.prepareProxyRequest(req);
+                this.proxy.ws(req, socket, head, activeProxyOptions);
+                (0, debug_1.Debug)(
+                  "server upgrade event received. Proxying WebSocket",
+                );
               }
+            } catch (err) {
+              this.proxy.emit("error", err, req, socket);
             }
-            if (scanToEnd === true) {
-              continue;
+          };
+          this.shouldProxy = (pathFilter, req) => {
+            try {
+              return (0, path_filter_1.matchPathFilter)(
+                pathFilter,
+                req.url,
+                req,
+              );
+            } catch (err) {
+              (0, debug_1.Debug)(
+                "Error: matchPathFilter() called with request url: ",
+                `"${req.url}"`,
+              );
+              this.logger.error(err);
+              return false;
             }
-            break;
-          }
-          if (
-            opts.nonegate !== true &&
-            code === CHAR_EXCLAMATION_MARK &&
-            index === start
-          ) {
-            negated = token.negated = true;
-            start++;
-            continue;
-          }
-          if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-            isGlob = token.isGlob = true;
-            if (scanToEnd === true) {
-              while (eos() !== true && (code = advance())) {
-                if (code === CHAR_LEFT_PARENTHESES) {
-                  backslashes = token.backslashes = true;
-                  code = advance();
-                  continue;
-                }
-                if (code === CHAR_RIGHT_PARENTHESES) {
-                  finished = true;
-                  break;
-                }
-              }
-              continue;
+          };
+          this.prepareProxyRequest = async (req) => {
+            if (this.middleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__) {
+              req.url = req.originalUrl || req.url;
             }
-            break;
-          }
-          if (isGlob === true) {
-            finished = true;
-            if (scanToEnd === true) {
-              continue;
+            const newProxyOptions = Object.assign({}, this.proxyOptions);
+            await this.applyRouter(req, newProxyOptions);
+            await this.applyPathRewrite(req, this.pathRewriter);
+            return newProxyOptions;
+          };
+          this.applyRouter = async (req, options) => {
+            let newTarget;
+            if (options.router) {
+              newTarget = await Router.getTarget(req, options);
+              if (newTarget) {
+                (0, debug_1.Debug)('router new target: "%s"', newTarget);
+                options.target = newTarget;
+              }
             }
-            break;
-          }
-        }
-        if (opts.noext === true) {
-          isExtglob = false;
-          isGlob = false;
-        }
-        let base = str;
-        let prefix = "";
-        let glob = "";
-        if (start > 0) {
-          prefix = str.slice(0, start);
-          str = str.slice(start);
-          lastIndex -= start;
-        }
-        if (base && isGlob === true && lastIndex > 0) {
-          base = str.slice(0, lastIndex);
-          glob = str.slice(lastIndex);
-        } else if (isGlob === true) {
-          base = "";
-          glob = str;
-        } else {
-          base = str;
-        }
-        if (base && base !== "" && base !== "/" && base !== str) {
-          if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-            base = base.slice(0, -1);
-          }
-        }
-        if (opts.unescape === true) {
-          if (glob) glob = utils.removeBackslashes(glob);
-          if (base && backslashes === true) {
-            base = utils.removeBackslashes(base);
-          }
-        }
-        const state = {
-          prefix,
-          input,
-          start,
-          base,
-          glob,
-          isBrace,
-          isBracket,
-          isGlob,
-          isExtglob,
-          isGlobstar,
-          negated,
-          negatedExtglob,
-        };
-        if (opts.tokens === true) {
-          state.maxDepth = 0;
-          if (!isPathSeparator(code)) {
-            tokens.push(token);
-          }
-          state.tokens = tokens;
-        }
-        if (opts.parts === true || opts.tokens === true) {
-          let prevIndex;
-          for (let idx = 0; idx < slashes.length; idx++) {
-            const n = prevIndex ? prevIndex + 1 : start;
-            const i = slashes[idx];
-            const value = input.slice(n, i);
-            if (opts.tokens) {
-              if (idx === 0 && start !== 0) {
-                tokens[idx].isPrefix = true;
-                tokens[idx].value = prefix;
+          };
+          this.applyPathRewrite = async (req, pathRewriter) => {
+            if (pathRewriter) {
+              const path = await pathRewriter(req.url, req);
+              if (typeof path === "string") {
+                (0, debug_1.Debug)("pathRewrite new path: %s", req.url);
+                req.url = path;
               } else {
-                tokens[idx].value = value;
+                (0, debug_1.Debug)(
+                  "pathRewrite: no rewritten path found: %s",
+                  req.url,
+                );
               }
-              depth(tokens[idx]);
-              state.maxDepth += tokens[idx].depth;
-            }
-            if (idx !== 0 || value !== "") {
-              parts.push(value);
-            }
-            prevIndex = i;
-          }
-          if (prevIndex && prevIndex + 1 < input.length) {
-            const value = input.slice(prevIndex + 1);
-            parts.push(value);
-            if (opts.tokens) {
-              tokens[tokens.length - 1].value = value;
-              depth(tokens[tokens.length - 1]);
-              state.maxDepth += tokens[tokens.length - 1].depth;
             }
-          }
-          state.slashes = slashes;
-          state.parts = parts;
-        }
-        return state;
-      };
-      module.exports = scan;
-    },
-    7910: (__unused_webpack_module, exports, __nccwpck_require__) => {
-      "use strict";
-      const path = __nccwpck_require__(6928);
-      const win32 = process.platform === "win32";
-      const {
-        REGEX_BACKSLASH,
-        REGEX_REMOVE_BACKSLASH,
-        REGEX_SPECIAL_CHARS,
-        REGEX_SPECIAL_CHARS_GLOBAL,
-      } = __nccwpck_require__(7054);
-      exports.isObject = (val) =>
-        val !== null && typeof val === "object" && !Array.isArray(val);
-      exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-      exports.isRegexChar = (str) =>
-        str.length === 1 && exports.hasRegexChars(str);
-      exports.escapeRegex = (str) =>
-        str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-      exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-      exports.removeBackslashes = (str) =>
-        str.replace(REGEX_REMOVE_BACKSLASH, (match) =>
-          match === "\\" ? "" : match,
-        );
-      exports.supportsLookbehinds = () => {
-        const segs = process.version.slice(1).split(".").map(Number);
-        if (
-          (segs.length === 3 && segs[0] >= 9) ||
-          (segs[0] === 8 && segs[1] >= 10)
-        ) {
-          return true;
-        }
-        return false;
-      };
-      exports.isWindows = (options) => {
-        if (options && typeof options.windows === "boolean") {
-          return options.windows;
-        }
-        return win32 === true || path.sep === "\\";
-      };
-      exports.escapeLast = (input, char, lastIdx) => {
-        const idx = input.lastIndexOf(char, lastIdx);
-        if (idx === -1) return input;
-        if (input[idx - 1] === "\\")
-          return exports.escapeLast(input, char, idx - 1);
-        return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-      };
-      exports.removePrefix = (input, state = {}) => {
-        let output = input;
-        if (output.startsWith("./")) {
-          output = output.slice(2);
-          state.prefix = "./";
+          };
+          (0, configuration_1.verifyConfig)(options);
+          this.proxyOptions = options;
+          this.logger = (0, logger_1.getLogger)(options);
+          (0, debug_1.Debug)(`create proxy server`);
+          this.proxy = httpProxy.createProxyServer({});
+          this.registerPlugins(this.proxy, this.proxyOptions);
+          this.pathRewriter = PathRewriter.createPathRewriter(
+            this.proxyOptions.pathRewrite,
+          );
+          this.middleware.upgrade = (req, socket, head) => {
+            if (!this.wsInternalSubscribed) {
+              this.handleUpgrade(req, socket, head);
+            }
+          };
         }
-        return output;
-      };
-      exports.wrapOutput = (input, state = {}, options = {}) => {
-        const prepend = options.contains ? "" : "^";
-        const append = options.contains ? "" : "$";
-        let output = `${prepend}(?:${input})${append}`;
-        if (state.negated === true) {
-          output = `(?:^(?!${output}).*$)`;
+        registerPlugins(proxy, options) {
+          const plugins = (0, get_plugins_1.getPlugins)(options);
+          plugins.forEach((plugin) => {
+            (0, debug_1.Debug)(
+              `register plugin: "${(0, function_1.getFunctionName)(plugin)}"`,
+            );
+            plugin(proxy, options);
+          });
         }
-        return output;
-      };
+      }
+      exports.HttpProxyMiddleware = HttpProxyMiddleware;
     },
-    7866: (module) => {
+    6289: function (__unused_webpack_module, exports, __nccwpck_require__) {
       "use strict";
-      module.exports = 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;
-          case "ftp":
-            return port !== 21;
-          case "gopher":
-            return port !== 70;
-          case "file":
-            return false;
-        }
-        return port !== 0;
-      };
+      var __createBinding =
+        (this && this.__createBinding) ||
+        (Object.create
+          ? function (o, m, k, k2) {
+              if (k2 === undefined) 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(o, k2, desc);
+            }
+          : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+            });
+      var __exportStar =
+        (this && this.__exportStar) ||
+        function (m, exports) {
+          for (var p in m)
+            if (
+              p !== "default" &&
+              !Object.prototype.hasOwnProperty.call(exports, p)
+            )
+              __createBinding(exports, m, p);
+        };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(__nccwpck_require__(1179), exports);
+      __exportStar(__nccwpck_require__(3623), exports);
+      __exportStar(__nccwpck_require__(3024), exports);
+      __exportStar(__nccwpck_require__(4233), exports);
     },
-    743: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    4041: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      /*!
-       * to-regex-range <https://github.com/micromatch/to-regex-range>
-       *
-       * Copyright (c) 2015-present, Jon Schlinkert.
-       * Released under the MIT License.
-       */ const isNumber = __nccwpck_require__(952);
-      const toRegexRange = (min, max, options) => {
-        if (isNumber(min) === false) {
-          throw new TypeError(
-            "toRegexRange: expected the first argument to be a number",
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.legacyCreateProxyMiddleware = legacyCreateProxyMiddleware;
+      const factory_1 = __nccwpck_require__(1179);
+      const debug_1 = __nccwpck_require__(5342);
+      const options_adapter_1 = __nccwpck_require__(3357);
+      const debug = debug_1.Debug.extend("legacy-create-proxy-middleware");
+      function legacyCreateProxyMiddleware(legacyContext, legacyOptions) {
+        debug("init");
+        const options = (0, options_adapter_1.legacyOptionsAdapter)(
+          legacyContext,
+          legacyOptions,
+        );
+        const proxyMiddleware = (0, factory_1.createProxyMiddleware)(options);
+        debug("add marker for patching req.url (old behavior)");
+        proxyMiddleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ = true;
+        return proxyMiddleware;
+      }
+    },
+    4233: function (__unused_webpack_module, exports, __nccwpck_require__) {
+      "use strict";
+      var __createBinding =
+        (this && this.__createBinding) ||
+        (Object.create
+          ? function (o, m, k, k2) {
+              if (k2 === undefined) 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(o, k2, desc);
+            }
+          : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+            });
+      var __exportStar =
+        (this && this.__exportStar) ||
+        function (m, exports) {
+          for (var p in m)
+            if (
+              p !== "default" &&
+              !Object.prototype.hasOwnProperty.call(exports, p)
+            )
+              __createBinding(exports, m, p);
+        };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(__nccwpck_require__(2328), exports);
+    },
+    3357: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.legacyOptionsAdapter = legacyOptionsAdapter;
+      const url = __nccwpck_require__(7016);
+      const debug_1 = __nccwpck_require__(5342);
+      const logger_1 = __nccwpck_require__(2001);
+      const debug = debug_1.Debug.extend("legacy-options-adapter");
+      const proxyEventMap = {
+        onError: "error",
+        onProxyReq: "proxyReq",
+        onProxyRes: "proxyRes",
+        onProxyReqWs: "proxyReqWs",
+        onOpen: "open",
+        onClose: "close",
+      };
+      function legacyOptionsAdapter(legacyContext, legacyOptions) {
+        let options = {};
+        let logger;
+        if (
+          typeof legacyContext === "string" &&
+          !!url.parse(legacyContext).host
+        ) {
+          throw new Error(
+            `Shorthand syntax is removed from legacyCreateProxyMiddleware().\n      Please use "legacyCreateProxyMiddleware({ target: 'http://www.example.org' })" instead.\n\n      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-shorthand-usage\n      `,
           );
         }
-        if (max === void 0 || min === max) {
-          return String(min);
-        }
-        if (isNumber(max) === false) {
-          throw new TypeError(
-            "toRegexRange: expected the second argument to be a number.",
+        if (legacyContext && legacyOptions) {
+          debug("map legacy context/filter to options.pathFilter");
+          options = { ...legacyOptions, pathFilter: legacyContext };
+          logger = getLegacyLogger(options);
+          logger.warn(
+            `[http-proxy-middleware] Legacy "context" argument is deprecated. Migrate your "context" to "options.pathFilter":\n\n      const options = {\n        pathFilter: '${legacyContext}',\n      }\n\n      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-context-argument\n      `,
           );
-        }
-        let opts = { relaxZeros: true, ...options };
-        if (typeof opts.strictZeros === "boolean") {
-          opts.relaxZeros = opts.strictZeros === false;
-        }
-        let relax = String(opts.relaxZeros);
-        let shorthand = String(opts.shorthand);
-        let capture = String(opts.capture);
-        let wrap = String(opts.wrap);
-        let cacheKey =
-          min + ":" + max + "=" + relax + shorthand + capture + wrap;
-        if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
-          return toRegexRange.cache[cacheKey].result;
-        }
-        let a = Math.min(min, max);
-        let b = Math.max(min, max);
-        if (Math.abs(a - b) === 1) {
-          let result = min + "|" + max;
-          if (opts.capture) {
-            return `(${result})`;
-          }
-          if (opts.wrap === false) {
-            return result;
-          }
-          return `(?:${result})`;
-        }
-        let isPadded = hasPadding(min) || hasPadding(max);
-        let state = { min, max, a, b };
-        let positives = [];
-        let negatives = [];
-        if (isPadded) {
-          state.isPadded = isPadded;
-          state.maxLen = String(state.max).length;
-        }
-        if (a < 0) {
-          let newMin = b < 0 ? Math.abs(b) : 1;
-          negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
-          a = state.a = 0;
-        }
-        if (b >= 0) {
-          positives = splitToPatterns(a, b, state, opts);
-        }
-        state.negatives = negatives;
-        state.positives = positives;
-        state.result = collatePatterns(negatives, positives, opts);
-        if (opts.capture === true) {
-          state.result = `(${state.result})`;
-        } else if (
-          opts.wrap !== false &&
-          positives.length + negatives.length > 1
-        ) {
-          state.result = `(?:${state.result})`;
-        }
-        toRegexRange.cache[cacheKey] = state;
-        return state.result;
-      };
-      function collatePatterns(neg, pos, options) {
-        let onlyNegative = filterPatterns(neg, pos, "-", false, options) || [];
-        let onlyPositive = filterPatterns(pos, neg, "", false, options) || [];
-        let intersected = filterPatterns(neg, pos, "-?", true, options) || [];
-        let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
-        return subpatterns.join("|");
-      }
-      function splitToRanges(min, max) {
-        let nines = 1;
-        let zeros = 1;
-        let stop = countNines(min, nines);
-        let stops = new Set([max]);
-        while (min <= stop && stop <= max) {
-          stops.add(stop);
-          nines += 1;
-          stop = countNines(min, nines);
-        }
-        stop = countZeros(max + 1, zeros) - 1;
-        while (min < stop && stop <= max) {
-          stops.add(stop);
-          zeros += 1;
-          stop = countZeros(max + 1, zeros) - 1;
-        }
-        stops = [...stops];
-        stops.sort(compare);
-        return stops;
-      }
-      function rangeToPattern(start, stop, options) {
-        if (start === stop) {
-          return { pattern: start, count: [], digits: 0 };
-        }
-        let zipped = zip(start, stop);
-        let digits = zipped.length;
-        let pattern = "";
-        let count = 0;
-        for (let i = 0; i < digits; i++) {
-          let [startDigit, stopDigit] = zipped[i];
-          if (startDigit === stopDigit) {
-            pattern += startDigit;
-          } else if (startDigit !== "0" || stopDigit !== "9") {
-            pattern += toCharacterClass(startDigit, stopDigit, options);
-          } else {
-            count++;
-          }
-        }
-        if (count) {
-          pattern += options.shorthand === true ? "\\d" : "[0-9]";
-        }
-        return { pattern, count: [count], digits };
-      }
-      function splitToPatterns(min, max, tok, options) {
-        let ranges = splitToRanges(min, max);
-        let tokens = [];
-        let start = min;
-        let prev;
-        for (let i = 0; i < ranges.length; i++) {
-          let max = ranges[i];
-          let obj = rangeToPattern(String(start), String(max), options);
-          let zeros = "";
-          if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
-            if (prev.count.length > 1) {
-              prev.count.pop();
+        } else if (legacyContext && !legacyOptions) {
+          options = { ...legacyContext };
+          logger = getLegacyLogger(options);
+        } else {
+          logger = getLegacyLogger({});
+        }
+        Object.entries(proxyEventMap).forEach(
+          ([legacyEventName, proxyEventName]) => {
+            if (options[legacyEventName]) {
+              options.on = { ...options.on };
+              options.on[proxyEventName] = options[legacyEventName];
+              debug(
+                'map legacy event "%s" to "on.%s"',
+                legacyEventName,
+                proxyEventName,
+              );
+              logger.warn(
+                `[http-proxy-middleware] Legacy "${legacyEventName}" is deprecated. Migrate to "options.on.${proxyEventName}":\n\n        const options = {\n          on: {\n            ${proxyEventName}: () => {},\n          },\n        }\n\n        More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#refactored-proxy-events\n        `,
+              );
             }
-            prev.count.push(obj.count[0]);
-            prev.string = prev.pattern + toQuantifier(prev.count);
-            start = max + 1;
-            continue;
-          }
-          if (tok.isPadded) {
-            zeros = padZeros(max, tok, options);
-          }
-          obj.string = zeros + obj.pattern + toQuantifier(obj.count);
-          tokens.push(obj);
-          start = max + 1;
-          prev = obj;
+          },
+        );
+        const logProvider = options.logProvider && options.logProvider();
+        const logLevel = options.logLevel;
+        debug("legacy logLevel", logLevel);
+        debug("legacy logProvider: %O", logProvider);
+        if (typeof logLevel === "string" && logLevel !== "silent") {
+          debug('map "logProvider" to "logger"');
+          logger.warn(
+            `[http-proxy-middleware] Legacy "logLevel" and "logProvider" are deprecated. Migrate to "options.logger":\n\n      const options = {\n        logger: console,\n      }\n\n      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-logprovider-and-loglevel-options\n      `,
+          );
+        }
+        return options;
+      }
+      function getLegacyLogger(options) {
+        const legacyLogger = options.logProvider && options.logProvider();
+        if (legacyLogger) {
+          options.logger = legacyLogger;
         }
-        return tokens;
+        return (0, logger_1.getLogger)(options);
       }
-      function filterPatterns(arr, comparison, prefix, intersection, options) {
-        let result = [];
-        for (let ele of arr) {
-          let { string } = ele;
-          if (!intersection && !contains(comparison, "string", string)) {
-            result.push(prefix + string);
+    },
+    2328: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.legacyCreateProxyMiddleware = void 0;
+      var create_proxy_middleware_1 = __nccwpck_require__(4041);
+      Object.defineProperty(exports, "legacyCreateProxyMiddleware", {
+        enumerable: true,
+        get: function () {
+          return create_proxy_middleware_1.legacyCreateProxyMiddleware;
+        },
+      });
+    },
+    2001: (__unused_webpack_module, exports) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getLogger = getLogger;
+      const noopLogger = { info: () => {}, warn: () => {}, error: () => {} };
+      function getLogger(options) {
+        return options.logger || noopLogger;
+      }
+    },
+    3833: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.matchPathFilter = matchPathFilter;
+      const isGlob = __nccwpck_require__(686);
+      const micromatch = __nccwpck_require__(9555);
+      const url = __nccwpck_require__(7016);
+      const errors_1 = __nccwpck_require__(4006);
+      function matchPathFilter(pathFilter = "/", uri, req) {
+        if (isStringPath(pathFilter)) {
+          return matchSingleStringPath(pathFilter, uri);
+        }
+        if (isGlobPath(pathFilter)) {
+          return matchSingleGlobPath(pathFilter, uri);
+        }
+        if (Array.isArray(pathFilter)) {
+          if (pathFilter.every(isStringPath)) {
+            return matchMultiPath(pathFilter, uri);
           }
-          if (intersection && contains(comparison, "string", string)) {
-            result.push(prefix + string);
+          if (pathFilter.every(isGlobPath)) {
+            return matchMultiGlobPath(pathFilter, uri);
           }
+          throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
         }
-        return result;
+        if (typeof pathFilter === "function") {
+          const pathname = getUrlPathName(uri);
+          return pathFilter(pathname, req);
+        }
+        throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
       }
-      function zip(a, b) {
-        let arr = [];
-        for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
-        return arr;
+      function matchSingleStringPath(pathFilter, uri) {
+        const pathname = getUrlPathName(uri);
+        return pathname?.indexOf(pathFilter) === 0;
       }
-      function compare(a, b) {
-        return a > b ? 1 : b > a ? -1 : 0;
+      function matchSingleGlobPath(pattern, uri) {
+        const pathname = getUrlPathName(uri);
+        const matches = micromatch([pathname], pattern);
+        return matches && matches.length > 0;
       }
-      function contains(arr, key, val) {
-        return arr.some((ele) => ele[key] === val);
+      function matchMultiGlobPath(patternList, uri) {
+        return matchSingleGlobPath(patternList, uri);
       }
-      function countNines(min, len) {
-        return Number(String(min).slice(0, -len) + "9".repeat(len));
+      function matchMultiPath(pathFilterList, uri) {
+        let isMultiPath = false;
+        for (const context of pathFilterList) {
+          if (matchSingleStringPath(context, uri)) {
+            isMultiPath = true;
+            break;
+          }
+        }
+        return isMultiPath;
       }
-      function countZeros(integer, zeros) {
-        return integer - (integer % Math.pow(10, zeros));
+      function getUrlPathName(uri) {
+        return uri && url.parse(uri).pathname;
       }
-      function toQuantifier(digits) {
-        let [start = 0, stop = ""] = digits;
-        if (stop || start > 1) {
-          return `{${start + (stop ? "," + stop : "")}}`;
-        }
-        return "";
+      function isStringPath(pathFilter) {
+        return typeof pathFilter === "string" && !isGlob(pathFilter);
       }
-      function toCharacterClass(a, b, options) {
-        return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
+      function isGlobPath(pathFilter) {
+        return isGlob(pathFilter);
       }
-      function hasPadding(str) {
-        return /^-?(0+)\d/.test(str);
+    },
+    3461: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.createPathRewriter = createPathRewriter;
+      const is_plain_object_1 = __nccwpck_require__(634);
+      const errors_1 = __nccwpck_require__(4006);
+      const debug_1 = __nccwpck_require__(5342);
+      const debug = debug_1.Debug.extend("path-rewriter");
+      function createPathRewriter(rewriteConfig) {
+        let rulesCache;
+        if (!isValidRewriteConfig(rewriteConfig)) {
+          return;
+        }
+        if (typeof rewriteConfig === "function") {
+          const customRewriteFn = rewriteConfig;
+          return customRewriteFn;
+        } else {
+          rulesCache = parsePathRewriteRules(rewriteConfig);
+          return rewritePath;
+        }
+        function rewritePath(path) {
+          let result = path;
+          for (const rule of rulesCache) {
+            if (rule.regex.test(path)) {
+              result = result.replace(rule.regex, rule.value);
+              debug('rewriting path from "%s" to "%s"', path, result);
+              break;
+            }
+          }
+          return result;
+        }
       }
-      function padZeros(value, tok, options) {
-        if (!tok.isPadded) {
-          return value;
+      function isValidRewriteConfig(rewriteConfig) {
+        if (typeof rewriteConfig === "function") {
+          return true;
+        } else if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) {
+          return Object.keys(rewriteConfig).length !== 0;
+        } else if (rewriteConfig === undefined || rewriteConfig === null) {
+          return false;
+        } else {
+          throw new Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
         }
-        let diff = Math.abs(tok.maxLen - String(value).length);
-        let relax = options.relaxZeros !== false;
-        switch (diff) {
-          case 0:
-            return "";
-          case 1:
-            return relax ? "0?" : "0";
-          case 2:
-            return relax ? "0{0,2}" : "00";
-          default: {
-            return relax ? `0{0,${diff}}` : `0{${diff}}`;
+      }
+      function parsePathRewriteRules(rewriteConfig) {
+        const rules = [];
+        if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) {
+          for (const [key, value] of Object.entries(rewriteConfig)) {
+            rules.push({ regex: new RegExp(key), value });
+            debug('rewrite rule created: "%s" ~> "%s"', key, value);
           }
         }
+        return rules;
       }
-      toRegexRange.cache = {};
-      toRegexRange.clearCache = () => (toRegexRange.cache = {});
-      module.exports = toRegexRange;
-    },
-    2814: (module) => {
-      module.exports = eval("require")("debug");
     },
-    2613: (module) => {
+    8150: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("assert");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.debugProxyErrorsPlugin = void 0;
+      const debug_1 = __nccwpck_require__(5342);
+      const debug = debug_1.Debug.extend("debug-proxy-errors-plugin");
+      const debugProxyErrorsPlugin = (proxyServer) => {
+        proxyServer.on("error", (error, req, res, target) => {
+          debug(`http-proxy error event: \n%O`, error);
+        });
+        proxyServer.on("proxyReq", (proxyReq, req, socket) => {
+          socket.on("error", (error) => {
+            debug("Socket error in proxyReq event: \n%O", error);
+          });
+        });
+        proxyServer.on("proxyRes", (proxyRes, req, res) => {
+          res.on("close", () => {
+            if (!res.writableEnded) {
+              debug("Destroying proxyRes in proxyRes close event");
+              proxyRes.destroy();
+            }
+          });
+        });
+        proxyServer.on("proxyReqWs", (proxyReq, req, socket) => {
+          socket.on("error", (error) => {
+            debug("Socket error in proxyReqWs event: \n%O", error);
+          });
+        });
+        proxyServer.on("open", (proxySocket) => {
+          proxySocket.on("error", (error) => {
+            debug("Socket error in open event: \n%O", error);
+          });
+        });
+        proxyServer.on("close", (req, socket, head) => {
+          socket.on("error", (error) => {
+            debug("Socket error in close event: \n%O", error);
+          });
+        });
+        proxyServer.on("econnreset", (error, req, res, target) => {
+          debug(`http-proxy econnreset event: \n%O`, error);
+        });
+      };
+      exports.debugProxyErrorsPlugin = debugProxyErrorsPlugin;
     },
-    8611: (module) => {
+    766: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("http");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.errorResponsePlugin = void 0;
+      const status_code_1 = __nccwpck_require__(4173);
+      function isResponseLike(obj) {
+        return obj && typeof obj.writeHead === "function";
+      }
+      function isSocketLike(obj) {
+        return obj && typeof obj.write === "function" && !("writeHead" in obj);
+      }
+      const errorResponsePlugin = (proxyServer, options) => {
+        proxyServer.on("error", (err, req, res, target) => {
+          if (!req && !res) {
+            throw err;
+          }
+          if (isResponseLike(res)) {
+            if (!res.headersSent) {
+              const statusCode = (0, status_code_1.getStatusCode)(err.code);
+              res.writeHead(statusCode);
+            }
+            const host = req.headers && req.headers.host;
+            res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
+          } else if (isSocketLike(res)) {
+            res.destroy();
+          }
+        });
+      };
+      exports.errorResponsePlugin = errorResponsePlugin;
     },
-    5692: (module) => {
+    3024: function (__unused_webpack_module, exports, __nccwpck_require__) {
       "use strict";
-      module.exports = require("https");
+      var __createBinding =
+        (this && this.__createBinding) ||
+        (Object.create
+          ? function (o, m, k, k2) {
+              if (k2 === undefined) 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(o, k2, desc);
+            }
+          : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+            });
+      var __exportStar =
+        (this && this.__exportStar) ||
+        function (m, exports) {
+          for (var p in m)
+            if (
+              p !== "default" &&
+              !Object.prototype.hasOwnProperty.call(exports, p)
+            )
+              __createBinding(exports, m, p);
+        };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(__nccwpck_require__(8150), exports);
+      __exportStar(__nccwpck_require__(766), exports);
+      __exportStar(__nccwpck_require__(232), exports);
+      __exportStar(__nccwpck_require__(5644), exports);
     },
-    6928: (module) => {
+    232: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("path");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.loggerPlugin = void 0;
+      const url_1 = __nccwpck_require__(7016);
+      const logger_1 = __nccwpck_require__(2001);
+      const logger_plugin_1 = __nccwpck_require__(9223);
+      const loggerPlugin = (proxyServer, options) => {
+        const logger = (0, logger_1.getLogger)(options);
+        proxyServer.on("error", (err, req, res, target) => {
+          const hostname = req?.headers?.host;
+          const requestHref = `${hostname}${req?.url}`;
+          const targetHref = `${target?.href}`;
+          const errorMessage =
+            "[HPM] Error occurred while proxying request %s to %s [%s] (%s)";
+          const errReference =
+            "https://nodejs.org/api/errors.html#errors_common_system_errors";
+          logger.error(
+            errorMessage,
+            requestHref,
+            targetHref,
+            err.code || err,
+            errReference,
+          );
+        });
+        proxyServer.on("proxyRes", (proxyRes, req, res) => {
+          const originalUrl =
+            req.originalUrl ?? `${req.baseUrl || ""}${req.url}`;
+          let target;
+          try {
+            const port = (0, logger_plugin_1.getPort)(
+              proxyRes.req?.agent?.sockets,
+            );
+            const obj = {
+              protocol: proxyRes.req.protocol,
+              host: proxyRes.req.host,
+              pathname: proxyRes.req.path,
+            };
+            target = new url_1.URL(
+              `${obj.protocol}//${obj.host}${obj.pathname}`,
+            );
+            if (port) {
+              target.port = port;
+            }
+          } catch (err) {
+            target = new url_1.URL(options.target);
+            target.pathname = proxyRes.req.path;
+          }
+          const targetUrl = target.toString();
+          const exchange = `[HPM] ${req.method} ${originalUrl} -> ${targetUrl} [${proxyRes.statusCode}]`;
+          logger.info(exchange);
+        });
+        proxyServer.on("open", (socket) => {
+          logger.info("[HPM] Client connected: %o", socket.address());
+        });
+        proxyServer.on("close", (req, proxySocket, proxyHead) => {
+          logger.info("[HPM] Client disconnected: %o", proxySocket.address());
+        });
+      };
+      exports.loggerPlugin = loggerPlugin;
     },
-    3480: (module) => {
+    5644: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("querystring");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.proxyEventsPlugin = void 0;
+      const debug_1 = __nccwpck_require__(5342);
+      const function_1 = __nccwpck_require__(7);
+      const debug = debug_1.Debug.extend("proxy-events-plugin");
+      const proxyEventsPlugin = (proxyServer, options) => {
+        Object.entries(options.on || {}).forEach(([eventName, handler]) => {
+          debug(
+            `register event handler: "${eventName}" -> "${(0, function_1.getFunctionName)(handler)}"`,
+          );
+          proxyServer.on(eventName, handler);
+        });
+      };
+      exports.proxyEventsPlugin = proxyEventsPlugin;
     },
-    2203: (module) => {
+    1976: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("stream");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getTarget = getTarget;
+      const is_plain_object_1 = __nccwpck_require__(634);
+      const debug_1 = __nccwpck_require__(5342);
+      const debug = debug_1.Debug.extend("router");
+      async function getTarget(req, config) {
+        let newTarget;
+        const router = config.router;
+        if ((0, is_plain_object_1.isPlainObject)(router)) {
+          newTarget = getTargetFromProxyTable(req, router);
+        } else if (typeof router === "function") {
+          newTarget = await router(req);
+        }
+        return newTarget;
+      }
+      function getTargetFromProxyTable(req, table) {
+        let result;
+        const host = req.headers.host;
+        const path = req.url;
+        const hostAndPath = host + path;
+        for (const [key, value] of Object.entries(table)) {
+          if (containsPath(key)) {
+            if (hostAndPath.indexOf(key) > -1) {
+              result = value;
+              debug('match: "%s" -> "%s"', key, result);
+              break;
+            }
+          } else {
+            if (key === host) {
+              result = value;
+              debug('match: "%s" -> "%s"', host, result);
+              break;
+            }
+          }
+        }
+        return result;
+      }
+      function containsPath(v) {
+        return v.indexOf("/") > -1;
+      }
     },
-    7016: (module) => {
+    4173: (__unused_webpack_module, exports) => {
       "use strict";
-      module.exports = require("url");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getStatusCode = getStatusCode;
+      function getStatusCode(errorCode) {
+        let statusCode;
+        if (/HPE_INVALID/.test(errorCode)) {
+          statusCode = 502;
+        } else {
+          switch (errorCode) {
+            case "ECONNRESET":
+            case "ENOTFOUND":
+            case "ECONNREFUSED":
+            case "ETIMEDOUT":
+              statusCode = 504;
+              break;
+            default:
+              statusCode = 500;
+              break;
+          }
+        }
+        return statusCode;
+      }
     },
-    9023: (module) => {
+    7: (__unused_webpack_module, exports) => {
       "use strict";
-      module.exports = require("util");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getFunctionName = getFunctionName;
+      function getFunctionName(fn) {
+        return fn.name || "[anonymous Function]";
+      }
     },
-    3106: (module) => {
+    9223: (__unused_webpack_module, exports) => {
       "use strict";
-      module.exports = require("zlib");
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.getPort = getPort;
+      function getPort(sockets) {
+        return Object.keys(sockets || {})?.[0]?.split(":")[1];
+      }
     },
   };
   var __webpack_module_cache__ = {};
@@ -5279,6 +6127,6 @@
   }
   if (typeof __nccwpck_require__ !== "undefined")
     __nccwpck_require__.ab = __dirname + "/";
-  var __webpack_exports__ = __nccwpck_require__(7861);
+  var __webpack_exports__ = __nccwpck_require__(6289);
   module.exports = __webpack_exports__;
 })();