@rsbuild/core 1.0.0 → 1.0.1-beta.0

package/compiled/html-rspack-plugin/license

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/compiled/html-rspack-plugin/loader.js

@@ -0,0 +1,173 @@
+/* This loader renders the template with lodash.template if no other loader was found */
+// @ts-nocheck
+
+/**
+ * This is a minimal implementation of `lodash.template`
+ * Modified based on lodash v4.17.21
+ * License: https://github.com/lodash/lodash/blob/main/LICENSE
+ */
+/** Used to match template delimiters. */
+const reEscape = /<%-([\s\S]+?)%>/g;
+/** Used to match template delimiters. */
+const reEvaluate = /<%([\s\S]+?)%>/g;
+/** Used to match template delimiters. */
+const reInterpolate = /<%=([\s\S]+?)%>/g;
+/** Used to match empty string literals in compiled template source. */
+const reEmptyStringLeading = /\b__p \+= '';/g,
+  reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+  reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+/**
+ * Used to match
+ * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
+ */
+const reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+/** Used to match unescaped characters in compiled string literals. */
+const reUnescapedString = /['\n\r\u2028\u2029\\]/g;
+
+/** Used to escape characters for inclusion in compiled string literals. */
+const stringEscapes = {
+  '\\': '\\',
+  "'": "'",
+  '\n': 'n',
+  '\r': 'r',
+  '\u2028': 'u2028',
+  '\u2029': 'u2029',
+};
+
+const escapeStringChar = (chr) => '\\' + stringEscapes[chr];
+
+function template(string) {
+  let isEscaping;
+  let isEvaluating;
+  let index = 0;
+  let source = "__p += '";
+
+  // Compile the regexp to match each delimiter.
+  const reDelimiters = RegExp(
+    reEscape.source +
+      '|' +
+      reInterpolate.source +
+      '|' +
+      reEsTemplate.source +
+      '|' +
+      reEvaluate.source +
+      '|$',
+    'g',
+  );
+
+  string.replace(
+    reDelimiters,
+    function (
+      match,
+      escapeValue,
+      interpolateValue,
+      esTemplateValue,
+      evaluateValue,
+      offset,
+    ) {
+      interpolateValue || (interpolateValue = esTemplateValue);
+
+      // Escape characters that can't be included in string literals.
+      source += string
+        .slice(index, offset)
+        .replace(reUnescapedString, escapeStringChar);
+
+      // Replace delimiters with snippets.
+      if (escapeValue) {
+        isEscaping = true;
+        source += "' +\n__e(" + escapeValue + ") +\n'";
+      }
+      if (evaluateValue) {
+        isEvaluating = true;
+        source += "';\n" + evaluateValue + ";\n__p += '";
+      }
+      if (interpolateValue) {
+        source +=
+          "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+      }
+      index = offset + match.length;
+
+      // The JS engine embedded in Adobe products needs `match` returned in
+      // order to produce the correct `offset` value.
+      return match;
+    },
+  );
+
+  source += "';\n";
+
+  // Cleanup code by stripping empty strings.
+  source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+    .replace(reEmptyStringMiddle, '$1')
+    .replace(reEmptyStringTrailing, '$1;');
+
+  // Frame code as the function body.
+  source =
+    'function(' +
+    'data' +
+    ') {\n' +
+    "let __t, __p = ''" +
+    (isEscaping ? ', __e = lodashEscape' : '') +
+    (isEvaluating
+      ? ', __j = Array.prototype.join;\n' +
+        "function print() { __p += __j.call(arguments, '') }\n"
+      : ';\n') +
+    source +
+    'return __p\n}';
+
+  return { compiled: source, isEscaping };
+}
+
+module.exports = function (source) {
+  const allLoadersButThisOne = this.loaders.filter(
+    (loader) => loader.normal !== module.exports,
+  );
+
+  // This loader shouldn't kick in if there is any other loader
+  if (allLoadersButThisOne.length > 0) {
+    return source;
+  }
+
+  // Allow only one html-webpack-plugin loader to allow loader options in the webpack config
+  const htmlWebpackPluginLoaders = this.loaders.filter(
+    (loader) => loader.normal === module.exports,
+  );
+  const lastHtmlRspackPluginLoader =
+    htmlWebpackPluginLoaders[htmlWebpackPluginLoaders.length - 1];
+  if (this.loaders[this.loaderIndex] !== lastHtmlRspackPluginLoader) {
+    return source;
+  }
+
+  if (/\.(c|m)?js$/.test(this.resourcePath)) {
+    return source;
+  }
+
+  const escapeCode = `const htmlEscapes = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+const escapeHtmlChar = (key) => htmlEscapes[key];
+const reUnescapedHtml = /[&<>"']/g, reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
+
+function lodashEscape(string) {
+  string = string.toString();
+  return string && reHasUnescapedHtml.test(string)
+    ? string.replace(reUnescapedHtml, escapeHtmlChar)
+    : string;
+};`;
+
+  // The following part renders the template with lodash as a minimalistic loader
+  const { compiled, isEscaping } = template(source);
+  // Use `eval("require")("lodash")` to enforce using the native nodejs require
+  // during template execution
+  return `
+module.exports = function (templateParams) { with(templateParams) {
+  ${isEscaping ? escapeCode : ''}
+  // Execute the lodash template
+  return (${compiled})(); 
+}}`;
+};

package/compiled/html-rspack-plugin/package.json

@@ -0,0 +1 @@
+{"name":"html-rspack-plugin","author":"Jan Nicklas <j.nicklas@me.com> (https://github.com/jantimon)","version":"6.0.0-beta.8","funding":{"type":"opencollective","url":"https://opencollective.com/html-webpack-plugin"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/http-compression/index.js

@@ -1 +1,134 @@
-(()=>{"use strict";var e={323:(e,t,r)=>{const n=r(796);const s=/text|javascript|\/json|xml/i;const noop=()=>{};const getChunkSize=(e,t)=>e?Buffer.byteLength(e,t):0;e.exports=({threshold:e=1024,level:t=-1,brotli:r=true,gzip:i=true,mimes:o=s}={})=>{const a=typeof r==="object"&&r||{};const c=typeof i==="object"&&i||{};if(r&&!n.createBrotliCompress)r=false;return(s,l,p=noop)=>{const f=s.headers["accept-encoding"];const u=f&&(r&&f.match(/\bbr\b/)||i&&f.match(/\bgzip\b/)||[])[0];if(s.method==="HEAD"||!u)return p();let _;let d;let b=[];let h=false;let g=0;function start(){h=true;g=l.getHeader("Content-Length")|0||g;const r=o.test(String(l.getHeader("Content-Type")||"text/plain"));const s=!l.getHeader("Content-Encoding");const i=b||[];if(r&&s&&g>=e){l.setHeader("Content-Encoding",u);l.removeHeader("Content-Length");if(u==="br"){const e={[n.constants.BROTLI_PARAM_QUALITY]:t,[n.constants.BROTLI_PARAM_SIZE_HINT]:g};_=n.createBrotliCompress({params:Object.assign(e,a)})}else{_=n.createGzip(Object.assign({level:t},c))}_.on("data",(e=>m.call(l,e)===false&&_.pause()));v.call(l,"drain",(()=>_.resume()));_.on("end",(()=>y.call(l)));i.forEach((e=>_.on.apply(_,e)))}else{b=null;i.forEach((e=>v.apply(l,e)))}w.call(l,d||l.statusCode)}const{end:y,write:m,on:v,writeHead:w}=l;l.writeHead=function(e,t,r){if(typeof t!=="string")[r,t]=[t,r];if(r)for(const e in r)l.setHeader(e,r[e]);d=e;return this};l.write=function(e,t){g+=getChunkSize(e,t);if(!h)start();if(!_)return m.apply(this,arguments);return _.write.apply(_,arguments)};l.end=function(e,t){if(arguments.length>0&&typeof e!=="function"){g+=getChunkSize(e,t)}if(!h)start();if(!_)return y.apply(this,arguments);return _.end.apply(_,arguments)};l.on=function(e,t){if(!b||e!=="drain")v.call(this,e,t);else if(_)_.on(e,t);else b.push([e,t]);return this};p()}}},796:e=>{e.exports=require("zlib")}};var t={};function __nccwpck_require__(r){var n=t[r];if(n!==undefined){return n.exports}var s=t[r]={exports:{}};var i=true;try{e[r](s,s.exports,__nccwpck_require__);i=false}finally{if(i)delete t[r]}return s.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var r=__nccwpck_require__(323);module.exports=r})();
+(() => {
+  "use strict";
+  var __webpack_modules__ = {
+    807: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      const zlib = __nccwpck_require__(796);
+      const MIMES = /text|javascript|\/json|xml/i;
+      const noop = () => {};
+      const getChunkSize = (chunk, enc) =>
+        chunk ? Buffer.byteLength(chunk, enc) : 0;
+      module.exports = ({
+        threshold = 1024,
+        level = -1,
+        brotli = true,
+        gzip = true,
+        mimes = MIMES,
+      } = {}) => {
+        const brotliOpts = (typeof brotli === "object" && brotli) || {};
+        const gzipOpts = (typeof gzip === "object" && gzip) || {};
+        if (brotli && !zlib.createBrotliCompress) brotli = false;
+        return (req, res, next = noop) => {
+          const accept = req.headers["accept-encoding"];
+          const encoding =
+            accept &&
+            ((brotli && accept.match(/\bbr\b/)) ||
+              (gzip && accept.match(/\bgzip\b/)) ||
+              [])[0];
+          if (req.method === "HEAD" || !encoding) return next();
+          let compress;
+          let pendingStatus;
+          let pendingListeners = [];
+          let started = false;
+          let size = 0;
+          function start() {
+            started = true;
+            size = res.getHeader("Content-Length") | 0 || size;
+            const compressible = mimes.test(
+              String(res.getHeader("Content-Type") || "text/plain"),
+            );
+            const cleartext = !res.getHeader("Content-Encoding");
+            const listeners = pendingListeners || [];
+            if (compressible && cleartext && size >= threshold) {
+              res.setHeader("Content-Encoding", encoding);
+              res.removeHeader("Content-Length");
+              if (encoding === "br") {
+                compress = zlib.createBrotliCompress({
+                  params: Object.assign(
+                    {
+                      [zlib.constants.BROTLI_PARAM_QUALITY]:
+                        level === -1 ? 1 : level,
+                      [zlib.constants.BROTLI_PARAM_SIZE_HINT]: size,
+                    },
+                    brotliOpts,
+                  ),
+                });
+              } else {
+                compress = zlib.createGzip(
+                  Object.assign({ level: level === -1 ? 7 : level }, gzipOpts),
+                );
+              }
+              compress.on(
+                "data",
+                (chunk) => write.call(res, chunk) === false && compress.pause(),
+              );
+              on.call(res, "drain", () => compress.resume());
+              compress.on("end", () => end.call(res));
+              listeners.forEach((p) => compress.on.apply(compress, p));
+            } else {
+              pendingListeners = null;
+              listeners.forEach((p) => on.apply(res, p));
+            }
+            writeHead.call(res, pendingStatus || res.statusCode);
+          }
+          const { end, write, on, writeHead } = res;
+          res.writeHead = function (status, reason, headers) {
+            if (typeof reason !== "string")
+              [headers, reason] = [reason, headers];
+            if (headers) for (const i in headers) res.setHeader(i, headers[i]);
+            pendingStatus = status;
+            return this;
+          };
+          res.write = function (chunk, enc) {
+            size += getChunkSize(chunk, enc);
+            if (!started) start();
+            if (!compress) return write.apply(this, arguments);
+            return compress.write.apply(compress, arguments);
+          };
+          res.end = function (chunk, enc) {
+            if (arguments.length > 0 && typeof chunk !== "function") {
+              size += getChunkSize(chunk, enc);
+            }
+            if (!started) start();
+            if (!compress) return end.apply(this, arguments);
+            return compress.end.apply(compress, arguments);
+          };
+          res.on = function (type, listener) {
+            if (!pendingListeners || type !== "drain")
+              on.call(this, type, listener);
+            else if (compress) compress.on(type, listener);
+            else pendingListeners.push([type, listener]);
+            return this;
+          };
+          next();
+        };
+      };
+    },
+    796: (module) => {
+      module.exports = require("zlib");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(807);
+  module.exports = __webpack_exports__;
+})();

package/compiled/http-compression/package.json

@@ -1 +1 @@
-{"name":"http-compression","author":{"email":"josefrancisco.verdu@gmail.com","name":"Kiko Beats","url":"https://kikobeats.com"},"version":"1.0.6","license":"MIT","types":"index.d.ts"}
+{"name":"http-compression","author":{"email":"josefrancisco.verdu@gmail.com","name":"Kiko Beats","url":"https://kikobeats.com"},"version":"1.0.20","license":"MIT","types":"index.d.ts","type":"commonjs"}

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

@@ -0,0 +1,315 @@
+/// <reference types="node" />
+import * as express from 'express';
+import * as http from 'http';
+import * as events from 'events';
+import * as net from 'net';
+import * as stream from 'stream';
+import * as url from 'url';
+
+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;
+}
+
+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 regular HTTP(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;
+}
+
+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;
+    }
+
+    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;
+}
+
+/**
+ * Based on definition by DefinitelyTyped:
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/6f529c6c67a447190f86bfbf894d1061e41e07b7/types/http-proxy-middleware/index.d.ts
+ */
+
+interface Request extends express.Request {
+}
+interface Response extends express.Response {
+}
+interface RequestHandler extends express.RequestHandler {
+    upgrade?: (req: Request, socket: net.Socket, head: any) => void;
+}
+declare type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
+interface Options extends Server.ServerOptions {
+    pathRewrite?: {
+        [regexp: string]: string;
+    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
+    router?: {
+        [hostOrPath: string]: Server.ServerOptions['target'];
+    } | ((req: Request) => Server.ServerOptions['target']) | ((req: Request) => Promise<Server.ServerOptions['target']>);
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    logProvider?: LogProviderCallback;
+    onError?: OnErrorCallback;
+    onProxyRes?: OnProxyResCallback;
+    onProxyReq?: OnProxyReqCallback;
+    onProxyReqWs?: OnProxyReqWsCallback;
+    onOpen?: OnOpenCallback;
+    onClose?: OnCloseCallback;
+}
+interface LogProvider {
+    log: Logger;
+    debug?: Logger;
+    info?: Logger;
+    warn?: Logger;
+    error?: Logger;
+}
+declare type Logger = (...args: any[]) => void;
+declare type LogProviderCallback = (provider: LogProvider) => LogProvider;
+/**
+ * Use types based on the events listeners from http-proxy
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/51504fd999031b7f025220fab279f1b2155cbaff/types/http-proxy/index.d.ts
+ */
+declare type OnErrorCallback = (err: Error, req: Request, res: Response, target?: string | Partial<url.Url>) => void;
+declare type OnProxyResCallback = (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
+declare type OnProxyReqCallback = (proxyReq: http.ClientRequest, req: Request, res: Response, options: Server.ServerOptions) => void;
+declare type OnProxyReqWsCallback = (proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: Server.ServerOptions, head: any) => void;
+declare type OnCloseCallback = (proxyRes: Response, proxySocket: net.Socket, proxyHead: any) => void;
+declare type OnOpenCallback = (proxySocket: net.Socket) => void;
+
+declare type Interceptor = (buffer: Buffer, proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<Buffer | string>;
+/**
+ * Intercept responses from upstream.
+ * Automatically decompress (deflate, gzip, brotli).
+ * Give developer the opportunity to modify intercepted Buffer and http.ServerResponse
+ *
+ * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
+ */
+declare function responseInterceptor(interceptor: Interceptor): (proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+
+/**
+ * Fix proxied body if bodyParser is involved.
+ */
+declare function fixRequestBody(proxyReq: http.ClientRequest, req: http.IncomingMessage): void;
+
+declare function createProxyMiddleware(context: Filter | Options, options?: Options): RequestHandler;
+
+export { type Filter, type Options, type RequestHandler, createProxyMiddleware, fixRequestBody, responseInterceptor };