@rspack/dev-server 2.0.3 → 2.2.0

package/dist/0~debug.js

@@ -1,7 +1,7 @@
-import { __webpack_require__ } from "./465.js";
-import "./465.js";
+import { __webpack_require__ } from "./619.js";
+import "./619.js";
 __webpack_require__.add({
-    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js" (module, exports, __webpack_require__) {
+    "./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/browser.js" (module, exports, __webpack_require__) {
         exports.formatArgs = formatArgs;
         exports.save = save;
         exports.load = load;
@@ -134,7 +134,7 @@ __webpack_require__.add({
                 return localStorage;
             } catch (error) {}
         }
-        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(exports);
+        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/common.js")(exports);
         const { formatters } = module.exports;
         formatters.j = function(v) {
             try {
@@ -144,7 +144,7 @@ __webpack_require__.add({
             }
         };
     },
-    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/common.js" (module, __unused_rspack_exports, __webpack_require__) {
         function setup(env) {
             createDebug.debug = createDebug;
             createDebug.default = createDebug;
@@ -286,11 +286,11 @@ __webpack_require__.add({
         }
         module.exports = setup;
     },
-    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        if ("u" < typeof process || 'renderer' === process.type || true === process.browser || process.__nwjs) module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js");
-        else module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js");
+    "./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        if ("u" < typeof process || 'renderer' === process.type || true === process.browser || process.__nwjs) module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/browser.js");
+        else module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/node.js");
     },
-    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js" (module, exports, __webpack_require__) {
+    "./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/node.js" (module, exports, __webpack_require__) {
         const tty = __webpack_require__("tty");
         const util = __webpack_require__("util");
         exports.init = init;
@@ -428,7 +428,7 @@ __webpack_require__.add({
             const keys = Object.keys(exports.inspectOpts);
             for(let i = 0; i < keys.length; i++)debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
         }
-        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(exports);
+        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/common.js")(exports);
         const { formatters } = module.exports;
         formatters.o = function(v) {
             this.inspectOpts.colors = this.useColors;

package/dist/0~http-proxy-middleware.js

@@ -5,13 +5,14 @@ import node_http2 from "node:http2";
 import { EventEmitter } from "node:events";
 import "node:net";
 import "node:stream";
+import { styleText } from "node:util";
 import { URL as external_node_url_URL } from "node:url";
 import { URL as external_url_URL } from "url";
 import "node:zlib";
 import "node:querystring";
-import { __webpack_require__ } from "./465.js";
+import { __webpack_require__ } from "./619.js";
 import "./0~debug.js";
-import "./465.js";
+import "./619.js";
 __webpack_require__.add({
     "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
@@ -2796,6 +2797,7 @@ __webpack_require__.add({
     }
 });
 const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+const transferEncodingConnectionToken = /(^|,)\s*transfer-encoding\s*($|,)/i;
 const defaultAgents = {
     http: new node_http.Agent({
         keepAlive: true,
@@ -2809,6 +2811,16 @@ const defaultAgents = {
     })
 };
 const isSSL = /^https|wss/;
+function forceConnectionCloseForTransferEncoding(headers) {
+    let carriesTransferEncoding = false;
+    for(const key in headers)if (void 0 !== headers[key] && "transfer-encoding" === key.toLowerCase()) {
+        carriesTransferEncoding = true;
+        break;
+    }
+    const connection = headers.connection;
+    const connectionMarksTransferEncoding = "string" == typeof connection && transferEncodingConnectionToken.test(connection);
+    if (carriesTransferEncoding || connectionMarksTransferEncoding) headers.connection = "close";
+}
 const HTTP2_HEADER_BLACKLIST = [
     ":method",
     ":path",
@@ -2832,6 +2844,10 @@ function setupOutgoing(outgoing, options, req, forward) {
         const value = options[forward || "target"][e];
         if (void 0 !== value) outgoing[e] = value;
     }
+    if (void 0 === outgoing.host && "string" == typeof outgoing.hostname) {
+        const bracketedHost = outgoing.hostname.includes(":") && !outgoing.hostname.startsWith("[") ? `[${outgoing.hostname}]` : outgoing.hostname;
+        outgoing.host = outgoing.port ? `${bracketedHost}:${outgoing.port}` : bracketedHost;
+    }
     outgoing.method = options.method || req.method;
     outgoing.headers = {
         ...req.headers
@@ -2853,6 +2869,8 @@ function setupOutgoing(outgoing, options, req, forward) {
         outgoing.headers = outgoing.headers || {};
         if ("string" != typeof outgoing.headers.connection || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = "close";
     }
+    outgoing.headers = outgoing.headers || {};
+    forceConnectionCloseForTransferEncoding(outgoing.headers);
     const target = options[forward || "target"];
     const targetPath = target && false !== options.prependPath ? target.pathname || "" : "";
     const targetSearch = target instanceof URL && false !== options.prependPath ? target.search || "" : "";
@@ -2950,6 +2968,7 @@ const webOutgoingMiddleware = [
     defineProxyOutgoingMiddleware((req, res, proxyRes, options)=>{
         if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(String(proxyRes.statusCode))) {
             const target = _toURL(options.target);
+            const keepProtocolRelative = proxyRes.headers.location.startsWith("//") && !options.protocolRewrite;
             const u = new URL(proxyRes.headers.location, target);
             if (target.host !== u.host) return;
             if (options.hostRewrite) u.host = options.hostRewrite;
@@ -2958,7 +2977,7 @@ const webOutgoingMiddleware = [
                 else if (req.headers.host) u.host = req.headers.host;
             }
             if (options.protocolRewrite) u.protocol = options.protocolRewrite;
-            proxyRes.headers.location = u.toString();
+            proxyRes.headers.location = keepProtocolRelative ? u.href.slice(u.protocol.length) : u.href;
         }
     }),
     defineProxyOutgoingMiddleware((req, res, proxyRes, options)=>{
@@ -3008,7 +3027,7 @@ const nativeAgents = {
     http: node_http,
     https: node_https
 };
-const redirectStatuses = new Set([
+const redirectStatuses = /* @__PURE__ */ new Set([
     301,
     302,
     303,
@@ -3017,10 +3036,7 @@ const redirectStatuses = new Set([
 ]);
 const webIncomingMiddleware = [
     defineProxyMiddleware((req)=>{
-        if (("DELETE" === req.method || "OPTIONS" === req.method) && !req.headers["content-length"]) {
-            req.headers["content-length"] = "0";
-            delete req.headers["transfer-encoding"];
-        }
+        if (("DELETE" === req.method || "OPTIONS" === req.method) && !req.headers["content-length"] && !req.headers["transfer-encoding"]) req.headers["content-length"] = "0";
     }),
     defineProxyMiddleware((req, res, options)=>{
         if (options.timeout) req.socket.setTimeout(options.timeout, ()=>{
@@ -3123,6 +3139,7 @@ const webIncomingMiddleware = [
                     delete redirectHeaders["content-type"];
                     delete redirectHeaders["transfer-encoding"];
                 }
+                forceConnectionCloseForTransferEncoding(redirectHeaders);
                 const redirectOpts = {
                     hostname: location.hostname,
                     port: location.port || (isHTTPS ? 443 : 80),
@@ -3349,15 +3366,15 @@ function _createProxyFn(type, server) {
         for (const pass of server._getPasses(type)){
             let stop;
             try {
-                stop = pass(req, res, requestOptions, server, head, (error)=>{
+                stop = pass(req, res, requestOptions, server, head, (error, _req, _res, url)=>{
                     if (server.listenerCount("error") > 0) {
-                        server.emit("error", error, req, res);
+                        server.emit("error", error, req, res, url);
                         _resolve();
                     } else _reject(error);
                 });
             } catch (error) {
                 if (server.listenerCount("error") > 0) {
-                    server.emit("error", error, req, res);
+                    server.emit("error", error, req, res, requestOptions.target || requestOptions.forward);
                     _resolve();
                 } else _reject(error);
                 break;
@@ -3370,29 +3387,41 @@ function _createProxyFn(type, server) {
         return callbackPromise;
     };
 }
-new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]);
-var errors_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_ERRORS || (errors_ERRORS = {}));
+class errors_HttpProxyMiddlewareError extends Error {
+    code;
+    constructor(message, code){
+        super(message);
+        this.code = code;
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+    }
+}
 function verifyConfig(options) {
-    if (!options.target && !options.router) throw new Error(errors_ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+    if (!options.target && !options.router) throw new errors_HttpProxyMiddlewareError('[HPM] Missing "target" option. Example: {target: "http://www.example.org"}', 'ERR_CONFIG_FACTORY_TARGET_MISSING');
 }
-const src = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js");
+const src = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js");
 const Debug = src('http-proxy-middleware');
+function definePlugin(fn) {
+    return fn;
+}
 const debug = Debug.extend('debug-proxy-errors-plugin');
-const debugProxyErrorsPlugin = (proxyServer)=>{
+const BODY_PARSER_ERROR_MESSAGE = `[HPM] Connection reset (ECONNRESET) detected with non-empty "req.body" [ERR_HPM.GH40].
+
+      This usually means that the POST request body (req.body) was already parsed before reaching the proxy.
+      When bodyParser runs first, it consumes the request stream, leaving the proxy unable to forward the body data to the target server.
+
+      How to fix this issue:
+      - Option 1: Place the proxy middleware before the bodyParser middleware.
+      - Option 2: Use 'fixRequestBody()' helper to fix this issue.
+
+      For more details, see: https://github.com/chimurai/http-proxy-middleware/issues/40\n`;
+function hasParsedBody(req) {
+    return Boolean(req && 'POST' === req.method && 'body' in req && req.body);
+}
+const debugProxyErrorsPlugin = definePlugin((proxyServer, options)=>{
     proxyServer.on('error', (error, req, res, target)=>{
         debug(`httpxy error event: \n%O`, error);
+        if ('ECONNRESET' === error.code && hasParsedBody(req)) console.error(styleText('red', BODY_PARSER_ERROR_MESSAGE));
     });
     proxyServer.on('proxyReq', (proxyReq, req, socket)=>{
         socket.on('error', (error)=>{
@@ -3425,11 +3454,18 @@ const debugProxyErrorsPlugin = (proxyServer)=>{
     proxyServer.on('econnreset', (error, req, res, target)=>{
         debug(`httpxy econnreset event: \n%O`, error);
     });
-};
+});
 function getStatusCode(errorCode) {
     let statusCode;
-    if (/HPE_INVALID/.test(errorCode)) statusCode = 502;
-    else switch(errorCode){
+    if (/HPE_INVALID/.test(errorCode)) {
+        statusCode = 502;
+        return statusCode;
+    }
+    if (/HPM_ERR_INVALID_MULTIPART_/.test(errorCode)) {
+        statusCode = 400;
+        return statusCode;
+    }
+    switch(errorCode){
         case 'ECONNRESET':
         case 'ENOTFOUND':
         case 'ECONNREFUSED':
@@ -3451,7 +3487,7 @@ function isResponseLike(obj) {
 function isSocketLike(obj) {
     return obj && 'function' == typeof obj.write && !('writeHead' in obj);
 }
-const errorResponsePlugin = (proxyServer, options)=>{
+const errorResponsePlugin = definePlugin((proxyServer, options)=>{
     proxyServer.on('error', (err, req, res, target)=>{
         if (!req || !res) throw err;
         if (isResponseLike(res)) {
@@ -3463,7 +3499,7 @@ const errorResponsePlugin = (proxyServer, options)=>{
             res.end(`Error occurred while trying to proxy: ${sanitize(host)}${sanitize(req.url)}`);
         } else if (isSocketLike(res)) res.destroy();
     });
-};
+});
 const noopLogger = {
     info: ()=>{},
     warn: ()=>{},
@@ -3483,7 +3519,7 @@ function createUrl({ protocol, host, port, path }) {
 function logger_plugin_getPort(sockets) {
     return Object.keys(sockets || {})?.[0]?.split(':')[1];
 }
-const loggerPlugin = (proxyServer, options)=>{
+const loggerPlugin = definePlugin((proxyServer, options)=>{
     const logger = getLogger(options);
     proxyServer.on('error', (err, req, res, target)=>{
         const hostname = req?.headers?.host;
@@ -3520,12 +3556,12 @@ const loggerPlugin = (proxyServer, options)=>{
     proxyServer.on('close', (req, proxySocket, proxyHead)=>{
         logger.info('[HPM] Client disconnected: %o', proxySocket.address());
     });
-};
+});
 function function_getFunctionName(fn) {
     return fn.name || '[anonymous Function]';
 }
 const proxy_events_debug = Debug.extend('proxy-events-plugin');
-const proxyEventsPlugin = (proxyServer, options)=>{
+const proxyEventsPlugin = definePlugin((proxyServer, options)=>{
     if (!options.on) return;
     let eventName;
     for(eventName in options.on)if (Object.prototype.hasOwnProperty.call(options.on, eventName)) {
@@ -3534,7 +3570,7 @@ const proxyEventsPlugin = (proxyServer, options)=>{
         proxy_events_debug(`register event handler: "${eventName}" -> "${function_getFunctionName(handler)}"`);
         proxyServer.on(eventName, handler);
     }
-};
+});
 function getPlugins(options) {
     const maybeErrorResponsePlugin = options.on?.error ? [] : [
         errorResponsePlugin
@@ -3559,13 +3595,13 @@ function matchPathFilter(pathFilter = '/', uri, req) {
     if (Array.isArray(pathFilter)) {
         if (pathFilter.every(isStringPath)) return matchMultiPath(pathFilter, uri);
         if (pathFilter.every(isGlobPath)) return matchMultiGlobPath(pathFilter, uri);
-        throw new Error(errors_ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+        throw new errors_HttpProxyMiddlewareError('[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"].', 'HPM_INVALID_PATH_FILTER_ARRAY_CONFIG');
     }
     if ('function' == typeof pathFilter) {
         const pathname = getUrlPathName(uri);
-        return pathFilter(pathname, req);
+        return Boolean(pathFilter(pathname, req));
     }
-    throw new Error(errors_ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
+    throw new errors_HttpProxyMiddlewareError('[HPM] Invalid pathFilter. Expecting something like: "/api" or ["/api", "/ajax"]', 'HPM_INVALID_PATH_FILTER_CONFIG');
 }
 function matchSingleStringPath(pathFilter, uri) {
     const pathname = getUrlPathName(uri);
@@ -3627,7 +3663,7 @@ function isValidRewriteConfig(rewriteConfig) {
     if ('function' == typeof rewriteConfig) return true;
     if (isPlainObject(rewriteConfig)) return 0 !== Object.keys(rewriteConfig).length;
     if (null == rewriteConfig) return false;
-    throw new Error(errors_ERRORS.ERR_PATH_REWRITER_CONFIG);
+    throw new errors_HttpProxyMiddlewareError('[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function', 'HPM_INVALID_PATH_REWRITER_CONFIG');
 }
 function parsePathRewriteRules(rewriteConfig) {
     const rules = [];
@@ -3641,20 +3677,26 @@ function parsePathRewriteRules(rewriteConfig) {
     return rules;
 }
 const router_debug = Debug.extend('router');
-async function getTarget(req, config) {
+async function getTarget(req, res, config) {
     let newTarget;
     const router = config.router;
     if (isPlainObject(router)) newTarget = getTargetFromProxyTable(req, router);
-    else if ('function' == typeof router) newTarget = await router(req);
+    else if ('function' == typeof router) newTarget = await router(req, res, config);
     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) {
+        if (isHostAndPathKey(key)) {
+            const [keyHost, keyPath] = splitHostAndPathKey(key);
+            if (host === keyHost && path.startsWith(keyPath)) {
+                result = value;
+                router_debug('match: "%s" -> "%s"', key, result);
+                break;
+            }
+        } else if (path.startsWith(key)) {
             result = value;
             router_debug('match: "%s" -> "%s"', key, result);
             break;
@@ -3669,6 +3711,16 @@ function getTargetFromProxyTable(req, table) {
 function containsPath(v) {
     return v.indexOf('/') > -1;
 }
+function isHostAndPathKey(v) {
+    return containsPath(v) && !v.startsWith('/');
+}
+function splitHostAndPathKey(v) {
+    const firstSlash = v.indexOf('/');
+    return [
+        v.slice(0, firstSlash),
+        v.slice(firstSlash)
+    ];
+}
 const ipv6_debug = Debug.extend('ipv6');
 function normalizeIPv6LiteralTargets(options) {
     options.target = normalizeIPv6ProxyTarget(options.target, 'target');
@@ -3677,9 +3729,12 @@ function normalizeIPv6LiteralTargets(options) {
 function normalizeIPv6ProxyTarget(target, optionName) {
     const targetUrl = toTargetUrl(target);
     if (targetUrl && isBracketedIPv6Hostname(targetUrl.hostname)) {
+        const normalizedHostname = normalizeIPv6DestinationHostname(stripBrackets(targetUrl.hostname));
         ipv6_debug('normalized IPv6 "%s" %s', optionName, target);
+        const auth = targetUrl.username || targetUrl.password ? `${targetUrl.username}:${targetUrl.password}` : void 0;
         return {
-            hostname: stripBrackets(targetUrl.hostname),
+            hostname: normalizedHostname,
+            auth,
             pathname: targetUrl.pathname,
             port: targetUrl.port,
             protocol: targetUrl.protocol,
@@ -3698,9 +3753,16 @@ function isBracketedIPv6Hostname(hostname) {
 function stripBrackets(hostname) {
     return hostname.replace(/^\[|\]$/g, '');
 }
+function normalizeIPv6DestinationHostname(hostname) {
+    if ('::' === hostname) {
+        ipv6_debug('normalizing hostname unspecified IPv6 address (::) to loopback (::1)');
+        return '::1';
+    }
+    return hostname;
+}
 class HttpProxyMiddleware {
-    wsInternalSubscribed = false;
-    serverOnCloseSubscribed = false;
+    wsInternalSubscribedServers = new WeakSet();
+    activeServers = new Set();
     proxyOptions;
     proxy;
     pathRewriter;
@@ -3714,14 +3776,18 @@ class HttpProxyMiddleware {
         this.registerPlugins(this.proxy, this.proxyOptions);
         this.pathRewriter = createPathRewriter(this.proxyOptions.pathRewrite);
         this.middleware.upgrade = (req, socket, head)=>{
-            if (!this.wsInternalSubscribed) this.handleUpgrade(req, socket, head);
+            const server = this.#getServer(req);
+            if (server && !this.wsInternalSubscribedServers.has(server)) this.handleUpgrade(req, socket, head);
         };
     }
+    #getServer(req) {
+        return req.socket?.server;
+    }
     middleware = async (req, res, next)=>{
         if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
             let activeProxyOptions;
             try {
-                activeProxyOptions = await this.prepareProxyRequest(req);
+                activeProxyOptions = await this.prepareProxyRequest(req, res);
                 if (!activeProxyOptions.target && !activeProxyOptions.forward) throw new Error('Must provide a proper URL as target');
             } catch (err) {
                 next?.(err);
@@ -3735,15 +3801,17 @@ class HttpProxyMiddleware {
                 next?.(err);
             }
         } else next?.();
-        const server = req.socket?.server;
-        if (server && !this.serverOnCloseSubscribed) {
+        const server = this.#getServer(req);
+        if (server && !this.activeServers.has(server)) {
+            Debug('registering server close listener');
+            this.activeServers.add(server);
             server.on('close', ()=>{
-                Debug('server close signal received: closing proxy server');
-                this.proxy.close(()=>{
-                    Debug('proxy server closed');
-                });
+                Debug('server close signal received.');
+                this.activeServers.delete(server);
+                if (this.activeServers.size > 0) return void Debug(`proxy server not closed: ${this.activeServers.size} server(s) still active`);
+                Debug('closing proxy server');
+                this.proxy.close(()=>Debug('proxy server closed'));
             });
-            this.serverOnCloseSubscribed = true;
         }
         if (true === this.proxyOptions.ws && server) this.catchUpgradeRequest(server);
     };
@@ -3755,18 +3823,17 @@ class HttpProxyMiddleware {
         });
     }
     catchUpgradeRequest = (server)=>{
-        if (!this.wsInternalSubscribed) {
+        if (!this.wsInternalSubscribedServers.has(server)) {
             Debug('subscribing to server upgrade event');
             server.on('upgrade', this.handleUpgrade);
-            this.wsInternalSubscribed = true;
+            this.wsInternalSubscribedServers.add(server);
         }
     };
     handleUpgrade = async (req, socket, head)=>{
         try {
             if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
-                const proxiedReq = req;
-                const activeProxyOptions = await this.prepareProxyRequest(proxiedReq);
-                await this.proxy.ws(proxiedReq, socket, activeProxyOptions, head);
+                const activeProxyOptions = await this.prepareProxyRequest(req, void 0);
+                await this.proxy.ws(req, socket, activeProxyOptions, head);
                 Debug('server upgrade event received. Proxying WebSocket');
             }
         } catch (err) {
@@ -3782,26 +3849,26 @@ class HttpProxyMiddleware {
             return false;
         }
     };
-    prepareProxyRequest = async (req)=>{
+    prepareProxyRequest = async (req, res)=>{
         const newProxyOptions = Object.assign({}, this.proxyOptions);
-        await this.applyRouter(req, newProxyOptions);
+        await this.applyRouter(req, res, newProxyOptions);
         normalizeIPv6LiteralTargets(newProxyOptions);
-        await this.applyPathRewrite(req, this.pathRewriter);
+        await this.applyPathRewrite(req, res, this.pathRewriter, newProxyOptions);
         return newProxyOptions;
     };
-    applyRouter = async (req, options)=>{
+    applyRouter = async (req, res, options)=>{
         let newTarget;
         if (options.router) {
-            newTarget = await getTarget(req, options);
+            newTarget = await getTarget(req, res, options);
             if (newTarget) {
                 Debug('router new target: "%s"', newTarget);
                 options.target = newTarget;
             }
         }
     };
-    applyPathRewrite = async (req, pathRewriter)=>{
+    applyPathRewrite = async (req, res, pathRewriter, options)=>{
         if (req.url && pathRewriter) {
-            const path = await pathRewriter(req.url, req);
+            const path = await pathRewriter(req.url, req, res, options);
             if ('string' == typeof path) {
                 Debug('pathRewrite new path: %s', path);
                 req.url = path;