@rspack/core 1.1.0 → 1.1.1

package/dist/index.js

@@ -696,6 +696,8 @@ __export(src_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -758,6 +760,8 @@ __export(exports_exports, {
   CopyRspackPlugin: () => CopyRspackPlugin,
   CssExtractRspackPlugin: () => CssExtractRspackPlugin,
   DefinePlugin: () => DefinePlugin,
+  DllPlugin: () => DllPlugin,
+  DllReferencePlugin: () => DllReferencePlugin,
   DynamicEntryPlugin: () => DynamicEntryPlugin,
   EntryOptionPlugin: () => EntryOptionPlugin_default,
   EntryPlugin: () => EntryPlugin,
@@ -9590,55 +9594,204 @@ var keyedNestedConfig = (value, fn2, customKeys) => {
 
 // src/config/zod.ts
 var import_node_path7 = __toESM(require("path"));
+var import_zod2 = require("../compiled/zod/index.js");
+
+// src/config/utils.ts
 var import_zod = require("../compiled/zod/index.js");
-var filenameTemplate = import_zod.z.string();
+function processCreateParams(params) {
+  if (!params) return {};
+  const { errorMap, invalid_type_error, required_error, description } = params;
+  if (errorMap && (invalid_type_error || required_error)) {
+    throw new Error(
+      `Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`
+    );
+  }
+  if (errorMap) return { errorMap, description };
+  const customMap = (iss, ctx) => {
+    const { message } = params;
+    if (iss.code === "invalid_enum_value") {
+      return { message: message ?? ctx.defaultError };
+    }
+    if (typeof ctx.data === "undefined") {
+      return { message: message ?? required_error ?? ctx.defaultError };
+    }
+    if (iss.code !== "invalid_type") return { message: ctx.defaultError };
+    return { message: message ?? invalid_type_error ?? ctx.defaultError };
+  };
+  return { errorMap: customMap, description };
+}
+var _RspackZodUnion = class _RspackZodUnion extends import_zod.z.ZodUnion {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const options = this._def.options;
+    function handleResults(results) {
+      for (const result2 of results) {
+        if (result2.result.status === "valid") {
+          return result2.result;
+        }
+      }
+      for (const result2 of results) {
+        if (result2.result.status === "dirty") {
+          ctx.common.issues.push(...result2.ctx.common.issues);
+          return result2.result;
+        }
+      }
+      const unionErrors2 = results.map(
+        (result2) => new import_zod.ZodError(result2.ctx.common.issues)
+      );
+      (0, import_zod.addIssueToContext)(ctx, {
+        code: import_zod.ZodIssueCode.invalid_union,
+        unionErrors: unionErrors2
+      });
+      return import_zod.INVALID;
+    }
+    if (ctx.common.async) {
+      return Promise.all(
+        options.map(async (option) => {
+          const childCtx = {
+            ...ctx,
+            common: {
+              ...ctx.common,
+              issues: []
+            },
+            parent: ctx
+          };
+          return {
+            result: await option._parseAsync({
+              data: ctx.data,
+              path: ctx.path,
+              parent: childCtx
+            }),
+            ctx: childCtx
+          };
+        })
+      ).then(handleResults);
+    }
+    let dirty = void 0;
+    const issues = [];
+    for (const option of options) {
+      const childCtx = {
+        ...ctx,
+        common: {
+          ...ctx.common,
+          issues: []
+        },
+        parent: ctx
+      };
+      const result2 = option._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: childCtx
+      });
+      if (result2.status === "valid") {
+        return result2;
+      }
+      if (result2.status === "dirty" && !dirty) {
+        dirty = { result: result2, ctx: childCtx };
+      }
+      if (childCtx.common.issues.length) {
+        issues.push(childCtx.common.issues);
+      }
+    }
+    if (dirty) {
+      ctx.common.issues.push(...dirty.ctx.common.issues);
+      return dirty.result;
+    }
+    const unionErrors = issues.map((issues2) => new import_zod.ZodError(issues2));
+    (0, import_zod.addIssueToContext)(ctx, {
+      code: import_zod.ZodIssueCode.invalid_union,
+      unionErrors
+    });
+    return import_zod.INVALID;
+  }
+};
+_RspackZodUnion.create = (types, params) => {
+  return new _RspackZodUnion({
+    options: types,
+    typeName: import_zod.ZodFirstPartyTypeKind.ZodUnion,
+    ...processCreateParams(params)
+  });
+};
+var RspackZodUnion = _RspackZodUnion;
+import_zod.ZodUnion.create = RspackZodUnion.create;
+var ZodRspackCrossChecker = class extends import_zod.ZodType {
+  constructor(params) {
+    super(params);
+    this.params = params;
+  }
+  _parse(input) {
+    const ctx = this._getOrReturnCtx(input);
+    const root = this._getRootData(ctx);
+    for (const pattern of this.params.patterns) {
+      if (pattern.test(root)) {
+        const res = pattern.type._parse(input);
+        const issues = typeof pattern.issue === "function" ? pattern.issue(res) : [];
+        for (const issue of issues) {
+          (0, import_zod.addIssueToContext)(ctx, issue);
+        }
+        return res;
+      }
+    }
+    return this.params.default._parse(input);
+  }
+  _getRootData(ctx) {
+    let root = ctx;
+    while (root.parent) {
+      root = root.parent;
+    }
+    return root.data;
+  }
+};
+
+// src/config/zod.ts
+var filenameTemplate = import_zod2.z.string();
 var filename = filenameTemplate.or(
-  import_zod.z.function().args(import_zod.z.custom(), import_zod.z.custom().optional()).returns(import_zod.z.string())
+  import_zod2.z.function().args(import_zod2.z.custom(), import_zod2.z.custom().optional()).returns(import_zod2.z.string())
 );
-var name = import_zod.z.string();
-var dependencies = import_zod.z.array(name);
-var context = import_zod.z.string().refine(
+var name = import_zod2.z.string();
+var dependencies = import_zod2.z.array(name);
+var context = import_zod2.z.string().refine(
   (val) => import_node_path7.default.isAbsolute(val),
   (val) => ({
     message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
   })
 );
-var mode = import_zod.z.enum([
+var mode = import_zod2.z.enum([
   "development",
   "production",
   "none"
 ]);
-var falsy = import_zod.z.union([
-  import_zod.z.literal(false),
-  import_zod.z.literal(0),
-  import_zod.z.literal(""),
-  import_zod.z.null(),
-  import_zod.z.undefined()
+var falsy = import_zod2.z.union([
+  import_zod2.z.literal(false),
+  import_zod2.z.literal(0),
+  import_zod2.z.literal(""),
+  import_zod2.z.null(),
+  import_zod2.z.undefined()
 ]);
-var publicPath = import_zod.z.literal("auto").or(filename);
-var baseUri = import_zod.z.string();
-var chunkLoadingType = import_zod.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod.z.string());
-var chunkLoading = import_zod.z.literal(false).or(chunkLoadingType);
-var asyncChunks = import_zod.z.boolean();
-var wasmLoadingType = import_zod.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod.z.string());
-var wasmLoading = import_zod.z.literal(false).or(wasmLoadingType);
-var scriptType = import_zod.z.enum(["text/javascript", "module"]).or(import_zod.z.literal(false));
-var libraryCustomUmdObject = import_zod.z.strictObject({
-  amd: import_zod.z.string().optional(),
-  commonjs: import_zod.z.string().optional(),
-  root: import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).optional()
+var publicPath = import_zod2.z.literal("auto").or(filename);
+var baseUri = import_zod2.z.string();
+var chunkLoadingType = import_zod2.z.enum(["jsonp", "import-scripts", "require", "async-node", "import"]).or(import_zod2.z.string());
+var chunkLoading = import_zod2.z.literal(false).or(chunkLoadingType);
+var asyncChunks = import_zod2.z.boolean();
+var wasmLoadingType = import_zod2.z.enum(["fetch-streaming", "fetch", "async-node"]).or(import_zod2.z.string());
+var wasmLoading = import_zod2.z.literal(false).or(wasmLoadingType);
+var scriptType = import_zod2.z.enum(["text/javascript", "module"]).or(import_zod2.z.literal(false));
+var libraryCustomUmdObject = import_zod2.z.strictObject({
+  amd: import_zod2.z.string().optional(),
+  commonjs: import_zod2.z.string().optional(),
+  root: import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())).optional()
 });
-var libraryName = import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).or(libraryCustomUmdObject);
-var libraryCustomUmdCommentObject = import_zod.z.strictObject({
-  amd: import_zod.z.string().optional(),
-  commonjs: import_zod.z.string().optional(),
-  commonjs2: import_zod.z.string().optional(),
-  root: import_zod.z.string().optional()
+var libraryName = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())).or(libraryCustomUmdObject);
+var libraryCustomUmdCommentObject = import_zod2.z.strictObject({
+  amd: import_zod2.z.string().optional(),
+  commonjs: import_zod2.z.string().optional(),
+  commonjs2: import_zod2.z.string().optional(),
+  root: import_zod2.z.string().optional()
 });
-var amdContainer = import_zod.z.string();
-var auxiliaryComment = import_zod.z.string().or(libraryCustomUmdCommentObject);
-var libraryExport = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var libraryType = import_zod.z.enum([
+var amdContainer = import_zod2.z.string();
+var auxiliaryComment = import_zod2.z.string().or(libraryCustomUmdCommentObject);
+var libraryExport = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var libraryType = import_zod2.z.enum([
   "var",
   "module",
   "assign",
@@ -9657,9 +9810,9 @@ var libraryType = import_zod.z.enum([
   "umd2",
   "jsonp",
   "system"
-]).or(import_zod.z.string());
-var umdNamedDefine = import_zod.z.boolean();
-var libraryOptions = import_zod.z.strictObject({
+]).or(import_zod2.z.string());
+var umdNamedDefine = import_zod2.z.boolean();
+var libraryOptions = import_zod2.z.strictObject({
   amdContainer: amdContainer.optional(),
   auxiliaryComment: auxiliaryComment.optional(),
   export: libraryExport.optional(),
@@ -9668,12 +9821,12 @@ var libraryOptions = import_zod.z.strictObject({
   umdNamedDefine: umdNamedDefine.optional()
 });
 var library = libraryName.or(libraryOptions).optional();
-var layer = import_zod.z.string().or(import_zod.z.null());
+var layer = import_zod2.z.string().or(import_zod2.z.null());
 var entryFilename = filename;
-var entryRuntime = import_zod.z.literal(false).or(import_zod.z.string());
-var entryItem = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var entryDependOn = import_zod.z.string().or(import_zod.z.array(import_zod.z.string()));
-var entryDescription = import_zod.z.strictObject({
+var entryRuntime = import_zod2.z.literal(false).or(import_zod2.z.string());
+var entryItem = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var entryDependOn = import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()));
+var entryDescription = import_zod2.z.strictObject({
   import: entryItem,
   runtime: entryRuntime.optional(),
   publicPath: publicPath.optional(),
@@ -9687,84 +9840,84 @@ var entryDescription = import_zod.z.strictObject({
   layer: layer.optional()
 });
 var entryUnnamed = entryItem;
-var entryObject = import_zod.z.record(
+var entryObject = import_zod2.z.record(
   entryItem.or(entryDescription)
 );
 var entryStatic = entryObject.or(
   entryUnnamed
 );
-var entryDynamic = import_zod.z.function().returns(
-  entryStatic.or(import_zod.z.promise(entryStatic))
+var entryDynamic = import_zod2.z.function().returns(
+  entryStatic.or(import_zod2.z.promise(entryStatic))
 );
 var entry = entryStatic.or(entryDynamic);
-var path6 = import_zod.z.string();
-var pathinfo = import_zod.z.boolean().or(import_zod.z.literal("verbose"));
+var path6 = import_zod2.z.string();
+var pathinfo = import_zod2.z.boolean().or(import_zod2.z.literal("verbose"));
 var assetModuleFilename = filename;
-var webassemblyModuleFilename = import_zod.z.string();
+var webassemblyModuleFilename = import_zod2.z.string();
 var chunkFilename = filename;
-var crossOriginLoading = import_zod.z.literal(false).or(
-  import_zod.z.enum(["anonymous", "use-credentials"])
+var crossOriginLoading = import_zod2.z.literal(false).or(
+  import_zod2.z.enum(["anonymous", "use-credentials"])
 );
 var cssFilename = filename;
 var cssChunkFilename = filename;
 var hotUpdateChunkFilename = filenameTemplate;
 var hotUpdateMainFilename = filenameTemplate;
-var hotUpdateGlobal = import_zod.z.string();
-var uniqueName = import_zod.z.string();
-var chunkLoadingGlobal = import_zod.z.string();
-var enabledLibraryTypes = import_zod.z.array(
+var hotUpdateGlobal = import_zod2.z.string();
+var uniqueName = import_zod2.z.string();
+var chunkLoadingGlobal = import_zod2.z.string();
+var enabledLibraryTypes = import_zod2.z.array(
   libraryType
 );
-var clean = import_zod.z.boolean();
-var outputModule = import_zod.z.boolean();
-var strictModuleExceptionHandling = import_zod.z.boolean();
-var strictModuleErrorHandling = import_zod.z.boolean();
-var globalObject = import_zod.z.string();
-var enabledWasmLoadingTypes = import_zod.z.array(
+var clean = import_zod2.z.boolean();
+var outputModule = import_zod2.z.boolean();
+var strictModuleExceptionHandling = import_zod2.z.boolean();
+var strictModuleErrorHandling = import_zod2.z.boolean();
+var globalObject = import_zod2.z.string();
+var enabledWasmLoadingTypes = import_zod2.z.array(
   wasmLoadingType
 );
-var importFunctionName = import_zod.z.string();
-var importMetaName = import_zod.z.string();
-var iife = import_zod.z.boolean();
-var enabledChunkLoadingTypes = import_zod.z.array(
+var importFunctionName = import_zod2.z.string();
+var importMetaName = import_zod2.z.string();
+var iife = import_zod2.z.boolean();
+var enabledChunkLoadingTypes = import_zod2.z.array(
   chunkLoadingType
 );
-var chunkFormat = import_zod.z.literal(false).or(import_zod.z.string());
-var workerPublicPath = import_zod.z.string();
-var trustedTypes = import_zod.z.strictObject({
-  policyName: import_zod.z.string().optional()
+var chunkFormat = import_zod2.z.literal(false).or(import_zod2.z.string());
+var workerPublicPath = import_zod2.z.string();
+var trustedTypes = import_zod2.z.strictObject({
+  policyName: import_zod2.z.string().optional()
 });
-var hashDigest = import_zod.z.string();
-var hashDigestLength = import_zod.z.number();
-var hashFunction = import_zod.z.enum([
+var hashDigest = import_zod2.z.string();
+var hashDigestLength = import_zod2.z.number();
+var hashFunction = import_zod2.z.enum([
   "md4",
   "xxhash64"
 ]);
-var hashSalt = import_zod.z.string();
-var sourceMapFilename = import_zod.z.string();
-var devtoolNamespace = import_zod.z.string();
-var devtoolModuleFilenameTemplate = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.function(import_zod.z.tuple([import_zod.z.any()]), import_zod.z.any())
+var hashSalt = import_zod2.z.string();
+var sourceMapFilename = import_zod2.z.string();
+var devtoolNamespace = import_zod2.z.string();
+var devtoolModuleFilenameTemplate = import_zod2.z.union([
+  import_zod2.z.string(),
+  import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.any()]), import_zod2.z.any())
 ]);
 var devtoolFallbackModuleFilenameTemplate = devtoolModuleFilenameTemplate;
-var environment = import_zod.z.strictObject({
-  arrowFunction: import_zod.z.boolean().optional(),
-  asyncFunction: import_zod.z.boolean().optional(),
-  bigIntLiteral: import_zod.z.boolean().optional(),
-  const: import_zod.z.boolean().optional(),
-  destructuring: import_zod.z.boolean().optional(),
-  document: import_zod.z.boolean().optional(),
-  dynamicImport: import_zod.z.boolean().optional(),
-  dynamicImportInWorker: import_zod.z.boolean().optional(),
-  forOf: import_zod.z.boolean().optional(),
-  globalThis: import_zod.z.boolean().optional(),
-  module: import_zod.z.boolean().optional(),
-  nodePrefixForCoreModules: import_zod.z.boolean().optional(),
-  optionalChaining: import_zod.z.boolean().optional(),
-  templateLiteral: import_zod.z.boolean().optional()
+var environment = import_zod2.z.strictObject({
+  arrowFunction: import_zod2.z.boolean().optional(),
+  asyncFunction: import_zod2.z.boolean().optional(),
+  bigIntLiteral: import_zod2.z.boolean().optional(),
+  const: import_zod2.z.boolean().optional(),
+  destructuring: import_zod2.z.boolean().optional(),
+  document: import_zod2.z.boolean().optional(),
+  dynamicImport: import_zod2.z.boolean().optional(),
+  dynamicImportInWorker: import_zod2.z.boolean().optional(),
+  forOf: import_zod2.z.boolean().optional(),
+  globalThis: import_zod2.z.boolean().optional(),
+  module: import_zod2.z.boolean().optional(),
+  nodePrefixForCoreModules: import_zod2.z.boolean().optional(),
+  optionalChaining: import_zod2.z.boolean().optional(),
+  templateLiteral: import_zod2.z.boolean().optional()
 });
-var output = import_zod.z.strictObject({
+var output = import_zod2.z.strictObject({
   path: path6.optional(),
   pathinfo: pathinfo.optional(),
   clean: clean.optional(),
@@ -9773,7 +9926,7 @@ var output = import_zod.z.strictObject({
   chunkFilename: chunkFilename.optional(),
   crossOriginLoading: crossOriginLoading.optional(),
   cssFilename: cssFilename.optional(),
-  cssHeadDataCompression: import_zod.z.boolean().optional(),
+  cssHeadDataCompression: import_zod2.z.boolean().optional(),
   cssChunkFilename: cssChunkFilename.optional(),
   hotUpdateMainFilename: hotUpdateMainFilename.optional(),
   hotUpdateChunkFilename: hotUpdateChunkFilename.optional(),
@@ -9800,7 +9953,7 @@ var output = import_zod.z.strictObject({
   chunkFormat: chunkFormat.optional(),
   chunkLoading: chunkLoading.optional(),
   enabledChunkLoadingTypes: enabledChunkLoadingTypes.optional(),
-  trustedTypes: import_zod.z.literal(true).or(import_zod.z.string()).or(trustedTypes).optional(),
+  trustedTypes: import_zod2.z.literal(true).or(import_zod2.z.string()).or(trustedTypes).optional(),
   sourceMapFilename: sourceMapFilename.optional(),
   hashDigest: hashDigest.optional(),
   hashDigestLength: hashDigestLength.optional(),
@@ -9814,60 +9967,60 @@ var output = import_zod.z.strictObject({
   devtoolNamespace: devtoolNamespace.optional(),
   devtoolModuleFilenameTemplate: devtoolModuleFilenameTemplate.optional(),
   devtoolFallbackModuleFilenameTemplate: devtoolFallbackModuleFilenameTemplate.optional(),
-  chunkLoadTimeout: import_zod.z.number().optional(),
-  charset: import_zod.z.boolean().optional(),
+  chunkLoadTimeout: import_zod2.z.number().optional(),
+  charset: import_zod2.z.boolean().optional(),
   environment: environment.optional(),
-  compareBeforeEmit: import_zod.z.boolean().optional()
+  compareBeforeEmit: import_zod2.z.boolean().optional()
 });
-var resolveAlias = import_zod.z.record(
-  import_zod.z.literal(false).or(import_zod.z.string()).or(import_zod.z.array(import_zod.z.string().or(import_zod.z.literal(false))))
+var resolveAlias = import_zod2.z.record(
+  import_zod2.z.literal(false).or(import_zod2.z.string()).or(import_zod2.z.array(import_zod2.z.string().or(import_zod2.z.literal(false))))
 );
-var resolveTsConfigFile = import_zod.z.string();
+var resolveTsConfigFile = import_zod2.z.string();
 var resolveTsConfig = resolveTsConfigFile.or(
-  import_zod.z.strictObject({
+  import_zod2.z.strictObject({
     configFile: resolveTsConfigFile,
-    references: import_zod.z.array(import_zod.z.string()).or(import_zod.z.literal("auto")).optional()
+    references: import_zod2.z.array(import_zod2.z.string()).or(import_zod2.z.literal("auto")).optional()
   })
 );
-var baseResolveOptions = import_zod.z.strictObject({
+var baseResolveOptions = import_zod2.z.strictObject({
   alias: resolveAlias.optional(),
-  conditionNames: import_zod.z.array(import_zod.z.string()).optional(),
-  extensions: import_zod.z.array(import_zod.z.string()).optional(),
+  conditionNames: import_zod2.z.array(import_zod2.z.string()).optional(),
+  extensions: import_zod2.z.array(import_zod2.z.string()).optional(),
   fallback: resolveAlias.optional(),
-  mainFields: import_zod.z.array(import_zod.z.string()).optional(),
-  mainFiles: import_zod.z.array(import_zod.z.string()).optional(),
-  modules: import_zod.z.array(import_zod.z.string()).optional(),
-  preferRelative: import_zod.z.boolean().optional(),
-  preferAbsolute: import_zod.z.boolean().optional(),
-  symlinks: import_zod.z.boolean().optional(),
-  enforceExtension: import_zod.z.boolean().optional(),
-  importsFields: import_zod.z.array(import_zod.z.string()).optional(),
-  descriptionFiles: import_zod.z.array(import_zod.z.string()).optional(),
+  mainFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  mainFiles: import_zod2.z.array(import_zod2.z.string()).optional(),
+  modules: import_zod2.z.array(import_zod2.z.string()).optional(),
+  preferRelative: import_zod2.z.boolean().optional(),
+  preferAbsolute: import_zod2.z.boolean().optional(),
+  symlinks: import_zod2.z.boolean().optional(),
+  enforceExtension: import_zod2.z.boolean().optional(),
+  importsFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  descriptionFiles: import_zod2.z.array(import_zod2.z.string()).optional(),
   tsConfig: resolveTsConfig.optional(),
-  fullySpecified: import_zod.z.boolean().optional(),
-  exportsFields: import_zod.z.array(import_zod.z.string()).optional(),
-  extensionAlias: import_zod.z.record(import_zod.z.string().or(import_zod.z.array(import_zod.z.string()))).optional(),
-  aliasFields: import_zod.z.array(import_zod.z.string()).optional(),
-  restrictions: import_zod.z.array(import_zod.z.string()).optional(),
-  roots: import_zod.z.array(import_zod.z.string()).optional()
+  fullySpecified: import_zod2.z.boolean().optional(),
+  exportsFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  extensionAlias: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string()))).optional(),
+  aliasFields: import_zod2.z.array(import_zod2.z.string()).optional(),
+  restrictions: import_zod2.z.array(import_zod2.z.string()).optional(),
+  roots: import_zod2.z.array(import_zod2.z.string()).optional()
 });
 var resolveOptions = baseResolveOptions.extend({
-  byDependency: import_zod.z.lazy(() => import_zod.z.record(resolveOptions)).optional()
+  byDependency: import_zod2.z.lazy(() => import_zod2.z.record(resolveOptions)).optional()
 });
-var baseRuleSetCondition = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
-var ruleSetCondition = baseRuleSetCondition.or(import_zod.z.lazy(() => ruleSetConditions)).or(import_zod.z.lazy(() => ruleSetLogicalConditions));
-var ruleSetConditions = import_zod.z.lazy(
-  () => import_zod.z.array(ruleSetCondition)
+var baseRuleSetCondition = import_zod2.z.instanceof(RegExp).or(import_zod2.z.string()).or(import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()));
+var ruleSetCondition = baseRuleSetCondition.or(import_zod2.z.lazy(() => ruleSetConditions)).or(import_zod2.z.lazy(() => ruleSetLogicalConditions));
+var ruleSetConditions = import_zod2.z.lazy(
+  () => import_zod2.z.array(ruleSetCondition)
 );
-var ruleSetLogicalConditions = import_zod.z.strictObject({
+var ruleSetLogicalConditions = import_zod2.z.strictObject({
   and: ruleSetConditions.optional(),
   or: ruleSetConditions.optional(),
   not: ruleSetCondition.optional()
 });
-var ruleSetLoader = import_zod.z.string();
-var ruleSetLoaderOptions = import_zod.z.string().or(import_zod.z.record(import_zod.z.any()));
-var ruleSetLoaderWithOptions = import_zod.z.strictObject({
-  ident: import_zod.z.string().optional(),
+var ruleSetLoader = import_zod2.z.string();
+var ruleSetLoaderOptions = import_zod2.z.string().or(import_zod2.z.record(import_zod2.z.any()));
+var ruleSetLoaderWithOptions = import_zod2.z.strictObject({
+  ident: import_zod2.z.string().optional(),
   loader: ruleSetLoader,
   options: ruleSetLoaderOptions.optional()
 });
@@ -9875,9 +10028,9 @@ var ruleSetUseItem = ruleSetLoader.or(
   ruleSetLoaderWithOptions
 );
 var ruleSetUse = ruleSetUseItem.or(ruleSetUseItem.array()).or(
-  import_zod.z.function().args(import_zod.z.custom()).returns(ruleSetUseItem.array())
+  import_zod2.z.function().args(import_zod2.z.custom()).returns(ruleSetUseItem.array())
 );
-var baseRuleSetRule = import_zod.z.strictObject({
+var baseRuleSetRule = import_zod2.z.strictObject({
   test: ruleSetCondition.optional(),
   exclude: ruleSetCondition.optional(),
   include: ruleSetCondition.optional(),
@@ -9889,67 +10042,67 @@ var baseRuleSetRule = import_zod.z.strictObject({
   resourceQuery: ruleSetCondition.optional(),
   scheme: ruleSetCondition.optional(),
   mimetype: ruleSetCondition.optional(),
-  descriptionData: import_zod.z.record(ruleSetCondition).optional(),
-  with: import_zod.z.record(ruleSetCondition).optional(),
-  type: import_zod.z.string().optional(),
-  layer: import_zod.z.string().optional(),
+  descriptionData: import_zod2.z.record(ruleSetCondition).optional(),
+  with: import_zod2.z.record(ruleSetCondition).optional(),
+  type: import_zod2.z.string().optional(),
+  layer: import_zod2.z.string().optional(),
   loader: ruleSetLoader.optional(),
   options: ruleSetLoaderOptions.optional(),
   use: ruleSetUse.optional(),
-  parser: import_zod.z.record(import_zod.z.any()).optional(),
-  generator: import_zod.z.record(import_zod.z.any()).optional(),
+  parser: import_zod2.z.record(import_zod2.z.any()).optional(),
+  generator: import_zod2.z.record(import_zod2.z.any()).optional(),
   resolve: resolveOptions.optional(),
-  sideEffects: import_zod.z.boolean().optional(),
-  enforce: import_zod.z.literal("pre").or(import_zod.z.literal("post")).optional()
+  sideEffects: import_zod2.z.boolean().optional(),
+  enforce: import_zod2.z.literal("pre").or(import_zod2.z.literal("post")).optional()
 });
 var ruleSetRule = baseRuleSetRule.extend({
-  oneOf: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
-  rules: import_zod.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
+  oneOf: import_zod2.z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
+  rules: import_zod2.z.lazy(() => ruleSetRule.or(falsy).array()).optional()
 });
-var ruleSetRules = import_zod.z.array(
-  import_zod.z.literal("...").or(ruleSetRule).or(falsy)
+var ruleSetRules = import_zod2.z.array(
+  import_zod2.z.literal("...").or(ruleSetRule).or(falsy)
 );
-var assetParserDataUrlOptions = import_zod.z.strictObject({
-  maxSize: import_zod.z.number().optional()
+var assetParserDataUrlOptions = import_zod2.z.strictObject({
+  maxSize: import_zod2.z.number().optional()
 });
 var assetParserDataUrl = assetParserDataUrlOptions;
-var assetParserOptions = import_zod.z.strictObject({
+var assetParserOptions = import_zod2.z.strictObject({
   dataUrlCondition: assetParserDataUrl.optional()
 });
-var cssParserNamedExports = import_zod.z.boolean();
-var cssParserOptions = import_zod.z.strictObject({
+var cssParserNamedExports = import_zod2.z.boolean();
+var cssParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssAutoParserOptions = import_zod.z.strictObject({
+var cssAutoParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var cssModuleParserOptions = import_zod.z.strictObject({
+var cssModuleParserOptions = import_zod2.z.strictObject({
   namedExports: cssParserNamedExports.optional()
 });
-var dynamicImportMode = import_zod.z.enum(["eager", "lazy", "weak", "lazy-once"]);
-var dynamicImportPreload = import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]);
-var dynamicImportPrefetch = import_zod.z.union([import_zod.z.boolean(), import_zod.z.number()]);
-var dynamicImportFetchPriority = import_zod.z.enum(["low", "high", "auto"]);
-var javascriptParserUrl = import_zod.z.union([import_zod.z.literal("relative"), import_zod.z.boolean()]);
-var exprContextCritical = import_zod.z.boolean();
-var wrappedContextCritical = import_zod.z.boolean();
-var wrappedContextRegExp = import_zod.z.instanceof(RegExp);
-var exportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var importExportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var reexportExportsPresence = import_zod.z.enum(["error", "warn", "auto"]).or(import_zod.z.literal(false));
-var strictExportPresence = import_zod.z.boolean();
-var worker = import_zod.z.array(import_zod.z.string()).or(import_zod.z.boolean());
-var overrideStrict = import_zod.z.enum(["strict", "non-strict"]);
-var requireAsExpression = import_zod.z.boolean();
-var requireDynamic = import_zod.z.boolean();
-var requireResolve = import_zod.z.boolean();
-var importDynamic = import_zod.z.boolean();
-var javascriptParserOptions = import_zod.z.strictObject({
+var dynamicImportMode = import_zod2.z.enum(["eager", "lazy", "weak", "lazy-once"]);
+var dynamicImportPreload = import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number()]);
+var dynamicImportPrefetch = import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.number()]);
+var dynamicImportFetchPriority = import_zod2.z.enum(["low", "high", "auto"]);
+var javascriptParserUrl = import_zod2.z.union([import_zod2.z.literal("relative"), import_zod2.z.boolean()]);
+var exprContextCritical = import_zod2.z.boolean();
+var wrappedContextCritical = import_zod2.z.boolean();
+var wrappedContextRegExp = import_zod2.z.instanceof(RegExp);
+var exportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var importExportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var reexportExportsPresence = import_zod2.z.enum(["error", "warn", "auto"]).or(import_zod2.z.literal(false));
+var strictExportPresence = import_zod2.z.boolean();
+var worker = import_zod2.z.array(import_zod2.z.string()).or(import_zod2.z.boolean());
+var overrideStrict = import_zod2.z.enum(["strict", "non-strict"]);
+var requireAsExpression = import_zod2.z.boolean();
+var requireDynamic = import_zod2.z.boolean();
+var requireResolve = import_zod2.z.boolean();
+var importDynamic = import_zod2.z.boolean();
+var javascriptParserOptions = import_zod2.z.strictObject({
   dynamicImportMode: dynamicImportMode.optional(),
   dynamicImportPreload: dynamicImportPreload.optional(),
   dynamicImportPrefetch: dynamicImportPrefetch.optional(),
   dynamicImportFetchPriority: dynamicImportFetchPriority.optional(),
-  importMeta: import_zod.z.boolean().optional(),
+  importMeta: import_zod2.z.boolean().optional(),
   url: javascriptParserUrl.optional(),
   exprContextCritical: exprContextCritical.optional(),
   wrappedContextCritical: wrappedContextCritical.optional(),
@@ -9967,7 +10120,7 @@ var javascriptParserOptions = import_zod.z.strictObject({
   importDynamic: importDynamic.optional()
   // #endregion
 });
-var parserOptionsByModuleTypeKnown = import_zod.z.strictObject({
+var parserOptionsByModuleTypeKnown = import_zod2.z.strictObject({
   asset: assetParserOptions.optional(),
   css: cssParserOptions.optional(),
   "css/auto": cssAutoParserOptions.optional(),
@@ -9977,63 +10130,63 @@ var parserOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "javascript/dynamic": javascriptParserOptions.optional(),
   "javascript/esm": javascriptParserOptions.optional()
 });
-var parserOptionsByModuleTypeUnknown = import_zod.z.record(
-  import_zod.z.record(import_zod.z.any())
+var parserOptionsByModuleTypeUnknown = import_zod2.z.record(
+  import_zod2.z.record(import_zod2.z.any())
 );
 var parserOptionsByModuleType = parserOptionsByModuleTypeKnown.or(
   parserOptionsByModuleTypeUnknown
 );
-var assetGeneratorDataUrlOptions = import_zod.z.strictObject({
-  encoding: import_zod.z.literal(false).or(import_zod.z.literal("base64")).optional(),
-  mimetype: import_zod.z.string().optional()
+var assetGeneratorDataUrlOptions = import_zod2.z.strictObject({
+  encoding: import_zod2.z.literal(false).or(import_zod2.z.literal("base64")).optional(),
+  mimetype: import_zod2.z.string().optional()
 });
-var assetGeneratorDataUrlFunction = import_zod.z.function().args(
-  import_zod.z.strictObject({
-    content: import_zod.z.string(),
-    filename: import_zod.z.string()
+var assetGeneratorDataUrlFunction = import_zod2.z.function().args(
+  import_zod2.z.strictObject({
+    content: import_zod2.z.string(),
+    filename: import_zod2.z.string()
   })
-).returns(import_zod.z.string());
+).returns(import_zod2.z.string());
 var assetGeneratorDataUrl = assetGeneratorDataUrlOptions.or(
   assetGeneratorDataUrlFunction
 );
-var assetInlineGeneratorOptions = import_zod.z.strictObject({
+var assetInlineGeneratorOptions = import_zod2.z.strictObject({
   dataUrl: assetGeneratorDataUrl.optional()
 });
-var assetResourceGeneratorOptions = import_zod.z.strictObject({
-  emit: import_zod.z.boolean().optional(),
+var assetResourceGeneratorOptions = import_zod2.z.strictObject({
+  emit: import_zod2.z.boolean().optional(),
   filename: filename.optional(),
   publicPath: publicPath.optional()
 });
 var assetGeneratorOptions = assetInlineGeneratorOptions.merge(
   assetResourceGeneratorOptions
 );
-var cssGeneratorExportsConvention = import_zod.z.enum([
+var cssGeneratorExportsConvention = import_zod2.z.enum([
   "as-is",
   "camel-case",
   "camel-case-only",
   "dashes",
   "dashes-only"
 ]);
-var cssGeneratorExportsOnly = import_zod.z.boolean();
-var cssGeneratorLocalIdentName = import_zod.z.string();
-var cssGeneratorEsModule = import_zod.z.boolean();
-var cssGeneratorOptions = import_zod.z.strictObject({
+var cssGeneratorExportsOnly = import_zod2.z.boolean();
+var cssGeneratorLocalIdentName = import_zod2.z.string();
+var cssGeneratorEsModule = import_zod2.z.boolean();
+var cssGeneratorOptions = import_zod2.z.strictObject({
   exportsOnly: cssGeneratorExportsOnly.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssAutoGeneratorOptions = import_zod.z.strictObject({
+var cssAutoGeneratorOptions = import_zod2.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var cssModuleGeneratorOptions = import_zod.z.strictObject({
+var cssModuleGeneratorOptions = import_zod2.z.strictObject({
   exportsConvention: cssGeneratorExportsConvention.optional(),
   exportsOnly: cssGeneratorExportsOnly.optional(),
   localIdentName: cssGeneratorLocalIdentName.optional(),
   esModule: cssGeneratorEsModule.optional()
 });
-var generatorOptionsByModuleTypeKnown = import_zod.z.strictObject({
+var generatorOptionsByModuleTypeKnown = import_zod2.z.strictObject({
   asset: assetGeneratorOptions.optional(),
   "asset/inline": assetInlineGeneratorOptions.optional(),
   "asset/resource": assetResourceGeneratorOptions.optional(),
@@ -10041,25 +10194,25 @@ var generatorOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "css/auto": cssAutoGeneratorOptions.optional(),
   "css/module": cssModuleGeneratorOptions.optional()
 });
-var generatorOptionsByModuleTypeUnknown = import_zod.z.record(
-  import_zod.z.record(import_zod.z.any())
+var generatorOptionsByModuleTypeUnknown = import_zod2.z.record(
+  import_zod2.z.record(import_zod2.z.any())
 );
 var generatorOptionsByModuleType = generatorOptionsByModuleTypeKnown.or(
   generatorOptionsByModuleTypeUnknown
 );
-var noParseOptionSingle = import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
+var noParseOptionSingle = import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()));
 var noParseOption = noParseOptionSingle.or(
-  import_zod.z.array(noParseOptionSingle)
+  import_zod2.z.array(noParseOptionSingle)
 );
-var moduleOptions = import_zod.z.strictObject({
+var moduleOptions = import_zod2.z.strictObject({
   defaultRules: ruleSetRules.optional(),
   rules: ruleSetRules.optional(),
   parser: parserOptionsByModuleType.optional(),
   generator: generatorOptionsByModuleType.optional(),
   noParse: noParseOption.optional()
 });
-var allowTarget = import_zod.z.union([
-  import_zod.z.enum([
+var allowTarget = import_zod2.z.union([
+  import_zod2.z.enum([
     "web",
     "webworker",
     "es3",
@@ -10073,66 +10226,66 @@ var allowTarget = import_zod.z.union([
     "es2021",
     "es2022"
   ]),
-  import_zod.z.literal("node"),
-  import_zod.z.literal("async-node"),
-  import_zod.z.custom(
+  import_zod2.z.literal("node"),
+  import_zod2.z.literal("async-node"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^async-node\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node\d+\.\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^async-node\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("electron-main"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-main"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-main$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-main$/.test(value)
   ),
-  import_zod.z.literal("electron-renderer"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-renderer"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-renderer$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-renderer$/.test(value)
   ),
-  import_zod.z.literal("electron-preload"),
-  import_zod.z.custom(
+  import_zod2.z.literal("electron-preload"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+-preload$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^electron\d+\.\d+-preload$/.test(value)
   ),
-  import_zod.z.literal("nwjs"),
-  import_zod.z.custom(
+  import_zod2.z.literal("nwjs"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^nwjs\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("node-webkit"),
-  import_zod.z.custom(
+  import_zod2.z.literal("node-webkit"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+$/.test(value)
   ),
-  import_zod.z.custom(
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^node-webkit\d+\.\d+$/.test(value)
   ),
-  import_zod.z.literal("browserslist"),
-  import_zod.z.custom(
+  import_zod2.z.literal("browserslist"),
+  import_zod2.z.custom(
     (value) => typeof value === "string" && /^browserslist:(.+)$/.test(value)
   )
 ]);
-var target = import_zod.z.union([
-  import_zod.z.literal(false),
+var target = import_zod2.z.union([
+  import_zod2.z.literal(false),
   allowTarget,
   allowTarget.array()
 ]);
-var externalsType = import_zod.z.enum([
+var externalsType = import_zod2.z.enum([
   "var",
   "module",
   "assign",
@@ -10156,62 +10309,94 @@ var externalsType = import_zod.z.enum([
   "script",
   "node-commonjs"
 ]);
-var externalItemValue = import_zod.z.string().or(import_zod.z.boolean()).or(import_zod.z.string().array().min(1)).or(
-  import_zod.z.strictObject({
-    root: import_zod.z.string().or(import_zod.z.string().array()),
-    commonjs: import_zod.z.string().or(import_zod.z.string().array()),
-    commonjs2: import_zod.z.string().or(import_zod.z.string().array()),
-    amd: import_zod.z.string().or(import_zod.z.string().array()).optional()
-  })
-);
-var externalItemObjectUnknown = import_zod.z.record(
+var ZodExternalObjectValue = new ZodRspackCrossChecker({
+  patterns: [
+    {
+      test: (config2) => {
+        var _a, _b;
+        let isLibraryUmd = false;
+        const library3 = (_a = config2 == null ? void 0 : config2.output) == null ? void 0 : _a.library;
+        if (typeof library3 === "object" && "type" in library3) {
+          isLibraryUmd = library3.type === "umd";
+        } else {
+          isLibraryUmd = ((_b = config2 == null ? void 0 : config2.output) == null ? void 0 : _b.libraryTarget) === "umd";
+        }
+        if (isLibraryUmd) {
+          return (config2 == null ? void 0 : config2.externalsType) === void 0 || (config2 == null ? void 0 : config2.externalsType) === "umd";
+        }
+        return false;
+      },
+      type: import_zod2.z.strictObject({
+        root: import_zod2.z.string().or(import_zod2.z.string().array()),
+        commonjs: import_zod2.z.string().or(import_zod2.z.string().array()),
+        commonjs2: import_zod2.z.string().or(import_zod2.z.string().array()),
+        amd: import_zod2.z.string().or(import_zod2.z.string().array())
+      }),
+      issue: (res) => {
+        if (res.status === "aborted") {
+          return [
+            {
+              fatal: true,
+              code: import_zod2.ZodIssueCode.custom,
+              message: `External object must have "root", "commonjs", "commonjs2", "amd" properties when "libraryType" or "externalsType" is "umd"`
+            }
+          ];
+        }
+        return [];
+      }
+    }
+  ],
+  default: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.string().array()))
+});
+var externalItemValue = import_zod2.z.string().or(import_zod2.z.boolean()).or(import_zod2.z.string().array().min(1)).or(ZodExternalObjectValue);
+var externalItemObjectUnknown = import_zod2.z.record(
   externalItemValue
 );
-var externalItemFunctionData = import_zod.z.strictObject({
-  context: import_zod.z.string().optional(),
-  dependencyType: import_zod.z.string().optional(),
-  request: import_zod.z.string().optional(),
-  contextInfo: import_zod.z.strictObject({
-    issuer: import_zod.z.string()
+var externalItemFunctionData = import_zod2.z.strictObject({
+  context: import_zod2.z.string().optional(),
+  dependencyType: import_zod2.z.string().optional(),
+  request: import_zod2.z.string().optional(),
+  contextInfo: import_zod2.z.strictObject({
+    issuer: import_zod2.z.string()
   }).optional()
 });
-var externalItem = import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
-  import_zod.z.function().args(
+var externalItem = import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(externalItemObjectUnknown).or(
+  import_zod2.z.function().args(
     externalItemFunctionData,
-    import_zod.z.function().args(
-      import_zod.z.instanceof(Error).optional(),
+    import_zod2.z.function().args(
+      import_zod2.z.instanceof(Error).optional(),
       externalItemValue.optional(),
       externalsType.optional()
-    ).returns(import_zod.z.void())
+    ).returns(import_zod2.z.void())
   )
 ).or(
-  import_zod.z.function().args(externalItemFunctionData).returns(import_zod.z.promise(externalItemValue))
+  import_zod2.z.function().args(externalItemFunctionData).returns(import_zod2.z.promise(externalItemValue))
 );
 var externals = externalItem.array().or(externalItem);
-var externalsPresets = import_zod.z.strictObject({
-  node: import_zod.z.boolean().optional(),
-  web: import_zod.z.boolean().optional(),
-  webAsync: import_zod.z.boolean().optional(),
-  electron: import_zod.z.boolean().optional(),
-  electronMain: import_zod.z.boolean().optional(),
-  electronPreload: import_zod.z.boolean().optional(),
-  electronRenderer: import_zod.z.boolean().optional(),
-  nwjs: import_zod.z.boolean().optional()
+var externalsPresets = import_zod2.z.strictObject({
+  node: import_zod2.z.boolean().optional(),
+  web: import_zod2.z.boolean().optional(),
+  webAsync: import_zod2.z.boolean().optional(),
+  electron: import_zod2.z.boolean().optional(),
+  electronMain: import_zod2.z.boolean().optional(),
+  electronPreload: import_zod2.z.boolean().optional(),
+  electronRenderer: import_zod2.z.boolean().optional(),
+  nwjs: import_zod2.z.boolean().optional()
 });
-var filterItemTypes = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(
-  import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean())
+var filterItemTypes = import_zod2.z.instanceof(RegExp).or(import_zod2.z.string()).or(
+  import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean())
 );
 var filterTypes = filterItemTypes.array().or(filterItemTypes);
-var infrastructureLogging = import_zod.z.strictObject({
-  appendOnly: import_zod.z.boolean().optional(),
-  colors: import_zod.z.boolean().optional(),
-  console: import_zod.z.custom().optional(),
-  debug: import_zod.z.boolean().or(filterTypes).optional(),
-  level: import_zod.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
-  stream: import_zod.z.custom().optional()
+var infrastructureLogging = import_zod2.z.strictObject({
+  appendOnly: import_zod2.z.boolean().optional(),
+  colors: import_zod2.z.boolean().optional(),
+  console: import_zod2.z.custom().optional(),
+  debug: import_zod2.z.boolean().or(filterTypes).optional(),
+  level: import_zod2.z.enum(["none", "error", "warn", "info", "log", "verbose"]).optional(),
+  stream: import_zod2.z.custom().optional()
 });
-var devTool = import_zod.z.literal(false).or(
-  import_zod.z.enum([
+var devTool = import_zod2.z.literal(false).or(
+  import_zod2.z.enum([
     "eval",
     "cheap-source-map",
     "cheap-module-source-map",
@@ -10239,18 +10424,18 @@ var devTool = import_zod.z.literal(false).or(
     "eval-nosources-source-map"
   ])
 );
-var nodeOptions = import_zod.z.strictObject({
-  __dirname: import_zod.z.boolean().or(import_zod.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  __filename: import_zod.z.boolean().or(import_zod.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
-  global: import_zod.z.boolean().or(import_zod.z.literal("warn")).optional()
+var nodeOptions = import_zod2.z.strictObject({
+  __dirname: import_zod2.z.boolean().or(import_zod2.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  __filename: import_zod2.z.boolean().or(import_zod2.z.enum(["warn-mock", "mock", "eval-only", "node-module"])).optional(),
+  global: import_zod2.z.boolean().or(import_zod2.z.literal("warn")).optional()
 });
-var node = import_zod.z.literal(false).or(nodeOptions);
-var loader = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
-var snapshotOptions = import_zod.z.strictObject(
+var node = import_zod2.z.literal(false).or(nodeOptions);
+var loader = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any());
+var snapshotOptions = import_zod2.z.strictObject(
   {}
 );
-var cacheOptions = import_zod.z.boolean();
-var statsPresets = import_zod.z.enum([
+var cacheOptions = import_zod2.z.boolean();
+var statsPresets = import_zod2.z.enum([
   "normal",
   "none",
   "verbose",
@@ -10260,244 +10445,244 @@ var statsPresets = import_zod.z.enum([
   "detailed",
   "summary"
 ]);
-var statsOptions = import_zod.z.strictObject({
-  all: import_zod.z.boolean().optional(),
-  preset: import_zod.z.boolean().or(statsPresets).optional(),
-  assets: import_zod.z.boolean().optional(),
-  chunks: import_zod.z.boolean().optional(),
-  modules: import_zod.z.boolean().optional(),
-  entrypoints: import_zod.z.boolean().or(import_zod.z.literal("auto")).optional(),
-  chunkGroups: import_zod.z.boolean().optional(),
-  warnings: import_zod.z.boolean().optional(),
-  warningsCount: import_zod.z.boolean().optional(),
-  errors: import_zod.z.boolean().optional(),
-  errorsCount: import_zod.z.boolean().optional(),
-  colors: import_zod.z.boolean().optional(),
-  hash: import_zod.z.boolean().optional(),
-  version: import_zod.z.boolean().optional(),
-  reasons: import_zod.z.boolean().optional(),
-  publicPath: import_zod.z.boolean().optional(),
-  outputPath: import_zod.z.boolean().optional(),
-  chunkModules: import_zod.z.boolean().optional(),
-  chunkRelations: import_zod.z.boolean().optional(),
-  ids: import_zod.z.boolean().optional(),
-  timings: import_zod.z.boolean().optional(),
-  builtAt: import_zod.z.boolean().optional(),
-  moduleAssets: import_zod.z.boolean().optional(),
-  nestedModules: import_zod.z.boolean().optional(),
-  source: import_zod.z.boolean().optional(),
-  logging: import_zod.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod.z.boolean()).optional(),
-  loggingDebug: import_zod.z.boolean().or(filterTypes).optional(),
-  loggingTrace: import_zod.z.boolean().optional(),
-  runtimeModules: import_zod.z.boolean().optional(),
-  children: import_zod.z.boolean().optional(),
-  usedExports: import_zod.z.boolean().optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  optimizationBailout: import_zod.z.boolean().optional(),
-  groupModulesByType: import_zod.z.boolean().optional(),
-  groupModulesByCacheStatus: import_zod.z.boolean().optional(),
-  groupModulesByLayer: import_zod.z.boolean().optional(),
-  groupModulesByAttributes: import_zod.z.boolean().optional(),
-  groupModulesByPath: import_zod.z.boolean().optional(),
-  groupModulesByExtension: import_zod.z.boolean().optional(),
-  modulesSpace: import_zod.z.number().optional(),
-  chunkModulesSpace: import_zod.z.number().optional(),
-  nestedModulesSpace: import_zod.z.number().optional(),
-  relatedAssets: import_zod.z.boolean().optional(),
-  groupAssetsByEmitStatus: import_zod.z.boolean().optional(),
-  groupAssetsByInfo: import_zod.z.boolean().optional(),
-  groupAssetsByPath: import_zod.z.boolean().optional(),
-  groupAssetsByExtension: import_zod.z.boolean().optional(),
-  groupAssetsByChunk: import_zod.z.boolean().optional(),
-  assetsSpace: import_zod.z.number().optional(),
-  orphanModules: import_zod.z.boolean().optional(),
-  excludeModules: import_zod.z.array(
-    import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any(), import_zod.z.any()]), import_zod.z.boolean()))
-  ).or(import_zod.z.string()).or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any(), import_zod.z.any()]), import_zod.z.boolean())).or(import_zod.z.boolean()).optional(),
-  excludeAssets: import_zod.z.array(
-    import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any()]), import_zod.z.boolean()))
-  ).or(import_zod.z.string()).or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function(import_zod.z.tuple([import_zod.z.string(), import_zod.z.any()]), import_zod.z.boolean())).optional(),
-  modulesSort: import_zod.z.string().optional(),
-  chunkModulesSort: import_zod.z.string().optional(),
-  nestedModulesSort: import_zod.z.string().optional(),
-  chunksSort: import_zod.z.string().optional(),
-  assetsSort: import_zod.z.string().optional(),
-  performance: import_zod.z.boolean().optional(),
-  env: import_zod.z.boolean().optional(),
-  chunkGroupAuxiliary: import_zod.z.boolean().optional(),
-  chunkGroupChildren: import_zod.z.boolean().optional(),
-  chunkGroupMaxAssets: import_zod.z.number().optional(),
-  dependentModules: import_zod.z.boolean().optional(),
-  chunkOrigins: import_zod.z.boolean().optional(),
-  runtime: import_zod.z.boolean().optional(),
-  depth: import_zod.z.boolean().optional(),
-  reasonsSpace: import_zod.z.number().optional(),
-  groupReasonsByOrigin: import_zod.z.boolean().optional(),
-  errorDetails: import_zod.z.boolean().optional(),
-  errorStack: import_zod.z.boolean().optional(),
-  moduleTrace: import_zod.z.boolean().optional(),
-  cachedModules: import_zod.z.boolean().optional(),
-  cachedAssets: import_zod.z.boolean().optional(),
-  cached: import_zod.z.boolean().optional(),
-  errorsSpace: import_zod.z.number().optional(),
-  warningsSpace: import_zod.z.number().optional()
+var statsOptions = import_zod2.z.strictObject({
+  all: import_zod2.z.boolean().optional(),
+  preset: import_zod2.z.boolean().or(statsPresets).optional(),
+  assets: import_zod2.z.boolean().optional(),
+  chunks: import_zod2.z.boolean().optional(),
+  modules: import_zod2.z.boolean().optional(),
+  entrypoints: import_zod2.z.boolean().or(import_zod2.z.literal("auto")).optional(),
+  chunkGroups: import_zod2.z.boolean().optional(),
+  warnings: import_zod2.z.boolean().optional(),
+  warningsCount: import_zod2.z.boolean().optional(),
+  errors: import_zod2.z.boolean().optional(),
+  errorsCount: import_zod2.z.boolean().optional(),
+  colors: import_zod2.z.boolean().optional(),
+  hash: import_zod2.z.boolean().optional(),
+  version: import_zod2.z.boolean().optional(),
+  reasons: import_zod2.z.boolean().optional(),
+  publicPath: import_zod2.z.boolean().optional(),
+  outputPath: import_zod2.z.boolean().optional(),
+  chunkModules: import_zod2.z.boolean().optional(),
+  chunkRelations: import_zod2.z.boolean().optional(),
+  ids: import_zod2.z.boolean().optional(),
+  timings: import_zod2.z.boolean().optional(),
+  builtAt: import_zod2.z.boolean().optional(),
+  moduleAssets: import_zod2.z.boolean().optional(),
+  nestedModules: import_zod2.z.boolean().optional(),
+  source: import_zod2.z.boolean().optional(),
+  logging: import_zod2.z.enum(["none", "error", "warn", "info", "log", "verbose"]).or(import_zod2.z.boolean()).optional(),
+  loggingDebug: import_zod2.z.boolean().or(filterTypes).optional(),
+  loggingTrace: import_zod2.z.boolean().optional(),
+  runtimeModules: import_zod2.z.boolean().optional(),
+  children: import_zod2.z.boolean().optional(),
+  usedExports: import_zod2.z.boolean().optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  optimizationBailout: import_zod2.z.boolean().optional(),
+  groupModulesByType: import_zod2.z.boolean().optional(),
+  groupModulesByCacheStatus: import_zod2.z.boolean().optional(),
+  groupModulesByLayer: import_zod2.z.boolean().optional(),
+  groupModulesByAttributes: import_zod2.z.boolean().optional(),
+  groupModulesByPath: import_zod2.z.boolean().optional(),
+  groupModulesByExtension: import_zod2.z.boolean().optional(),
+  modulesSpace: import_zod2.z.number().optional(),
+  chunkModulesSpace: import_zod2.z.number().optional(),
+  nestedModulesSpace: import_zod2.z.number().optional(),
+  relatedAssets: import_zod2.z.boolean().optional(),
+  groupAssetsByEmitStatus: import_zod2.z.boolean().optional(),
+  groupAssetsByInfo: import_zod2.z.boolean().optional(),
+  groupAssetsByPath: import_zod2.z.boolean().optional(),
+  groupAssetsByExtension: import_zod2.z.boolean().optional(),
+  groupAssetsByChunk: import_zod2.z.boolean().optional(),
+  assetsSpace: import_zod2.z.number().optional(),
+  orphanModules: import_zod2.z.boolean().optional(),
+  excludeModules: import_zod2.z.array(
+    import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any(), import_zod2.z.any()]), import_zod2.z.boolean()))
+  ).or(import_zod2.z.string()).or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any(), import_zod2.z.any()]), import_zod2.z.boolean())).or(import_zod2.z.boolean()).optional(),
+  excludeAssets: import_zod2.z.array(
+    import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any()]), import_zod2.z.boolean()))
+  ).or(import_zod2.z.string()).or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.function(import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.any()]), import_zod2.z.boolean())).optional(),
+  modulesSort: import_zod2.z.string().optional(),
+  chunkModulesSort: import_zod2.z.string().optional(),
+  nestedModulesSort: import_zod2.z.string().optional(),
+  chunksSort: import_zod2.z.string().optional(),
+  assetsSort: import_zod2.z.string().optional(),
+  performance: import_zod2.z.boolean().optional(),
+  env: import_zod2.z.boolean().optional(),
+  chunkGroupAuxiliary: import_zod2.z.boolean().optional(),
+  chunkGroupChildren: import_zod2.z.boolean().optional(),
+  chunkGroupMaxAssets: import_zod2.z.number().optional(),
+  dependentModules: import_zod2.z.boolean().optional(),
+  chunkOrigins: import_zod2.z.boolean().optional(),
+  runtime: import_zod2.z.boolean().optional(),
+  depth: import_zod2.z.boolean().optional(),
+  reasonsSpace: import_zod2.z.number().optional(),
+  groupReasonsByOrigin: import_zod2.z.boolean().optional(),
+  errorDetails: import_zod2.z.boolean().optional(),
+  errorStack: import_zod2.z.boolean().optional(),
+  moduleTrace: import_zod2.z.boolean().optional(),
+  cachedModules: import_zod2.z.boolean().optional(),
+  cachedAssets: import_zod2.z.boolean().optional(),
+  cached: import_zod2.z.boolean().optional(),
+  errorsSpace: import_zod2.z.number().optional(),
+  warningsSpace: import_zod2.z.number().optional()
 });
-var statsValue = import_zod.z.boolean().or(statsPresets).or(statsOptions);
-var plugin = import_zod.z.union([
-  import_zod.z.custom(),
+var statsValue = import_zod2.z.boolean().or(statsPresets).or(statsOptions);
+var plugin = import_zod2.z.union([
+  import_zod2.z.custom(),
   falsy
 ]);
 var plugins = plugin.array();
-var optimizationRuntimeChunk = import_zod.z.enum(["single", "multiple"]).or(import_zod.z.boolean()).or(
-  import_zod.z.strictObject({
-    name: import_zod.z.string().or(
-      import_zod.z.function().args(import_zod.z.strictObject({ name: import_zod.z.string() })).returns(import_zod.z.string())
+var optimizationRuntimeChunk = import_zod2.z.enum(["single", "multiple"]).or(import_zod2.z.boolean()).or(
+  import_zod2.z.strictObject({
+    name: import_zod2.z.string().or(
+      import_zod2.z.function().args(import_zod2.z.strictObject({ name: import_zod2.z.string() })).returns(import_zod2.z.string())
     ).optional()
   })
 );
-var optimizationSplitChunksNameFunction = import_zod.z.function().args(
-  import_zod.z.instanceof(Module).optional()
+var optimizationSplitChunksNameFunction = import_zod2.z.function().args(
+  import_zod2.z.instanceof(Module).optional()
   // FIXME: z.array(z.instanceof(Chunk)).optional(), z.string()
   // FIXME: Chunk[],   															cacheChunkKey
 );
-var optimizationSplitChunksName = import_zod.z.string().or(import_zod.z.literal(false)).or(optimizationSplitChunksNameFunction);
-var optimizationSplitChunksChunks = import_zod.z.enum(["initial", "async", "all"]).or(import_zod.z.instanceof(RegExp)).or(
-  import_zod.z.function().args(import_zod.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod.z.boolean())
+var optimizationSplitChunksName = import_zod2.z.string().or(import_zod2.z.literal(false)).or(optimizationSplitChunksNameFunction);
+var optimizationSplitChunksChunks = import_zod2.z.enum(["initial", "async", "all"]).or(import_zod2.z.instanceof(RegExp)).or(
+  import_zod2.z.function().args(import_zod2.z.instanceof(Chunk, { message: "Input not instance of Chunk" })).returns(import_zod2.z.boolean())
 );
-var optimizationSplitChunksSizes = import_zod.z.number().or(import_zod.z.record(import_zod.z.number()));
-var optimizationSplitChunksDefaultSizeTypes = import_zod.z.array(import_zod.z.string());
+var optimizationSplitChunksSizes = import_zod2.z.number().or(import_zod2.z.record(import_zod2.z.number()));
+var optimizationSplitChunksDefaultSizeTypes = import_zod2.z.array(import_zod2.z.string());
 var sharedOptimizationSplitChunksCacheGroup = {
   chunks: optimizationSplitChunksChunks.optional(),
   defaultSizeTypes: optimizationSplitChunksDefaultSizeTypes.optional(),
-  minChunks: import_zod.z.number().min(1).optional(),
-  usedExports: import_zod.z.boolean().optional(),
+  minChunks: import_zod2.z.number().min(1).optional(),
+  usedExports: import_zod2.z.boolean().optional(),
   name: optimizationSplitChunksName.optional(),
   minSize: optimizationSplitChunksSizes.optional(),
   maxSize: optimizationSplitChunksSizes.optional(),
   maxAsyncSize: optimizationSplitChunksSizes.optional(),
   maxInitialSize: optimizationSplitChunksSizes.optional(),
-  maxAsyncRequests: import_zod.z.number().optional(),
-  maxInitialRequests: import_zod.z.number().optional(),
-  automaticNameDelimiter: import_zod.z.string().optional()
-};
-var optimizationSplitChunksCacheGroup = import_zod.z.strictObject({
-  test: import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(
-    import_zod.z.function().args(
-      import_zod.z.instanceof(Module)
+  maxAsyncRequests: import_zod2.z.number().optional(),
+  maxInitialRequests: import_zod2.z.number().optional(),
+  automaticNameDelimiter: import_zod2.z.string().optional()
+};
+var optimizationSplitChunksCacheGroup = import_zod2.z.strictObject({
+  test: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).or(
+    import_zod2.z.function().args(
+      import_zod2.z.instanceof(Module)
       /** FIXME: lack of CacheGroupContext */
     )
   ).optional(),
-  priority: import_zod.z.number().optional(),
-  enforce: import_zod.z.boolean().optional(),
-  filename: import_zod.z.string().optional(),
-  reuseExistingChunk: import_zod.z.boolean().optional(),
-  type: import_zod.z.string().or(import_zod.z.instanceof(RegExp)).optional(),
-  idHint: import_zod.z.string().optional(),
+  priority: import_zod2.z.number().optional(),
+  enforce: import_zod2.z.boolean().optional(),
+  filename: import_zod2.z.string().optional(),
+  reuseExistingChunk: import_zod2.z.boolean().optional(),
+  type: import_zod2.z.string().or(import_zod2.z.instanceof(RegExp)).optional(),
+  idHint: import_zod2.z.string().optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimizationSplitChunksOptions = import_zod.z.strictObject({
-  cacheGroups: import_zod.z.record(import_zod.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
-  fallbackCacheGroup: import_zod.z.strictObject({
+var optimizationSplitChunksOptions = import_zod2.z.strictObject({
+  cacheGroups: import_zod2.z.record(import_zod2.z.literal(false).or(optimizationSplitChunksCacheGroup)).optional(),
+  fallbackCacheGroup: import_zod2.z.strictObject({
     chunks: optimizationSplitChunksChunks.optional(),
-    minSize: import_zod.z.number().optional(),
-    maxSize: import_zod.z.number().optional(),
-    maxAsyncSize: import_zod.z.number().optional(),
-    maxInitialSize: import_zod.z.number().optional(),
-    automaticNameDelimiter: import_zod.z.string().optional()
+    minSize: import_zod2.z.number().optional(),
+    maxSize: import_zod2.z.number().optional(),
+    maxAsyncSize: import_zod2.z.number().optional(),
+    maxInitialSize: import_zod2.z.number().optional(),
+    automaticNameDelimiter: import_zod2.z.string().optional()
   }).optional(),
-  hidePathInfo: import_zod.z.boolean().optional(),
+  hidePathInfo: import_zod2.z.boolean().optional(),
   ...sharedOptimizationSplitChunksCacheGroup
 });
-var optimization = import_zod.z.strictObject({
-  moduleIds: import_zod.z.enum(["named", "natural", "deterministic"]).optional(),
-  chunkIds: import_zod.z.enum(["natural", "named", "deterministic"]).optional(),
-  minimize: import_zod.z.boolean().optional(),
-  minimizer: import_zod.z.literal("...").or(plugin).array().optional(),
-  mergeDuplicateChunks: import_zod.z.boolean().optional(),
-  splitChunks: import_zod.z.literal(false).or(optimizationSplitChunksOptions).optional(),
+var optimization = import_zod2.z.strictObject({
+  moduleIds: import_zod2.z.enum(["named", "natural", "deterministic"]).optional(),
+  chunkIds: import_zod2.z.enum(["natural", "named", "deterministic"]).optional(),
+  minimize: import_zod2.z.boolean().optional(),
+  minimizer: import_zod2.z.literal("...").or(plugin).array().optional(),
+  mergeDuplicateChunks: import_zod2.z.boolean().optional(),
+  splitChunks: import_zod2.z.literal(false).or(optimizationSplitChunksOptions).optional(),
   runtimeChunk: optimizationRuntimeChunk.optional(),
-  removeAvailableModules: import_zod.z.boolean().optional(),
-  removeEmptyChunks: import_zod.z.boolean().optional(),
-  realContentHash: import_zod.z.boolean().optional(),
-  sideEffects: import_zod.z.enum(["flag"]).or(import_zod.z.boolean()).optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  concatenateModules: import_zod.z.boolean().optional(),
-  innerGraph: import_zod.z.boolean().optional(),
-  usedExports: import_zod.z.enum(["global"]).or(import_zod.z.boolean()).optional(),
-  mangleExports: import_zod.z.enum(["size", "deterministic"]).or(import_zod.z.boolean()).optional(),
-  nodeEnv: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
-  emitOnErrors: import_zod.z.boolean().optional()
+  removeAvailableModules: import_zod2.z.boolean().optional(),
+  removeEmptyChunks: import_zod2.z.boolean().optional(),
+  realContentHash: import_zod2.z.boolean().optional(),
+  sideEffects: import_zod2.z.enum(["flag"]).or(import_zod2.z.boolean()).optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  concatenateModules: import_zod2.z.boolean().optional(),
+  innerGraph: import_zod2.z.boolean().optional(),
+  usedExports: import_zod2.z.enum(["global"]).or(import_zod2.z.boolean()).optional(),
+  mangleExports: import_zod2.z.enum(["size", "deterministic"]).or(import_zod2.z.boolean()).optional(),
+  nodeEnv: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.literal(false)]).optional(),
+  emitOnErrors: import_zod2.z.boolean().optional()
 });
-var rspackFutureOptions = import_zod.z.strictObject({
-  bundlerInfo: import_zod.z.strictObject({
-    version: import_zod.z.string().optional(),
-    bundler: import_zod.z.string().optional(),
-    force: import_zod.z.boolean().or(import_zod.z.array(import_zod.z.enum(["version", "uniqueId"]))).optional()
+var rspackFutureOptions = import_zod2.z.strictObject({
+  bundlerInfo: import_zod2.z.strictObject({
+    version: import_zod2.z.string().optional(),
+    bundler: import_zod2.z.string().optional(),
+    force: import_zod2.z.boolean().or(import_zod2.z.array(import_zod2.z.enum(["version", "uniqueId"]))).optional()
   }).optional()
 });
-var listenOptions = import_zod.z.object({
-  port: import_zod.z.number().optional(),
-  host: import_zod.z.string().optional(),
-  backlog: import_zod.z.number().optional(),
-  path: import_zod.z.string().optional(),
-  exclusive: import_zod.z.boolean().optional(),
-  readableAll: import_zod.z.boolean().optional(),
-  writableAll: import_zod.z.boolean().optional(),
-  ipv6Only: import_zod.z.boolean().optional()
+var listenOptions = import_zod2.z.object({
+  port: import_zod2.z.number().optional(),
+  host: import_zod2.z.string().optional(),
+  backlog: import_zod2.z.number().optional(),
+  path: import_zod2.z.string().optional(),
+  exclusive: import_zod2.z.boolean().optional(),
+  readableAll: import_zod2.z.boolean().optional(),
+  writableAll: import_zod2.z.boolean().optional(),
+  ipv6Only: import_zod2.z.boolean().optional()
 });
-var lazyCompilationOptions = import_zod.z.object({
-  backend: import_zod.z.object({
-    client: import_zod.z.string().optional(),
-    listen: import_zod.z.number().optional().or(listenOptions),
-    protocol: import_zod.z.enum(["http", "https"]).optional()
+var lazyCompilationOptions = import_zod2.z.object({
+  backend: import_zod2.z.object({
+    client: import_zod2.z.string().optional(),
+    listen: import_zod2.z.number().optional().or(listenOptions),
+    protocol: import_zod2.z.enum(["http", "https"]).optional()
   }).optional(),
-  imports: import_zod.z.boolean().optional(),
-  entries: import_zod.z.boolean().optional(),
-  test: import_zod.z.instanceof(RegExp).or(import_zod.z.function().args(import_zod.z.custom()).returns(import_zod.z.boolean())).optional()
+  imports: import_zod2.z.boolean().optional(),
+  entries: import_zod2.z.boolean().optional(),
+  test: import_zod2.z.instanceof(RegExp).or(import_zod2.z.function().args(import_zod2.z.custom()).returns(import_zod2.z.boolean())).optional()
 });
-var incremental = import_zod.z.strictObject({
-  make: import_zod.z.boolean().optional(),
-  emitAssets: import_zod.z.boolean().optional(),
-  inferAsyncModules: import_zod.z.boolean().optional(),
-  providedExports: import_zod.z.boolean().optional(),
-  dependenciesDiagnostics: import_zod.z.boolean().optional(),
-  modulesHashes: import_zod.z.boolean().optional(),
-  modulesCodegen: import_zod.z.boolean().optional(),
-  modulesRuntimeRequirements: import_zod.z.boolean().optional(),
-  buildChunkGraph: import_zod.z.boolean().optional()
+var incremental = import_zod2.z.strictObject({
+  make: import_zod2.z.boolean().optional(),
+  emitAssets: import_zod2.z.boolean().optional(),
+  inferAsyncModules: import_zod2.z.boolean().optional(),
+  providedExports: import_zod2.z.boolean().optional(),
+  dependenciesDiagnostics: import_zod2.z.boolean().optional(),
+  modulesHashes: import_zod2.z.boolean().optional(),
+  modulesCodegen: import_zod2.z.boolean().optional(),
+  modulesRuntimeRequirements: import_zod2.z.boolean().optional(),
+  buildChunkGraph: import_zod2.z.boolean().optional()
 });
-var experiments = import_zod.z.strictObject({
-  lazyCompilation: import_zod.z.boolean().optional().or(lazyCompilationOptions),
-  asyncWebAssembly: import_zod.z.boolean().optional(),
-  outputModule: import_zod.z.boolean().optional(),
-  topLevelAwait: import_zod.z.boolean().optional(),
-  css: import_zod.z.boolean().optional(),
-  layers: import_zod.z.boolean().optional(),
-  incremental: import_zod.z.boolean().or(incremental).optional(),
-  futureDefaults: import_zod.z.boolean().optional(),
+var experiments = import_zod2.z.strictObject({
+  lazyCompilation: import_zod2.z.boolean().optional().or(lazyCompilationOptions),
+  asyncWebAssembly: import_zod2.z.boolean().optional(),
+  outputModule: import_zod2.z.boolean().optional(),
+  topLevelAwait: import_zod2.z.boolean().optional(),
+  css: import_zod2.z.boolean().optional(),
+  layers: import_zod2.z.boolean().optional(),
+  incremental: import_zod2.z.boolean().or(incremental).optional(),
+  futureDefaults: import_zod2.z.boolean().optional(),
   rspackFuture: rspackFutureOptions.optional()
 });
-var watch = import_zod.z.boolean();
-var watchOptions = import_zod.z.strictObject({
-  aggregateTimeout: import_zod.z.number().optional(),
-  followSymlinks: import_zod.z.boolean().optional(),
-  ignored: import_zod.z.string().array().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.string()).optional(),
-  poll: import_zod.z.number().or(import_zod.z.boolean()).optional(),
-  stdin: import_zod.z.boolean().optional()
+var watch = import_zod2.z.boolean();
+var watchOptions = import_zod2.z.strictObject({
+  aggregateTimeout: import_zod2.z.number().optional(),
+  followSymlinks: import_zod2.z.boolean().optional(),
+  ignored: import_zod2.z.string().array().or(import_zod2.z.instanceof(RegExp)).or(import_zod2.z.string()).optional(),
+  poll: import_zod2.z.number().or(import_zod2.z.boolean()).optional(),
+  stdin: import_zod2.z.boolean().optional()
 });
-var devServer = import_zod.z.custom();
-var ignoreWarnings = import_zod.z.instanceof(RegExp).or(
-  import_zod.z.function().args(import_zod.z.instanceof(Error), import_zod.z.custom()).returns(import_zod.z.boolean())
+var devServer = import_zod2.z.custom();
+var ignoreWarnings = import_zod2.z.instanceof(RegExp).or(
+  import_zod2.z.function().args(import_zod2.z.instanceof(Error), import_zod2.z.custom()).returns(import_zod2.z.boolean())
 ).array();
-var profile = import_zod.z.boolean();
-var bail = import_zod.z.boolean();
-var performance = import_zod.z.strictObject({
-  assetFilter: import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()).optional(),
-  hints: import_zod.z.enum(["error", "warning"]).or(import_zod.z.literal(false)).optional(),
-  maxAssetSize: import_zod.z.number().optional(),
-  maxEntrypointSize: import_zod.z.number().optional()
-}).or(import_zod.z.literal(false));
-var rspackOptions = import_zod.z.strictObject({
+var profile = import_zod2.z.boolean();
+var bail = import_zod2.z.boolean();
+var performance = import_zod2.z.strictObject({
+  assetFilter: import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.boolean()).optional(),
+  hints: import_zod2.z.enum(["error", "warning"]).or(import_zod2.z.literal(false)).optional(),
+  maxAssetSize: import_zod2.z.number().optional(),
+  maxEntrypointSize: import_zod2.z.number().optional()
+}).or(import_zod2.z.literal(false));
+var rspackOptions = import_zod2.z.strictObject({
   name: name.optional(),
   dependencies: dependencies.optional(),
   entry: entry.optional(),
@@ -10812,7 +10997,7 @@ var import_node_fs2 = __toESM(require("fs"));
 var import_node_path8 = __toESM(require("path"));
 var import_binding39 = require("@rspack/binding");
 var liteTapable3 = __toESM(require("@rspack/lite-tapable"));
-var import_zod2 = require("../compiled/zod/index.js");
+var import_zod3 = require("../compiled/zod/index.js");
 
 // ../../node_modules/.pnpm/zod-validation-error@3.4.0_zod@3.23.8/node_modules/zod-validation-error/dist/index.mjs
 var zod2 = __toESM(require("../compiled/zod/index.js"), 1);
@@ -11063,40 +11248,40 @@ function isValidate(opts, schema) {
 }
 
 // src/builtin-plugin/HtmlRspackPlugin.ts
-var templateRenderFunction = import_zod2.z.function().args(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())).returns(
-  import_zod2.z.string().or(import_zod2.z.promise(import_zod2.z.string()))
+var templateRenderFunction = import_zod3.z.function().args(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())).returns(
+  import_zod3.z.string().or(import_zod3.z.promise(import_zod3.z.string()))
 );
-var templateParamFunction = import_zod2.z.function().args(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())).returns(
-  import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any()).or(import_zod2.z.promise(import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any())))
+var templateParamFunction = import_zod3.z.function().args(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())).returns(
+  import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).or(import_zod3.z.promise(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any())))
 );
-var templateFilenameFunction = import_zod2.z.function().args(import_zod2.z.string()).returns(import_zod2.z.string());
-var htmlRspackPluginOptions = import_zod2.z.strictObject({
-  filename: import_zod2.z.string().or(templateFilenameFunction).optional(),
-  template: import_zod2.z.string().refine(
+var templateFilenameFunction = import_zod3.z.function().args(import_zod3.z.string()).returns(import_zod3.z.string());
+var htmlRspackPluginOptions = import_zod3.z.strictObject({
+  filename: import_zod3.z.string().or(templateFilenameFunction).optional(),
+  template: import_zod3.z.string().refine(
     (val) => !val.includes("!"),
     () => ({
       message: "HtmlRspackPlugin does not support template path with loader yet"
     })
   ).optional(),
-  templateContent: import_zod2.z.string().or(templateRenderFunction).optional(),
-  templateParameters: import_zod2.z.record(import_zod2.z.string()).or(import_zod2.z.boolean()).or(templateParamFunction).optional(),
-  inject: import_zod2.z.enum(["head", "body"]).or(import_zod2.z.boolean()).optional(),
-  publicPath: import_zod2.z.string().optional(),
-  base: import_zod2.z.string().or(
-    import_zod2.z.strictObject({
-      href: import_zod2.z.string().optional(),
-      target: import_zod2.z.enum(["_self", "_blank", "_parent", "_top"]).optional()
+  templateContent: import_zod3.z.string().or(templateRenderFunction).optional(),
+  templateParameters: import_zod3.z.record(import_zod3.z.string()).or(import_zod3.z.boolean()).or(templateParamFunction).optional(),
+  inject: import_zod3.z.enum(["head", "body"]).or(import_zod3.z.boolean()).optional(),
+  publicPath: import_zod3.z.string().optional(),
+  base: import_zod3.z.string().or(
+    import_zod3.z.strictObject({
+      href: import_zod3.z.string().optional(),
+      target: import_zod3.z.enum(["_self", "_blank", "_parent", "_top"]).optional()
     })
   ).optional(),
-  scriptLoading: import_zod2.z.enum(["blocking", "defer", "module", "systemjs-module"]).optional(),
-  chunks: import_zod2.z.string().array().optional(),
-  excludeChunks: import_zod2.z.string().array().optional(),
-  sri: import_zod2.z.enum(["sha256", "sha384", "sha512"]).optional(),
-  minify: import_zod2.z.boolean().optional(),
-  title: import_zod2.z.string().optional(),
-  favicon: import_zod2.z.string().optional(),
-  meta: import_zod2.z.record(import_zod2.z.string().or(import_zod2.z.record(import_zod2.z.string()))).optional(),
-  hash: import_zod2.z.boolean().optional()
+  scriptLoading: import_zod3.z.enum(["blocking", "defer", "module", "systemjs-module"]).optional(),
+  chunks: import_zod3.z.string().array().optional(),
+  excludeChunks: import_zod3.z.string().array().optional(),
+  sri: import_zod3.z.enum(["sha256", "sha384", "sha512"]).optional(),
+  minify: import_zod3.z.boolean().optional(),
+  title: import_zod3.z.string().optional(),
+  favicon: import_zod3.z.string().optional(),
+  meta: import_zod3.z.record(import_zod3.z.string().or(import_zod3.z.record(import_zod3.z.string()))).optional(),
+  hash: import_zod3.z.boolean().optional()
 });
 var HtmlRspackPluginImpl = create2(
   import_binding39.BuiltinPluginName.HtmlRspackPlugin,
@@ -11349,14 +11534,14 @@ var HttpExternalsRspackPlugin = create2(
 
 // src/builtin-plugin/IgnorePlugin.ts
 var import_binding41 = require("@rspack/binding");
-var import_zod3 = require("../compiled/zod/index.js");
-var IgnorePluginOptions = import_zod3.z.union([
-  import_zod3.z.object({
-    contextRegExp: import_zod3.z.instanceof(RegExp).optional(),
-    resourceRegExp: import_zod3.z.instanceof(RegExp)
+var import_zod4 = require("../compiled/zod/index.js");
+var IgnorePluginOptions = import_zod4.z.union([
+  import_zod4.z.object({
+    contextRegExp: import_zod4.z.instanceof(RegExp).optional(),
+    resourceRegExp: import_zod4.z.instanceof(RegExp)
   }),
-  import_zod3.z.object({
-    checkResource: import_zod3.z.function(import_zod3.z.tuple([import_zod3.z.string(), import_zod3.z.string()]), import_zod3.z.boolean())
+  import_zod4.z.object({
+    checkResource: import_zod4.z.function(import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]), import_zod4.z.boolean())
   })
 ]);
 var IgnorePlugin = create2(
@@ -12216,6 +12401,43 @@ var ContextReplacementPlugin = create2(
   }
 );
 
+// src/builtin-plugin/LibManifestPlugin.ts
+var import_binding76 = require("@rspack/binding");
+var LibManifestPlugin = create2(
+  import_binding76.BuiltinPluginName.LibManifestPlugin,
+  (options) => {
+    const { context: context2, entryOnly, format: format3, name: name2, path: path10, type } = options;
+    return {
+      context: context2,
+      entryOnly,
+      format: format3,
+      name: name2,
+      path: path10,
+      type
+    };
+  }
+);
+
+// src/builtin-plugin/DllEntryPlugin.ts
+var import_binding77 = require("@rspack/binding");
+var DllEntryPlugin = create2(
+  import_binding77.BuiltinPluginName.DllEntryPlugin,
+  (context2, entries, options) => {
+    return {
+      context: context2,
+      entries,
+      name: options.name
+    };
+  }
+);
+
+// src/builtin-plugin/DllReferenceAgencyPlugin.ts
+var import_binding78 = require("@rspack/binding");
+var DllReferenceAgencyPlugin = create2(
+  import_binding78.BuiltinPluginName.DllReferenceAgencyPlugin,
+  (options) => options
+);
+
 // src/ContextModuleFactory.ts
 var liteTapable5 = __toESM(require("@rspack/lite-tapable"));
 var ContextModuleFactory = class {
@@ -12937,6 +13159,9 @@ var Compiler = class _Compiler {
     this.watchMode = false;
     new JsLoaderRspackPlugin(this).apply(this);
     new ExecuteModulePlugin().apply(this);
+    this.hooks.shutdown.tap("rspack:cleanup", () => {
+      this.#instance = void 0;
+    });
   }
   get recordsInputPath() {
     return unsupported("Compiler.recordsInputPath");
@@ -13371,465 +13596,797 @@ var Compiler = class _Compiler {
       this.#ruleSet.builtinReferences.entries()
     );
     const instanceBinding = require("@rspack/binding");
+    const that = new WeakRef(this);
     this.#registers = {
       registerCompilerThisCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerThisCompilation,
-        () => this.hooks.thisCompilation,
-        (queried) => (native) => {
-          this.#createCompilation(native);
-          queried.call(this.#compilation, this.#compilationParams);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.thisCompilation;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(native) {
+            that.deref().#createCompilation(native);
+            return queried.call(
+              that.deref().#compilation,
+              that.deref().#compilationParams
+            );
+          };
         }
       ),
       registerCompilerCompilationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerCompilation,
-        () => this.hooks.compilation,
-        (queried) => () => queried.call(this.#compilation, this.#compilationParams)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.compilation;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(
+              that.deref().#compilation,
+              that.deref().#compilationParams
+            );
+          };
+        }
       ),
       registerCompilerMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerMake,
-        () => this.hooks.make,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.make;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerFinishMakeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerFinishMake,
-        () => this.hooks.finishMake,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.finishMake;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerShouldEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerShouldEmit,
-        () => this.hooks.shouldEmit,
-        (queried) => () => queried.call(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.shouldEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerEmit,
-        () => this.hooks.emit,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.emit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAfterEmit,
-        () => this.hooks.afterEmit,
-        (queried) => async () => await queried.promise(this.#compilation)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.afterEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation);
+          };
+        }
       ),
       registerCompilerAssetEmittedTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilerAssetEmitted,
-        () => this.hooks.assetEmitted,
-        (queried) => async ({
-          filename: filename2,
-          targetPath,
-          outputPath
-        }) => {
-          return queried.promise(filename2, {
-            compilation: this.#compilation,
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().hooks.assetEmitted;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function({
+            filename: filename2,
             targetPath,
-            outputPath,
-            get source() {
-              var _a;
-              return (_a = this.compilation.getAsset(filename2)) == null ? void 0 : _a.source;
-            },
-            get content() {
-              var _a;
-              return (_a = this.source) == null ? void 0 : _a.buffer();
-            }
-          });
+            outputPath
+          }) {
+            return queried.promise(filename2, {
+              compilation: that.deref().#compilation,
+              targetPath,
+              outputPath,
+              get source() {
+                var _a;
+                return (_a = that.deref().#compilation.getAsset(filename2)) == null ? void 0 : _a.source;
+              },
+              get content() {
+                var _a;
+                return (_a = this.source) == null ? void 0 : _a.buffer();
+              }
+            });
+          };
         }
       ),
       registerCompilationAdditionalTreeRuntimeRequirements: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAdditionalTreeRuntimeRequirements,
-        () => this.#compilation.hooks.additionalTreeRuntimeRequirements,
-        (queried) => ({
-          chunk,
-          runtimeRequirements
-        }) => {
-          const set = __from_binding_runtime_globals(runtimeRequirements);
-          queried.call(
-            Chunk.__from_binding(chunk, this.#compilation),
-            set
-          );
-          return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.additionalTreeRuntimeRequirements;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            chunk,
+            runtimeRequirements
+          }) {
+            const set = __from_binding_runtime_globals(runtimeRequirements);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              set
+            );
+            return {
+              runtimeRequirements: __to_binding_runtime_globals(set)
+            };
           };
         }
       ),
       registerCompilationRuntimeRequirementInTree: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeRequirementInTree,
-        () => this.#compilation.hooks.runtimeRequirementInTree,
-        (queried) => ({
-          chunk: rawChunk,
-          runtimeRequirements
-        }) => {
-          const set = __from_binding_runtime_globals(runtimeRequirements);
-          const chunk = Chunk.__from_binding(rawChunk, this.#compilation);
-          for (const r of set) {
-            queried.for(r).call(chunk, set);
-          }
-          return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.runtimeRequirementInTree;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            chunk: rawChunk,
+            runtimeRequirements
+          }) {
+            const set = __from_binding_runtime_globals(runtimeRequirements);
+            const chunk = Chunk.__from_binding(
+              rawChunk,
+              that.deref().#compilation
+            );
+            for (const r of set) {
+              queried.for(r).call(chunk, set);
+            }
+            return {
+              runtimeRequirements: __to_binding_runtime_globals(set)
+            };
           };
         }
       ),
       registerCompilationRuntimeModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationRuntimeModule,
-        () => this.#compilation.hooks.runtimeModule,
-        (queried) => ({ module: module2, chunk }) => {
-          var _a, _b;
-          const originSource = (_a = module2.source) == null ? void 0 : _a.source;
-          queried.call(
-            module2,
-            Chunk.__from_binding(chunk, this.#compilation)
-          );
-          const newSource = (_b = module2.source) == null ? void 0 : _b.source;
-          if (newSource && newSource !== originSource) {
-            return module2;
-          }
-          return;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.runtimeModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({ module: module2, chunk }) {
+            var _a, _b;
+            const originSource = (_a = module2.source) == null ? void 0 : _a.source;
+            queried.call(
+              module2,
+              Chunk.__from_binding(chunk, that.deref().#compilation)
+            );
+            const newSource = (_b = module2.source) == null ? void 0 : _b.source;
+            if (newSource && newSource !== originSource) {
+              return module2;
+            }
+            return;
+          };
         }
       ),
       registerCompilationBuildModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationBuildModule,
-        () => this.#compilation.hooks.buildModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.buildModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationStillValidModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationStillValidModule,
-        () => this.#compilation.hooks.stillValidModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.stillValidModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationSucceedModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSucceedModule,
-        () => this.#compilation.hooks.succeedModule,
-        (queired) => (m) => queired.call(Module.__from_binding(m, this.#compilation))
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.succeedModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(m) {
+            return queried.call(
+              Module.__from_binding(m, that.deref().#compilation)
+            );
+          };
+        }
       ),
       registerCompilationExecuteModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationExecuteModule,
-        () => this.#compilation.hooks.executeModule,
-        (queried) => ({
-          entry: entry2,
-          id,
-          codegenResults,
-          runtimeModules
-        }) => {
-          const __webpack_require__ = (id2) => {
-            const cached = moduleCache[id2];
-            if (cached !== void 0) {
-              if (cached.error) throw cached.error;
-              return cached.exports;
-            }
-            const execOptions = {
-              id: id2,
-              module: {
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.executeModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({
+            entry: entry2,
+            id,
+            codegenResults,
+            runtimeModules
+          }) {
+            const __webpack_require__ = (id2) => {
+              const cached = moduleCache[id2];
+              if (cached !== void 0) {
+                if (cached.error) throw cached.error;
+                return cached.exports;
+              }
+              const execOptions = {
                 id: id2,
-                exports: {},
-                loaded: false,
-                error: void 0
-              },
-              require: __webpack_require__
+                module: {
+                  id: id2,
+                  exports: {},
+                  loaded: false,
+                  error: void 0
+                },
+                require: __webpack_require__
+              };
+              for (const handler of interceptModuleExecution) {
+                handler(execOptions);
+              }
+              const result2 = codegenResults.map[id2]["build time"];
+              const moduleObject = execOptions.module;
+              if (id2) moduleCache[id2] = moduleObject;
+              tryRunOrWebpackError(
+                () => queried.call(
+                  {
+                    codeGenerationResult: new CodeGenerationResult(result2),
+                    moduleObject
+                  },
+                  { __webpack_require__ }
+                ),
+                "Compilation.hooks.executeModule"
+              );
+              moduleObject.loaded = true;
+              return moduleObject.exports;
             };
-            for (const handler of interceptModuleExecution) {
-              handler(execOptions);
+            const moduleCache = __webpack_require__[RuntimeGlobals.moduleCache.replace(
+              `${RuntimeGlobals.require}.`,
+              ""
+            )] = {};
+            const interceptModuleExecution = __webpack_require__[RuntimeGlobals.interceptModuleExecution.replace(
+              `${RuntimeGlobals.require}.`,
+              ""
+            )] = [];
+            for (const runtimeModule of runtimeModules) {
+              __webpack_require__(runtimeModule);
             }
-            const result2 = codegenResults.map[id2]["build time"];
-            const moduleObject = execOptions.module;
-            if (id2) moduleCache[id2] = moduleObject;
-            tryRunOrWebpackError(
-              () => queried.call(
-                {
-                  codeGenerationResult: new CodeGenerationResult(result2),
-                  moduleObject
-                },
-                { __webpack_require__ }
-              ),
-              "Compilation.hooks.executeModule"
-            );
-            moduleObject.loaded = true;
-            return moduleObject.exports;
+            const executeResult = __webpack_require__(entry2);
+            that.deref().#moduleExecutionResultsMap.set(id, executeResult);
           };
-          const moduleCache = __webpack_require__[RuntimeGlobals.moduleCache.replace(
-            `${RuntimeGlobals.require}.`,
-            ""
-          )] = {};
-          const interceptModuleExecution = __webpack_require__[RuntimeGlobals.interceptModuleExecution.replace(
-            `${RuntimeGlobals.require}.`,
-            ""
-          )] = [];
-          for (const runtimeModule of runtimeModules) {
-            __webpack_require__(runtimeModule);
-          }
-          const executeResult = __webpack_require__(entry2);
-          this.#moduleExecutionResultsMap.set(id, executeResult);
         }
       ),
       registerCompilationFinishModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationFinishModules,
-        () => this.#compilation.hooks.finishModules,
-        (queried) => async () => await queried.promise(this.#compilation.modules)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.finishModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation.modules);
+          };
+        }
       ),
       registerCompilationOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeModules,
-        () => this.#compilation.hooks.optimizeModules,
-        (queried) => () => queried.call(this.#compilation.modules.values())
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation.modules.values());
+          };
+        }
       ),
       registerCompilationAfterOptimizeModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterOptimizeModules,
-        () => this.#compilation.hooks.afterOptimizeModules,
-        (queried) => () => {
-          queried.call(this.#compilation.modules.values());
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterOptimizeModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            queried.call(that.deref().#compilation.modules.values());
+          };
         }
       ),
       registerCompilationOptimizeTreeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeTree,
-        () => this.#compilation.hooks.optimizeTree,
-        (queried) => async () => await queried.promise(
-          this.#compilation.chunks,
-          this.#compilation.modules
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeTree;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(
+              that.deref().#compilation.chunks,
+              that.deref().#compilation.modules
+            );
+          };
+        }
       ),
       registerCompilationOptimizeChunkModulesTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationOptimizeChunkModules,
-        () => this.#compilation.hooks.optimizeChunkModules,
-        (queried) => async () => await queried.promise(
-          this.#compilation.chunks,
-          this.#compilation.modules
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.optimizeChunkModules;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(
+              that.deref().#compilation.chunks,
+              that.deref().#compilation.modules
+            );
+          };
+        }
       ),
       registerCompilationChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkHash,
-        () => this.#compilation.hooks.chunkHash,
-        (queried) => (chunk) => {
-          if (!this.options.output.hashFunction) {
-            throw new Error("'output.hashFunction' cannot be undefined");
-          }
-          const hash = createHash(this.options.output.hashFunction);
-          queried.call(Chunk.__from_binding(chunk, this.#compilation), hash);
-          const digestResult = hash.digest(this.options.output.hashDigest);
-          return Buffer.from(digestResult);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.chunkHash;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(chunk) {
+            if (!that.deref().options.output.hashFunction) {
+              throw new Error("'output.hashFunction' cannot be undefined");
+            }
+            const hash = createHash(that.deref().options.output.hashFunction);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              hash
+            );
+            const digestResult = hash.digest(
+              that.deref().options.output.hashDigest
+            );
+            return Buffer.from(digestResult);
+          };
         }
       ),
       registerCompilationChunkAssetTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationChunkAsset,
-        () => this.#compilation.hooks.chunkAsset,
-        (queried) => ({ chunk, filename: filename2 }) => queried.call(
-          Chunk.__from_binding(chunk, this.#compilation),
-          filename2
-        )
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.chunkAsset;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function({ chunk, filename: filename2 }) {
+            return queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              filename2
+            );
+          };
+        }
       ),
       registerCompilationProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationProcessAssets,
-        () => this.#compilation.hooks.processAssets,
-        (queried) => async () => await queried.promise(this.#compilation.assets)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.processAssets;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise(that.deref().#compilation.assets);
+          };
+        }
       ),
       registerCompilationAfterProcessAssetsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterProcessAssets,
-        () => this.#compilation.hooks.afterProcessAssets,
-        (queried) => () => queried.call(this.#compilation.assets)
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterProcessAssets;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call(that.deref().#compilation.assets);
+          };
+        }
       ),
       registerCompilationSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationSeal,
-        () => this.#compilation.hooks.seal,
-        (queried) => () => queried.call()
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.seal;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function() {
+            return queried.call();
+          };
+        }
       ),
       registerCompilationAfterSealTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.CompilationAfterSeal,
-        () => this.#compilation.hooks.afterSeal,
-        (queried) => async () => await queried.promise()
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilation.hooks.afterSeal;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function() {
+            return await queried.promise();
+          };
+        }
       ),
       registerNormalModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryBeforeResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.beforeResolve,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.beforeResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            const ret = await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return [ret, resolveData];
           };
-          const ret = await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return [ret, resolveData];
         }
       ),
       registerNormalModuleFactoryFactorizeTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryFactorize,
-        () => this.#compilationParams.normalModuleFactory.hooks.factorize,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.factorize;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
           };
-          await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return resolveData;
         }
       ),
       registerNormalModuleFactoryResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.resolve,
-        (queried) => async (resolveData) => {
-          const normalizedResolveData = {
-            contextInfo: {
-              issuer: resolveData.issuer
-            },
-            request: resolveData.request,
-            context: resolveData.context,
-            fileDependencies: [],
-            missingDependencies: [],
-            contextDependencies: []
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.resolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(resolveData) {
+            const normalizedResolveData = {
+              contextInfo: {
+                issuer: resolveData.issuer
+              },
+              request: resolveData.request,
+              context: resolveData.context,
+              fileDependencies: [],
+              missingDependencies: [],
+              contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
           };
-          await queried.promise(normalizedResolveData);
-          resolveData.request = normalizedResolveData.request;
-          resolveData.context = normalizedResolveData.context;
-          return resolveData;
         }
       ),
       registerNormalModuleFactoryResolveForSchemeTaps: this.#createHookMapRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryResolveForScheme,
-        () => this.#compilationParams.normalModuleFactory.hooks.resolveForScheme,
-        (queried) => async (args) => {
-          const ret = await queried.for(args.scheme).promise(args.resourceData);
-          return [ret, args.resourceData];
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.resolveForScheme;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(args) {
+            const ret = await queried.for(args.scheme).promise(args.resourceData);
+            return [ret, args.resourceData];
+          };
         }
       ),
       registerNormalModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryAfterResolve,
-        () => this.#compilationParams.normalModuleFactory.hooks.afterResolve,
-        (queried) => async (arg) => {
-          const data = {
-            contextInfo: {
-              issuer: arg.issuer
-            },
-            request: arg.request,
-            context: arg.context,
-            fileDependencies: arg.fileDependencies,
-            missingDependencies: arg.missingDependencies,
-            contextDependencies: arg.contextDependencies,
-            createData: arg.createData
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.afterResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(arg) {
+            const data = {
+              contextInfo: {
+                issuer: arg.issuer
+              },
+              request: arg.request,
+              context: arg.context,
+              fileDependencies: arg.fileDependencies,
+              missingDependencies: arg.missingDependencies,
+              contextDependencies: arg.contextDependencies,
+              createData: arg.createData
+            };
+            const ret = await queried.promise(data);
+            return [ret, data.createData];
           };
-          const ret = await queried.promise(data);
-          return [ret, data.createData];
         }
       ),
       registerNormalModuleFactoryCreateModuleTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.NormalModuleFactoryCreateModule,
-        () => this.#compilationParams.normalModuleFactory.hooks.createModule,
-        (queried) => async (args) => {
-          const data = {
-            ...args,
-            settings: {}
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.normalModuleFactory.hooks.createModule;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(args) {
+            const data = {
+              ...args,
+              settings: {}
+            };
+            await queried.promise(data, {});
           };
-          await queried.promise(data, {});
         }
       ),
       registerContextModuleFactoryBeforeResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryBeforeResolve,
-        () => this.#compilationParams.contextModuleFactory.hooks.beforeResolve,
-        (queried) => async (bindingData) => {
-          const data = bindingData ? ContextModuleFactoryBeforeResolveData.__from_binding(
-            bindingData
-          ) : false;
-          const result2 = await queried.promise(data);
-          return result2 ? ContextModuleFactoryBeforeResolveData.__to_binding(result2) : false;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.contextModuleFactory.hooks.beforeResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(bindingData) {
+            const data = bindingData ? ContextModuleFactoryBeforeResolveData.__from_binding(
+              bindingData
+            ) : false;
+            const result2 = await queried.promise(data);
+            return result2 ? ContextModuleFactoryBeforeResolveData.__to_binding(result2) : false;
+          };
         }
       ),
       registerContextModuleFactoryAfterResolveTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.ContextModuleFactoryAfterResolve,
-        () => this.#compilationParams.contextModuleFactory.hooks.afterResolve,
-        (queried) => async (bindingData) => {
-          const data = bindingData ? ContextModuleFactoryAfterResolveData.__from_binding(
-            bindingData
-          ) : false;
-          const result2 = await queried.promise(data);
-          return result2 ? ContextModuleFactoryAfterResolveData.__to_binding(result2) : false;
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return that.deref().#compilationParams.contextModuleFactory.hooks.afterResolve;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(bindingData) {
+            const data = bindingData ? ContextModuleFactoryAfterResolveData.__from_binding(
+              bindingData
+            ) : false;
+            const result2 = await queried.promise(data);
+            return result2 ? ContextModuleFactoryAfterResolveData.__to_binding(result2) : false;
+          };
         }
       ),
       registerJavascriptModulesChunkHashTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.JavascriptModulesChunkHash,
-        () => JavascriptModulesPlugin.getCompilationHooks(this.#compilation).chunkHash,
-        (queried) => (chunk) => {
-          if (!this.options.output.hashFunction) {
-            throw new Error("'output.hashFunction' cannot be undefined");
-          }
-          const hash = createHash(this.options.output.hashFunction);
-          queried.call(Chunk.__from_binding(chunk, this.#compilation), hash);
-          const digestResult = hash.digest(this.options.output.hashDigest);
-          return Buffer.from(digestResult);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return JavascriptModulesPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).chunkHash;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return function(chunk) {
+            if (!that.deref().options.output.hashFunction) {
+              throw new Error("'output.hashFunction' cannot be undefined");
+            }
+            const hash = createHash(that.deref().options.output.hashFunction);
+            queried.call(
+              Chunk.__from_binding(chunk, that.deref().#compilation),
+              hash
+            );
+            const digestResult = hash.digest(
+              that.deref().options.output.hashDigest
+            );
+            return Buffer.from(digestResult);
+          };
         }
       ),
       registerHtmlPluginBeforeAssetTagGenerationTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeAssetTagGeneration,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).beforeAssetTagGeneration,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).beforeAssetTagGeneration;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAlterAssetTagsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTags,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).alterAssetTags,
-        (queried) => async (data) => {
-          return await queried.promise(data);
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).alterAssetTags;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise(data);
+          };
         }
       ),
       registerHtmlPluginAlterAssetTagGroupsTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAlterAssetTagGroups,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).alterAssetTagGroups,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).alterAssetTagGroups;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAfterTemplateExecutionTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterTemplateExecution,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).afterTemplateExecution,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).afterTemplateExecution;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginBeforeEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginBeforeEmit,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).beforeEmit,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).beforeEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       ),
       registerHtmlPluginAfterEmitTaps: this.#createHookRegisterTaps(
         binding2.RegisterJsTapKind.HtmlPluginAfterEmit,
-        () => HtmlRspackPlugin.getCompilationHooks(this.#compilation).afterEmit,
-        (queried) => async (data) => {
-          return await queried.promise({
-            ...data,
-            plugin: {
-              options: HtmlRspackPlugin.getCompilationOptions(this.#compilation) || {}
-            }
-          });
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function() {
+          return HtmlRspackPlugin.getCompilationHooks(
+            that.deref().#compilation
+          ).afterEmit;
+        },
+        // biome-ignore lint/complexity/useArrowFunction: <explanation>
+        function(queried) {
+          return async function(data) {
+            return await queried.promise({
+              ...data,
+              plugin: {
+                options: HtmlRspackPlugin.getCompilationOptions(
+                  that.deref().#compilation
+                ) || {}
+              }
+            });
+          };
         }
       )
     };
@@ -13878,7 +14435,9 @@ var Compiler = class _Compiler {
     }
   }
   #createHookRegisterTaps(registerKind, getHook, createTap) {
+    const that = new WeakRef(this);
     const getTaps = (stages) => {
+      const compiler = that.deref();
       const hook = getHook();
       if (!hook.isUsed()) return [];
       const breakpoints = [
@@ -13898,7 +14457,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -13906,7 +14465,9 @@ var Compiler = class _Compiler {
     return getTaps;
   }
   #createHookMapRegisterTaps(registerKind, getHookMap, createTap) {
+    const that = new WeakRef(this);
     const getTaps = (stages) => {
+      const compiler = that.deref();
       const map = getHookMap();
       if (!map.isUsed()) return [];
       const breakpoints = [
@@ -13926,7 +14487,7 @@ var Compiler = class _Compiler {
           stage: liteTapable7.safeStage(from + 1)
         });
       }
-      this.#decorateJsTaps(jsTaps);
+      compiler.#decorateJsTaps(jsTaps);
       return jsTaps;
     };
     getTaps.registerKind = registerKind;
@@ -17755,6 +18316,203 @@ var RspackOptionsApply = class {
   }
 };
 
+// src/lib/DllPlugin.ts
+var import_zod5 = __toESM(require("../compiled/zod/index.js"));
+
+// src/builtin-plugin/FlagAllModulesAsUsedPlugin.ts
+var import_binding79 = require("@rspack/binding");
+var FlagAllModulesAsUsedPlugin = create2(
+  import_binding79.BuiltinPluginName.FlagAllModulesAsUsedPlugin,
+  (explanation) => {
+    return {
+      explanation
+    };
+  }
+);
+
+// src/lib/DllPlugin.ts
+var dllPluginOptions = import_zod5.default.object({
+  context: import_zod5.default.string().optional(),
+  entryOnly: import_zod5.default.boolean().optional(),
+  format: import_zod5.default.boolean().optional(),
+  name: import_zod5.default.string().optional(),
+  path: import_zod5.default.string(),
+  type: import_zod5.default.string().optional()
+});
+var DllPlugin = class _DllPlugin {
+  constructor(options) {
+    validate(options, dllPluginOptions);
+    this.options = {
+      ...options,
+      entryOnly: options.entryOnly !== false
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.entryOption.tap(_DllPlugin.name, (context2, entry2) => {
+      if (typeof entry2 === "function") {
+        throw new Error(
+          "DllPlugin doesn't support dynamic entry (function) yet"
+        );
+      }
+      for (const name2 of Object.keys(entry2)) {
+        const options = {
+          name: name2
+        };
+        const entries = entry2[name2].import || [];
+        new DllEntryPlugin(context2, entries, options).apply(compiler);
+      }
+      return true;
+    });
+    new LibManifestPlugin(this.options).apply(compiler);
+    if (!this.options.entryOnly) {
+      new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+    }
+  }
+};
+
+// src/lib/DllReferencePlugin.ts
+var import_zod6 = __toESM(require("../compiled/zod/index.js"));
+var dllReferencePluginOptionsContentItem = import_zod6.default.object({
+  buildMeta: import_zod6.default.custom().optional(),
+  exports: import_zod6.default.array(import_zod6.default.string()).or(import_zod6.default.literal(true)).optional(),
+  id: import_zod6.default.string().optional()
+});
+var dllReferencePluginOptionsContent = import_zod6.default.record(
+  dllReferencePluginOptionsContentItem
+);
+var dllReferencePluginOptionsSourceType = import_zod6.default.enum([
+  "var",
+  "assign",
+  "this",
+  "window",
+  "global",
+  "commonjs",
+  "commonjs2",
+  "commonjs-module",
+  "amd",
+  "amd-require",
+  "umd",
+  "umd2",
+  "jsonp",
+  "system"
+]);
+var dllReferencePluginOptionsManifest = import_zod6.default.object({
+  content: dllReferencePluginOptionsContent,
+  name: import_zod6.default.string().optional(),
+  type: dllReferencePluginOptionsSourceType.optional()
+});
+var dllReferencePluginOptions = import_zod6.default.union([
+  import_zod6.default.object({
+    context: import_zod6.default.string().optional(),
+    extensions: import_zod6.default.array(import_zod6.default.string()).optional(),
+    manifest: import_zod6.default.string().or(dllReferencePluginOptionsManifest),
+    name: import_zod6.default.string().optional(),
+    scope: import_zod6.default.string().optional(),
+    sourceType: dllReferencePluginOptionsSourceType.optional(),
+    type: import_zod6.default.enum(["require", "object"]).optional()
+  }),
+  import_zod6.default.object({
+    content: dllReferencePluginOptionsContent,
+    context: import_zod6.default.string().optional(),
+    extensions: import_zod6.default.array(import_zod6.default.string()).optional(),
+    name: import_zod6.default.string(),
+    scope: import_zod6.default.string().optional(),
+    sourceType: dllReferencePluginOptionsSourceType.optional(),
+    type: import_zod6.default.enum(["require", "object"]).optional()
+  })
+]);
+var DllReferencePlugin = class _DllReferencePlugin {
+  constructor(options) {
+    validate(options, dllReferencePluginOptions);
+    this.options = options;
+    this.errors = /* @__PURE__ */ new WeakMap();
+  }
+  apply(compiler) {
+    compiler.hooks.beforeCompile.tapPromise(
+      _DllReferencePlugin.name,
+      async (params) => {
+        const manifest = await new Promise((resolve2, reject) => {
+          var _a;
+          if ("manifest" in this.options) {
+            const manifest2 = this.options.manifest;
+            if (typeof manifest2 === "string") {
+              const manifestParameter = manifest2;
+              (_a = compiler.inputFileSystem) == null ? void 0 : _a.readFile(
+                manifestParameter,
+                "utf8",
+                (err, result2) => {
+                  if (err) return reject(err);
+                  if (!result2)
+                    return reject(
+                      new DllManifestError(
+                        manifestParameter,
+                        `Can't read anything from ${manifestParameter}`
+                      )
+                    );
+                  try {
+                    const manifest3 = JSON.parse(result2);
+                    resolve2(manifest3);
+                  } catch (parseError) {
+                    const manifestPath = makePathsRelative(
+                      compiler.context,
+                      manifestParameter,
+                      compiler.root
+                    );
+                    this.errors.set(
+                      params,
+                      new DllManifestError(
+                        manifestPath,
+                        parseError.message
+                      )
+                    );
+                  }
+                }
+              );
+            } else {
+              resolve2(manifest2);
+            }
+          } else {
+            resolve2(void 0);
+          }
+        });
+        if (!this.errors.has(params)) {
+          new DllReferenceAgencyPlugin({
+            ...this.options,
+            type: this.options.type || "require",
+            extensions: this.options.extensions || [
+              "",
+              ".js",
+              ".json",
+              ".wasm"
+            ],
+            manifest
+          }).apply(compiler);
+        }
+      }
+    );
+    compiler.hooks.compilation.tap(
+      _DllReferencePlugin.name,
+      (compilation, params) => {
+        if ("manifest" in this.options && typeof this.options.manifest === "string") {
+          const error = this.errors.get(params);
+          if (error) {
+            compilation.errors.push(error);
+          }
+          compilation.fileDependencies.add(this.options.manifest);
+        }
+      }
+    );
+  }
+};
+var DllManifestError = class extends WebpackError_default {
+  constructor(filename2, message) {
+    super();
+    this.name = "DllManifestError";
+    this.message = `Dll manifest ${filename2}
+${message}`;
+  }
+};
+
 // src/lib/EnvironmentPlugin.ts
 var EnvironmentPlugin = class {
   constructor(...keys) {
@@ -18453,9 +19211,9 @@ var NodeTemplatePlugin = class {
 };
 
 // src/container/ModuleFederationRuntimePlugin.ts
-var import_binding76 = require("@rspack/binding");
+var import_binding80 = require("@rspack/binding");
 var ModuleFederationRuntimePlugin = create2(
-  import_binding76.BuiltinPluginName.ModuleFederationRuntimePlugin,
+  import_binding80.BuiltinPluginName.ModuleFederationRuntimePlugin,
   () => {
   }
 );
@@ -18651,10 +19409,10 @@ function getDefaultEntryRuntime(paths, options, compiler) {
 }
 
 // src/sharing/ConsumeSharedPlugin.ts
-var import_binding78 = require("@rspack/binding");
+var import_binding82 = require("@rspack/binding");
 
 // src/sharing/ShareRuntimePlugin.ts
-var import_binding77 = require("@rspack/binding");
+var import_binding81 = require("@rspack/binding");
 var compilerSet = /* @__PURE__ */ new WeakSet();
 function isSingleton(compiler) {
   return compilerSet.has(compiler);
@@ -18666,7 +19424,7 @@ var ShareRuntimePlugin = class extends RspackBuiltinPlugin {
   constructor(enhanced = false) {
     super();
     this.enhanced = enhanced;
-    this.name = import_binding77.BuiltinPluginName.ShareRuntimePlugin;
+    this.name = import_binding81.BuiltinPluginName.ShareRuntimePlugin;
   }
   raw(compiler) {
     if (isSingleton(compiler)) return;
@@ -18685,7 +19443,7 @@ function isRequiredVersion(str) {
 var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding78.BuiltinPluginName.ConsumeSharedPlugin;
+    this.name = import_binding82.BuiltinPluginName.ConsumeSharedPlugin;
     this._options = {
       consumes: parseOptions(
         options.consumes,
@@ -18748,11 +19506,11 @@ var ConsumeSharedPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/sharing/ProvideSharedPlugin.ts
-var import_binding79 = require("@rspack/binding");
+var import_binding83 = require("@rspack/binding");
 var ProvideSharedPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding79.BuiltinPluginName.ProvideSharedPlugin;
+    this.name = import_binding83.BuiltinPluginName.ProvideSharedPlugin;
     this._provides = parseOptions(
       options.provides,
       (item) => {
@@ -18857,11 +19615,11 @@ var SharePlugin = class {
 };
 
 // src/container/ContainerPlugin.ts
-var import_binding80 = require("@rspack/binding");
+var import_binding84 = require("@rspack/binding");
 var ContainerPlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding80.BuiltinPluginName.ContainerPlugin;
+    this.name = import_binding84.BuiltinPluginName.ContainerPlugin;
     this._options = {
       name: options.name,
       shareScope: options.shareScope || "default",
@@ -18905,11 +19663,11 @@ var ContainerPlugin = class extends RspackBuiltinPlugin {
 };
 
 // src/container/ContainerReferencePlugin.ts
-var import_binding81 = require("@rspack/binding");
+var import_binding85 = require("@rspack/binding");
 var ContainerReferencePlugin = class extends RspackBuiltinPlugin {
   constructor(options) {
     super();
-    this.name = import_binding81.BuiltinPluginName.ContainerReferencePlugin;
+    this.name = import_binding85.BuiltinPluginName.ContainerReferencePlugin;
     this._options = {
       remoteType: options.remoteType,
       remotes: parseOptions(
@@ -18994,7 +19752,7 @@ var ModuleFederationPluginV1 = class {
 };
 
 // src/exports.ts
-var import_binding82 = require("@rspack/binding");
+var import_binding86 = require("@rspack/binding");
 var rspackVersion = import_package.version;
 var version = import_package.webpackVersion;
 var WebpackError2 = Error;
@@ -19040,8 +19798,8 @@ var sharing = {
 };
 var experiments2 = {
   globalTrace: {
-    register: import_binding82.registerGlobalTrace,
-    cleanup: import_binding82.cleanupGlobalTrace
+    register: import_binding86.registerGlobalTrace,
+    cleanup: import_binding86.cleanupGlobalTrace
   },
   RemoveDuplicateModulesPlugin
 };
@@ -19162,6 +19920,8 @@ module.exports = rspack;
   CopyRspackPlugin,
   CssExtractRspackPlugin,
   DefinePlugin,
+  DllPlugin,
+  DllReferencePlugin,
   DynamicEntryPlugin,
   EntryOptionPlugin,
   EntryPlugin,