@rsbuild/core 2.0.0-alpha.4 → 2.0.0-beta.1

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

@@ -525,7 +525,7 @@
     },
     407: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      const { AsyncSeriesWaterfallHook } = __nccwpck_require__(408);
+      const { AsyncSeriesWaterfallHook } = __nccwpck_require__(159);
       const htmlWebpackPluginHooksMap = new WeakMap();
       function getHtmlRspackPluginHooks(compilation) {
         let hooks = htmlWebpackPluginHooksMap.get(compilation);
@@ -1557,10 +1557,6 @@
       HtmlRspackPlugin.createHtmlTagObject = createHtmlTagObject;
       module.exports = HtmlRspackPlugin;
     },
-    408: (module) => {
-      "use strict";
-      module.exports = require("@rspack/lite-tapable");
-    },
     896: (module) => {
       "use strict";
       module.exports = require("fs");
@@ -1577,6 +1573,853 @@
       "use strict";
       module.exports = require("vm");
     },
+    159: (__unused_webpack_module, exports) => {
+      "use strict";
+      var __nested_webpack_require_18__ = {};
+      (() => {
+        __nested_webpack_require_18__.d = (exports1, definition) => {
+          for (var key in definition)
+            if (
+              __nested_webpack_require_18__.o(definition, key) &&
+              !__nested_webpack_require_18__.o(exports1, key)
+            )
+              Object.defineProperty(exports1, key, {
+                enumerable: true,
+                get: definition[key],
+              });
+        };
+      })();
+      (() => {
+        __nested_webpack_require_18__.o = (obj, prop) =>
+          Object.prototype.hasOwnProperty.call(obj, prop);
+      })();
+      (() => {
+        __nested_webpack_require_18__.r = (exports1) => {
+          if ("undefined" != typeof Symbol && Symbol.toStringTag)
+            Object.defineProperty(exports1, Symbol.toStringTag, {
+              value: "Module",
+            });
+          Object.defineProperty(exports1, "__esModule", { value: true });
+        };
+      })();
+      var __nested_webpack_exports__ = {};
+      __nested_webpack_require_18__.r(__nested_webpack_exports__);
+      __nested_webpack_require_18__.d(__nested_webpack_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,
+      });
+      function _define_property(obj, key, value) {
+        if (key in obj)
+          Object.defineProperty(obj, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+          });
+        else obj[key] = value;
+        return obj;
+      }
+      class HookBase {
+        intercept(interceptor) {
+          this.interceptors.push(Object.assign({}, interceptor));
+          if (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 (const interceptor of this.interceptors)
+            if (interceptor.call) interceptor.call(...args);
+        }
+        _runErrorInterceptors(e) {
+          for (const interceptor of this.interceptors)
+            if (interceptor.error) interceptor.error(e);
+        }
+        _runTapInterceptors(tap) {
+          for (const interceptor of this.interceptors)
+            if (interceptor.tap) interceptor.tap(tap);
+        }
+        _runDoneInterceptors() {
+          for (const interceptor of this.interceptors)
+            if (interceptor.done) interceptor.done();
+        }
+        _runResultInterceptors(r) {
+          for (const interceptor of this.interceptors)
+            if (interceptor.result) interceptor.result(r);
+        }
+        withOptions(options) {
+          const 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 new 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) => {
+              if (e) return reject(e);
+              return 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 new Error("Invalid tap options");
+          if (
+            "string" != typeof normalizedOptions.name ||
+            "" === normalizedOptions.name
+          )
+            throw new Error("Missing name for tap");
+          this._insert(
+            this._runRegisterInterceptors(
+              Object.assign({ type, fn }, normalizedOptions),
+            ),
+          );
+        }
+        _insert(item) {
+          let before;
+          if ("string" == typeof item.before) before = new Set([item.before]);
+          else if (Array.isArray(item.before)) before = new Set(item.before);
+          let stage = 0;
+          if ("number" == typeof item.stage) stage = item.stage;
+          let i = this.taps.length;
+          while (i > 0) {
+            i--;
+            const x = this.taps[i];
+            this.taps[i + 1] = x;
+            const xStage = x.stage || 0;
+            if (before) {
+              if (before.has(x.name)) {
+                before.delete(x.name);
+                continue;
+              }
+              if (before.size > 0) continue;
+            }
+            if (xStage > stage) continue;
+            i++;
+            break;
+          }
+          this.taps[i] = item;
+        }
+        _prepareArgs(args) {
+          const len = this.args.length;
+          if (args.length < len) {
+            args.length = len;
+            return args.fill(void 0, args.length, len);
+          }
+          if (args.length > len) args.length = len;
+          return 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 = [];
+        }
+      }
+      const minStage = -1 / 0;
+      const maxStage = 1 / 0;
+      const allStageRange = [minStage, maxStage];
+      const i32MIN = -(2 ** 31);
+      const i32MAX = 2 ** 31 - 1;
+      const safeStage = (stage) => {
+        if (stage < i32MIN) return i32MIN;
+        if (stage > i32MAX) return i32MAX;
+        return stage;
+      };
+      class QueriedHook {
+        isUsed() {
+          if (this.tapsInRange.length > 0) return true;
+          if (
+            this.stageRange[0] === minStage &&
+            this.hook.interceptors.some((i) => i.call)
+          )
+            return true;
+          if (
+            this.stageRange[1] === maxStage &&
+            this.hook.interceptors.some((i) => i.done)
+          )
+            return true;
+          return false;
+        }
+        call(...args) {
+          if ("function" != typeof this.hook.callStageRange)
+            throw new 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);
+          const tapsInRange = [];
+          const [from, to] = stageRange;
+          for (const tap of hook.taps) {
+            const stage = tap.stage ?? 0;
+            if (from <= stage && stage < to) tapsInRange.push(tap);
+            else if (to === maxStage && stage === maxStage)
+              tapsInRange.push(tap);
+          }
+          this.stageRange = stageRange;
+          this.hook = hook;
+          this.tapsInRange = tapsInRange;
+        }
+      }
+      class SyncHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from, to],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          for (const tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            try {
+              tap.fn(...args2);
+            } catch (e) {
+              const err = e;
+              this._runErrorInterceptors(err);
+              return cb(err);
+            }
+          }
+          if (to === maxStage) {
+            this._runDoneInterceptors();
+            cb(null);
+          }
+        }
+        call(...args) {
+          return this.callStageRange(
+            this.queryStageRange(allStageRange),
+            ...args,
+          );
+        }
+        callStageRange(queried, ...args) {
+          let result;
+          let error;
+          this.callAsyncStageRange(queried, ...args, (e, r) => {
+            error = e;
+            result = r;
+          });
+          if (error) throw error;
+          return result;
+        }
+        tapAsync() {
+          throw new Error("tapAsync is not supported on a SyncHook");
+        }
+        tapPromise() {
+          throw new Error("tapPromise is not supported on a SyncHook");
+        }
+      }
+      class SyncBailHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from, to],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          for (const tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            let r;
+            try {
+              r = tap.fn(...args2);
+            } catch (e) {
+              const err = e;
+              this._runErrorInterceptors(err);
+              return cb(err);
+            }
+            if (void 0 !== r) {
+              this._runResultInterceptors(r);
+              return cb(null, r);
+            }
+          }
+          if (to === maxStage) {
+            this._runDoneInterceptors();
+            cb(null);
+          }
+        }
+        call(...args) {
+          return this.callStageRange(
+            this.queryStageRange(allStageRange),
+            ...args,
+          );
+        }
+        callStageRange(queried, ...args) {
+          let result;
+          let error;
+          this.callAsyncStageRange(queried, ...args, (e, r) => {
+            error = e;
+            result = r;
+          });
+          if (error) throw error;
+          return result;
+        }
+        tapAsync() {
+          throw new Error("tapAsync is not supported on a SyncBailHook");
+        }
+        tapPromise() {
+          throw new Error("tapPromise is not supported on a SyncBailHook");
+        }
+      }
+      class SyncWaterfallHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from, to],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          for (const tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            try {
+              const r = tap.fn(...args2);
+              if (void 0 !== r) args2[0] = r;
+            } catch (e) {
+              const err = e;
+              this._runErrorInterceptors(err);
+              return cb(err);
+            }
+          }
+          if (to === maxStage) {
+            this._runDoneInterceptors();
+            cb(null, args2[0]);
+          }
+        }
+        call(...args) {
+          return this.callStageRange(
+            this.queryStageRange(allStageRange),
+            ...args,
+          );
+        }
+        callStageRange(queried, ...args) {
+          let result;
+          let error;
+          this.callAsyncStageRange(queried, ...args, (e, r) => {
+            error = e;
+            result = r;
+          });
+          if (error) throw error;
+          return result;
+        }
+        tapAsync() {
+          throw new Error("tapAsync is not supported on a SyncWaterfallHook");
+        }
+        tapPromise() {
+          throw new Error("tapPromise is not supported on a SyncWaterfallHook");
+        }
+        constructor(args = [], name) {
+          if (args.length < 1)
+            throw new Error("Waterfall hooks must have at least one argument");
+          super(args, name);
+        }
+      }
+      class AsyncParallelHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          const done = () => {
+            this._runDoneInterceptors();
+            cb(null);
+          };
+          const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+          };
+          if (0 === tapsInRange.length) return done();
+          let counter = tapsInRange.length;
+          for (const tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            if ("promise" === tap.type) {
+              const promise = tap.fn(...args2);
+              if (!promise || !promise.then)
+                throw new Error(
+                  `Tap function (tapPromise) did not return promise (returned ${promise})`,
+                );
+              promise.then(
+                () => {
+                  counter -= 1;
+                  if (0 === counter) done();
+                },
+                (e) => {
+                  counter = 0;
+                  error(e);
+                },
+              );
+            } else if ("async" === tap.type)
+              tap.fn(...args2, (e) => {
+                if (e) {
+                  counter = 0;
+                  error(e);
+                } else {
+                  counter -= 1;
+                  if (0 === counter) done();
+                }
+              });
+            else {
+              let hasError = false;
+              try {
+                tap.fn(...args2);
+              } catch (e) {
+                hasError = true;
+                counter = 0;
+                error(e);
+              }
+              if (!hasError && 0 === --counter) done();
+            }
+            if (counter <= 0) return;
+          }
+        }
+      }
+      class AsyncSeriesHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          const done = () => {
+            this._runDoneInterceptors();
+            cb(null);
+          };
+          const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+          };
+          if (0 === tapsInRange.length) return done();
+          let index = 0;
+          const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if ("promise" === tap.type) {
+              const promise = tap.fn(...args2);
+              if (!promise || !promise.then)
+                throw new Error(
+                  `Tap function (tapPromise) did not return promise (returned ${promise})`,
+                );
+              promise.then(
+                () => {
+                  index += 1;
+                  if (index === tapsInRange.length) done();
+                  else next();
+                },
+                (e) => {
+                  index = tapsInRange.length;
+                  error(e);
+                },
+              );
+            } else if ("async" === tap.type)
+              tap.fn(...args2, (e) => {
+                if (e) {
+                  index = tapsInRange.length;
+                  error(e);
+                } else {
+                  index += 1;
+                  if (index === tapsInRange.length) done();
+                  else next();
+                }
+              });
+            else {
+              let hasError = false;
+              try {
+                tap.fn(...args2);
+              } catch (e) {
+                hasError = true;
+                index = tapsInRange.length;
+                error(e);
+              }
+              if (!hasError) {
+                index += 1;
+                if (index === tapsInRange.length) done();
+                else next();
+              }
+            }
+            if (index === tapsInRange.length) return;
+          };
+          next();
+        }
+      }
+      class AsyncSeriesBailHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          const done = () => {
+            this._runDoneInterceptors();
+            cb(null);
+          };
+          const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+          };
+          const result = (r) => {
+            this._runResultInterceptors(r);
+            cb(null, r);
+          };
+          if (0 === tapsInRange.length) return done();
+          let index = 0;
+          const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if ("promise" === tap.type) {
+              const promise = tap.fn(...args2);
+              if (!promise || !promise.then)
+                throw new Error(
+                  `Tap function (tapPromise) did not return promise (returned ${promise})`,
+                );
+              promise.then(
+                (r) => {
+                  index += 1;
+                  if (void 0 !== r) result(r);
+                  else if (index === tapsInRange.length) done();
+                  else next();
+                },
+                (e) => {
+                  index = tapsInRange.length;
+                  error(e);
+                },
+              );
+            } else if ("async" === tap.type)
+              tap.fn(...args2, (e, r) => {
+                if (e) {
+                  index = tapsInRange.length;
+                  error(e);
+                } else {
+                  index += 1;
+                  if (void 0 !== r) result(r);
+                  else if (index === tapsInRange.length) done();
+                  else next();
+                }
+              });
+            else {
+              let hasError = false;
+              let r;
+              try {
+                r = tap.fn(...args2);
+              } catch (e) {
+                hasError = true;
+                index = tapsInRange.length;
+                error(e);
+              }
+              if (!hasError) {
+                index += 1;
+                if (void 0 !== r) result(r);
+                else if (index === tapsInRange.length) done();
+                else next();
+              }
+            }
+            if (index === tapsInRange.length) return;
+          };
+          next();
+        }
+      }
+      class AsyncSeriesWaterfallHook extends HookBase {
+        callAsyncStageRange(queried, ...args) {
+          const {
+            stageRange: [from],
+            tapsInRange,
+          } = queried;
+          const argsWithoutCb = args.slice(0, args.length - 1);
+          const cb = args[args.length - 1];
+          const args2 = this._prepareArgs(argsWithoutCb);
+          if (from === minStage) this._runCallInterceptors(...args2);
+          const result = (r) => {
+            this._runResultInterceptors(r);
+            cb(null, r);
+          };
+          const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+          };
+          if (0 === tapsInRange.length) return result(args2[0]);
+          let index = 0;
+          const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if ("promise" === tap.type) {
+              const promise = tap.fn(...args2);
+              if (!promise || !promise.then)
+                throw new Error(
+                  `Tap function (tapPromise) did not return promise (returned ${promise})`,
+                );
+              promise.then(
+                (r) => {
+                  index += 1;
+                  if (void 0 !== r) args2[0] = r;
+                  if (index === tapsInRange.length) result(args2[0]);
+                  else next();
+                },
+                (e) => {
+                  index = tapsInRange.length;
+                  error(e);
+                },
+              );
+            } else if ("async" === tap.type)
+              tap.fn(...args2, (e, r) => {
+                if (e) {
+                  index = tapsInRange.length;
+                  error(e);
+                } else {
+                  index += 1;
+                  if (void 0 !== r) args2[0] = r;
+                  if (index === tapsInRange.length) result(args2[0]);
+                  else next();
+                }
+              });
+            else {
+              let hasError = false;
+              try {
+                const r = tap.fn(...args2);
+                if (void 0 !== r) args2[0] = r;
+              } catch (e) {
+                hasError = true;
+                index = tapsInRange.length;
+                error(e);
+              }
+              if (!hasError) {
+                index += 1;
+                if (index === tapsInRange.length) result(args2[0]);
+                else next();
+              }
+            }
+            if (index === tapsInRange.length) return;
+          };
+          next();
+        }
+        constructor(args = [], name) {
+          if (args.length < 1)
+            throw new Error("Waterfall hooks must have at least one argument");
+          super(args, name);
+        }
+      }
+      const defaultFactory = (key, hook) => hook;
+      class HookMap {
+        get(key) {
+          return this._map.get(key);
+        }
+        for(key) {
+          const hook = this.get(key);
+          if (void 0 !== hook) return hook;
+          let newHook = this._factory(key);
+          const interceptors = this._interceptors;
+          for (let i = 0; i < interceptors.length; i++) {
+            const factory = interceptors[i].factory;
+            if (factory) newHook = factory(key, newHook);
+          }
+          this._map.set(key, newHook);
+          return newHook;
+        }
+        intercept(interceptor) {
+          this._interceptors.push(
+            Object.assign({ factory: defaultFactory }, interceptor),
+          );
+        }
+        isUsed() {
+          for (const key of this._map.keys()) {
+            const hook = this.get(key);
+            if (hook?.isUsed()) return true;
+          }
+          return false;
+        }
+        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 (const key of this.hookMap._map.keys())
+            if (this.get(key)?.isUsed()) return true;
+          return false;
+        }
+        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 (const hook of this.hooks) hook.tap(options, fn);
+        }
+        tapAsync(options, fn) {
+          for (const hook of this.hooks) hook.tapAsync(options, fn);
+        }
+        tapPromise(options, fn) {
+          for (const hook of this.hooks) hook.tapPromise(options, fn);
+        }
+        isUsed() {
+          for (const hook of this.hooks) if (hook.isUsed()) return true;
+          return false;
+        }
+        intercept(interceptor) {
+          for (const 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;
+        }
+      }
+      exports.AsyncParallelHook = __nested_webpack_exports__.AsyncParallelHook;
+      exports.AsyncSeriesBailHook =
+        __nested_webpack_exports__.AsyncSeriesBailHook;
+      exports.AsyncSeriesHook = __nested_webpack_exports__.AsyncSeriesHook;
+      exports.AsyncSeriesWaterfallHook =
+        __nested_webpack_exports__.AsyncSeriesWaterfallHook;
+      exports.HookBase = __nested_webpack_exports__.HookBase;
+      exports.HookMap = __nested_webpack_exports__.HookMap;
+      exports.MultiHook = __nested_webpack_exports__.MultiHook;
+      exports.QueriedHook = __nested_webpack_exports__.QueriedHook;
+      exports.QueriedHookMap = __nested_webpack_exports__.QueriedHookMap;
+      exports.SyncBailHook = __nested_webpack_exports__.SyncBailHook;
+      exports.SyncHook = __nested_webpack_exports__.SyncHook;
+      exports.SyncWaterfallHook = __nested_webpack_exports__.SyncWaterfallHook;
+      exports.maxStage = __nested_webpack_exports__.maxStage;
+      exports.minStage = __nested_webpack_exports__.minStage;
+      exports.safeStage = __nested_webpack_exports__.safeStage;
+      for (var __webpack_i__ in __nested_webpack_exports__)
+        if (
+          -1 ===
+          [
+            "AsyncParallelHook",
+            "AsyncSeriesBailHook",
+            "AsyncSeriesHook",
+            "AsyncSeriesWaterfallHook",
+            "HookBase",
+            "HookMap",
+            "MultiHook",
+            "QueriedHook",
+            "QueriedHookMap",
+            "SyncBailHook",
+            "SyncHook",
+            "SyncWaterfallHook",
+            "maxStage",
+            "minStage",
+            "safeStage",
+          ].indexOf(__webpack_i__)
+        )
+          exports[__webpack_i__] = __nested_webpack_exports__[__webpack_i__];
+      Object.defineProperty(exports, "__esModule", { value: true });
+    },
   };
   var __webpack_module_cache__ = {};
   function __nccwpck_require__(moduleId) {