http-proxy-middleware 3.0.5 → 4.0.0-beta.2

package/dist/http-proxy-middleware.js

@@ -1,161 +1,186 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpProxyMiddleware = void 0;
-const httpProxy = require("http-proxy");
-const configuration_1 = require("./configuration");
-const get_plugins_1 = require("./get-plugins");
-const path_filter_1 = require("./path-filter");
-const PathRewriter = require("./path-rewriter");
-const Router = require("./router");
-const debug_1 = require("./debug");
-const function_1 = require("./utils/function");
-const logger_1 = require("./logger");
-class HttpProxyMiddleware {
+import { createProxyServer } from 'httpxy';
+import { verifyConfig } from './configuration.js';
+import { Debug as debug } from './debug.js';
+import { getPlugins } from './get-plugins.js';
+import { getLogger } from './logger.js';
+import { matchPathFilter } from './path-filter.js';
+import * as PathRewriter from './path-rewriter.js';
+import * as Router from './router.js';
+import { getFunctionName } from './utils/function.js';
+export class HttpProxyMiddleware {
+    wsInternalSubscribed = false;
+    serverOnCloseSubscribed = false;
+    proxyOptions;
+    proxy;
+    pathRewriter;
+    logger;
     constructor(options) {
-        this.wsInternalSubscribed = false;
-        this.serverOnCloseSubscribed = false;
-        // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
-        this.middleware = (async (req, res, next) => {
-            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
-                try {
-                    const activeProxyOptions = await this.prepareProxyRequest(req);
-                    (0, debug_1.Debug)(`proxy request to target: %O`, activeProxyOptions.target);
-                    this.proxy.web(req, res, activeProxyOptions);
-                }
-                catch (err) {
-                    next?.(err);
-                }
-            }
-            else {
-                next?.();
-            }
-            /**
-             * Get the server object to subscribe to server events;
-             * 'upgrade' for websocket and 'close' for graceful shutdown
-             *
-             * NOTE:
-             * req.socket: node >= 13
-             * req.connection: node < 13 (Remove this when node 12/13 support is dropped)
-             */
-            const server = (req.socket ?? req.connection)?.server;
-            if (server && !this.serverOnCloseSubscribed) {
-                server.on('close', () => {
-                    (0, debug_1.Debug)('server close signal received: closing proxy server');
-                    this.proxy.close();
-                });
-                this.serverOnCloseSubscribed = true;
-            }
-            if (this.proxyOptions.ws === true) {
-                // use initial request to access the server object to subscribe to http upgrade event
-                this.catchUpgradeRequest(server);
-            }
-        });
-        this.catchUpgradeRequest = (server) => {
+        verifyConfig(options);
+        this.proxyOptions = options;
+        this.logger = getLogger(options);
+        debug(`create proxy server`);
+        this.proxy = createProxyServer({});
+        this.registerPlugins(this.proxy, this.proxyOptions);
+        this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
+        // https://github.com/chimurai/http-proxy-middleware/issues/19
+        // expose function to upgrade externally
+        this.middleware.upgrade = (req, socket, head) => {
             if (!this.wsInternalSubscribed) {
-                (0, debug_1.Debug)('subscribing to server upgrade event');
-                server.on('upgrade', this.handleUpgrade);
-                // prevent duplicate upgrade handling;
-                // in case external upgrade is also configured
-                this.wsInternalSubscribed = true;
+                this.handleUpgrade(req, socket, head);
             }
         };
-        this.handleUpgrade = async (req, socket, head) => {
+    }
+    // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
+    middleware = (async (req, res, next) => {
+        if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+            let activeProxyOptions;
             try {
-                if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
-                    const activeProxyOptions = await this.prepareProxyRequest(req);
-                    this.proxy.ws(req, socket, head, activeProxyOptions);
-                    (0, debug_1.Debug)('server upgrade event received. Proxying WebSocket');
+                // Preparation Phase: Apply router and path rewriter.
+                activeProxyOptions = await this.prepareProxyRequest(req);
+                // [Smoking Gun] httpxy is inconsistent with error handling:
+                // 1. If target is missing (here), it emits 'error' but returns a boolean (bypassing our catch/next).
+                // 2. If a network error occurs (in proxy.web), it rejects the promise but SKIPS emitting 'error'.
+                // We manually throw here to force Case 1 into the catch block so next(err) is called for Express.
+                if (!activeProxyOptions.target && !activeProxyOptions.forward) {
+                    throw new Error('Must provide a proper URL as target');
                 }
             }
             catch (err) {
-                // This error does not include the URL as the fourth argument as we won't
-                // have the URL if `this.prepareProxyRequest` throws an error.
-                this.proxy.emit('error', err, req, socket);
+                next?.(err);
+                return;
             }
-        };
-        /**
-         * Determine whether request should be proxied.
-         */
-        this.shouldProxy = (pathFilter, req) => {
             try {
-                return (0, path_filter_1.matchPathFilter)(pathFilter, req.url, req);
+                // Proxying Phase: Handle the actual web request.
+                debug(`proxy request to target: %O`, activeProxyOptions.target);
+                await this.proxy.web(req, res, activeProxyOptions);
             }
             catch (err) {
-                (0, debug_1.Debug)('Error: matchPathFilter() called with request url: ', `"${req.url}"`);
-                this.logger.error(err);
-                return false;
+                // Manually emit 'error' event because httpxy's promise-based API does not emit it automatically.
+                // This is crucial for backward compatibility with HPM plugins (like error-response-plugin)
+                // and custom listeners registered via the 'on: { error: ... }' option.
+                /**
+                 * TODO: Ideally, TReq and TRes should be restricted via "TReq extends http.IncomingMessage = http.IncomingMessage"
+                 * and "TRes extends http.ServerResponse = http.ServerResponse", which allows us to avoid the "req as TReq" below.
+                 *
+                 * However, making TReq and TRes constrained types may cause a breaking change for TypeScript users downstream.
+                 * So we leave this as a TODO for now, and revisit it in a future major release.
+                 */
+                this.proxy.emit('error', err, req, res, activeProxyOptions.target);
+                next?.(err);
             }
-        };
+        }
+        else {
+            next?.();
+        }
         /**
-         * Apply option.router and option.pathRewrite
-         * Order matters:
-         *    Router uses original path for routing;
-         *    NOT the modified path, after it has been rewritten by pathRewrite
-         * @param {Object} req
-         * @return {Object} proxy options
+         * Get the server object to subscribe to server events;
+         * 'upgrade' for websocket and 'close' for graceful shutdown
          */
-        this.prepareProxyRequest = async (req) => {
-            /**
-             * Incorrect usage confirmed: https://github.com/expressjs/express/issues/4854#issuecomment-1066171160
-             * Temporary restore req.url patch for {@link src/legacy/create-proxy-middleware.ts legacyCreateProxyMiddleware()}
-             * FIXME: remove this patch in future release
-             */
-            if (this.middleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__) {
-                req.url = req.originalUrl || req.url;
-            }
-            const newProxyOptions = Object.assign({}, this.proxyOptions);
-            // Apply in order:
-            // 1. option.router
-            // 2. option.pathRewrite
-            await this.applyRouter(req, newProxyOptions);
-            await this.applyPathRewrite(req, this.pathRewriter);
-            return newProxyOptions;
-        };
-        // Modify option.target when router present.
-        this.applyRouter = async (req, options) => {
-            let newTarget;
-            if (options.router) {
-                newTarget = await Router.getTarget(req, options);
-                if (newTarget) {
-                    (0, debug_1.Debug)('router new target: "%s"', newTarget);
-                    options.target = newTarget;
-                }
-            }
-        };
-        // rewrite path
-        this.applyPathRewrite = async (req, pathRewriter) => {
-            if (pathRewriter) {
-                const path = await pathRewriter(req.url, req);
-                if (typeof path === 'string') {
-                    (0, debug_1.Debug)('pathRewrite new path: %s', req.url);
-                    req.url = path;
-                }
-                else {
-                    (0, debug_1.Debug)('pathRewrite: no rewritten path found: %s', req.url);
-                }
-            }
-        };
-        (0, configuration_1.verifyConfig)(options);
-        this.proxyOptions = options;
-        this.logger = (0, logger_1.getLogger)(options);
-        (0, debug_1.Debug)(`create proxy server`);
-        this.proxy = httpProxy.createProxyServer({});
-        this.registerPlugins(this.proxy, this.proxyOptions);
-        this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
-        // https://github.com/chimurai/http-proxy-middleware/issues/19
-        // expose function to upgrade externally
-        this.middleware.upgrade = (req, socket, head) => {
-            if (!this.wsInternalSubscribed) {
-                this.handleUpgrade(req, socket, head);
-            }
-        };
-    }
+        const server = req.socket?.server;
+        if (server && !this.serverOnCloseSubscribed) {
+            server.on('close', () => {
+                debug('server close signal received: closing proxy server');
+                this.proxy.close(() => {
+                    debug('proxy server closed');
+                });
+            });
+            this.serverOnCloseSubscribed = true;
+        }
+        if (this.proxyOptions.ws === true && server) {
+            // use initial request to access the server object to subscribe to http upgrade event
+            this.catchUpgradeRequest(server);
+        }
+    });
     registerPlugins(proxy, options) {
-        const plugins = (0, get_plugins_1.getPlugins)(options);
+        const plugins = getPlugins(options);
         plugins.forEach((plugin) => {
-            (0, debug_1.Debug)(`register plugin: "${(0, function_1.getFunctionName)(plugin)}"`);
+            debug(`register plugin: "${getFunctionName(plugin)}"`);
             plugin(proxy, options);
         });
     }
+    catchUpgradeRequest = (server) => {
+        if (!this.wsInternalSubscribed) {
+            debug('subscribing to server upgrade event');
+            server.on('upgrade', this.handleUpgrade);
+            // prevent duplicate upgrade handling;
+            // in case external upgrade is also configured
+            this.wsInternalSubscribed = true;
+        }
+    };
+    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);
+                debug('server upgrade event received. Proxying WebSocket');
+            }
+        }
+        catch (err) {
+            // This error does not include the URL as the fourth argument as we won't
+            // have the URL if `this.prepareProxyRequest` throws an error.
+            /**
+             * TODO: Ideally, TReq and TRes should be restricted via "TReq extends http.IncomingMessage = http.IncomingMessage"
+             * and "TRes extends http.ServerResponse = http.ServerResponse", which allows us to avoid the "req as TReq" below.
+             *
+             * However, making TReq and TRes constrained types may cause a breaking change for TypeScript users downstream.
+             * So we leave this as a TODO for now, and revisit it in a future major release.
+             */
+            this.proxy.emit('error', err, req, socket);
+        }
+    };
+    /**
+     * Determine whether request should be proxied.
+     */
+    shouldProxy = (pathFilter, req) => {
+        try {
+            return matchPathFilter(pathFilter, req.url, req);
+        }
+        catch (err) {
+            debug('Error: matchPathFilter() called with request url: ', `"${req.url}"`);
+            this.logger.error(err);
+            return false;
+        }
+    };
+    /**
+     * Apply option.router and option.pathRewrite
+     * Order matters:
+     *    Router uses original path for routing;
+     *    NOT the modified path, after it has been rewritten by pathRewrite
+     * @param {Object} req
+     * @return {Object} proxy options
+     */
+    prepareProxyRequest = async (req) => {
+        const newProxyOptions = Object.assign({}, this.proxyOptions);
+        // Apply in order:
+        // 1. option.router
+        // 2. option.pathRewrite
+        await this.applyRouter(req, newProxyOptions);
+        await this.applyPathRewrite(req, this.pathRewriter);
+        return newProxyOptions;
+    };
+    // Modify option.target when router present.
+    applyRouter = async (req, options) => {
+        let newTarget;
+        if (options.router) {
+            newTarget = await Router.getTarget(req, options);
+            if (newTarget) {
+                debug('router new target: "%s"', newTarget);
+                options.target = newTarget;
+            }
+        }
+    };
+    // rewrite path
+    applyPathRewrite = async (req, pathRewriter) => {
+        if (pathRewriter) {
+            const path = await pathRewriter(req.url, req);
+            if (typeof path === 'string') {
+                debug('pathRewrite new path: %s', path);
+                req.url = path;
+            }
+            else {
+                debug('pathRewrite: no rewritten path found: %s', req.url);
+            }
+        }
+    };
 }
-exports.HttpProxyMiddleware = HttpProxyMiddleware;

package/dist/index.d.ts

@@ -1,11 +1,7 @@
-export * from './factory';
-export * from './handlers';
-export type { Plugin, Filter, Options, RequestHandler } from './types';
+export * from './factory.js';
+export * from './handlers/index.js';
+export type { Plugin, Filter, Options, RequestHandler } from './types.js';
 /**
  * Default plugins
  */
-export * from './plugins/default';
-/**
- * Legacy exports
- */
-export * from './legacy';
+export * from './plugins/default/index.js';

package/dist/index.js

@@ -1,26 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./factory"), exports);
-__exportStar(require("./handlers"), exports);
+export * from './factory.js';
+export * from './handlers/index.js';
 /**
  * Default plugins
  */
-__exportStar(require("./plugins/default"), exports);
-/**
- * Legacy exports
- */
-__exportStar(require("./legacy"), exports);
+export * from './plugins/default/index.js';

package/dist/logger.d.ts

@@ -1,2 +1,2 @@
-import { Logger, Options } from './types';
+import { Logger, Options } from './types.js';
 export declare function getLogger(options: Options): Logger;

package/dist/logger.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogger = getLogger;
 /**
  * Compatibility matrix
  *
@@ -19,6 +16,6 @@ const noopLogger = {
     warn: () => { },
     error: () => { },
 };
-function getLogger(options) {
+export function getLogger(options) {
     return options.logger || noopLogger;
 }

package/dist/path-filter.d.ts

@@ -1,3 +1,3 @@
-import type { Filter } from './types';
-import type * as http from 'http';
-export declare function matchPathFilter<TReq = http.IncomingMessage>(pathFilter: Filter<TReq> | undefined, uri: string | undefined, req: http.IncomingMessage): boolean;
+import type * as http from 'node:http';
+import type { Filter } from './types.js';
+export declare function matchPathFilter<TReq extends http.IncomingMessage = http.IncomingMessage>(pathFilter: Filter<TReq> | undefined, uri: string | undefined, req: http.IncomingMessage): boolean;

package/dist/path-filter.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchPathFilter = matchPathFilter;
-const isGlob = require("is-glob");
-const micromatch = require("micromatch");
-const url = require("url");
-const errors_1 = require("./errors");
-function matchPathFilter(pathFilter = '/', uri, req) {
+import isGlob from 'is-glob';
+import micromatch from 'micromatch';
+import { ERRORS } from './errors.js';
+export function matchPathFilter(pathFilter = '/', uri, req) {
     // single path
     if (isStringPath(pathFilter)) {
         return matchSingleStringPath(pathFilter, uri);
@@ -22,14 +18,14 @@ function matchPathFilter(pathFilter = '/', uri, req) {
         if (pathFilter.every(isGlobPath)) {
             return matchMultiGlobPath(pathFilter, uri);
         }
-        throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+        throw new Error(ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
     }
     // custom matching
     if (typeof pathFilter === 'function') {
         const pathname = getUrlPathName(uri);
         return pathFilter(pathname, req);
     }
-    throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
+    throw new Error(ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
 }
 /**
  * @param  {String} pathFilter '/api'
@@ -70,7 +66,7 @@ function matchMultiPath(pathFilterList, uri) {
  * @return {String}     RFC 3986 path
  */
 function getUrlPathName(uri) {
-    return uri && url.parse(uri).pathname;
+    return uri && new URL(uri, 'http://0.0.0.0').pathname;
 }
 function isStringPath(pathFilter) {
     return typeof pathFilter === 'string' && !isGlob(pathFilter);

package/dist/path-rewriter.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPathRewriter = createPathRewriter;
-const is_plain_object_1 = require("is-plain-object");
-const errors_1 = require("./errors");
-const debug_1 = require("./debug");
-const debug = debug_1.Debug.extend('path-rewriter');
+import { isPlainObject } from 'is-plain-object';
+import { Debug } from './debug.js';
+import { ERRORS } from './errors.js';
+const debug = Debug.extend('path-rewriter');
 /**
  * Create rewrite function, to cache parsed rewrite rules.
  *
  * @param {Object} rewriteConfig
  * @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
  */
-function createPathRewriter(rewriteConfig) {
+export function createPathRewriter(rewriteConfig) {
     let rulesCache;
     if (!isValidRewriteConfig(rewriteConfig)) {
         return;
@@ -40,19 +37,19 @@ function isValidRewriteConfig(rewriteConfig) {
     if (typeof rewriteConfig === 'function') {
         return true;
     }
-    else if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) {
+    else if (isPlainObject(rewriteConfig)) {
         return Object.keys(rewriteConfig).length !== 0;
     }
     else if (rewriteConfig === undefined || rewriteConfig === null) {
         return false;
     }
     else {
-        throw new Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
+        throw new Error(ERRORS.ERR_PATH_REWRITER_CONFIG);
     }
 }
 function parsePathRewriteRules(rewriteConfig) {
     const rules = [];
-    if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) {
+    if (isPlainObject(rewriteConfig)) {
         for (const [key, value] of Object.entries(rewriteConfig)) {
             rules.push({
                 regex: new RegExp(key),

package/dist/plugins/default/debug-proxy-errors-plugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '../../types';
+import { Plugin } from '../../types.js';
 /**
  * Subscribe to {@link https://www.npmjs.com/package/http-proxy#listening-for-proxy-events http-proxy error events} to prevent server from crashing.
  * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.

package/dist/plugins/default/debug-proxy-errors-plugin.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugProxyErrorsPlugin = void 0;
-const debug_1 = require("../../debug");
-const debug = debug_1.Debug.extend('debug-proxy-errors-plugin');
+import { Debug } from '../../debug.js';
+const debug = Debug.extend('debug-proxy-errors-plugin');
 /**
  * Subscribe to {@link https://www.npmjs.com/package/http-proxy#listening-for-proxy-events http-proxy error events} to prevent server from crashing.
  * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
  */
-const debugProxyErrorsPlugin = (proxyServer) => {
+export const debugProxyErrorsPlugin = (proxyServer) => {
     /**
      * http-proxy doesn't handle any errors by default (https://github.com/http-party/node-http-proxy#listening-for-proxy-events)
      * Prevent server from crashing when http-proxy errors (uncaught errors)
@@ -58,4 +55,3 @@ const debugProxyErrorsPlugin = (proxyServer) => {
         debug(`http-proxy econnreset event: \n%O`, error);
     });
 };
-exports.debugProxyErrorsPlugin = debugProxyErrorsPlugin;

package/dist/plugins/default/error-response-plugin.d.ts

@@ -1,2 +1,2 @@
-import { Plugin } from '../../types';
+import { Plugin } from '../../types.js';
 export declare const errorResponsePlugin: Plugin;

package/dist/plugins/default/error-response-plugin.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorResponsePlugin = void 0;
-const status_code_1 = require("../../status-code");
+import { getStatusCode } from '../../status-code.js';
+import { sanitize } from '../../utils/sanitize.js';
 function isResponseLike(obj) {
     return obj && typeof obj.writeHead === 'function';
 }
 function isSocketLike(obj) {
     return obj && typeof obj.write === 'function' && !('writeHead' in obj);
 }
-const errorResponsePlugin = (proxyServer, options) => {
+export const errorResponsePlugin = (proxyServer, options) => {
     proxyServer.on('error', (err, req, res, target) => {
         // Re-throw error. Not recoverable since req & res are empty.
-        if (!req && !res) {
+        if (!req || !res) {
             throw err; // "Error: Must provide a proper URL as target"
         }
         if (isResponseLike(res)) {
             if (!res.headersSent) {
-                const statusCode = (0, status_code_1.getStatusCode)(err.code);
+                const statusCode = getStatusCode(err.code);
                 res.writeHead(statusCode);
             }
             const host = req.headers && req.headers.host;
-            res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
+            res.end(`Error occurred while trying to proxy: ${sanitize(host)}${sanitize(req.url)}`);
         }
         else if (isSocketLike(res)) {
             res.destroy();
         }
     });
 };
-exports.errorResponsePlugin = errorResponsePlugin;

package/dist/plugins/default/index.d.ts

@@ -1,4 +1,4 @@
-export * from './debug-proxy-errors-plugin';
-export * from './error-response-plugin';
-export * from './logger-plugin';
-export * from './proxy-events';
+export * from './debug-proxy-errors-plugin.js';
+export * from './error-response-plugin.js';
+export * from './logger-plugin.js';
+export * from './proxy-events.js';

package/dist/plugins/default/index.js

@@ -1,20 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./debug-proxy-errors-plugin"), exports);
-__exportStar(require("./error-response-plugin"), exports);
-__exportStar(require("./logger-plugin"), exports);
-__exportStar(require("./proxy-events"), exports);
+export * from './debug-proxy-errors-plugin.js';
+export * from './error-response-plugin.js';
+export * from './logger-plugin.js';
+export * from './proxy-events.js';

package/dist/plugins/default/logger-plugin.d.ts

@@ -1,2 +1,2 @@
-import { Plugin } from '../../types';
+import { Plugin } from '../../types.js';
 export declare const loggerPlugin: Plugin;