@rsbuild/core 2.0.0-beta.0 → 2.0.0-beta.1

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

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

package/dist/131.js

@@ -3444,7 +3444,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.0-beta.0",
+        version: "2.0.0-beta.1",
         rootPath,
         distPath: '',
         cachePath,
@@ -5489,11 +5489,7 @@ function getPackageNameFromModulePath(modulePath) {
     let handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
     if (!handleModuleContext) return;
     let [, scope, name] = handleModuleContext;
-    return [
-        'npm',
-        (scope ?? '').replace('@', ''),
-        name
-    ].filter(Boolean).join('.');
+    return `npm-${scope ? `${scope.replace('@', '')}_` : ''}${name}`;
 }
 function splitByModule(ctx) {
     let { config, override, forceSplittingGroups } = ctx, perPackageOptions = resolvePerPackagePreset();
@@ -5577,6 +5573,8 @@ function getSplitChunksByPreset(config, preset) {
             return resolveSingleVendorPreset();
         case 'per-package':
             return resolvePerPackagePreset();
+        case 'none':
+            return {};
         default:
             throw Error(`[rsbuild] Unknown splitChunks preset: ${preset}`);
     }
@@ -6729,30 +6727,35 @@ let faviconFallbackMiddleware = (req, res, next)=>{
         }), res.end(`The server is configured with a base URL of ${base} - did you mean to visit ${redirectPath} instead?`);
     };
 function formatProxyOptions(proxyOptions) {
-    let ret = [];
-    if (Array.isArray(proxyOptions)) ret.push(...proxyOptions);
-    else if ('target' in proxyOptions) ret.push(proxyOptions);
-    else for (let [context, options] of Object.entries(proxyOptions)){
-        let opts = {
-            context,
-            changeOrigin: !0,
-            logLevel: 'warn',
-            logProvider: ()=>src_logger
-        };
-        'string' == typeof options ? opts.target = options : Object.assign(opts, options), ret.push(opts);
-    }
-    return ret;
+    let logPrefix = picocolors_default().dim('[http-proxy-middleware]: '), defaultOptions = {
+        changeOrigin: !0,
+        logger: {
+            info (msg) {
+                src_logger.debug(logPrefix + msg);
+            },
+            warn: (msg)=>{
+                src_logger.warn(logPrefix + msg);
+            },
+            error: (msg)=>{
+                src_logger.error(logPrefix + msg);
+            }
+        }
+    };
+    return Array.isArray(proxyOptions) ? proxyOptions.map((options)=>({
+            ...defaultOptions,
+            ...options
+        })) : Object.entries(proxyOptions).map(([pathFilter, value])=>({
+            ...defaultOptions,
+            pathFilter,
+            ...'string' == typeof value ? {
+                target: value
+            } : value
+        }));
 }
 function createProxyMiddleware(proxyOptions) {
     let formattedOptions = formatProxyOptions(proxyOptions), proxyMiddlewares = [], middlewares = [], { createProxyMiddleware: baseMiddleware } = requireCompiledPackage('http-proxy-middleware');
     for (let opts of formattedOptions){
-        let { onProxyRes } = opts;
-        opts.onProxyRes = (proxyRes, _req, res)=>{
-            onProxyRes && onProxyRes(proxyRes, _req, res), res.on('close', ()=>{
-                res.writableEnded || proxyRes.destroy();
-            });
-        };
-        let proxyMiddleware = baseMiddleware(opts.context, opts), middleware = async (req, res, next)=>{
+        let proxyMiddleware = baseMiddleware(opts), middleware = async (req, res, next)=>{
             let bypassUrl = 'function' == typeof opts.bypass ? await opts.bypass(req, res, opts) : null;
             !1 === bypassUrl ? (res.statusCode = 404, next()) : 'string' == typeof bypassUrl ? (req.url = bypassUrl, next()) : !0 === bypassUrl ? next() : proxyMiddleware(req, res, next);
         };
@@ -8383,7 +8386,7 @@ try {
                     }), isServer || isWebWorker) {
                         if (!1 === splitChunks || 0 === Object.keys(splitChunks).length) chain.optimization.splitChunks(!1);
                         else {
-                            let { preset, ...rest } = splitChunks;
+                            let { preset = 'none', ...rest } = splitChunks;
                             chain.optimization.splitChunks({
                                 ...getSplitChunksByPreset(config, preset),
                                 ...rest
@@ -9142,7 +9145,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.0-beta.0"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.0-beta.1"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -9211,7 +9214,7 @@ function initNodeEnv() {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.0-beta.0\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.0-beta.1\n`);
 }
 function setupLogLevel() {
     let logLevelIndex = process.argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
@@ -9232,5 +9235,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.0-beta.0";
+let src_version = "2.0.0-beta.1";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, external_node_os_type, external_node_util_promisify, loadConfig_loadConfig as loadConfig, loadEnv, mergeRsbuildConfig, node_os, node_process, runCLI, src_logger as logger, src_version as version };

package/dist/manifest-plugin.js

@@ -1,4 +1,3 @@
-import * as __rspack_external__rspack_lite_tapable_c6bdf810 from "@rspack/lite-tapable";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./131.js";
 __webpack_require__.add({
@@ -68,7 +67,7 @@ __webpack_require__.add({
         Object.defineProperty(exports, "__esModule", {
             value: !0
         }), exports.normalModuleLoaderHook = exports.getCompilerHooks = exports.emitHook = exports.beforeRunHook = void 0;
-        let node_fs_1 = __webpack_require__("node:fs"), node_path_1 = __webpack_require__("node:path"), lite_tapable_1 = __webpack_require__("@rspack/lite-tapable"), helpers_1 = __webpack_require__("../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-alpha.1_@module-federation+runtime-tools@0.23.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/helpers.js"), compilerHookMap = new WeakMap(), getCompilerHooks = (compiler)=>{
+        let node_fs_1 = __webpack_require__("node:fs"), node_path_1 = __webpack_require__("node:path"), lite_tapable_1 = __webpack_require__("../../node_modules/.pnpm/@rspack+lite-tapable@1.1.0/node_modules/@rspack/lite-tapable/dist/index.cjs"), helpers_1 = __webpack_require__("../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-alpha.1_@module-federation+runtime-tools@0.23.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/helpers.js"), compilerHookMap = new WeakMap(), getCompilerHooks = (compiler)=>{
             let hooks = compilerHookMap.get(compiler);
             return void 0 === hooks && (hooks = {
                 afterEmit: new lite_tapable_1.SyncWaterfallHook([
@@ -166,7 +165,530 @@ __webpack_require__.add({
             }
         };
     },
-    "@rspack/lite-tapable" (module) {
-        module.exports = __rspack_external__rspack_lite_tapable_c6bdf810;
+    "../../node_modules/.pnpm/@rspack+lite-tapable@1.1.0/node_modules/@rspack/lite-tapable/dist/index.cjs" (__unused_rspack_module, exports) {
+        var __nested_rspack_require_18_37__ = {};
+        __nested_rspack_require_18_37__.d = (exports1, definition)=>{
+            for(var key in definition)__nested_rspack_require_18_37__.o(definition, key) && !__nested_rspack_require_18_37__.o(exports1, key) && Object.defineProperty(exports1, key, {
+                enumerable: !0,
+                get: definition[key]
+            });
+        }, __nested_rspack_require_18_37__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __nested_rspack_require_18_37__.r = (exports1)=>{
+            "u" > typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+                value: 'Module'
+            }), Object.defineProperty(exports1, '__esModule', {
+                value: !0
+            });
+        };
+        var __nested_rspack_exports__ = {};
+        function _define_property(obj, key, value) {
+            return key in obj ? Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : obj[key] = value, obj;
+        }
+        __nested_rspack_require_18_37__.r(__nested_rspack_exports__), __nested_rspack_require_18_37__.d(__nested_rspack_exports__, {
+            AsyncParallelHook: ()=>AsyncParallelHook,
+            AsyncSeriesBailHook: ()=>AsyncSeriesBailHook,
+            AsyncSeriesHook: ()=>AsyncSeriesHook,
+            AsyncSeriesWaterfallHook: ()=>AsyncSeriesWaterfallHook,
+            HookBase: ()=>HookBase,
+            HookMap: ()=>HookMap,
+            MultiHook: ()=>MultiHook,
+            QueriedHook: ()=>QueriedHook,
+            QueriedHookMap: ()=>QueriedHookMap,
+            SyncBailHook: ()=>SyncBailHook,
+            SyncHook: ()=>SyncHook,
+            SyncWaterfallHook: ()=>SyncWaterfallHook,
+            maxStage: ()=>maxStage,
+            minStage: ()=>minStage,
+            safeStage: ()=>safeStage
+        });
+        class HookBase {
+            intercept(interceptor) {
+                if (this.interceptors.push(Object.assign({}, interceptor)), interceptor.register) for(let i = 0; i < this.taps.length; i++)this.taps[i] = interceptor.register(this.taps[i]);
+            }
+            _runRegisterInterceptors(options) {
+                return this.interceptors.reduce((options, interceptor)=>interceptor.register?.(options) ?? options, options);
+            }
+            _runCallInterceptors(...args) {
+                for (let interceptor of this.interceptors)interceptor.call && interceptor.call(...args);
+            }
+            _runErrorInterceptors(e) {
+                for (let interceptor of this.interceptors)interceptor.error && interceptor.error(e);
+            }
+            _runTapInterceptors(tap) {
+                for (let interceptor of this.interceptors)interceptor.tap && interceptor.tap(tap);
+            }
+            _runDoneInterceptors() {
+                for (let interceptor of this.interceptors)interceptor.done && interceptor.done();
+            }
+            _runResultInterceptors(r) {
+                for (let interceptor of this.interceptors)interceptor.result && interceptor.result(r);
+            }
+            withOptions(options) {
+                let mergeOptions = (opt)=>Object.assign({}, options, 'string' == typeof opt ? {
+                        name: opt
+                    } : opt);
+                return {
+                    name: this.name,
+                    tap: (opt, fn)=>this.tap(mergeOptions(opt), fn),
+                    tapAsync: (opt, fn)=>this.tapAsync(mergeOptions(opt), fn),
+                    tapPromise: (opt, fn)=>this.tapPromise(mergeOptions(opt), fn),
+                    intercept: (interceptor)=>this.intercept(interceptor),
+                    isUsed: ()=>this.isUsed(),
+                    withOptions: (opt)=>this.withOptions(mergeOptions(opt)),
+                    queryStageRange: (stageRange)=>this.queryStageRange(stageRange)
+                };
+            }
+            isUsed() {
+                return this.taps.length > 0 || this.interceptors.length > 0;
+            }
+            queryStageRange(stageRange) {
+                return new QueriedHook(stageRange, this);
+            }
+            callAsyncStageRange(queried) {
+                throw Error('Hook should implement there own _callAsyncStageRange');
+            }
+            callAsync(...args) {
+                return this.callAsyncStageRange(this.queryStageRange(allStageRange), ...args);
+            }
+            promiseStageRange(queried, ...args) {
+                return new Promise((resolve, reject)=>{
+                    this.callAsyncStageRange(queried, ...args, (e, r)=>e ? reject(e) : resolve(r));
+                });
+            }
+            promise(...args) {
+                return this.promiseStageRange(this.queryStageRange(allStageRange), ...args);
+            }
+            tap(options, fn) {
+                this._tap('sync', options, fn);
+            }
+            tapAsync(options, fn) {
+                this._tap('async', options, fn);
+            }
+            tapPromise(options, fn) {
+                this._tap('promise', options, fn);
+            }
+            _tap(type, options, fn) {
+                let normalizedOptions = options;
+                if ('string' == typeof options) normalizedOptions = {
+                    name: options.trim()
+                };
+                else if ('object' != typeof options || null === options) throw Error('Invalid tap options');
+                if ('string' != typeof normalizedOptions.name || '' === normalizedOptions.name) throw Error('Missing name for tap');
+                this._insert(this._runRegisterInterceptors(Object.assign({
+                    type,
+                    fn
+                }, normalizedOptions)));
+            }
+            _insert(item) {
+                let before;
+                'string' == typeof item.before ? before = new Set([
+                    item.before
+                ]) : Array.isArray(item.before) && (before = new Set(item.before));
+                let stage = 0;
+                'number' == typeof item.stage && (stage = item.stage);
+                let i = this.taps.length;
+                for(; i > 0;){
+                    i--;
+                    let x = this.taps[i];
+                    this.taps[i + 1] = x;
+                    let xStage = x.stage || 0;
+                    if (before) {
+                        if (before.has(x.name)) {
+                            before.delete(x.name);
+                            continue;
+                        }
+                        if (before.size > 0) continue;
+                    }
+                    if (!(xStage > stage)) {
+                        i++;
+                        break;
+                    }
+                }
+                this.taps[i] = item;
+            }
+            _prepareArgs(args) {
+                let len = this.args.length;
+                return args.length < len ? (args.length = len, args.fill(void 0, args.length, len)) : (args.length > len && (args.length = len), args);
+            }
+            constructor(args = [], name){
+                _define_property(this, "args", void 0), _define_property(this, "name", void 0), _define_property(this, "taps", void 0), _define_property(this, "interceptors", void 0), this.args = args, this.name = name, this.taps = [], this.interceptors = [];
+            }
+        }
+        let minStage = -1 / 0, maxStage = 1 / 0, allStageRange = [
+            minStage,
+            1 / 0
+        ], i32MAX = 2147483648 - 1, safeStage = (stage)=>stage < -2147483648 ? -2147483648 : stage > i32MAX ? i32MAX : stage;
+        class QueriedHook {
+            isUsed() {
+                return !!(this.tapsInRange.length > 0 || this.stageRange[0] === minStage && this.hook.interceptors.some((i)=>i.call) || this.stageRange[1] === maxStage && this.hook.interceptors.some((i)=>i.done));
+            }
+            call(...args) {
+                if ('function' != typeof this.hook.callStageRange) throw Error('hook is not a SyncHook, call methods only exists on SyncHook');
+                return this.hook.callStageRange(this, ...args);
+            }
+            callAsync(...args) {
+                return this.hook.callAsyncStageRange(this, ...args);
+            }
+            promise(...args) {
+                return this.hook.promiseStageRange(this, ...args);
+            }
+            constructor(stageRange, hook){
+                _define_property(this, "stageRange", void 0), _define_property(this, "hook", void 0), _define_property(this, "tapsInRange", void 0);
+                let tapsInRange = [], [from, to] = stageRange;
+                for (let tap of hook.taps){
+                    let stage = tap.stage ?? 0;
+                    from <= stage && stage < to ? tapsInRange.push(tap) : to === maxStage && stage === maxStage && tapsInRange.push(tap);
+                }
+                this.stageRange = stageRange, this.hook = hook, this.tapsInRange = tapsInRange;
+            }
+        }
+        class SyncHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+                    this._runTapInterceptors(tap);
+                    try {
+                        tap.fn(...args2);
+                    } catch (e) {
+                        return this._runErrorInterceptors(e), cb(e);
+                    }
+                }
+                to === maxStage && (this._runDoneInterceptors(), cb(null));
+            }
+            call(...args) {
+                return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+            }
+            callStageRange(queried, ...args) {
+                let result, error;
+                if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+                    error = e, result = r;
+                }), error) throw error;
+                return result;
+            }
+            tapAsync() {
+                throw Error('tapAsync is not supported on a SyncHook');
+            }
+            tapPromise() {
+                throw Error('tapPromise is not supported on a SyncHook');
+            }
+        }
+        class SyncBailHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+                    let r;
+                    this._runTapInterceptors(tap);
+                    try {
+                        r = tap.fn(...args2);
+                    } catch (e) {
+                        return this._runErrorInterceptors(e), cb(e);
+                    }
+                    if (void 0 !== r) return this._runResultInterceptors(r), cb(null, r);
+                }
+                to === maxStage && (this._runDoneInterceptors(), cb(null));
+            }
+            call(...args) {
+                return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+            }
+            callStageRange(queried, ...args) {
+                let result, error;
+                if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+                    error = e, result = r;
+                }), error) throw error;
+                return result;
+            }
+            tapAsync() {
+                throw Error('tapAsync is not supported on a SyncBailHook');
+            }
+            tapPromise() {
+                throw Error('tapPromise is not supported on a SyncBailHook');
+            }
+        }
+        class SyncWaterfallHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+                    this._runTapInterceptors(tap);
+                    try {
+                        let r = tap.fn(...args2);
+                        void 0 !== r && (args2[0] = r);
+                    } catch (e) {
+                        return this._runErrorInterceptors(e), cb(e);
+                    }
+                }
+                to === maxStage && (this._runDoneInterceptors(), cb(null, args2[0]));
+            }
+            call(...args) {
+                return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+            }
+            callStageRange(queried, ...args) {
+                let result, error;
+                if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+                    error = e, result = r;
+                }), error) throw error;
+                return result;
+            }
+            tapAsync() {
+                throw Error('tapAsync is not supported on a SyncWaterfallHook');
+            }
+            tapPromise() {
+                throw Error('tapPromise is not supported on a SyncWaterfallHook');
+            }
+            constructor(args = [], name){
+                if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+                super(args, name);
+            }
+        }
+        class AsyncParallelHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                from === minStage && this._runCallInterceptors(...args2);
+                let done = ()=>{
+                    this._runDoneInterceptors(), cb(null);
+                }, error = (e)=>{
+                    this._runErrorInterceptors(e), cb(e);
+                };
+                if (0 === tapsInRange.length) return done();
+                let counter = tapsInRange.length;
+                for (let tap of tapsInRange){
+                    if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                        let promise = tap.fn(...args2);
+                        if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                        promise.then(()=>{
+                            0 == (counter -= 1) && done();
+                        }, (e)=>{
+                            counter = 0, error(e);
+                        });
+                    } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                        e ? (counter = 0, error(e)) : 0 == (counter -= 1) && done();
+                    });
+                    else {
+                        let hasError = !1;
+                        try {
+                            tap.fn(...args2);
+                        } catch (e) {
+                            hasError = !0, counter = 0, error(e);
+                        }
+                        hasError || 0 != --counter || done();
+                    }
+                    if (counter <= 0) return;
+                }
+            }
+        }
+        class AsyncSeriesHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                from === minStage && this._runCallInterceptors(...args2);
+                let done = ()=>{
+                    this._runDoneInterceptors(), cb(null);
+                }, error = (e)=>{
+                    this._runErrorInterceptors(e), cb(e);
+                };
+                if (0 === tapsInRange.length) return done();
+                let index = 0, next = ()=>{
+                    let tap = tapsInRange[index];
+                    if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                        let promise = tap.fn(...args2);
+                        if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                        promise.then(()=>{
+                            (index += 1) === tapsInRange.length ? done() : next();
+                        }, (e)=>{
+                            index = tapsInRange.length, error(e);
+                        });
+                    } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                        e ? (index = tapsInRange.length, error(e)) : (index += 1) === tapsInRange.length ? done() : next();
+                    });
+                    else {
+                        let hasError = !1;
+                        try {
+                            tap.fn(...args2);
+                        } catch (e) {
+                            hasError = !0, index = tapsInRange.length, error(e);
+                        }
+                        hasError || ((index += 1) === tapsInRange.length ? done() : next());
+                    }
+                    if (index === tapsInRange.length) return;
+                };
+                next();
+            }
+        }
+        class AsyncSeriesBailHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                from === minStage && this._runCallInterceptors(...args2);
+                let done = ()=>{
+                    this._runDoneInterceptors(), cb(null);
+                }, error = (e)=>{
+                    this._runErrorInterceptors(e), cb(e);
+                }, result = (r)=>{
+                    this._runResultInterceptors(r), cb(null, r);
+                };
+                if (0 === tapsInRange.length) return done();
+                let index = 0, next = ()=>{
+                    let tap = tapsInRange[index];
+                    if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                        let promise = tap.fn(...args2);
+                        if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                        promise.then((r)=>{
+                            index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next();
+                        }, (e)=>{
+                            index = tapsInRange.length, error(e);
+                        });
+                    } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                        e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+                    });
+                    else {
+                        let r, hasError = !1;
+                        try {
+                            r = tap.fn(...args2);
+                        } catch (e) {
+                            hasError = !0, index = tapsInRange.length, error(e);
+                        }
+                        hasError || (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+                    }
+                    if (index === tapsInRange.length) return;
+                };
+                next();
+            }
+        }
+        class AsyncSeriesWaterfallHook extends HookBase {
+            callAsyncStageRange(queried, ...args) {
+                let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+                from === minStage && this._runCallInterceptors(...args2);
+                let result = (r)=>{
+                    this._runResultInterceptors(r), cb(null, r);
+                }, error = (e)=>{
+                    this._runErrorInterceptors(e), cb(e);
+                };
+                if (0 === tapsInRange.length) return result(args2[0]);
+                let index = 0, next = ()=>{
+                    let tap = tapsInRange[index];
+                    if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                        let promise = tap.fn(...args2);
+                        if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                        promise.then((r)=>{
+                            index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next();
+                        }, (e)=>{
+                            index = tapsInRange.length, error(e);
+                        });
+                    } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                        e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next());
+                    });
+                    else {
+                        let hasError = !1;
+                        try {
+                            let r = tap.fn(...args2);
+                            void 0 !== r && (args2[0] = r);
+                        } catch (e) {
+                            hasError = !0, index = tapsInRange.length, error(e);
+                        }
+                        hasError || ((index += 1) === tapsInRange.length ? result(args2[0]) : next());
+                    }
+                    if (index === tapsInRange.length) return;
+                };
+                next();
+            }
+            constructor(args = [], name){
+                if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+                super(args, name);
+            }
+        }
+        let defaultFactory = (key, hook)=>hook;
+        class HookMap {
+            get(key) {
+                return this._map.get(key);
+            }
+            for(key) {
+                let hook = this.get(key);
+                if (void 0 !== hook) return hook;
+                let newHook = this._factory(key), interceptors = this._interceptors;
+                for(let i = 0; i < interceptors.length; i++){
+                    let factory = interceptors[i].factory;
+                    factory && (newHook = factory(key, newHook));
+                }
+                return this._map.set(key, newHook), newHook;
+            }
+            intercept(interceptor) {
+                this._interceptors.push(Object.assign({
+                    factory: defaultFactory
+                }, interceptor));
+            }
+            isUsed() {
+                for (let key of this._map.keys()){
+                    let hook = this.get(key);
+                    if (hook?.isUsed()) return !0;
+                }
+                return !1;
+            }
+            queryStageRange(stageRange) {
+                return new QueriedHookMap(stageRange, this);
+            }
+            constructor(factory, name){
+                _define_property(this, "_map", new Map()), _define_property(this, "_factory", void 0), _define_property(this, "name", void 0), _define_property(this, "_interceptors", void 0), this.name = name, this._factory = factory, this._interceptors = [];
+            }
+        }
+        class QueriedHookMap {
+            get(key) {
+                return this.hookMap.get(key)?.queryStageRange(this.stageRange);
+            }
+            for(key) {
+                return this.hookMap.for(key).queryStageRange(this.stageRange);
+            }
+            isUsed() {
+                for (let key of this.hookMap._map.keys())if (this.get(key)?.isUsed()) return !0;
+                return !1;
+            }
+            constructor(stageRange, hookMap){
+                _define_property(this, "stageRange", void 0), _define_property(this, "hookMap", void 0), this.stageRange = stageRange, this.hookMap = hookMap;
+            }
+        }
+        class MultiHook {
+            tap(options, fn) {
+                for (let hook of this.hooks)hook.tap(options, fn);
+            }
+            tapAsync(options, fn) {
+                for (let hook of this.hooks)hook.tapAsync(options, fn);
+            }
+            tapPromise(options, fn) {
+                for (let hook of this.hooks)hook.tapPromise(options, fn);
+            }
+            isUsed() {
+                for (let hook of this.hooks)if (hook.isUsed()) return !0;
+                return !1;
+            }
+            intercept(interceptor) {
+                for (let hook of this.hooks)hook.intercept(interceptor);
+            }
+            withOptions(options) {
+                return new MultiHook(this.hooks.map((h)=>h.withOptions(options)), this.name);
+            }
+            constructor(hooks, name){
+                _define_property(this, "hooks", void 0), _define_property(this, "name", void 0), this.hooks = hooks, this.name = name;
+            }
+        }
+        for(var __webpack_i__ in exports.AsyncParallelHook = __nested_rspack_exports__.AsyncParallelHook, exports.AsyncSeriesBailHook = __nested_rspack_exports__.AsyncSeriesBailHook, exports.AsyncSeriesHook = __nested_rspack_exports__.AsyncSeriesHook, exports.AsyncSeriesWaterfallHook = __nested_rspack_exports__.AsyncSeriesWaterfallHook, exports.HookBase = __nested_rspack_exports__.HookBase, exports.HookMap = __nested_rspack_exports__.HookMap, exports.MultiHook = __nested_rspack_exports__.MultiHook, exports.QueriedHook = __nested_rspack_exports__.QueriedHook, exports.QueriedHookMap = __nested_rspack_exports__.QueriedHookMap, exports.SyncBailHook = __nested_rspack_exports__.SyncBailHook, exports.SyncHook = __nested_rspack_exports__.SyncHook, exports.SyncWaterfallHook = __nested_rspack_exports__.SyncWaterfallHook, exports.maxStage = __nested_rspack_exports__.maxStage, exports.minStage = __nested_rspack_exports__.minStage, exports.safeStage = __nested_rspack_exports__.safeStage, __nested_rspack_exports__)-1 === [
+            "AsyncParallelHook",
+            "AsyncSeriesBailHook",
+            "AsyncSeriesHook",
+            "AsyncSeriesWaterfallHook",
+            "HookBase",
+            "HookMap",
+            "MultiHook",
+            "QueriedHook",
+            "QueriedHookMap",
+            "SyncBailHook",
+            "SyncHook",
+            "SyncWaterfallHook",
+            "maxStage",
+            "minStage",
+            "safeStage"
+        ].indexOf(__webpack_i__) && (exports[__webpack_i__] = __nested_rspack_exports__[__webpack_i__]);
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        });
     }
 });