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

package/dist/manifest-plugin.js

@@ -1,8 +1,7 @@
-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({
-    "../../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" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.0_@module-federation+runtime-tools@0.24.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/helpers.js" (__unused_rspack_module, exports, __webpack_require__) {
         Object.defineProperty(exports, "__esModule", {
             value: !0
         }), exports.transformFiles = exports.reduceChunk = exports.reduceAssets = exports.generateManifest = void 0;
@@ -64,11 +63,11 @@ __webpack_require__.add({
                 'sort'
             ].filter((fname)=>!!options[fname]).reduce((prev, fname)=>prev[fname](options[fname]), files).map(standardizeFilePaths);
     },
-    "../../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/hooks.js" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.0_@module-federation+runtime-tools@0.24.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/hooks.js" (__unused_rspack_module, exports, __webpack_require__) {
         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-beta.0_@module-federation+runtime-tools@0.24.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([
@@ -122,9 +121,9 @@ __webpack_require__.add({
                 }), emitFile.call(module, file, content, sourceMap));
         };
     },
-    "../../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/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.0_@module-federation+runtime-tools@0.24.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/index.js" (__unused_rspack_module, exports, __webpack_require__) {
         exports.RspackManifestPlugin = void 0;
-        let node_path_1 = __webpack_require__("node:path"), hooks_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/hooks.js"), emitCountMap = new Map(), defaults = {
+        let node_path_1 = __webpack_require__("node:path"), hooks_1 = __webpack_require__("../../node_modules/.pnpm/rspack-manifest-plugin@5.2.1_@rspack+core@2.0.0-beta.0_@module-federation+runtime-tools@0.24.0_@swc+helpers@0.5.18_/node_modules/rspack-manifest-plugin/dist/hooks.js"), emitCountMap = new Map(), defaults = {
             assetHookStage: 1 / 0,
             basePath: '',
             fileName: 'manifest.json',
@@ -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
+        });
     }
 });

package/dist/open.js

@@ -1,7 +1,7 @@
 let isDockerCached, cachedResult, canAccessPowerShellPromise, mountPoint, defaultMountPoint;
 import { __webpack_require__ } from "./rslib-runtime.js";
 import node_child_process, { execFile } from "node:child_process";
-import { node_process, node_os, external_node_util_promisify } from "./131.js";
+import { external_node_util_promisify } from "./131.js";
 import "./743.js";
 import { constants, promises } from "./7.js";
 let external_node_fs_ = __webpack_require__("node:fs");
@@ -31,15 +31,15 @@ function isInsideContainer() {
         }
     })() || isDocker()), cachedResult;
 }
-let isWsl = ()=>{
-    if ('linux' !== node_process.platform) return !1;
-    if (node_os.release().toLowerCase().includes('microsoft')) return !isInsideContainer();
+let external_node_process_ = __webpack_require__("node:process"), external_node_os_ = __webpack_require__("node:os"), isWsl = ()=>{
+    if ('linux' !== external_node_process_.default.platform) return !1;
+    if (external_node_os_.default.release().toLowerCase().includes('microsoft')) return !isInsideContainer();
     try {
         return !!external_node_fs_.default.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') && !isInsideContainer();
     } catch  {
         return !1;
     }
-}, is_wsl = node_process.env.__IS_WSL_TEST__ ? isWsl : isWsl(), external_node_buffer_ = __webpack_require__("node:buffer"), powershell_utils_execFile = external_node_util_promisify(node_child_process.execFile), powerShellPath = ()=>`${node_process.env.SYSTEMROOT || node_process.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {})=>{
+}, is_wsl = external_node_process_.default.env.__IS_WSL_TEST__ ? isWsl : isWsl(), external_node_buffer_ = __webpack_require__("node:buffer"), powershell_utils_execFile = external_node_util_promisify(node_child_process.execFile), powerShellPath = ()=>`${external_node_process_.default.env.SYSTEMROOT || external_node_process_.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {})=>{
     let { powerShellPath: psPath, ...execFileOptions } = options, encodedCommand = executePowerShell.encodeCommand(command);
     return powershell_utils_execFile(psPath ?? powerShellPath(), [
         ...executePowerShell.argumentsPrefix,
@@ -123,7 +123,7 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 }
 let execFileAsync = external_node_util_promisify(execFile);
 async function defaultBrowserId() {
-    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    if ('darwin' !== external_node_process_.default.platform) throw Error('macOS only');
     let { stdout } = await execFileAsync('defaults', [
         'read',
         'com.apple.LaunchServices/com.apple.launchservices.secure',
@@ -133,7 +133,7 @@ async function defaultBrowserId() {
 }
 let run_applescript_execFileAsync = external_node_util_promisify(execFile);
 async function runAppleScript(script, { humanReadableOutput = !0, signal } = {}) {
-    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    if ('darwin' !== external_node_process_.default.platform) throw Error('macOS only');
     let execOptions = {};
     signal && (execOptions.signal = signal);
     let { stdout } = await run_applescript_execFileAsync("osascript", [
@@ -230,14 +230,14 @@ async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
 }
 let default_browser_execFileAsync = external_node_util_promisify(execFile);
 async function default_browser_defaultBrowser() {
-    if ('darwin' === node_process.platform) {
+    if ('darwin' === external_node_process_.default.platform) {
         let id = await defaultBrowserId();
         return {
             name: await bundleName(id),
             id
         };
     }
-    if ('linux' === node_process.platform) {
+    if ('linux' === external_node_process_.default.platform) {
         let { stdout } = await default_browser_execFileAsync('xdg-mime', [
             'query',
             'default',
@@ -248,10 +248,10 @@ async function default_browser_defaultBrowser() {
             id
         };
     }
-    if ('win32' === node_process.platform) return defaultBrowser();
+    if ('win32' === external_node_process_.default.platform) return defaultBrowser();
     throw Error('Only macOS, Linux, and Windows are supported');
 }
-let isInSsh = !!(node_process.env.SSH_CONNECTION || node_process.env.SSH_CLIENT || node_process.env.SSH_TTY), external_node_path_ = __webpack_require__("node:path"), external_node_url_ = __webpack_require__("node:url"), fallbackAttemptSymbol = Symbol('fallbackAttempt'), open_dirname = import.meta.url ? external_node_path_.default.dirname((0, external_node_url_.fileURLToPath)(import.meta.url)) : '', localXdgOpenPath = external_node_path_.default.join(open_dirname, 'xdg-open'), { platform: platform, arch: arch } = node_process, tryEachApp = async (apps, opener)=>{
+let isInSsh = !!(external_node_process_.default.env.SSH_CONNECTION || external_node_process_.default.env.SSH_CLIENT || external_node_process_.default.env.SSH_TTY), external_node_path_ = __webpack_require__("node:path"), external_node_url_ = __webpack_require__("node:url"), fallbackAttemptSymbol = Symbol('fallbackAttempt'), open_dirname = import.meta.url ? external_node_path_.default.dirname((0, external_node_url_.fileURLToPath)(import.meta.url)) : '', localXdgOpenPath = external_node_path_.default.join(open_dirname, 'xdg-open'), { platform: platform, arch: arch } = external_node_process_.default, tryEachApp = async (apps, opener)=>{
     if (0 === apps.length) return;
     let errors = [];
     for (let app of apps)try {
@@ -338,7 +338,7 @@ let isInSsh = !!(node_process.env.SSH_CONNECTION || node_process.env.SSH_CLIENT
             try {
                 await promises.access(localXdgOpenPath, constants.X_OK), exeLocalXdgOpen = !0;
             } catch  {}
-            command = node_process.versions.electron ?? ('android' === platform || !open_dirname || '/' === open_dirname || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
+            command = external_node_process_.default.versions.electron ?? ('android' === platform || !open_dirname || '/' === open_dirname || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
         }
         appArguments.length > 0 && cliArguments.push(...appArguments), options.wait || (childProcessOptions.stdio = 'ignore', childProcessOptions.detached = !0);
     }

package/dist/rslib-runtime.js

@@ -5,7 +5,7 @@ function __webpack_require__(moduleId) {
     var module = __webpack_module_cache__[moduleId] = {
         exports: {}
     };
-    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
+    return __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__), module.exports;
 }
 __webpack_require__.m = __webpack_modules__, __webpack_require__.add = function registerModules(modules) {
     Object.assign(__webpack_require__.m, modules);