@rspack-debug/core 2.0.0 → 2.0.1

package/compiled/http-proxy-middleware/index.d.ts

@@ -1,250 +1,135 @@
-/// <reference types="node" />
-import * as http from 'http';
-import events from 'events';
-import * as net from 'net';
-import stream from 'stream';
-import * as url from 'url';
+import * as http from 'node:http';
+import http__default, { ServerResponse, IncomingMessage } from 'node:http';
+import * as net from 'node:net';
+import net__default, { Socket } from 'node:net';
+import http2, { Http2ServerResponse, Http2ServerRequest } from 'node:http2';
+import { EventEmitter } from 'node:events';
+import * as stream from 'node:stream';
+import { HttpBindings } from '@hono/node-server';
+import { MiddlewareHandler } from 'hono';
 
 interface ProxyTargetDetailed {
-    host: string;
-    port: number;
-    protocol?: string | undefined;
-    hostname?: string | undefined;
-    socketPath?: string | undefined;
-    key?: string | undefined;
-    passphrase?: string | undefined;
-    pfx?: Buffer | string | undefined;
-    cert?: string | undefined;
-    ca?: string | undefined;
-    ciphers?: string | undefined;
-    secureProtocol?: string | undefined;
+  host?: string;
+  port?: number | string;
+  protocol?: string;
+  hostname?: string;
+  socketPath?: string;
+  key?: string;
+  passphrase?: string;
+  pfx?: Buffer | string;
+  cert?: string;
+  ca?: string;
+  ciphers?: string;
+  secureProtocol?: string;
 }
-
-declare class Server<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>
-    extends events.EventEmitter
-{
-    /**
-     * Creates the proxy server with specified options.
-     * @param options - Config object passed to the proxy
-     */
-    constructor(options?: Server.ServerOptions);
-
-    /**
-     * Used for proxying regular HTTP(S) requests
-     * @param req - Client request.
-     * @param res - Client response.
-     * @param options - Additional options.
-     */
-    web(
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        options?: Server.ServerOptions,
-        callback?: Server.ErrorCallback,
-    ): void;
-
-    /**
-     * Used for proxying WS(S) requests
-     * @param req - Client request.
-     * @param socket - Client socket.
-     * @param head - Client head.
-     * @param options - Additionnal options.
-     */
-    ws(
-        req: http.IncomingMessage,
-        socket: any,
-        head: any,
-        options?: Server.ServerOptions,
-        callback?: Server.ErrorCallback,
-    ): void;
-
-    /**
-     * A function that wraps the object in a webserver, for your convenience
-     * @param port - Port to listen on
-     * @param hostname - The hostname to listen on
-     */
-    listen(port: number, hostname?: string): Server<TIncomingMessage, TServerResponse>;
-
-    /**
-     * A function that closes the inner webserver and stops listening on given port
-     */
-    close(callback?: () => void): void;
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    // tslint:disable:no-unnecessary-generics
-    static createProxyServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
-        options?: Server.ServerOptions,
-    ): Server<TIncomingMessage, TServerResponse>;
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    // tslint:disable:no-unnecessary-generics
-    static createServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
-        options?: Server.ServerOptions,
-    ): Server<TIncomingMessage, TServerResponse>;
-
-    /**
-     * Creates the proxy server with specified options.
-     * @param options Config object passed to the proxy
-     * @returns Proxy object with handlers for `ws` and `web` requests
-     */
-    // tslint:disable:no-unnecessary-generics
-    static createProxy<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
-        options?: Server.ServerOptions,
-    ): Server<TIncomingMessage, TServerResponse>;
-
-    addListener(event: string, listener: () => void): this;
-    on(event: string, listener: () => void): this;
-    on(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
-    on(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
-    on(
-        event: "proxyReq",
-        listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
-    ): this;
-    on(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
-    on(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
-    on(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
-    on(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
-    on(event: "open", listener: Server.OpenCallback): this;
-    on(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
-
-    once(event: string, listener: () => void): this;
-    once(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
-    once(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
-    once(
-        event: "proxyReq",
-        listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
-    ): this;
-    once(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
-    once(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
-    once(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
-    once(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
-    once(event: "open", listener: Server.OpenCallback): this;
-    once(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
-    removeListener(event: string, listener: () => void): this;
-    removeAllListeners(event?: string): this;
-    getMaxListeners(): number;
-    setMaxListeners(n: number): this;
-    listeners(event: string): Array<() => void>;
-    emit(event: string, ...args: any[]): boolean;
-    listenerCount(type: string): number;
+type ProxyTarget = string | URL | ProxyTargetDetailed;
+interface ProxyServerOptions {
+  /** URL string to be parsed. */
+  target?: ProxyTarget;
+  /** URL string to be parsed. */
+  forward?: ProxyTarget;
+  /** Object to be passed to http(s).request. */
+  agent?: any;
+  /** Enable HTTP/2 listener, default is `false` */
+  http2?: boolean;
+  /** Object to be passed to https.createServer()
+   * or http2.createSecureServer() if the `http2` option is enabled
+   */
+  ssl?: any;
+  /** If you want to proxy websockets. */
+  ws?: boolean;
+  /** Adds x- forward headers. */
+  xfwd?: boolean;
+  /** Verify SSL certificate. */
+  secure?: boolean;
+  /** Explicitly specify if we are proxying to another proxy. */
+  toProxy?: boolean;
+  /** Specify whether you want to prepend the target's path to the proxy path. */
+  prependPath?: boolean;
+  /** Specify whether you want to ignore the proxy path of the incoming request. */
+  ignorePath?: boolean;
+  /** Local interface string to bind for outgoing connections. */
+  localAddress?: string;
+  /** Changes the origin of the host header to the target URL. */
+  changeOrigin?: boolean;
+  /** specify whether you want to keep letter case of response header key */
+  preserveHeaderKeyCase?: boolean;
+  /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+  auth?: string;
+  /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+  hostRewrite?: string;
+  /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+  autoRewrite?: boolean;
+  /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+  protocolRewrite?: string;
+  /** Rewrites domain of set-cookie headers. */
+  cookieDomainRewrite?: false | string | {
+    [oldDomain: string]: string;
+  };
+  /** Rewrites path of set-cookie headers. Default: false */
+  cookiePathRewrite?: false | string | {
+    [oldPath: string]: string;
+  };
+  /** Object with extra headers to be added to target requests. */
+  headers?: {
+    [header: string]: string;
+  };
+  /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+  proxyTimeout?: number;
+  /** Timeout (in milliseconds) for incoming requests */
+  timeout?: number;
+  /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+  selfHandleResponse?: boolean;
+  /** Follow HTTP redirects from target. `true` = max 5 hops; number = custom max. */
+  followRedirects?: boolean | number;
+  /** Buffer */
+  buffer?: stream.Stream;
 }
-
-declare namespace Server {
-    type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
-    type ProxyTargetUrl = string | Partial<url.Url>;
-
-    interface ServerOptions {
-        /** URL string to be parsed with the url module. */
-        target?: ProxyTarget | undefined;
-        /** URL string to be parsed with the url module. */
-        forward?: ProxyTargetUrl | undefined;
-        /** Object to be passed to http(s).request. */
-        agent?: any;
-        /** Object to be passed to https.createServer(). */
-        ssl?: any;
-        /** If you want to proxy websockets. */
-        ws?: boolean | undefined;
-        /** Adds x- forward headers. */
-        xfwd?: boolean | undefined;
-        /** Verify SSL certificate. */
-        secure?: boolean | undefined;
-        /** Explicitly specify if we are proxying to another proxy. */
-        toProxy?: boolean | undefined;
-        /** Specify whether you want to prepend the target's path to the proxy path. */
-        prependPath?: boolean | undefined;
-        /** Specify whether you want to ignore the proxy path of the incoming request. */
-        ignorePath?: boolean | undefined;
-        /** Local interface string to bind for outgoing connections. */
-        localAddress?: string | undefined;
-        /** Changes the origin of the host header to the target URL. */
-        changeOrigin?: boolean | undefined;
-        /** specify whether you want to keep letter case of response header key */
-        preserveHeaderKeyCase?: boolean | undefined;
-        /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
-        auth?: string | undefined;
-        /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
-        hostRewrite?: string | undefined;
-        /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
-        autoRewrite?: boolean | undefined;
-        /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
-        protocolRewrite?: string | undefined;
-        /** rewrites domain of set-cookie headers. */
-        cookieDomainRewrite?: false | string | { [oldDomain: string]: string } | undefined;
-        /** rewrites path of set-cookie headers. Default: false */
-        cookiePathRewrite?: false | string | { [oldPath: string]: string } | undefined;
-        /** object with extra headers to be added to target requests. */
-        headers?: { [header: string]: string } | undefined;
-        /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
-        proxyTimeout?: number | undefined;
-        /** Timeout (in milliseconds) for incoming requests */
-        timeout?: number | undefined;
-        /** Specify whether you want to follow redirects. Default: false */
-        followRedirects?: boolean | undefined;
-        /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
-        selfHandleResponse?: boolean | undefined;
-        /** Buffer */
-        buffer?: stream.Stream | undefined;
-        /** Explicitly set the method type of the ProxyReq */
-        method?: string | undefined;
-    }
-
-    type StartCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
-        req: TIncomingMessage,
-        res: TServerResponse,
-        target: ProxyTargetUrl,
-    ) => void;
-    type ProxyReqCallback<
-        TClientRequest = http.ClientRequest,
-        TIncomingMessage = http.IncomingMessage,
-        TServerResponse = http.ServerResponse,
-    > = (proxyReq: TClientRequest, req: TIncomingMessage, res: TServerResponse, options: ServerOptions) => void;
-    type ProxyResCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
-        proxyRes: TIncomingMessage,
-        req: TIncomingMessage,
-        res: TServerResponse,
-    ) => void;
-    type ProxyReqWsCallback<TClientRequest = http.ClientRequest, TIncomingMessage = http.IncomingMessage> = (
-        proxyReq: TClientRequest,
-        req: TIncomingMessage,
-        socket: net.Socket,
-        options: ServerOptions,
-        head: any,
-    ) => void;
-    type EconnresetCallback<
-        TError = Error,
-        TIncomingMessage = http.IncomingMessage,
-        TServerResponse = http.ServerResponse,
-    > = (
-        err: TError,
-        req: TIncomingMessage,
-        res: TServerResponse,
-        target: ProxyTargetUrl,
-    ) => void;
-    type EndCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
-        req: TIncomingMessage,
-        res: TServerResponse,
-        proxyRes: TIncomingMessage,
-    ) => void;
-    type OpenCallback = (proxySocket: net.Socket) => void;
-    type CloseCallback<TIncomingMessage = http.IncomingMessage> = (
-        proxyRes: TIncomingMessage,
-        proxySocket: net.Socket,
-        proxyHead: any,
-    ) => void;
-    type ErrorCallback<TError = Error, TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> =
-        (
-            err: TError,
-            req: TIncomingMessage,
-            res: TServerResponse | net.Socket,
-            target?: ProxyTargetUrl,
-        ) => void;
+type ResOfType<T extends "web" | "ws"> = T extends "ws" ? T extends "web" ? ServerResponse | Http2ServerResponse | Socket : Socket : T extends "web" ? ServerResponse | Http2ServerResponse : never;
+type ProxyMiddleware<T extends ServerResponse | Http2ServerResponse | Socket> = (req: IncomingMessage | Http2ServerRequest, res: T, opts: ProxyServerOptions & {
+  target: URL | ProxyTargetDetailed;
+  forward: URL;
+}, server: ProxyServer<IncomingMessage | Http2ServerRequest, ServerResponse | Http2ServerResponse>, head?: Buffer, callback?: (err: any, req: IncomingMessage | Http2ServerRequest, socket: T, url?: any) => void) => void | true;
+interface ProxyServerEventMap<Req extends http__default.IncomingMessage | http2.Http2ServerRequest = http__default.IncomingMessage, Res extends http__default.ServerResponse | http2.Http2ServerResponse = http__default.ServerResponse> {
+  error: [err: Error, req?: Req, res?: Res | net__default.Socket, target?: URL | ProxyTarget];
+  start: [req: Req, res: Res, target: URL | ProxyTarget];
+  econnreset: [err: Error, req: Req, res: Res, target: URL | ProxyTarget];
+  proxyReq: [proxyReq: http__default.ClientRequest, req: Req, res: Res, options: ProxyServerOptions];
+  proxyReqWs: [proxyReq: http__default.ClientRequest, req: Req, socket: net__default.Socket, options: ProxyServerOptions, head: any];
+  proxyRes: [proxyRes: http__default.IncomingMessage, req: Req, res: Res];
+  end: [req: Req, res: Res, proxyRes: http__default.IncomingMessage];
+  open: [proxySocket: net__default.Socket];
+  /** @deprecated */
+  proxySocket: [proxySocket: net__default.Socket];
+  close: [proxyRes: Req, proxySocket: net__default.Socket, proxyHead: any];
+}
+declare class ProxyServer<Req extends http__default.IncomingMessage | http2.Http2ServerRequest = http__default.IncomingMessage, Res extends http__default.ServerResponse | http2.Http2ServerResponse = http__default.ServerResponse> extends EventEmitter<ProxyServerEventMap<Req, Res>> {
+  private _server?;
+  _webPasses: ProxyMiddleware<http__default.ServerResponse>[];
+  _wsPasses: ProxyMiddleware<net__default.Socket>[];
+  options: ProxyServerOptions;
+  web: (req: Req, res: Res, opts?: ProxyServerOptions, head?: any) => Promise<void>;
+  ws: (req: Req, socket: net__default.Socket, opts: ProxyServerOptions, head?: any) => Promise<void>;
+  /**
+   * Creates the proxy server with specified options.
+   * @param options - Config object passed to the proxy
+   */
+  constructor(options?: ProxyServerOptions);
+  /**
+   * A function that wraps the object in a webserver, for your convenience
+   * @param port - Port to listen on
+   * @param hostname - The hostname to listen on
+   * @param listeningListener - A callback function that is called when the server starts listening
+   */
+  listen(port: number, hostname?: string, listeningListener?: () => void): this;
+  /**
+   * A function that closes the inner webserver and stops listening on given port
+   */
+  close(callback?: () => void): void;
+  before<Type extends "ws" | "web">(type: Type, passName: string, pass: ProxyMiddleware<ResOfType<Type>>): void;
+  after<Type extends "ws" | "web">(type: Type, passName: string, pass: ProxyMiddleware<ResOfType<Type>>): void;
+  /** @internal */
+  _getPasses<Type extends "ws" | "web">(type: Type): ProxyMiddleware<ResOfType<Type>>[];
 }
 
 /**
@@ -253,27 +138,30 @@ declare namespace Server {
  */
 
 type NextFunction<T = (err?: any) => void> = T;
-interface RequestHandler<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction> {
+interface RequestHandler<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction> {
     (req: TReq, res: TRes, next?: TNext): Promise<void>;
-    upgrade: (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => void;
+    upgrade: (req: TReq, socket: net.Socket, head: Buffer) => void;
 }
-type Filter<TReq = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
-interface Plugin<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
-    (proxyServer: Server<TReq, TRes>, options: Options<TReq, TRes>): void;
+type Filter<TReq extends http.IncomingMessage = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
+interface Plugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
+    (proxyServer: ProxyServer<TReq, TRes>, options: Options<TReq, TRes>): void;
 }
-interface OnProxyEvent<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
-    error?: Server.ErrorCallback<Error, TReq, TRes>;
-    proxyReq?: Server.ProxyReqCallback<http.ClientRequest, TReq, TRes>;
-    proxyReqWs?: Server.ProxyReqWsCallback<http.ClientRequest, TReq>;
-    proxyRes?: Server.ProxyResCallback<TReq, TRes>;
-    open?: Server.OpenCallback;
-    close?: Server.CloseCallback<TReq>;
-    start?: Server.StartCallback<TReq, TRes>;
-    end?: Server.EndCallback<TReq, TRes>;
-    econnreset?: Server.EconnresetCallback<Error, TReq, TRes>;
+interface OnProxyEvent<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
+    error?: (err: Error, req: TReq, res: TRes | net.Socket, target?: string | Partial<URL>) => void;
+    proxyReq?: (proxyReq: http.ClientRequest, req: TReq, res: TRes, options: ProxyServerOptions) => void;
+    proxyReqWs?: (proxyReq: http.ClientRequest, req: TReq, socket: net.Socket, options: ProxyServerOptions, head: any) => void;
+    proxyRes?: (proxyRes: TReq, req: TReq, res: TRes) => void | Promise<void>;
+    open?: (proxySocket: net.Socket) => void;
+    close?: (proxyRes: TReq, proxySocket: net.Socket, proxyHead: any) => void;
+    start?: (req: TReq, res: TRes, target: string | Partial<URL>) => void;
+    end?: (req: TReq, res: TRes, proxyRes: TReq) => void;
+    econnreset?: (err: Error, req: TReq, res: TRes, target: string | Partial<URL>) => void;
 }
 type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
-interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends Server.ServerOptions {
+type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage> = {
+    [regexp: string]: string;
+} | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
+interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> extends ProxyServerOptions {
     /**
      * Narrow down requests to proxy or not.
      * Filter on {@link http.IncomingMessage.url `pathname`} which is relative to the proxy's "mounting" point in the server.
@@ -294,9 +182,7 @@ interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> exten
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
      */
-    pathRewrite?: {
-        [regexp: string]: string;
-    } | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
+    pathRewrite?: PathRewriteConfig<TReq>;
     /**
      * Access the internal http-proxy server instance to customize behavior
      *
@@ -351,9 +237,7 @@ interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> exten
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
      */
-    router?: {
-        [hostOrPath: string]: Server.ServerOptions['target'];
-    } | ((req: TReq) => Server.ServerOptions['target']) | ((req: TReq) => Promise<Server.ServerOptions['target']>);
+    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
     /**
      * Log information from http-proxy-middleware
      * @example
@@ -365,12 +249,111 @@ interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> exten
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/logger.md
      * @since v3.0.0
      */
-    logger?: Logger | any;
+    logger?: Logger;
 }
 
-declare function createProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;
+/**
+ * Create proxy middleware for Express-like servers. ([list of servers with examples](https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/servers.md))
+ *
+ * @example Basic proxy to a single target.
+ * ```ts
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://www.example.org',
+ *   changeOrigin: true,
+ * });
+ * ```
+ *
+ * @example Proxy only matching paths and rewrite the forwarded path.
+ * ```ts
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://localhost:3000',
+ *   pathFilter: '/api',
+ *   pathRewrite: {
+ *     '^/api/': '/',
+ *   },
+ * });
+ * ```
+ *
+ * @example Native path rewrite by mounting at a route (alternative to `pathRewrite`).
+ * ```ts
+ * import express from 'express';
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const app = express();
+ * app.use(
+ *   '/users',
+ *   createProxyMiddleware({
+ *     target: 'http://jsonplaceholder.typicode.com/users',
+ *     changeOrigin: true,
+ *   }),
+ * );
+ * ```
+ *
+ * @example Use framework-specific request/response types (Express).
+ * ```ts
+ * import type { Request, Response } from 'express';
+ * import { createProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware<Request, Response>({
+ *   target: 'http://www.example.org/api',
+ *   changeOrigin: true,
+ * });
+ * ```
+ *
+ * @example Intercept and modify a proxied response body.
+ * ```ts
+ * import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
+ *
+ * const proxy = createProxyMiddleware({
+ *   target: 'http://www.example.org',
+ *   selfHandleResponse: true,
+ *   on: {
+ *     proxyRes: responseInterceptor(async (responseBuffer) => {
+ *       const response = responseBuffer.toString('utf8');
+ *       return response.replace('Hello', 'Goodbye');
+ *     }),
+ *   },
+ * });
+ * ```
+ *
+ * @see https://github.com/chimurai/http-proxy-middleware/
+ * @see https://github.com/chimurai/http-proxy-middleware/#basic-usage
+ * @see https://github.com/chimurai/http-proxy-middleware/#intercept-and-manipulate-responses
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/servers.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathFilter.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
+ * @see https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/response-interceptor.md
+ */
+declare function createProxyMiddleware<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;
+
+/**
+ * Creates a Hono middleware that proxies requests using http-proxy-middleware.
+ *
+ * `@remarks`
+ * This middleware requires Hono to be running on Node.js via `@hono/node-server`.
+ * It uses `c.env.incoming` and `c.env.outgoing` which are only available with `HttpBindings`.
+ *
+ * `@experimental` This API is experimental and may change without a major version bump.
+ *
+ * `@example`
+ * ```ts
+ * import { serve } from '@hono/node-server';
+ * import { Hono } from 'hono';
+ * import { createHonoProxyMiddleware } from 'http-proxy-middleware';
+ *
+ * const app = new Hono();
+ * app.use('/api', createHonoProxyMiddleware({ target: 'http://example.com', changeOrigin: true }));
+ * serve(app);
+ */
+declare function createHonoProxyMiddleware(options: Options): MiddlewareHandler<{
+    Bindings: HttpBindings;
+}>;
 
-type Interceptor<TReq = http.IncomingMessage, TRes = http.ServerResponse> = (buffer: Buffer, proxyRes: TReq, req: TReq, res: TRes) => Promise<Buffer | string>;
+type Interceptor<TReq = http.IncomingMessage, TRes = http.ServerResponse> = (buffer: Buffer, proxyRes: http.IncomingMessage, req: TReq, res: TRes) => Promise<Buffer | string>;
 /**
  * Intercept responses from upstream.
  * Automatically decompress (deflate, gzip, brotli).
@@ -378,7 +361,7 @@ type Interceptor<TReq = http.IncomingMessage, TRes = http.ServerResponse> = (buf
  *
  * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
  */
-declare function responseInterceptor<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(interceptor: Interceptor<TReq, TRes>): (proxyRes: TReq, req: TReq, res: TRes) => Promise<void>;
+declare function responseInterceptor<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(interceptor: Interceptor<TReq, TRes>): (proxyRes: http.IncomingMessage, req: TReq, res: TRes) => Promise<void>;
 
 type BodyParserLikeRequest = http.IncomingMessage & {
     body?: any;
@@ -420,125 +403,5 @@ declare const loggerPlugin: Plugin;
  */
 declare const proxyEventsPlugin: Plugin;
 
-/**
- * @deprecated
- *
- * Will be removed in a future version.
- */
-interface LegacyOptions<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends Options<TReq, TRes> {
-    /**
-     * @deprecated
-     * Use `on.error` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    error: () => {}
-     * }
-     * ```
-     */
-    onError?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `on.proxyRes` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    proxyRes: () => {}
-     * }
-     * ```
-     */
-    onProxyRes?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `on.proxyReq` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    proxyReq: () => {}
-     * }
-     * ```
-     */
-    onProxyReq?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `on.proxyReqWs` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    proxyReqWs: () => {}
-     * }
-     * ```
-     */
-    onProxyReqWs?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `on.open` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    open: () => {}
-     * }
-     * ```
-     */
-    onOpen?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `on.close` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *   on: {
-     *    close: () => {}
-     * }
-     * ```
-     */
-    onClose?: (...args: any[]) => void;
-    /**
-     * @deprecated
-     * Use `logger` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *  logger: console
-     * }
-     * ```
-     */
-    logProvider?: any;
-    /**
-     * @deprecated
-     * Use `logger` instead.
-     *
-     * @example
-     * ```js
-     * {
-     *  logger: console
-     * }
-     * ```
-     */
-    logLevel?: any;
-}
-
-/**
- * @deprecated
- * This function is deprecated and will be removed in a future version.
- *
- * Use {@link createProxyMiddleware} instead.
- */
-declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(shortHand: string): RequestHandler<TReq, TRes>;
-declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;
-declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyContext: Filter<TReq>, legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;
-
-export { createProxyMiddleware, debugProxyErrorsPlugin, errorResponsePlugin, fixRequestBody, legacyCreateProxyMiddleware, loggerPlugin, proxyEventsPlugin, responseInterceptor };
-export type { Filter, LegacyOptions, Options, Plugin, RequestHandler };
+export { createHonoProxyMiddleware, createProxyMiddleware, debugProxyErrorsPlugin, errorResponsePlugin, fixRequestBody, loggerPlugin, proxyEventsPlugin, responseInterceptor };
+export type { Filter, Options, Plugin, RequestHandler };

package/compiled/http-proxy-middleware/package.json

@@ -1 +1 @@
-{"name":"http-proxy-middleware","author":"Steven Chim","version":"3.0.5","license":"MIT","types":"index.d.ts","type":"commonjs"}
+{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0-beta.5","license":"MIT","types":"index.d.ts","type":"module"}

package/dist/index.js

@@ -34,7 +34,7 @@ __webpack_require__.m = __webpack_modules__, __webpack_require__.n = (module)=>{
         value: !0
     });
 }, __webpack_require__.add({
-    "../../node_modules/.pnpm/enhanced-resolve@5.20.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/enhanced-resolve@5.21.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
         let { nextTick } = __webpack_require__("process"), dirname = (path)=>{
             let idx = path.length - 1;
             for(; idx >= 0;){
@@ -76,7 +76,7 @@ __webpack_require__.m = __webpack_modules__, __webpack_require__.n = (module)=>{
             constructor(duration, provider, syncProvider, providerContext){
                 this._duration = duration, this._provider = provider, this._syncProvider = syncProvider, this._providerContext = providerContext, this._activeAsyncOperations = new Map(), this._data = new Map(), this._levels = [];
                 for(let i = 0; i < 10; i++)this._levels.push(new Set());
-                for(let i = 5000; i < duration; i += 500)this._levels.push(new Set());
+                if (duration !== 1 / 0) for(let i = 5000; i < duration; i += 500)this._levels.push(new Set());
                 this._currentLevel = 0, this._tickInterval = Math.floor(duration / this._levels.length), this._mode = 0, this._timeout = void 0, this._nextDecay = void 0, this.provide = provider ? this.provide.bind(this) : null, this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
             }
             provide(path, options, callback) {
@@ -176,7 +176,7 @@ __webpack_require__.m = __webpack_modules__, __webpack_require__.n = (module)=>{
                         if (this._runDecays(), 0 === this._mode) return;
                         timeout = Math.max(0, this._nextDecay - Date.now());
                 }
-                this._mode = 2;
+                if (this._mode = 2, this._duration === 1 / 0) return;
                 let ref = setTimeout(()=>{
                     this._mode = 1, this._runDecays();
                 }, timeout);
@@ -1809,7 +1809,7 @@ function createDiagnosticArray(adm) {
             return copy.sort(compareFn), adm.spliceWithArray(0, adm.length, copy), this;
         },
         at: (index)=>adm.get(index),
-        concat: (...items)=>([].includes, adm.values().concat(...items)),
+        concat: (...items)=>adm.values().concat(...items),
         flat: ()=>adm.values(),
         every: (predicate, thisArg)=>adm.values().every(predicate, thisArg),
         filter: (predicate, thisArg)=>adm.values().filter(predicate, thisArg),
@@ -6865,7 +6865,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return output.wasmLoading && enabledWasmLoadingTypes.add(output.wasmLoading), output.workerWasmLoading && enabledWasmLoadingTypes.add(output.workerWasmLoading), forEachEntry((desc)=>{
             desc.wasmLoading && enabledWasmLoadingTypes.add(desc.wasmLoading);
         }), Array.from(enabledWasmLoadingTypes);
-    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !1));
+    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.1"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !1));
 }, applyExternalsPresetsDefaults = (externalsPresets, { targetProperties, buildHttp, outputModule })=>{
     let isUniversal = (key)=>!!(outputModule && targetProperties && null === targetProperties[key]);
     D(externalsPresets, 'web', !buildHttp && targetProperties && (targetProperties.web || isUniversal('node'))), D(externalsPresets, 'node', targetProperties && (targetProperties.node || isUniversal('node'))), D(externalsPresets, 'electron', targetProperties && targetProperties.electron || isUniversal('electron')), D(externalsPresets, 'electronMain', targetProperties && !!targetProperties.electron && (targetProperties.electronMain || isUniversal('electronMain'))), D(externalsPresets, 'electronPreload', targetProperties && !!targetProperties.electron && (targetProperties.electronPreload || isUniversal('electronPreload'))), D(externalsPresets, 'electronRenderer', targetProperties && !!targetProperties.electron && (targetProperties.electronRenderer || isUniversal('electronRenderer'))), D(externalsPresets, 'nwjs', targetProperties && (targetProperties.nwjs || isUniversal('nwjs')));
@@ -8119,7 +8119,7 @@ class MultiStats {
         obj.children = this.stats.map((stat, idx)=>{
             let obj = stat.toJson(childOptions.children[idx]), compilationName = stat.compilation.name;
             return obj.name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root), obj;
-        }), childOptions.version && (obj.rspackVersion = "2.0.0", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
+        }), childOptions.version && (obj.rspackVersion = "2.0.1", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
         let mapError = (j, obj)=>({
                 ...obj,
                 compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
@@ -8628,7 +8628,7 @@ let arraySum = (array)=>{
         let str = `${a}`, length = lengths[i];
         return str.length === length ? str : length > 5 ? `...${str.slice(-length + 3)}` : length > 0 ? str.slice(-length) : '';
     });
-}, CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.20.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
+}, CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.21.0/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
 var CachedInputFileSystem_default = __webpack_require__.n(CachedInputFileSystem);
 class NodeEnvironmentPlugin {
     options;
@@ -9390,7 +9390,7 @@ let iterateConfig = (config, options, fn)=>{
             object.hash = context.getStatsCompilation(compilation).hash;
         },
         version: (object)=>{
-            object.version = "5.75.0", object.rspackVersion = "2.0.0";
+            object.version = "5.75.0", object.rspackVersion = "2.0.1";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -11048,7 +11048,7 @@ class TraceHookPlugin {
         });
     }
 }
-let CORE_VERSION = "2.0.0", VFILES_BY_COMPILER = new WeakMap();
+let CORE_VERSION = "2.0.1", VFILES_BY_COMPILER = new WeakMap();
 class VirtualModulesPlugin {
     #staticModules;
     #compiler;
@@ -13351,7 +13351,7 @@ async function transform(source, options) {
     let _options = JSON.stringify(options || {});
     return binding_default().transform(source, _options);
 }
-let exports_rspackVersion = "2.0.0", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
+let exports_rspackVersion = "2.0.1", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
     getNormalizedRspackOptions: getNormalizedRspackOptions,
     applyRspackOptionsDefaults: applyRspackOptionsDefaults,
     getNormalizedWebpackOptions: getNormalizedRspackOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-debug/core",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "Fast Rust-based bundler for the web with a modernized webpack API",
@@ -40,7 +40,7 @@
     "@ast-grep/napi": "^0.42.1",
     "@napi-rs/wasm-runtime": "1.1.4",
     "@rsbuild/plugin-node-polyfill": "^1.4.4",
-    "@rslib/core": "0.21.2",
+    "@rslib/core": "0.21.3",
     "@rspack/lite-tapable": "1.1.0",
     "@swc/types": "0.1.26",
     "@types/node": "^20.19.39",
@@ -48,8 +48,8 @@
     "browserslist-load-config": "^1.0.1",
     "browserslist-to-es-version": "^1.4.1",
     "connect-next": "^4.0.1",
-    "enhanced-resolve": "5.20.1",
-    "http-proxy-middleware": "^3.0.5",
+    "enhanced-resolve": "5.21.0",
+    "http-proxy-middleware": "^4.0.0-beta.5",
     "memfs": "4.53.0",
     "open": "^11.0.0",
     "prebundle": "^1.6.4",
@@ -59,7 +59,7 @@
     "webpack-sources": "3.3.4"
   },
   "dependencies": {
-    "@rspack/binding": "npm:@rspack-debug/binding@2.0.0"
+    "@rspack/binding": "npm:@rspack-debug/binding@2.0.1"
   },
   "peerDependencies": {
     "@module-federation/runtime-tools": "^0.24.1 || ^2.0.0",