@rspack-canary/core 1.5.9-canary-740cd963-20250929173807 → 1.5.9-canary-61eba72c-20251001174057

package/dist/index.js

@@ -28,12 +28,11 @@ var __webpack_modules__ = {
                     if ("function" == typeof options && (callback = options, options = void 0), "string" != typeof path && !Buffer.isBuffer(path) && !(path instanceof URL) && "number" != typeof path) return void callback(TypeError("path must be a string, Buffer, URL or number"));
                     if (options) return this._provider.call(this._providerContext, path, options, callback);
                     let callbacks = this._activeAsyncOperations.get(path);
-                    if (callbacks) return void callbacks.push(callback);
-                    this._activeAsyncOperations.set(path, callbacks = [
+                    callbacks ? callbacks.push(callback) : (this._activeAsyncOperations.set(path, callbacks = [
                         callback
                     ]), provider(path, (err, result)=>{
                         this._activeAsyncOperations.delete(path), runCallbacks(callbacks, err, result);
-                    });
+                    }));
                 } : null, this.provideSync = this._syncProvider ? (path, options)=>this._syncProvider.call(this._providerContext, path, options) : null;
             }
             purge() {}
@@ -54,12 +53,11 @@ var __webpack_modules__ = {
                 let cacheEntry = this._data.get(strPath);
                 if (void 0 !== cacheEntry) return cacheEntry.err ? nextTick(callback, cacheEntry.err) : nextTick(callback, null, cacheEntry.result);
                 let callbacks = this._activeAsyncOperations.get(strPath);
-                if (void 0 !== callbacks) return void callbacks.push(callback);
-                this._activeAsyncOperations.set(strPath, callbacks = [
+                void 0 !== callbacks ? callbacks.push(callback) : (this._activeAsyncOperations.set(strPath, callbacks = [
                     callback
                 ]), this._provider.call(this._providerContext, path, (err, result)=>{
                     this._activeAsyncOperations.delete(strPath), this._storeResult(strPath, err, result), this._enterAsyncMode(), runCallbacks(callbacks, err, result);
-                });
+                }));
             }
             provideSync(path, options) {
                 let result;
@@ -161,21 +159,21 @@ var __webpack_modules__ = {
         module.exports = class {
             constructor(fileSystem, duration){
                 this.fileSystem = fileSystem, this._lstatBackend = createBackend(duration, this.fileSystem.lstat, this.fileSystem.lstatSync, this.fileSystem);
-                let lstat = this._lstatBackend.provide;
+                const lstat = this._lstatBackend.provide;
                 this.lstat = lstat;
-                let lstatSync = this._lstatBackend.provideSync;
+                const lstatSync = this._lstatBackend.provideSync;
                 this.lstatSync = lstatSync, this._statBackend = createBackend(duration, this.fileSystem.stat, this.fileSystem.statSync, this.fileSystem);
-                let stat = this._statBackend.provide;
+                const stat = this._statBackend.provide;
                 this.stat = stat;
-                let statSync = this._statBackend.provideSync;
+                const statSync = this._statBackend.provideSync;
                 this.statSync = statSync, this._readdirBackend = createBackend(duration, this.fileSystem.readdir, this.fileSystem.readdirSync, this.fileSystem);
-                let readdir = this._readdirBackend.provide;
+                const readdir = this._readdirBackend.provide;
                 this.readdir = readdir;
-                let readdirSync = this._readdirBackend.provideSync;
+                const readdirSync = this._readdirBackend.provideSync;
                 this.readdirSync = readdirSync, this._readFileBackend = createBackend(duration, this.fileSystem.readFile, this.fileSystem.readFileSync, this.fileSystem);
-                let readFile = this._readFileBackend.provide;
+                const readFile = this._readFileBackend.provide;
                 this.readFile = readFile;
-                let readFileSync = this._readFileBackend.provideSync;
+                const readFileSync = this._readFileBackend.provideSync;
                 this.readFileSync = readFileSync, this._readJsonBackend = createBackend(duration, this.fileSystem.readJson || this.readFile && ((path, callback)=>{
                     this.readFile(path, (err, buffer)=>{
                         let data;
@@ -189,17 +187,17 @@ var __webpack_modules__ = {
                         callback(null, data);
                     });
                 }), this.fileSystem.readJsonSync || this.readFileSync && ((path)=>JSON.parse(this.readFileSync(path).toString("utf8"))), this.fileSystem);
-                let readJson = this._readJsonBackend.provide;
+                const readJson = this._readJsonBackend.provide;
                 this.readJson = readJson;
-                let readJsonSync = this._readJsonBackend.provideSync;
+                const readJsonSync = this._readJsonBackend.provideSync;
                 this.readJsonSync = readJsonSync, this._readlinkBackend = createBackend(duration, this.fileSystem.readlink, this.fileSystem.readlinkSync, this.fileSystem);
-                let readlink = this._readlinkBackend.provide;
+                const readlink = this._readlinkBackend.provide;
                 this.readlink = readlink;
-                let readlinkSync = this._readlinkBackend.provideSync;
+                const readlinkSync = this._readlinkBackend.provideSync;
                 this.readlinkSync = readlinkSync, this._realpathBackend = createBackend(duration, this.fileSystem.realpath, this.fileSystem.realpathSync, this.fileSystem);
-                let realpath = this._realpathBackend.provide;
+                const realpath = this._realpathBackend.provide;
                 this.realpath = realpath;
-                let realpathSync = this._realpathBackend.provideSync;
+                const realpathSync = this._realpathBackend.provideSync;
                 this.realpathSync = realpathSync;
             }
             purge(what) {
@@ -964,8 +962,8 @@ for(var __webpack_i__ in (()=>{
                         "context"
                     ]))
             });
-            let hooks = this.hooks, caches = {};
-            for (let key of Object.keys(hooks))caches[key] = new Map();
+            const hooks = this.hooks, caches = {};
+            for (const key of Object.keys(hooks))caches[key] = new Map();
             this._caches = caches, this._inCreate = !1;
         }
         _getAllLevelHooks(hookMap, cache, type) {
@@ -1509,8 +1507,10 @@ for(var __webpack_i__ in (()=>{
         #addEntryDispatcher;
         [_computedKey];
         constructor(compiler, inner){
+            var name, stage, getArgs;
+            let errorMessage, getOptions;
             this.#inner = inner, this.#shutdown = !1;
-            let processAssetsHook = new lite_tapable_namespaceObject.AsyncSeriesHook([
+            const processAssetsHook = new lite_tapable_namespaceObject.AsyncSeriesHook([
                 "assets"
             ]);
             this.hooks = {
@@ -1518,35 +1518,32 @@ for(var __webpack_i__ in (()=>{
                 afterProcessAssets: new lite_tapable_namespaceObject.SyncHook([
                     "assets"
                 ]),
-                additionalAssets: ((name, stage, getArgs)=>{
-                    let errorMessage = (reason)=>`Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
+                additionalAssets: (name = "additionalAssets", stage = Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, getArgs = ()=>[], errorMessage = (reason)=>`Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`, getOptions = (options)=>{
-                        let isString = "string" == typeof options;
-                        if (!isString && options.stage) throw Error(errorMessage("it's using the 'stage' option"));
-                        return {
-                            ...isString ? {
-                                name: options
-                            } : options,
-                            stage: stage
-                        };
+                    let isString = "string" == typeof options;
+                    if (!isString && options.stage) throw Error(errorMessage("it's using the 'stage' option"));
+                    return {
+                        ...isString ? {
+                            name: options
+                        } : options,
+                        stage: stage
                     };
-                    return Object.freeze({
-                        name,
-                        intercept () {
-                            throw Error(errorMessage("it's using 'intercept'"));
-                        },
-                        tap: (options, fn)=>{
-                            processAssetsHook.tap(getOptions(options), ()=>fn(...getArgs()));
-                        },
-                        tapAsync: (options, fn)=>{
-                            processAssetsHook.tapAsync(getOptions(options), (assets, callback)=>fn(...getArgs(), callback));
-                        },
-                        tapPromise: (options, fn)=>{
-                            processAssetsHook.tapPromise(getOptions(options), ()=>fn(...getArgs()));
-                        },
-                        _fakeHook: !0
-                    });
-                })("additionalAssets", Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, ()=>[]),
+                }, Object.freeze({
+                    name,
+                    intercept () {
+                        throw Error(errorMessage("it's using 'intercept'"));
+                    },
+                    tap: (options, fn)=>{
+                        processAssetsHook.tap(getOptions(options), ()=>fn(...getArgs()));
+                    },
+                    tapAsync: (options, fn)=>{
+                        processAssetsHook.tapAsync(getOptions(options), (assets, callback)=>fn(...getArgs(), callback));
+                    },
+                    tapPromise: (options, fn)=>{
+                        processAssetsHook.tapPromise(getOptions(options), ()=>fn(...getArgs()));
+                    },
+                    _fakeHook: !0
+                })),
                 childCompiler: new lite_tapable_namespaceObject.SyncHook([
                     "childCompiler",
                     "compilerName",
@@ -2754,7 +2751,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
     class Message extends Error {
         constructor(){
             super(), this.stack = void 0, Error.captureStackTrace(this);
-            let match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+            const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
             this.message = match?.[1] ? createMessage(match[1]) : createMessage();
         }
     }
@@ -2780,7 +2777,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
         chunkSize;
         digestSize;
         constructor(instance, instancesPool, chunkSize, digestSize){
-            let exports1 = instance.exports;
+            const exports1 = instance.exports;
             exports1.init(), this.exports = exports1, this.mem = Buffer.from(exports1.memory.buffer, 0, 65536), this.buffered = 0, this.instancesPool = instancesPool, this.chunkSize = chunkSize, this.digestSize = digestSize;
         }
         reset() {
@@ -3134,35 +3131,34 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
         parallel;
         loaderItem;
         constructor(loaderItem, compiler){
-            let { request, path, query, fragment, options, ident, normal, pitch, raw, type } = function(loader, compiler) {
-                let obj = {
-                    path: null,
-                    query: null,
-                    fragment: null,
-                    options: null,
-                    ident: null,
-                    normal: null,
-                    pitch: null,
-                    raw: null,
-                    data: null,
-                    pitchExecuted: !1,
-                    normalExecuted: !1
-                };
-                return Object.defineProperty(obj, "request", {
-                    enumerable: !0,
-                    get: ()=>obj.path.replace(/#/g, "\u200b#") + obj.query.replace(/#/g, "\u200b#") + obj.fragment,
-                    set: (value)=>{
-                        let splittedRequest = parseResourceWithoutFragment(value.loader);
-                        if (obj.path = splittedRequest.path, obj.query = splittedRequest.query, obj.fragment = "", obj.options = null === obj.options ? splittedRequest.query ? splittedRequest.query.slice(1) : void 0 : obj.options, "string" == typeof obj.options && "?" === obj.options[0]) {
-                            let ident = obj.options.slice(1);
-                            if ("[[missing ident]]" === ident) throw Error("No ident is provided by referenced loader. When using a function for Rule.use in config you need to provide an 'ident' property for referenced loader options.");
-                            if (obj.options = compiler.__internal__ruleSet.references.get(ident), void 0 === obj.options) throw Error("Invalid ident is provided by referenced loader");
-                            obj.ident = ident;
-                        }
-                        obj.type = "" === value.type ? void 0 : value.type, null === obj.options || void 0 === obj.options ? obj.query = "" : "string" == typeof obj.options ? obj.query = `?${obj.options}` : obj.ident ? obj.query = `??${obj.ident}` : "object" == typeof obj.options && obj.options.ident ? obj.query = `??${obj.options.ident}` : obj.query = `?${JSON.stringify(obj.options)}`;
+            var loader, compiler1;
+            let obj;
+            const { request, path, query, fragment, options, ident, normal, pitch, raw, type } = (loader = loaderItem, compiler1 = compiler, Object.defineProperty(obj = {
+                path: null,
+                query: null,
+                fragment: null,
+                options: null,
+                ident: null,
+                normal: null,
+                pitch: null,
+                raw: null,
+                data: null,
+                pitchExecuted: !1,
+                normalExecuted: !1
+            }, "request", {
+                enumerable: !0,
+                get: ()=>obj.path.replace(/#/g, "\u200b#") + obj.query.replace(/#/g, "\u200b#") + obj.fragment,
+                set: (value)=>{
+                    let splittedRequest = parseResourceWithoutFragment(value.loader);
+                    if (obj.path = splittedRequest.path, obj.query = splittedRequest.query, obj.fragment = "", obj.options = null === obj.options ? splittedRequest.query ? splittedRequest.query.slice(1) : void 0 : obj.options, "string" == typeof obj.options && "?" === obj.options[0]) {
+                        let ident = obj.options.slice(1);
+                        if ("[[missing ident]]" === ident) throw Error("No ident is provided by referenced loader. When using a function for Rule.use in config you need to provide an 'ident' property for referenced loader options.");
+                        if (obj.options = compiler1.__internal__ruleSet.references.get(ident), void 0 === obj.options) throw Error("Invalid ident is provided by referenced loader");
+                        obj.ident = ident;
                     }
-                }), obj.request = loader, Object.preventExtensions && Object.preventExtensions(obj), obj;
-            }(loaderItem, compiler);
+                    obj.type = "" === value.type ? void 0 : value.type, null === obj.options || void 0 === obj.options ? obj.query = "" : "string" == typeof obj.options ? obj.query = `?${obj.options}` : obj.ident ? obj.query = `??${obj.ident}` : "object" == typeof obj.options && obj.options.ident ? obj.query = `??${obj.options.ident}` : obj.query = `?${JSON.stringify(obj.options)}`;
+                }
+            }), obj.request = loader, Object.preventExtensions && Object.preventExtensions(obj), obj);
             this.request = request, this.path = path, this.query = query, this.fragment = fragment, this.options = options, this.ident = ident, this.normal = normal, this.pitch = pitch, this.raw = raw, this.type = type, this.parallel = !!ident && compiler.__internal__ruleSet.references.get(`${ident}$$parallelism`), this.loaderItem = loaderItem, this.loaderItem.data = this.loaderItem.data ?? {};
         }
         get pitchExecuted() {
@@ -3428,9 +3424,10 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                     is_pitch: pitch,
                     resource: resource
                 }
-            }), parallelism) result = await service_run(loaderName, {
-                loaderContext: (()=>{
-                    let normalModule = loaderContext._module instanceof binding_.NormalModule ? loaderContext._module : void 0, workerLoaderContext = {
+            }), parallelism) {
+                let normalModule, workerLoaderContext;
+                result = await service_run(loaderName, {
+                    loaderContext: (normalModule = loaderContext._module instanceof binding_.NormalModule ? loaderContext._module : void 0, Object.assign(workerLoaderContext = {
                         hot: loaderContext.hot,
                         context: loaderContext.context,
                         resourcePath: loaderContext.resourcePath,
@@ -3483,125 +3480,125 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                             userRequest: normalModule?.userRequest,
                             rawRequest: normalModule?.rawRequest
                         }
-                    };
-                    return Object.assign(workerLoaderContext, compiler.options.loader), workerLoaderContext;
-                })(),
-                loaderState,
-                args
-            }, {
-                handleIncomingRequest (requestType, ...args) {
-                    switch(requestType){
-                        case "AddDependency":
-                            loaderContext.addDependency(args[0]);
-                            break;
-                        case "AddContextDependency":
-                            loaderContext.addContextDependency(args[0]);
-                            break;
-                        case "AddMissingDependency":
-                            loaderContext.addMissingDependency(args[0]);
-                            break;
-                        case "AddBuildDependency":
-                            loaderContext.addBuildDependency(args[0]);
-                            break;
-                        case "GetDependencies":
-                            return loaderContext.getDependencies();
-                        case "GetContextDependencies":
-                            return loaderContext.getContextDependencies();
-                        case "GetMissingDependencies":
-                            return loaderContext.getMissingDependencies();
-                        case "ClearDependencies":
-                            loaderContext.clearDependencies();
-                            break;
-                        case "Resolve":
-                            return new Promise((resolve, reject)=>{
-                                loaderContext.resolve(args[0], args[1], (err, result)=>{
-                                    err ? reject(err) : resolve(result);
-                                });
-                            });
-                        case "GetResolve":
-                            return new Promise((resolve, reject)=>{
-                                loaderContext.getResolve(args[0])(args[1], args[2], (err, result)=>{
-                                    err ? reject(err) : resolve(result);
-                                });
-                            });
-                        case "GetLogger":
-                            {
-                                let [type, name, arg] = args;
-                                loaderContext.getLogger(name)[type](...arg);
-                            }
-                        case "EmitError":
-                            {
-                                let workerError = args[0], error = Error(workerError.message);
-                                error.stack = workerError.stack, error.name = workerError.name, loaderContext.emitError(error);
+                    }, compiler.options.loader), workerLoaderContext),
+                    loaderState,
+                    args
+                }, {
+                    handleIncomingRequest (requestType, ...args) {
+                        switch(requestType){
+                            case "AddDependency":
+                                loaderContext.addDependency(args[0]);
                                 break;
-                            }
-                        case "EmitWarning":
-                            {
-                                let workerError = args[0], error = Error(workerError.message);
-                                error.stack = workerError.stack, error.name = workerError.name, loaderContext.emitWarning(error);
+                            case "AddContextDependency":
+                                loaderContext.addContextDependency(args[0]);
                                 break;
-                            }
-                        case "EmitFile":
-                            {
-                                let [name, content, sourceMap, assetInfo] = args;
-                                loaderContext.emitFile(name, content, sourceMap, assetInfo);
+                            case "AddMissingDependency":
+                                loaderContext.addMissingDependency(args[0]);
                                 break;
-                            }
-                        case "EmitDiagnostic":
-                            {
-                                let diagnostic = args[0];
-                                loaderContext.experiments.emitDiagnostic(diagnostic);
+                            case "AddBuildDependency":
+                                loaderContext.addBuildDependency(args[0]);
                                 break;
-                            }
-                        case "SetCacheable":
-                            {
-                                let cacheable = args[0];
-                                loaderContext.cacheable(cacheable);
+                            case "GetDependencies":
+                                return loaderContext.getDependencies();
+                            case "GetContextDependencies":
+                                return loaderContext.getContextDependencies();
+                            case "GetMissingDependencies":
+                                return loaderContext.getMissingDependencies();
+                            case "ClearDependencies":
+                                loaderContext.clearDependencies();
                                 break;
-                            }
-                        case "ImportModule":
-                            return loaderContext.importModule(args[0], args[1]);
-                        case "UpdateLoaderObjects":
-                            {
-                                let updates = args[0];
-                                loaderContext.loaders = loaderContext.loaders.map((item, index)=>{
-                                    let update = updates[index];
-                                    return item.loaderItem.data = update.data, update.pitchExecuted && (item.pitchExecuted = !0), update.normalExecuted && (item.normalExecuted = !0), item;
+                            case "Resolve":
+                                return new Promise((resolve, reject)=>{
+                                    loaderContext.resolve(args[0], args[1], (err, result)=>{
+                                        err ? reject(err) : resolve(result);
+                                    });
                                 });
-                                break;
-                            }
-                        case "CompilationGetPath":
-                            {
-                                let filename = args[0], data = args[1];
-                                return compiler._lastCompilation.getPath(filename, data);
-                            }
-                        case "CompilationGetPathWithInfo":
-                            {
-                                let filename = args[0], data = args[1];
-                                return compiler._lastCompilation.getPathWithInfo(filename, data);
-                            }
-                        case "CompilationGetAssetPath":
-                            {
-                                let filename = args[0], data = args[1];
-                                return compiler._lastCompilation.getAssetPath(filename, data);
-                            }
-                        case "CompilationGetAssetPathWithInfo":
-                            {
-                                let filename = args[0], data = args[1];
-                                return compiler._lastCompilation.getAssetPathWithInfo(filename, data);
-                            }
-                        default:
-                            throw Error(`Unknown request type: ${requestType}`);
+                            case "GetResolve":
+                                return new Promise((resolve, reject)=>{
+                                    loaderContext.getResolve(args[0])(args[1], args[2], (err, result)=>{
+                                        err ? reject(err) : resolve(result);
+                                    });
+                                });
+                            case "GetLogger":
+                                {
+                                    let [type, name, arg] = args;
+                                    loaderContext.getLogger(name)[type](...arg);
+                                    break;
+                                }
+                            case "EmitError":
+                                {
+                                    let workerError = args[0], error = Error(workerError.message);
+                                    error.stack = workerError.stack, error.name = workerError.name, loaderContext.emitError(error);
+                                    break;
+                                }
+                            case "EmitWarning":
+                                {
+                                    let workerError = args[0], error = Error(workerError.message);
+                                    error.stack = workerError.stack, error.name = workerError.name, loaderContext.emitWarning(error);
+                                    break;
+                                }
+                            case "EmitFile":
+                                {
+                                    let [name, content, sourceMap, assetInfo] = args;
+                                    loaderContext.emitFile(name, content, sourceMap, assetInfo);
+                                    break;
+                                }
+                            case "EmitDiagnostic":
+                                {
+                                    let diagnostic = args[0];
+                                    loaderContext.experiments.emitDiagnostic(diagnostic);
+                                    break;
+                                }
+                            case "SetCacheable":
+                                {
+                                    let cacheable = args[0];
+                                    loaderContext.cacheable(cacheable);
+                                    break;
+                                }
+                            case "ImportModule":
+                                return loaderContext.importModule(args[0], args[1]);
+                            case "UpdateLoaderObjects":
+                                {
+                                    let updates = args[0];
+                                    loaderContext.loaders = loaderContext.loaders.map((item, index)=>{
+                                        let update = updates[index];
+                                        return item.loaderItem.data = update.data, update.pitchExecuted && (item.pitchExecuted = !0), update.normalExecuted && (item.normalExecuted = !0), item;
+                                    });
+                                    break;
+                                }
+                            case "CompilationGetPath":
+                                {
+                                    let filename = args[0], data = args[1];
+                                    return compiler._lastCompilation.getPath(filename, data);
+                                }
+                            case "CompilationGetPathWithInfo":
+                                {
+                                    let filename = args[0], data = args[1];
+                                    return compiler._lastCompilation.getPathWithInfo(filename, data);
+                                }
+                            case "CompilationGetAssetPath":
+                                {
+                                    let filename = args[0], data = args[1];
+                                    return compiler._lastCompilation.getAssetPath(filename, data);
+                                }
+                            case "CompilationGetAssetPathWithInfo":
+                                {
+                                    let filename = args[0], data = args[1];
+                                    return compiler._lastCompilation.getAssetPathWithInfo(filename, data);
+                                }
+                            default:
+                                throw Error(`Unknown request type: ${requestType}`);
+                        }
                     }
-                }
-            }) || [];
-            else {
-                var args1, raw;
-                loaderState === binding_.JsLoaderState.Normal && (args1 = args, !(raw = !!currentLoaderObject?.raw) && args1[0] instanceof Uint8Array ? args1[0] = function(buf) {
-                    let str = decoder.decode(buf.buffer instanceof SharedArrayBuffer ? Buffer.from(buf) : buf);
-                    return 0xfeff === str.charCodeAt(0) ? str.slice(1) : str;
-                }(args1[0]) : raw && "string" == typeof args1[0] && (args1[0] = Buffer.from(args1[0], "utf-8")), raw && args1[0] instanceof Uint8Array && !Buffer.isBuffer(args1[0]) && (args1[0] = Buffer.from(args1[0].buffer))), result = await utils_runSyncOrAsync(fn, loaderContext, args) || [];
-            }
+                }) || [];
+            } else loaderState === binding_.JsLoaderState.Normal && function(args, raw) {
+                if (!raw && args[0] instanceof Uint8Array) {
+                    var buf;
+                    let str;
+                    args[0] = (buf = args[0], 0xfeff === (str = decoder.decode(buf.buffer instanceof SharedArrayBuffer ? Buffer.from(buf) : buf)).charCodeAt(0) ? str.slice(1) : str);
+                } else raw && "string" == typeof args[0] && (args[0] = Buffer.from(args[0], "utf-8"));
+                raw && args[0] instanceof Uint8Array && !Buffer.isBuffer(args[0]) && (args[0] = Buffer.from(args[0].buffer));
+            }(args, !!currentLoaderObject?.raw), result = await utils_runSyncOrAsync(fn, loaderContext, args) || [];
             return JavaScriptTracer.endAsync({
                 name: loaderName,
                 trackName: loaderName,
@@ -3701,39 +3698,45 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             let o, isBuiltin = !1;
             if (use.loader.startsWith(BUILTIN_LOADER_PREFIX)) {
                 let temp = function(identifier, o, options) {
-                    if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}swc-loader`)) {
-                        var o1, options1, options2 = o;
-                        if (options2 && "object" == typeof options2) {
-                            options2.jsc ??= {}, options2.jsc.experimental ??= {}, options2.jsc.experimental.disableAllLints ??= !0;
-                            let { rspackExperiments } = options2;
-                            rspackExperiments && ((rspackExperiments.import || rspackExperiments.pluginImport) && (rspackExperiments.import = function(pluginImport) {
-                                if (pluginImport) return pluginImport.map((config)=>{
-                                    let rawConfig = {
-                                        ...config,
-                                        style: {}
-                                    };
-                                    if ("boolean" == typeof config.style) rawConfig.style.bool = config.style;
-                                    else if ("string" == typeof config.style) {
-                                        let isTpl = config.style.includes("{{");
-                                        rawConfig.style[isTpl ? "custom" : "css"] = config.style;
-                                    } else {
-                                        var val;
-                                        val = config.style, "[object Object]" === Object.prototype.toString.call(val) && (rawConfig.style = config.style);
-                                    }
-                                    return config.styleLibraryDirectory && (rawConfig.style = {
-                                        styleLibraryDirectory: config.styleLibraryDirectory
-                                    }), rawConfig;
+                    if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}swc-loader`)) return ((options, _)=>{
+                        if (options && "object" == typeof options) {
+                            options.jsc ??= {}, options.jsc.experimental ??= {}, options.jsc.experimental.disableAllLints ??= !0;
+                            let { rspackExperiments } = options;
+                            if (rspackExperiments) {
+                                var options1;
+                                (rspackExperiments.import || rspackExperiments.pluginImport) && (rspackExperiments.import = function(pluginImport) {
+                                    if (pluginImport) return pluginImport.map((config)=>{
+                                        let rawConfig = {
+                                            ...config,
+                                            style: {}
+                                        };
+                                        if ("boolean" == typeof config.style) rawConfig.style.bool = config.style;
+                                        else if ("string" == typeof config.style) {
+                                            let isTpl = config.style.includes("{{");
+                                            rawConfig.style[isTpl ? "custom" : "css"] = config.style;
+                                        } else {
+                                            var val;
+                                            val = config.style, "[object Object]" === Object.prototype.toString.call(val) && (rawConfig.style = config.style);
+                                        }
+                                        return config.styleLibraryDirectory && (rawConfig.style = {
+                                            styleLibraryDirectory: config.styleLibraryDirectory
+                                        }), rawConfig;
+                                    });
+                                }(rspackExperiments.import || rspackExperiments.pluginImport)), rspackExperiments.collectTypeScriptInfo && (rspackExperiments.collectTypeScriptInfo = {
+                                    typeExports: (options1 = rspackExperiments.collectTypeScriptInfo).typeExports,
+                                    exportedEnum: !0 === options1.exportedEnum ? "all" : !1 === options1.exportedEnum || void 0 === options1.exportedEnum ? "none" : "const-only"
                                 });
-                            }(rspackExperiments.import || rspackExperiments.pluginImport)), rspackExperiments.collectTypeScriptInfo && (rspackExperiments.collectTypeScriptInfo = {
-                                typeExports: (options1 = rspackExperiments.collectTypeScriptInfo).typeExports,
-                                exportedEnum: !0 === options1.exportedEnum ? "all" : !1 === options1.exportedEnum || void 0 === options1.exportedEnum ? "none" : "const-only"
-                            }));
+                            }
                         }
-                        return options2;
+                        return options;
+                    })(o, 0);
+                    if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}lightningcss-loader`)) {
+                        var o1;
+                        return (o1 = o) && "object" == typeof o1 && ("string" == typeof o1.targets && (o1.targets = [
+                            o1.targets
+                        ]), o1.include && "object" == typeof o1.include && (o1.include = toFeatures(o1.include)), o1.exclude && "object" == typeof o1.exclude && (o1.exclude = toFeatures(o1.exclude))), o1;
                     }
-                    return identifier.startsWith(`${BUILTIN_LOADER_PREFIX}lightningcss-loader`) ? ((o1 = o) && "object" == typeof o1 && ("string" == typeof o1.targets && (o1.targets = [
-                        o1.targets
-                    ]), o1.include && "object" == typeof o1.include && (o1.include = toFeatures(o1.include)), o1.exclude && "object" == typeof o1.exclude && (o1.exclude = toFeatures(o1.exclude))), o1) : o;
+                    return o;
                 }(use.loader, use.options, 0);
                 o = isNil(temp) ? void 0 : "string" == typeof temp ? temp : JSON.stringify(temp, null, 2), isBuiltin = !0;
             }
@@ -4188,11 +4191,10 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                         chunks.push(chunk);
                     }), stream.on("end", ()=>{
                         let bodyBuffer = Buffer.concat(chunks);
-                        if (!res.complete) return void reject(Error(`${url} request was terminated early`));
-                        resolve({
+                        res.complete ? resolve({
                             res,
                             body: bodyBuffer
-                        });
+                        }) : reject(Error(`${url} request was terminated early`));
                     });
                 }).on("error", reject);
             });
@@ -4462,11 +4464,10 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             var _a;
             (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
         }), inst._zod.check = (payload)=>{
+            var val, step;
+            let valDecCount, stepDecCount, decCount, valInt;
             if (typeof payload.value != typeof def.value) throw Error("Cannot mix number and bigint in multiple_of check.");
-            ("bigint" == typeof payload.value ? payload.value % def.value === BigInt(0) : 0 === function(val, step) {
-                let valDecCount = (val.toString().split(".")[1] || "").length, stepDecCount = (step.toString().split(".")[1] || "").length, decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount, valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-                return valInt % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
-            }(payload.value, def.value)) || payload.issues.push({
+            ("bigint" == typeof payload.value ? payload.value % def.value === BigInt(0) : 0 == (val = payload.value, step = def.value, valDecCount = (val.toString().split(".")[1] || "").length, stepDecCount = (step.toString().split(".")[1] || "").length, decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount, (valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""))) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount)) || payload.issues.push({
                 origin: typeof payload.value,
                 code: "not_multiple_of",
                 divisor: def.value,
@@ -4828,12 +4829,11 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             version: 1
         };
     }), $ZodString = $constructor("$ZodString", (inst, def)=>{
+        var params;
+        let regex;
         $ZodType.init(inst, def), inst._zod.pattern = [
             ...inst?._zod.bag?.patterns ?? []
-        ].pop() ?? ((params)=>{
-            let regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : "[\\s\\S]*";
-            return RegExp(`^${regex}$`);
-        })(inst._zod.bag), inst._zod.parse = (payload, _)=>{
+        ].pop() ?? (regex = (params = inst._zod.bag) ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : "[\\s\\S]*", RegExp(`^${regex}$`)), inst._zod.parse = (payload, _)=>{
             if (def.coerce) try {
                 payload.value = String(payload.value);
             } catch (_) {}
@@ -4913,16 +4913,13 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
     }), $ZodKSUID = $constructor("$ZodKSUID", (inst, def)=>{
         def.pattern ?? (def.pattern = ksuid), $ZodStringFormat.init(inst, def);
     }), $ZodISODateTime = $constructor("$ZodISODateTime", (inst, def)=>{
-        def.pattern ?? (def.pattern = function(args) {
-            let time = timeSource({
-                precision: args.precision
-            }), opts = [
-                "Z"
-            ];
-            args.local && opts.push(""), args.offset && opts.push("([+-]\\d{2}:\\d{2})");
-            let timeRegex = `${time}(?:${opts.join("|")})`;
-            return RegExp(`^${dateSource}T(?:${timeRegex})$`);
-        }(def)), $ZodStringFormat.init(inst, def);
+        var args;
+        let time, opts, timeRegex;
+        def.pattern ?? (time = timeSource({
+            precision: (args = def).precision
+        }), opts = [
+            "Z"
+        ], args.local && opts.push(""), args.offset && opts.push("([+-]\\d{2}:\\d{2})"), timeRegex = `${time}(?:${opts.join("|")})`, def.pattern = RegExp(`^${dateSource}T(?:${timeRegex})$`)), $ZodStringFormat.init(inst, def);
     }), $ZodISODate = $constructor("$ZodISODate", (inst, def)=>{
         def.pattern ?? (def.pattern = regexes_date), $ZodStringFormat.init(inst, def);
     }), $ZodISOTime = $constructor("$ZodISOTime", (inst, def)=>{
@@ -5464,11 +5461,10 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             return proms.length ? Promise.all(proms).then(()=>payload) : payload;
         };
     }), $ZodEnum = $constructor("$ZodEnum", (inst, def)=>{
+        var entries;
+        let numericValues;
         $ZodType.init(inst, def);
-        let values = function(entries) {
-            let numericValues = Object.values(entries).filter((v)=>"number" == typeof v);
-            return Object.entries(entries).filter(([k, _])=>-1 === numericValues.indexOf(+k)).map(([_, v])=>v);
-        }(def.entries);
+        let values = (numericValues = Object.values(entries = def.entries).filter((v)=>"number" == typeof v), Object.entries(entries).filter(([k, _])=>-1 === numericValues.indexOf(+k)).map(([_, v])=>v));
         inst._zod.values = new Set(values), inst._zod.pattern = RegExp(`^(${values.filter((k)=>propertyKeyTypes.has(typeof k)).map((o)=>"string" == typeof o ? escapeRegex(o) : o.toString()).join("|")})$`), inst._zod.parse = (payload, _ctx)=>{
             let input = payload.value;
             return inst._zod.values.has(input) || payload.issues.push({
@@ -5727,36 +5723,37 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
     }), classic_errors_initializer = (inst, issues)=>{
         $ZodError.init(inst, issues), inst.name = "ZodError", Object.defineProperties(inst, {
             format: {
-                value: (mapper)=>(function(error, _mapper) {
-                        let mapper = _mapper || function(issue) {
-                            return issue.message;
-                        }, fieldErrors = {
-                            _errors: []
-                        }, processError = (error)=>{
-                            for (let issue of error.issues)if ("invalid_union" === issue.code && issue.errors.length) issue.errors.map((issues)=>processError({
-                                    issues
-                                }));
-                            else if ("invalid_key" === issue.code) processError({
-                                issues: issue.issues
-                            });
-                            else if ("invalid_element" === issue.code) processError({
-                                issues: issue.issues
-                            });
-                            else if (0 === issue.path.length) fieldErrors._errors.push(mapper(issue));
-                            else {
-                                let curr = fieldErrors, i = 0;
-                                for(; i < issue.path.length;){
-                                    let el = issue.path[i];
-                                    i === issue.path.length - 1 ? (curr[el] = curr[el] || {
-                                        _errors: []
-                                    }, curr[el]._errors.push(mapper(issue))) : curr[el] = curr[el] || {
-                                        _errors: []
-                                    }, curr = curr[el], i++;
-                                }
+                value: (mapper)=>{
+                    var error;
+                    let mapper1, fieldErrors, processError;
+                    return error = inst, mapper1 = mapper || function(issue) {
+                        return issue.message;
+                    }, fieldErrors = {
+                        _errors: []
+                    }, (processError = (error)=>{
+                        for (let issue of error.issues)if ("invalid_union" === issue.code && issue.errors.length) issue.errors.map((issues)=>processError({
+                                issues
+                            }));
+                        else if ("invalid_key" === issue.code) processError({
+                            issues: issue.issues
+                        });
+                        else if ("invalid_element" === issue.code) processError({
+                            issues: issue.issues
+                        });
+                        else if (0 === issue.path.length) fieldErrors._errors.push(mapper1(issue));
+                        else {
+                            let curr = fieldErrors, i = 0;
+                            for(; i < issue.path.length;){
+                                let el = issue.path[i];
+                                i === issue.path.length - 1 ? (curr[el] = curr[el] || {
+                                    _errors: []
+                                }, curr[el]._errors.push(mapper1(issue))) : curr[el] = curr[el] || {
+                                    _errors: []
+                                }, curr = curr[el], i++;
                             }
-                        };
-                        return processError(error), fieldErrors;
-                    })(inst, mapper)
+                        }
+                    })(error), fieldErrors;
+                }
             },
             flatten: {
                 value: (mapper)=>(function(error, mapper = (issue)=>issue.message) {
@@ -5838,17 +5835,15 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                     fn: fn,
                     ...normalizeParams(_params)
                 });
-            }(check, params)), inst.superRefine = (refinement)=>inst.check(function(fn) {
-                let ch = function(fn) {
-                    let ch = new $ZodCheck({
-                        check: "custom"
-                    });
-                    return ch._zod.check = fn, ch;
-                }((payload)=>(payload.addIssue = (issue)=>{
-                        "string" == typeof issue ? payload.issues.push(util_issue(issue, payload.value, ch._zod.def)) : (issue.fatal && (issue.continue = !1), issue.code ?? (issue.code = "custom"), issue.input ?? (issue.input = payload.value), issue.inst ?? (issue.inst = ch), issue.continue ?? (issue.continue = !ch._zod.def.abort), payload.issues.push(util_issue(issue)));
-                    }, fn(payload.value, payload)));
-                return ch;
-            }(refinement)), inst.overwrite = (fn)=>inst.check(_overwrite(fn)), inst.optional = ()=>schemas_optional(inst), inst.nullable = ()=>nullable(inst), inst.nullish = ()=>schemas_optional(nullable(inst)), inst.nonoptional = (params)=>new ZodNonOptional({
+            }(check, params)), inst.superRefine = (refinement)=>{
+            var fn, fn1;
+            let ch, ch1;
+            return inst.check((fn = refinement, ch1 = (fn1 = (payload)=>(payload.addIssue = (issue)=>{
+                    "string" == typeof issue ? payload.issues.push(util_issue(issue, payload.value, ch1._zod.def)) : (issue.fatal && (issue.continue = !1), issue.code ?? (issue.code = "custom"), issue.input ?? (issue.input = payload.value), issue.inst ?? (issue.inst = ch1), issue.continue ?? (issue.continue = !ch1._zod.def.abort), payload.issues.push(util_issue(issue)));
+                }, fn(payload.value, payload)), (ch = new $ZodCheck({
+                check: "custom"
+            }))._zod.check = fn1, ch)));
+        }, inst.overwrite = (fn)=>inst.check(_overwrite(fn)), inst.optional = ()=>schemas_optional(inst), inst.nullable = ()=>nullable(inst), inst.nullish = ()=>schemas_optional(nullable(inst)), inst.nonoptional = (params)=>new ZodNonOptional({
                 type: "nonoptional",
                 innerType: inst,
                 ...normalizeParams(params)
@@ -6509,9 +6504,9 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
         $ZodCustom.init(inst, def), ZodType.init(inst, def);
     });
     function custom(fn, _params) {
-        var Class = ZodCustom, fn1 = fn ?? (()=>!0), _params1 = _params;
-        let norm = normalizeParams(_params1);
-        return norm.abort ?? (norm.abort = !0), new Class({
+        var Class, fn1;
+        let norm;
+        return Class = ZodCustom, fn1 = fn ?? (()=>!0), (norm = normalizeParams(_params)).abort ?? (norm.abort = !0), new Class({
             type: "custom",
             check: "custom",
             fn: fn1,
@@ -7174,9 +7169,9 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             let json = JSON.parse(data);
             "function" != typeof c.templateParameters && (json.compilation = compilation);
             let renderTag = function() {
-                var tag = this;
-                let attributes = Object.keys(tag.attributes || {}).filter((attributeName)=>"" === tag.attributes[attributeName] || tag.attributes[attributeName]).map((attributeName)=>"true" === tag.attributes[attributeName] ? attributeName : `${attributeName}="${tag.attributes[attributeName]}"`);
-                return `<${[
+                var tag;
+                let attributes;
+                return tag = this, attributes = Object.keys(tag.attributes || {}).filter((attributeName)=>"" === tag.attributes[attributeName] || tag.attributes[attributeName]).map((attributeName)=>"true" === tag.attributes[attributeName] ? attributeName : `${attributeName}="${tag.attributes[attributeName]}"`), `<${[
                     tag.tagName
                 ].concat(attributes).join(" ")}${tag.voidTag && !tag.innerHTML ? "/" : ""}>${tag.innerHTML || ""}${tag.voidTag && !tag.innerHTML ? "" : `</${tag.tagName}>`}`;
             }, renderTagList = function() {
@@ -7193,14 +7188,13 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             return json;
         }
         this.hooks.compilation.tap("HtmlRspackPlugin", (compilationInstance)=>{
-            var compilation1 = compilation = compilationInstance, uid1 = uid, options = c;
-            let optionsMap = compilationOptionsMap.get(compilation1) || {};
-            optionsMap[uid1] = options, compilationOptionsMap.set(compilation1, optionsMap);
+            var compilation1, uid1, options;
+            let optionsMap;
+            compilation1 = compilation = compilationInstance, uid1 = uid, options = c, (optionsMap = compilationOptionsMap.get(compilation1) || {})[uid1] = options, compilationOptionsMap.set(compilation1, optionsMap);
         }), this.hooks.done.tap("HtmlRspackPlugin", (stats)=>{
-            compilation = stats.compilation, hooks_compilationHooksMap.delete(compilation);
-            var compilation, compilation1 = stats.compilation, uid1 = uid;
-            let optionsMap = compilationOptionsMap.get(compilation1) || {};
-            delete optionsMap[uid1], 0 === Object.keys(optionsMap).length ? compilationOptionsMap.delete(compilation1) : compilationOptionsMap.set(compilation1, optionsMap);
+            var compilation, compilation1, uid1;
+            let optionsMap;
+            compilation = stats.compilation, hooks_compilationHooksMap.delete(compilation), compilation1 = stats.compilation, uid1 = uid, optionsMap = compilationOptionsMap.get(compilation1) || {}, delete optionsMap[uid1], 0 === Object.keys(optionsMap).length ? compilationOptionsMap.delete(compilation1) : compilationOptionsMap.set(compilation1, optionsMap);
         });
         let templateContent = c.templateContent;
         if ("function" == typeof templateContent) templateFn = async (data)=>{
@@ -7582,7 +7576,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             } catch (e) {
                 validateError = e;
             }
-            let finalOptions = validateError ? {
+            const finalOptions = validateError ? {
                 hashFuncNames: [
                     "sha384"
                 ],
@@ -7660,11 +7654,11 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                     });
                 });
             }), "string" == typeof this.options.htmlPlugin && this.options.htmlPlugin !== NATIVE_HTML_PLUGIN) {
+                var htmlPlugin, obj;
                 let self = this;
                 try {
-                    var obj, htmlPlugin = require(this.options.htmlPlugin);
-                    let getHooks = htmlPlugin.getCompilationHooks || htmlPlugin.getHooks;
-                    "function" == typeof getHooks && compiler.hooks.thisCompilation.tap(SubresourceIntegrityPlugin_PLUGIN_NAME, (compilation)=>{
+                    let getHooks;
+                    getHooks = (htmlPlugin = require(this.options.htmlPlugin)).getCompilationHooks || htmlPlugin.getHooks, "function" == typeof getHooks && compiler.hooks.thisCompilation.tap(SubresourceIntegrityPlugin_PLUGIN_NAME, (compilation)=>{
                         if ("string" == typeof compiler.options.output.chunkLoading && [
                             "require",
                             "async-node"
@@ -7702,7 +7696,8 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             include: options?.include,
             exclude: options?.exclude,
             extractComments: function(extractComments) {
-                let conditionStr = (condition)=>{
+                var value;
+                let type, conditionStr = (condition)=>{
                     if (void 0 === condition || !0 === condition) return "@preserve|@lic|@cc_on|^\\**!";
                     if (!1 === condition) throw Error("unreachable");
                     return condition.source;
@@ -7716,10 +7711,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
                 if (extractComments instanceof RegExp) return {
                     condition: extractComments.source
                 };
-                if (function(value) {
-                    let type = typeof value;
-                    return null != value && ("object" === type || "function" === type);
-                }(extractComments)) {
+                if (type = typeof (value = extractComments), null != value && ("object" === type || "function" === type)) {
                     if (!1 === extractComments.condition) return;
                     return {
                         condition: conditionStr(extractComments.condition),
@@ -7769,7 +7761,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             };
         }
     }
-    let DELTA_A_TO_Z = 26, NUMBER_OF_IDENTIFIER_START_CHARS = 54, NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = 64, FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g, INDENT_MULTILINE_REGEX = /^\t/gm, LINE_SEPARATOR_REGEX = /\r?\n/g, IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/, IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g, COMMENT_END_REGEX = /\*\//g, PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g, MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
+    let JSON_MODULE_TYPE = "json", DELTA_A_TO_Z = 26, NUMBER_OF_IDENTIFIER_START_CHARS = 54, NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS = 64, FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g, INDENT_MULTILINE_REGEX = /^\t/gm, LINE_SEPARATOR_REGEX = /\r?\n/g, IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/, IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g, COMMENT_END_REGEX = /\*\//g, PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g, MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
     class Template {
         static getFunctionContent(fn) {
             return fn.toString().replace(FUNCTION_CONTENT_REGEX, "").replace(INDENT_MULTILINE_REGEX, "").replace(LINE_SEPARATOR_REGEX, "\n");
@@ -8670,7 +8662,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }, applyExperimentsDefaults = (experiments, { development })=>{
         defaults_F(experiments, "cache", ()=>development), D(experiments, "futureDefaults", !1), D(experiments, "lazyCompilation", !1), D(experiments, "asyncWebAssembly", experiments.futureDefaults), D(experiments, "css", !!experiments.futureDefaults || void 0), D(experiments, "layers", !1), !1 === experiments.topLevelAwait && console.warn("`experiments.topLevelAwait` config has been deprecated and will be removed in Rspack v2.0. Top-level await will be always enabled. Please remove this option from your Rspack configuration."), D(experiments, "topLevelAwait", !0), D(experiments, "buildHttp", void 0), experiments.buildHttp && "object" == typeof experiments.buildHttp && D(experiments.buildHttp, "upgrade", !1), D(experiments, "incremental", {}), "object" == typeof experiments.incremental && (D(experiments.incremental, "silent", !0), D(experiments.incremental, "make", !0), D(experiments.incremental, "inferAsyncModules", !0), D(experiments.incremental, "providedExports", !0), D(experiments.incremental, "dependenciesDiagnostics", !0), D(experiments.incremental, "sideEffects", !0), D(experiments.incremental, "buildChunkGraph", !1), D(experiments.incremental, "moduleIds", !0), D(experiments.incremental, "chunkIds", !0), D(experiments.incremental, "modulesHashes", !0), D(experiments.incremental, "modulesCodegen", !0), D(experiments.incremental, "modulesRuntimeRequirements", !0), D(experiments.incremental, "chunksRuntimeRequirements", !0), D(experiments.incremental, "chunksHashes", !0), D(experiments.incremental, "chunksRender", !0), D(experiments.incremental, "emitAssets", !0)), D(experiments, "rspackFuture", {}), D(experiments, "parallelCodeSplitting", !1), D(experiments, "parallelLoader", !1), D(experiments, "useInputFileSystem", !1), D(experiments, "inlineConst", !1), D(experiments, "inlineEnum", !1), D(experiments, "typeReexportsPresence", !1), D(experiments, "lazyBarrel", !1);
     }, applybundlerInfoDefaults = (rspackFuture, library)=>{
-        "object" == typeof rspackFuture && (D(rspackFuture, "bundlerInfo", {}), "object" == typeof rspackFuture.bundlerInfo && (D(rspackFuture.bundlerInfo, "version", "1.5.9-canary-740cd963-20250929173807"), D(rspackFuture.bundlerInfo, "bundler", "rspack"), D(rspackFuture.bundlerInfo, "force", !library)));
+        "object" == typeof rspackFuture && (D(rspackFuture, "bundlerInfo", {}), "object" == typeof rspackFuture.bundlerInfo && (D(rspackFuture.bundlerInfo, "version", "1.5.9-canary-61eba72c-20251001174057"), D(rspackFuture.bundlerInfo, "bundler", "rspack"), D(rspackFuture.bundlerInfo, "force", !library)));
     }, applySnapshotDefaults = (_snapshot, _env)=>{}, applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName, usedExports, inlineConst })=>{
         if (assertNotNill(module.parser), assertNotNill(module.generator), defaults_F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), defaults_F(module.parser.asset, "dataUrlCondition", ()=>({})), "object" == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, "maxSize", 8096), defaults_F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { usedExports, inlineConst })=>{
             D(parserOptions, "dynamicImportMode", "lazy"), D(parserOptions, "dynamicImportPrefetch", !1), D(parserOptions, "dynamicImportPreload", !1), D(parserOptions, "url", !0), D(parserOptions, "exprContextCritical", !0), D(parserOptions, "unknownContextCritical", !0), D(parserOptions, "wrappedContextCritical", !1), D(parserOptions, "wrappedContextRegExp", /.*/), D(parserOptions, "strictExportPresence", !1), D(parserOptions, "requireAsExpression", !0), D(parserOptions, "requireDynamic", !0), D(parserOptions, "requireResolve", !0), D(parserOptions, "commonjs", !0), D(parserOptions, "importDynamic", !0), D(parserOptions, "worker", [
@@ -8679,7 +8671,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         })(module.parser.javascript, {
             usedExports,
             inlineConst
-        }), defaults_F(module.parser, "json", ()=>({})), assertNotNill(module.parser.json), D(module.parser.json, "exportsDepth", "development" === mode ? 1 : Number.MAX_SAFE_INTEGER), defaults_F(module.generator, "json", ()=>({})), assertNotNill(module.generator.json), D(module.generator.json, "JSONParse", !0), css) {
+        }), defaults_F(module.parser, JSON_MODULE_TYPE, ()=>({})), assertNotNill(module.parser[JSON_MODULE_TYPE]), D(module.parser[JSON_MODULE_TYPE], "exportsDepth", "development" === mode ? 1 : Number.MAX_SAFE_INTEGER), defaults_F(module.generator, "json", ()=>({})), assertNotNill(module.generator.json), D(module.generator.json, "JSONParse", !0), css) {
             defaults_F(module.parser, "css", ()=>({})), assertNotNill(module.parser.css), D(module.parser.css, "namedExports", !0), D(module.parser.css, "url", !0), defaults_F(module.parser, "css/auto", ()=>({})), assertNotNill(module.parser["css/auto"]), D(module.parser["css/auto"], "namedExports", !0), D(module.parser["css/auto"], "url", !0), defaults_F(module.parser, "css/module", ()=>({})), assertNotNill(module.parser["css/module"]), D(module.parser["css/module"], "namedExports", !0), D(module.parser["css/module"], "url", !0), defaults_F(module.generator, "css", ()=>({})), assertNotNill(module.generator.css), D(module.generator.css, "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator.css, "esModule", !0), defaults_F(module.generator, "css/auto", ()=>({})), assertNotNill(module.generator["css/auto"]), D(module.generator["css/auto"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/auto"], "exportsConvention", "as-is");
             let localIdentName = uniqueName && uniqueName.length > 0 ? "[uniqueName]-[id]-[local]" : "[id]-[local]";
             D(module.generator["css/auto"], "localIdentName", localIdentName), D(module.generator["css/auto"], "esModule", !0), defaults_F(module.generator, "css/module", ()=>({})), assertNotNill(module.generator["css/module"]), D(module.generator["css/module"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/module"], "exportsConvention", "as-is"), D(module.generator["css/module"], "localIdentName", localIdentName), D(module.generator["css/module"], "esModule", !0);
@@ -9446,10 +9438,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                         throw Error(`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`);
                     })(fs, p);
                     return dir === p ? void callback(err) : void mkdirp(fs, dir, (err)=>{
-                        if (err) return void callback(err);
-                        fs.mkdir(p, (err)=>{
-                            if (err) return "EEXIST" === err.code ? void callback() : void callback(err);
-                            callback();
+                        err ? callback(err) : fs.mkdir(p, (err)=>{
+                            err ? "EEXIST" === err.code ? callback() : callback(err) : callback();
                         });
                     });
                 }
@@ -9661,8 +9651,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         }
     }
     let makeWebpackErrorCallback = (callback, hook)=>(err, result)=>{
-            if (err) return err instanceof WebpackError ? void callback(err) : void callback(new HookWebpackError(err, hook));
-            callback(null, result);
+            err ? err instanceof WebpackError ? callback(err) : callback(new HookWebpackError(err, hook)) : callback(null, result);
         };
     class Cache {
         static STAGE_DISK = 10;
@@ -10314,7 +10303,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             });
         }
     }
-    let CORE_VERSION = "1.5.9-canary-740cd963-20250929173807", bindingVersionCheck_errorMessage = (coreVersion, expectedCoreVersion)=>process.env.RSPACK_BINDING ? `Unmatched version @rspack/core@${coreVersion} and binding version.
+    let CORE_VERSION = "1.5.9-canary-61eba72c-20251001174057", bindingVersionCheck_errorMessage = (coreVersion, expectedCoreVersion)=>process.env.RSPACK_BINDING ? `Unmatched version @rspack/core@${coreVersion} and binding version.
 
 Help:
 	Looks like you are using a custom binding (via environment variable 'RSPACK_BINDING=${process.env.RSPACK_BINDING}').
@@ -10846,10 +10835,9 @@ Help:
             });
         }
         close(callback) {
-            if (this.watching) return void this.watching.close(()=>{
+            this.watching ? this.watching.close(()=>{
                 this.close(callback);
-            });
-            this.hooks.shutdown.callAsync((err)=>{
+            }) : this.hooks.shutdown.callAsync((err)=>{
                 if (err) return callback(err);
                 this.cache.shutdown(()=>{
                     this.#getInstance((error, instance)=>{
@@ -10895,160 +10883,158 @@ Help:
             return this.#compilationParams = params, params;
         }
         #getInstance(callback) {
-            let error = CORE_VERSION === binding_default().EXPECTED_RSPACK_CORE_VERSION || CORE_VERSION.includes("canary") ? null : Error(bindingVersionCheck_errorMessage(CORE_VERSION, binding_default().EXPECTED_RSPACK_CORE_VERSION));
+            var options, compiler, output, module, options1, parser, generator, stats;
+            let mode, experiments, error = CORE_VERSION === binding_default().EXPECTED_RSPACK_CORE_VERSION || CORE_VERSION.includes("canary") ? null : Error(bindingVersionCheck_errorMessage(CORE_VERSION, binding_default().EXPECTED_RSPACK_CORE_VERSION));
             if (error) return callback(error);
             if (this.#instance) return callback(null, this.#instance);
-            let options = this.options, rawOptions = ((options, compiler)=>{
-                var output, module, options1, parser, generator, stats;
-                let mode = options.mode, experiments = options.experiments;
-                return {
-                    name: options.name,
+            let options2 = this.options, rawOptions = (options = options2, compiler = this, mode = options.mode, experiments = options.experiments, {
+                name: options.name,
+                mode,
+                context: options.context,
+                output: {
+                    ...output = options.output,
+                    environment: function(environment = {}) {
+                        return {
+                            const: !!environment.const,
+                            arrowFunction: !!environment.arrowFunction,
+                            nodePrefixForCoreModules: !!environment.nodePrefixForCoreModules,
+                            asyncFunction: !!environment.asyncFunction,
+                            bigIntLiteral: !!environment.bigIntLiteral,
+                            destructuring: !!environment.destructuring,
+                            document: !!environment.document,
+                            dynamicImport: !!environment.dynamicImport,
+                            forOf: !!environment.forOf,
+                            globalThis: !!environment.globalThis,
+                            module: !!environment.module,
+                            optionalChaining: !!environment.optionalChaining,
+                            templateLiteral: !!environment.templateLiteral
+                        };
+                    }(output.environment)
+                },
+                resolve: getRawResolve(options.resolve),
+                resolveLoader: getRawResolve(options.resolveLoader),
+                module: (module = options.module, options1 = {
+                    compiler,
                     mode,
                     context: options.context,
-                    output: {
-                        ...output = options.output,
-                        environment: function(environment = {}) {
-                            return {
-                                const: !!environment.const,
-                                arrowFunction: !!environment.arrowFunction,
-                                nodePrefixForCoreModules: !!environment.nodePrefixForCoreModules,
-                                asyncFunction: !!environment.asyncFunction,
-                                bigIntLiteral: !!environment.bigIntLiteral,
-                                destructuring: !!environment.destructuring,
-                                document: !!environment.document,
-                                dynamicImport: !!environment.dynamicImport,
-                                forOf: !!environment.forOf,
-                                globalThis: !!environment.globalThis,
-                                module: !!environment.module,
-                                optionalChaining: !!environment.optionalChaining,
-                                templateLiteral: !!environment.templateLiteral
-                            };
-                        }(output.environment)
-                    },
-                    resolve: getRawResolve(options.resolve),
-                    resolveLoader: getRawResolve(options.resolveLoader),
-                    module: (module = options.module, options1 = {
-                        compiler,
-                        mode,
-                        context: options.context,
-                        experiments
-                    }, external_node_assert_default()(!isNil(module.defaultRules), "module.defaultRules should not be nil after defaults"), {
-                        rules: [
-                            {
-                                rules: module.defaultRules
-                            },
-                            {
-                                rules: module.rules
-                            }
-                        ].map((rule, index)=>getRawModuleRule(rule, `ruleSet[${index}]`, options1, "javascript/auto")),
-                        parser: Object.fromEntries(Object.entries(parser = module.parser).map(([k, v])=>[
-                                k,
-                                getRawParserOptions(v, k)
-                            ]).filter(([k, v])=>void 0 !== v)),
-                        generator: Object.fromEntries(Object.entries(generator = module.generator).map(([k, v])=>[
-                                k,
-                                getRawGeneratorOptions(v, k)
-                            ]).filter(([k, v])=>void 0 !== v)),
-                        noParse: module.noParse
-                    }),
-                    optimization: options.optimization,
-                    stats: {
-                        colors: function(options) {
-                            if ("boolean" == typeof options || "string" == typeof options) return presetToOptions(options);
-                            if (!options) return {};
-                            let obj = {
-                                ...presetToOptions(options.preset),
-                                ...options
-                            };
-                            return delete obj.preset, obj;
-                        }(stats = options.stats).colors ?? !1
-                    },
-                    cache: {
-                        type: options.cache ? "memory" : "disable"
-                    },
-                    experiments,
-                    node: function(node) {
-                        if (!1 !== node) return external_node_assert_default()(!isNil(node.__dirname) && !isNil(node.global) && !isNil(node.__filename)), {
-                            dirname: String(node.__dirname),
-                            filename: String(node.__filename),
-                            global: String(node.global)
+                    experiments
+                }, external_node_assert_default()(!isNil(module.defaultRules), "module.defaultRules should not be nil after defaults"), {
+                    rules: [
+                        {
+                            rules: module.defaultRules
+                        },
+                        {
+                            rules: module.rules
+                        }
+                    ].map((rule, index)=>getRawModuleRule(rule, `ruleSet[${index}]`, options1, "javascript/auto")),
+                    parser: Object.fromEntries(Object.entries(parser = module.parser).map(([k, v])=>[
+                            k,
+                            getRawParserOptions(v, k)
+                        ]).filter(([k, v])=>void 0 !== v)),
+                    generator: Object.fromEntries(Object.entries(generator = module.generator).map(([k, v])=>[
+                            k,
+                            getRawGeneratorOptions(v, k)
+                        ]).filter(([k, v])=>void 0 !== v)),
+                    noParse: module.noParse
+                }),
+                optimization: options.optimization,
+                stats: {
+                    colors: !!function(options) {
+                        if ("boolean" == typeof options || "string" == typeof options) return presetToOptions(options);
+                        if (!options) return {};
+                        let obj = {
+                            ...presetToOptions(options.preset),
+                            ...options
                         };
-                    }(options.node),
-                    profile: options.profile,
-                    amd: options.amd ? JSON.stringify(options.amd || {}) : void 0,
-                    bail: options.bail,
-                    __references: {}
-                };
-            })(options, this);
+                        return delete obj.preset, obj;
+                    }(stats = options.stats).colors
+                },
+                cache: {
+                    type: options.cache ? "memory" : "disable"
+                },
+                experiments,
+                node: function(node) {
+                    if (!1 !== node) return external_node_assert_default()(!isNil(node.__dirname) && !isNil(node.global) && !isNil(node.__filename)), {
+                        dirname: String(node.__dirname),
+                        filename: String(node.__filename),
+                        global: String(node.global)
+                    };
+                }(options.node),
+                profile: options.profile,
+                amd: options.amd ? JSON.stringify(options.amd || {}) : void 0,
+                bail: options.bail,
+                __references: {}
+            });
             rawOptions.__references = Object.fromEntries(this.#ruleSet.builtinReferences.entries()), rawOptions.__virtual_files = VirtualModulesPlugin.__internal__take_virtual_files(this);
             let instanceBinding = __webpack_require__("@rspack/binding");
             this.#registers = this.#createHooksRegisters();
-            let inputFileSystem = this.inputFileSystem && ThreadsafeInputNodeFS.needsBinding(options.experiments.useInputFileSystem) ? ThreadsafeInputNodeFS.__to_binding(this.inputFileSystem) : void 0;
+            let inputFileSystem = this.inputFileSystem && ThreadsafeInputNodeFS.needsBinding(options2.experiments.useInputFileSystem) ? ThreadsafeInputNodeFS.__to_binding(this.inputFileSystem) : void 0;
             this.#instance = new instanceBinding.JsCompiler(this.compilerPath, rawOptions, this.#builtinPlugins, this.#registers, ThreadsafeOutputNodeFS.__to_binding(this.outputFileSystem), this.intermediateFileSystem ? ThreadsafeIntermediateNodeFS.__to_binding(this.intermediateFileSystem) : void 0, inputFileSystem, ResolverFactory.__to_binding(this.resolverFactory)), callback(null, this.#instance);
         }
         #createHooksRegisters() {
-            let getCompiler, createTap, getCompiler1, createTap1, createMapTap, getCompiler2, createTap2, createMapTap1, getCompiler3, createTap3, getCompiler4, getCompiler5, createTap4, getCompiler6, createTap5, ref = new WeakRef(this), getCompiler7 = ()=>ref.deref(), createTap6 = this.#createHookRegisterTaps.bind(this), createMapTap2 = this.#createHookMapRegisterTaps.bind(this);
+            var getCompiler, createTap;
+            let getCompiler1, createTap1, getCompiler2, createTap2, createMapTap, getCompiler3, createTap3, createMapTap1, getCompiler4, createTap4, getCompiler5, getOptions, getCompiler6, createTap5, getCompiler7, createTap6, ref = new WeakRef(this), getCompiler8 = ()=>ref.deref(), createTap7 = this.#createHookRegisterTaps.bind(this), createMapTap2 = this.#createHookMapRegisterTaps.bind(this);
             return {
-                ...(getCompiler = getCompiler7, {
-                    registerCompilerThisCompilationTaps: (createTap = createTap6)(binding_default().RegisterJsTapKind.CompilerThisCompilation, function() {
-                        return getCompiler().hooks.thisCompilation;
+                ...(getCompiler1 = getCompiler8, {
+                    registerCompilerThisCompilationTaps: (createTap1 = createTap7)(binding_default().RegisterJsTapKind.CompilerThisCompilation, function() {
+                        return getCompiler1().hooks.thisCompilation;
                     }, function(queried) {
                         return function(native) {
-                            return getCompiler().__internal__create_compilation(native), queried.call(getCompiler().__internal__get_compilation(), getCompiler().__internal__get_compilation_params());
+                            return getCompiler1().__internal__create_compilation(native), queried.call(getCompiler1().__internal__get_compilation(), getCompiler1().__internal__get_compilation_params());
                         };
                     }),
-                    registerCompilerCompilationTaps: createTap(binding_default().RegisterJsTapKind.CompilerCompilation, function() {
-                        return getCompiler().hooks.compilation;
+                    registerCompilerCompilationTaps: createTap1(binding_default().RegisterJsTapKind.CompilerCompilation, function() {
+                        return getCompiler1().hooks.compilation;
                     }, function(queried) {
                         return function() {
-                            return queried.call(getCompiler().__internal__get_compilation(), getCompiler().__internal__get_compilation_params());
+                            return queried.call(getCompiler1().__internal__get_compilation(), getCompiler1().__internal__get_compilation_params());
                         };
                     }),
-                    registerCompilerMakeTaps: createTap(binding_default().RegisterJsTapKind.CompilerMake, function() {
-                        return getCompiler().hooks.make;
+                    registerCompilerMakeTaps: createTap1(binding_default().RegisterJsTapKind.CompilerMake, function() {
+                        return getCompiler1().hooks.make;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler().__internal__get_compilation());
+                            return await queried.promise(getCompiler1().__internal__get_compilation());
                         };
                     }),
-                    registerCompilerFinishMakeTaps: createTap(binding_default().RegisterJsTapKind.CompilerFinishMake, function() {
-                        return getCompiler().hooks.finishMake;
+                    registerCompilerFinishMakeTaps: createTap1(binding_default().RegisterJsTapKind.CompilerFinishMake, function() {
+                        return getCompiler1().hooks.finishMake;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler().__internal__get_compilation());
+                            return await queried.promise(getCompiler1().__internal__get_compilation());
                         };
                     }),
-                    registerCompilerShouldEmitTaps: createTap(binding_default().RegisterJsTapKind.CompilerShouldEmit, function() {
-                        return getCompiler().hooks.shouldEmit;
+                    registerCompilerShouldEmitTaps: createTap1(binding_default().RegisterJsTapKind.CompilerShouldEmit, function() {
+                        return getCompiler1().hooks.shouldEmit;
                     }, function(queried) {
                         return function() {
-                            return queried.call(getCompiler().__internal__get_compilation());
+                            return queried.call(getCompiler1().__internal__get_compilation());
                         };
                     }),
-                    registerCompilerEmitTaps: createTap(binding_default().RegisterJsTapKind.CompilerEmit, function() {
-                        return getCompiler().hooks.emit;
+                    registerCompilerEmitTaps: createTap1(binding_default().RegisterJsTapKind.CompilerEmit, function() {
+                        return getCompiler1().hooks.emit;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler().__internal__get_compilation());
+                            return await queried.promise(getCompiler1().__internal__get_compilation());
                         };
                     }),
-                    registerCompilerAfterEmitTaps: createTap(binding_default().RegisterJsTapKind.CompilerAfterEmit, function() {
-                        return getCompiler().hooks.afterEmit;
+                    registerCompilerAfterEmitTaps: createTap1(binding_default().RegisterJsTapKind.CompilerAfterEmit, function() {
+                        return getCompiler1().hooks.afterEmit;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler().__internal__get_compilation());
+                            return await queried.promise(getCompiler1().__internal__get_compilation());
                         };
                     }),
-                    registerCompilerAssetEmittedTaps: createTap(binding_default().RegisterJsTapKind.CompilerAssetEmitted, function() {
-                        return getCompiler().hooks.assetEmitted;
+                    registerCompilerAssetEmittedTaps: createTap1(binding_default().RegisterJsTapKind.CompilerAssetEmitted, function() {
+                        return getCompiler1().hooks.assetEmitted;
                     }, function(queried) {
                         return async function({ filename, targetPath, outputPath }) {
                             return queried.promise(filename, {
-                                compilation: getCompiler().__internal__get_compilation(),
+                                compilation: getCompiler1().__internal__get_compilation(),
                                 targetPath,
                                 outputPath,
                                 get source () {
-                                    return getCompiler().__internal__get_compilation().getAsset(filename)?.source;
+                                    return getCompiler1().__internal__get_compilation().getAsset(filename)?.source;
                                 },
                                 get content () {
                                     return this.source?.buffer();
@@ -11057,9 +11043,9 @@ Help:
                         };
                     })
                 }),
-                ...(getCompiler1 = getCompiler7, createTap1 = createTap6, createMapTap = createMapTap2, {
-                    registerCompilationAdditionalTreeRuntimeRequirementsTaps: createTap1(binding_default().RegisterJsTapKind.CompilationAdditionalTreeRuntimeRequirements, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.additionalTreeRuntimeRequirements;
+                ...(getCompiler2 = getCompiler8, createTap2 = createTap7, createMapTap = createMapTap2, {
+                    registerCompilationAdditionalTreeRuntimeRequirementsTaps: createTap2(binding_default().RegisterJsTapKind.CompilationAdditionalTreeRuntimeRequirements, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.additionalTreeRuntimeRequirements;
                     }, function(queried) {
                         return function({ chunk, runtimeRequirements }) {
                             let set = __from_binding_runtime_globals(runtimeRequirements);
@@ -11069,7 +11055,7 @@ Help:
                         };
                     }),
                     registerCompilationRuntimeRequirementInTreeTaps: createMapTap(binding_default().RegisterJsTapKind.CompilationRuntimeRequirementInTree, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.runtimeRequirementInTree;
+                        return getCompiler2().__internal__get_compilation().hooks.runtimeRequirementInTree;
                     }, function(queried) {
                         return function({ chunk, allRuntimeRequirements, runtimeRequirements }) {
                             let set = __from_binding_runtime_globals(runtimeRequirements), all = __from_binding_runtime_globals(allRuntimeRequirements), customRuntimeGlobals = new Set(), originalAdd = all.add.bind(all), add = function(r) {
@@ -11083,8 +11069,8 @@ Help:
                             };
                         };
                     }),
-                    registerCompilationRuntimeModuleTaps: createTap1(binding_default().RegisterJsTapKind.CompilationRuntimeModule, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.runtimeModule;
+                    registerCompilationRuntimeModuleTaps: createTap2(binding_default().RegisterJsTapKind.CompilationRuntimeModule, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.runtimeModule;
                     }, function(queried) {
                         return function({ module, chunk }) {
                             let originSource = module.source?.source;
@@ -11093,29 +11079,29 @@ Help:
                             if (newSource && newSource !== originSource) return module;
                         };
                     }),
-                    registerCompilationBuildModuleTaps: createTap1(binding_default().RegisterJsTapKind.CompilationBuildModule, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.buildModule;
+                    registerCompilationBuildModuleTaps: createTap2(binding_default().RegisterJsTapKind.CompilationBuildModule, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.buildModule;
                     }, function(queried) {
                         return function(module) {
                             return queried.call(module);
                         };
                     }),
-                    registerCompilationStillValidModuleTaps: createTap1(binding_default().RegisterJsTapKind.CompilationStillValidModule, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.stillValidModule;
+                    registerCompilationStillValidModuleTaps: createTap2(binding_default().RegisterJsTapKind.CompilationStillValidModule, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.stillValidModule;
                     }, function(queried) {
                         return function(module) {
                             return queried.call(module);
                         };
                     }),
-                    registerCompilationSucceedModuleTaps: createTap1(binding_default().RegisterJsTapKind.CompilationSucceedModule, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.succeedModule;
+                    registerCompilationSucceedModuleTaps: createTap2(binding_default().RegisterJsTapKind.CompilationSucceedModule, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.succeedModule;
                     }, function(queried) {
                         return function(module) {
                             return queried.call(module);
                         };
                     }),
-                    registerCompilationExecuteModuleTaps: createTap1(binding_default().RegisterJsTapKind.CompilationExecuteModule, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.executeModule;
+                    registerCompilationExecuteModuleTaps: createTap2(binding_default().RegisterJsTapKind.CompilationExecuteModule, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.executeModule;
                     }, function(queried) {
                         return function({ entry, id, codegenResults, runtimeModules }) {
                             try {
@@ -11153,96 +11139,96 @@ Help:
                                 }, moduleCache = __nested_webpack_require_4781_4800__[RuntimeGlobals.moduleCache.replace(`${RuntimeGlobals.require}.`, "")] = {}, interceptModuleExecution = __nested_webpack_require_4781_4800__[RuntimeGlobals.interceptModuleExecution.replace(`${RuntimeGlobals.require}.`, "")] = [];
                                 for (let runtimeModule of runtimeModules)__nested_webpack_require_4781_4800__(runtimeModule);
                                 let executeResult = __nested_webpack_require_4781_4800__(entry);
-                                getCompiler1().__internal__get_module_execution_results_map().set(id, executeResult);
+                                getCompiler2().__internal__get_module_execution_results_map().set(id, executeResult);
                             } catch (e) {
-                                throw getCompiler1().__internal__get_module_execution_results_map().set(id, e), e;
+                                throw getCompiler2().__internal__get_module_execution_results_map().set(id, e), e;
                             }
                         };
                     }),
-                    registerCompilationFinishModulesTaps: createTap1(binding_default().RegisterJsTapKind.CompilationFinishModules, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.finishModules;
+                    registerCompilationFinishModulesTaps: createTap2(binding_default().RegisterJsTapKind.CompilationFinishModules, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.finishModules;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler1().__internal__get_compilation().modules);
+                            return await queried.promise(getCompiler2().__internal__get_compilation().modules);
                         };
                     }),
-                    registerCompilationOptimizeModulesTaps: createTap1(binding_default().RegisterJsTapKind.CompilationOptimizeModules, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.optimizeModules;
+                    registerCompilationOptimizeModulesTaps: createTap2(binding_default().RegisterJsTapKind.CompilationOptimizeModules, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.optimizeModules;
                     }, function(queried) {
                         return function() {
-                            return queried.call(getCompiler1().__internal__get_compilation().modules.values());
+                            return queried.call(getCompiler2().__internal__get_compilation().modules.values());
                         };
                     }),
-                    registerCompilationAfterOptimizeModulesTaps: createTap1(binding_default().RegisterJsTapKind.CompilationAfterOptimizeModules, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.afterOptimizeModules;
+                    registerCompilationAfterOptimizeModulesTaps: createTap2(binding_default().RegisterJsTapKind.CompilationAfterOptimizeModules, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.afterOptimizeModules;
                     }, function(queried) {
                         return function() {
-                            queried.call(getCompiler1().__internal__get_compilation().modules.values());
+                            queried.call(getCompiler2().__internal__get_compilation().modules.values());
                         };
                     }),
-                    registerCompilationOptimizeTreeTaps: createTap1(binding_default().RegisterJsTapKind.CompilationOptimizeTree, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.optimizeTree;
+                    registerCompilationOptimizeTreeTaps: createTap2(binding_default().RegisterJsTapKind.CompilationOptimizeTree, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.optimizeTree;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler1().__internal__get_compilation().chunks, getCompiler1().__internal__get_compilation().modules);
+                            return await queried.promise(getCompiler2().__internal__get_compilation().chunks, getCompiler2().__internal__get_compilation().modules);
                         };
                     }),
-                    registerCompilationOptimizeChunkModulesTaps: createTap1(binding_default().RegisterJsTapKind.CompilationOptimizeChunkModules, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.optimizeChunkModules;
+                    registerCompilationOptimizeChunkModulesTaps: createTap2(binding_default().RegisterJsTapKind.CompilationOptimizeChunkModules, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.optimizeChunkModules;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler1().__internal__get_compilation().chunks, getCompiler1().__internal__get_compilation().modules);
+                            return await queried.promise(getCompiler2().__internal__get_compilation().chunks, getCompiler2().__internal__get_compilation().modules);
                         };
                     }),
-                    registerCompilationChunkHashTaps: createTap1(binding_default().RegisterJsTapKind.CompilationChunkHash, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.chunkHash;
+                    registerCompilationChunkHashTaps: createTap2(binding_default().RegisterJsTapKind.CompilationChunkHash, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.chunkHash;
                     }, function(queried) {
                         return function(chunk) {
                             let digestResult;
-                            if (!getCompiler1().options.output.hashFunction) throw Error("'output.hashFunction' cannot be undefined");
-                            let hash = createHash(getCompiler1().options.output.hashFunction);
-                            return queried.call(chunk, hash), "string" == typeof (digestResult = getCompiler1().options.output.hashDigest ? hash.digest(getCompiler1().options.output.hashDigest) : hash.digest()) ? Buffer.from(digestResult) : digestResult;
+                            if (!getCompiler2().options.output.hashFunction) throw Error("'output.hashFunction' cannot be undefined");
+                            let hash = createHash(getCompiler2().options.output.hashFunction);
+                            return queried.call(chunk, hash), "string" == typeof (digestResult = getCompiler2().options.output.hashDigest ? hash.digest(getCompiler2().options.output.hashDigest) : hash.digest()) ? Buffer.from(digestResult) : digestResult;
                         };
                     }),
-                    registerCompilationChunkAssetTaps: createTap1(binding_default().RegisterJsTapKind.CompilationChunkAsset, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.chunkAsset;
+                    registerCompilationChunkAssetTaps: createTap2(binding_default().RegisterJsTapKind.CompilationChunkAsset, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.chunkAsset;
                     }, function(queried) {
                         return function({ chunk, filename }) {
                             return queried.call(chunk, filename);
                         };
                     }),
-                    registerCompilationProcessAssetsTaps: createTap1(binding_default().RegisterJsTapKind.CompilationProcessAssets, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.processAssets;
+                    registerCompilationProcessAssetsTaps: createTap2(binding_default().RegisterJsTapKind.CompilationProcessAssets, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.processAssets;
                     }, function(queried) {
                         return async function() {
-                            return await queried.promise(getCompiler1().__internal__get_compilation().assets);
+                            return await queried.promise(getCompiler2().__internal__get_compilation().assets);
                         };
                     }),
-                    registerCompilationAfterProcessAssetsTaps: createTap1(binding_default().RegisterJsTapKind.CompilationAfterProcessAssets, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.afterProcessAssets;
+                    registerCompilationAfterProcessAssetsTaps: createTap2(binding_default().RegisterJsTapKind.CompilationAfterProcessAssets, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.afterProcessAssets;
                     }, function(queried) {
                         return function() {
-                            return queried.call(getCompiler1().__internal__get_compilation().assets);
+                            return queried.call(getCompiler2().__internal__get_compilation().assets);
                         };
                     }),
-                    registerCompilationSealTaps: createTap1(binding_default().RegisterJsTapKind.CompilationSeal, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.seal;
+                    registerCompilationSealTaps: createTap2(binding_default().RegisterJsTapKind.CompilationSeal, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.seal;
                     }, function(queried) {
                         return function() {
                             return queried.call();
                         };
                     }),
-                    registerCompilationAfterSealTaps: createTap1(binding_default().RegisterJsTapKind.CompilationAfterSeal, function() {
-                        return getCompiler1().__internal__get_compilation().hooks.afterSeal;
+                    registerCompilationAfterSealTaps: createTap2(binding_default().RegisterJsTapKind.CompilationAfterSeal, function() {
+                        return getCompiler2().__internal__get_compilation().hooks.afterSeal;
                     }, function(queried) {
                         return async function() {
                             return await queried.promise();
                         };
                     })
                 }),
-                ...(getCompiler2 = getCompiler7, createTap2 = createTap6, createMapTap1 = createMapTap2, {
-                    registerNormalModuleFactoryBeforeResolveTaps: createTap2(binding_default().RegisterJsTapKind.NormalModuleFactoryBeforeResolve, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.beforeResolve;
+                ...(getCompiler3 = getCompiler8, createTap3 = createTap7, createMapTap1 = createMapTap2, {
+                    registerNormalModuleFactoryBeforeResolveTaps: createTap3(binding_default().RegisterJsTapKind.NormalModuleFactoryBeforeResolve, function() {
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.beforeResolve;
                     }, function(queried) {
                         return async function(resolveData) {
                             return [
@@ -11251,22 +11237,22 @@ Help:
                             ];
                         };
                     }),
-                    registerNormalModuleFactoryFactorizeTaps: createTap2(binding_default().RegisterJsTapKind.NormalModuleFactoryFactorize, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.factorize;
+                    registerNormalModuleFactoryFactorizeTaps: createTap3(binding_default().RegisterJsTapKind.NormalModuleFactoryFactorize, function() {
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.factorize;
                     }, function(queried) {
                         return async function(resolveData) {
                             return await queried.promise(resolveData), resolveData;
                         };
                     }),
-                    registerNormalModuleFactoryResolveTaps: createTap2(binding_default().RegisterJsTapKind.NormalModuleFactoryResolve, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.resolve;
+                    registerNormalModuleFactoryResolveTaps: createTap3(binding_default().RegisterJsTapKind.NormalModuleFactoryResolve, function() {
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.resolve;
                     }, function(queried) {
                         return async function(resolveData) {
                             return await queried.promise(resolveData), resolveData;
                         };
                     }),
                     registerNormalModuleFactoryResolveForSchemeTaps: createMapTap1(binding_default().RegisterJsTapKind.NormalModuleFactoryResolveForScheme, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.resolveForScheme;
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.resolveForScheme;
                     }, function(queried) {
                         return async function(args) {
                             return [
@@ -11275,8 +11261,8 @@ Help:
                             ];
                         };
                     }),
-                    registerNormalModuleFactoryAfterResolveTaps: createTap2(binding_default().RegisterJsTapKind.NormalModuleFactoryAfterResolve, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.afterResolve;
+                    registerNormalModuleFactoryAfterResolveTaps: createTap3(binding_default().RegisterJsTapKind.NormalModuleFactoryAfterResolve, function() {
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.afterResolve;
                     }, function(queried) {
                         return async function(resolveData) {
                             return [
@@ -11285,8 +11271,8 @@ Help:
                             ];
                         };
                     }),
-                    registerNormalModuleFactoryCreateModuleTaps: createTap2(binding_default().RegisterJsTapKind.NormalModuleFactoryCreateModule, function() {
-                        return getCompiler2().__internal__get_compilation_params().normalModuleFactory.hooks.createModule;
+                    registerNormalModuleFactoryCreateModuleTaps: createTap3(binding_default().RegisterJsTapKind.NormalModuleFactoryCreateModule, function() {
+                        return getCompiler3().__internal__get_compilation_params().normalModuleFactory.hooks.createModule;
                     }, function(queried) {
                         return async function(args) {
                             let data = {
@@ -11297,17 +11283,17 @@ Help:
                         };
                     })
                 }),
-                ...(getCompiler3 = getCompiler7, {
-                    registerContextModuleFactoryBeforeResolveTaps: (createTap3 = createTap6)(binding_default().RegisterJsTapKind.ContextModuleFactoryBeforeResolve, function() {
-                        return getCompiler3().__internal__get_compilation_params().contextModuleFactory.hooks.beforeResolve;
+                ...(getCompiler4 = getCompiler8, {
+                    registerContextModuleFactoryBeforeResolveTaps: (createTap4 = createTap7)(binding_default().RegisterJsTapKind.ContextModuleFactoryBeforeResolve, function() {
+                        return getCompiler4().__internal__get_compilation_params().contextModuleFactory.hooks.beforeResolve;
                     }, function(queried) {
                         return async function(bindingData) {
                             let data = !!bindingData && ContextModuleFactoryBeforeResolveData.__from_binding(bindingData), result = await queried.promise(data);
                             return !!result && ContextModuleFactoryBeforeResolveData.__to_binding(result);
                         };
                     }),
-                    registerContextModuleFactoryAfterResolveTaps: createTap3(binding_default().RegisterJsTapKind.ContextModuleFactoryAfterResolve, function() {
-                        return getCompiler3().__internal__get_compilation_params().contextModuleFactory.hooks.afterResolve;
+                    registerContextModuleFactoryAfterResolveTaps: createTap4(binding_default().RegisterJsTapKind.ContextModuleFactoryAfterResolve, function() {
+                        return getCompiler4().__internal__get_compilation_params().contextModuleFactory.hooks.afterResolve;
                     }, function(queried) {
                         return async function(bindingData) {
                             let data = !!bindingData && ContextModuleFactoryAfterResolveData.__from_binding(bindingData), result = await queried.promise(data);
@@ -11315,158 +11301,155 @@ Help:
                         };
                     })
                 }),
-                ...(getCompiler4 = getCompiler7, {
-                    registerJavascriptModulesChunkHashTaps: createTap6(binding_default().RegisterJsTapKind.JavascriptModulesChunkHash, function() {
-                        return JavascriptModulesPlugin.getCompilationHooks(getCompiler4().__internal__get_compilation()).chunkHash;
+                ...(getCompiler5 = getCompiler8, {
+                    registerJavascriptModulesChunkHashTaps: createTap7(binding_default().RegisterJsTapKind.JavascriptModulesChunkHash, function() {
+                        return JavascriptModulesPlugin.getCompilationHooks(getCompiler5().__internal__get_compilation()).chunkHash;
                     }, function(queried) {
                         return function(chunk) {
                             let digestResult;
-                            if (!getCompiler4().options.output.hashFunction) throw Error("'output.hashFunction' cannot be undefined");
-                            let hash = createHash(getCompiler4().options.output.hashFunction);
-                            return queried.call(chunk, hash), "string" == typeof (digestResult = getCompiler4().options.output.hashDigest ? hash.digest(getCompiler4().options.output.hashDigest) : hash.digest()) ? Buffer.from(digestResult) : digestResult;
+                            if (!getCompiler5().options.output.hashFunction) throw Error("'output.hashFunction' cannot be undefined");
+                            let hash = createHash(getCompiler5().options.output.hashFunction);
+                            return queried.call(chunk, hash), "string" == typeof (digestResult = getCompiler5().options.output.hashDigest ? hash.digest(getCompiler5().options.output.hashDigest) : hash.digest()) ? Buffer.from(digestResult) : digestResult;
                         };
                     })
                 }),
-                ...((getCompiler, createTap)=>{
-                    let getOptions = (uid)=>((compilation, uid)=>{
-                            if (!(compilation instanceof Compilation)) throw TypeError("The 'compilation' argument must be an instance of Compilation");
-                            return compilationOptionsMap.get(compilation)?.[uid];
-                        })(getCompiler().__internal__get_compilation(), uid);
-                    return {
-                        registerHtmlPluginBeforeAssetTagGenerationTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginBeforeAssetTagGeneration, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).beforeAssetTagGeneration;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res.uid = uid, res;
-                            };
-                        }),
-                        registerHtmlPluginAlterAssetTagsTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAlterAssetTags, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).alterAssetTags;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res.uid = uid, res;
-                            };
-                        }),
-                        registerHtmlPluginAlterAssetTagGroupsTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAlterAssetTagGroups, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).alterAssetTagGroups;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res.uid = uid, res;
-                            };
-                        }),
-                        registerHtmlPluginAfterTemplateExecutionTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAfterTemplateExecution, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).afterTemplateExecution;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res;
-                            };
-                        }),
-                        registerHtmlPluginBeforeEmitTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginBeforeEmit, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).beforeEmit;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res.uid = uid, res;
-                            };
-                        }),
-                        registerHtmlPluginAfterEmitTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAfterEmit, function() {
-                            return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).afterEmit;
-                        }, function(queried) {
-                            return async function(data) {
-                                let { compilationId, uid } = data, res = await queried.promise({
-                                    ...data,
-                                    plugin: {
-                                        options: getOptions(uid)
-                                    }
-                                });
-                                return res.compilationId = compilationId, res.uid = uid, res;
-                            };
-                        })
-                    };
-                })(getCompiler7, createTap6, createMapTap2),
-                ...(getCompiler5 = getCompiler7, {
-                    registerRuntimePluginCreateScriptTaps: (createTap4 = createTap6)(binding_default().RegisterJsTapKind.RuntimePluginCreateScript, function() {
-                        return RuntimePlugin.getCompilationHooks(getCompiler5().__internal__get_compilation()).createScript;
+                ...(getCompiler = getCompiler8, createTap = createTap7, getOptions = (uid)=>((compilation, uid)=>{
+                        if (!(compilation instanceof Compilation)) throw TypeError("The 'compilation' argument must be an instance of Compilation");
+                        return compilationOptionsMap.get(compilation)?.[uid];
+                    })(getCompiler().__internal__get_compilation(), uid), {
+                    registerHtmlPluginBeforeAssetTagGenerationTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginBeforeAssetTagGeneration, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).beforeAssetTagGeneration;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res.uid = uid, res;
+                        };
+                    }),
+                    registerHtmlPluginAlterAssetTagsTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAlterAssetTags, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).alterAssetTags;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res.uid = uid, res;
+                        };
+                    }),
+                    registerHtmlPluginAlterAssetTagGroupsTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAlterAssetTagGroups, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).alterAssetTagGroups;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res.uid = uid, res;
+                        };
+                    }),
+                    registerHtmlPluginAfterTemplateExecutionTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAfterTemplateExecution, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).afterTemplateExecution;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res;
+                        };
+                    }),
+                    registerHtmlPluginBeforeEmitTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginBeforeEmit, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).beforeEmit;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res.uid = uid, res;
+                        };
+                    }),
+                    registerHtmlPluginAfterEmitTaps: createTap(binding_default().RegisterJsTapKind.HtmlPluginAfterEmit, function() {
+                        return HtmlRspackPlugin.getCompilationHooks(getCompiler().__internal__get_compilation()).afterEmit;
+                    }, function(queried) {
+                        return async function(data) {
+                            let { compilationId, uid } = data, res = await queried.promise({
+                                ...data,
+                                plugin: {
+                                    options: getOptions(uid)
+                                }
+                            });
+                            return res.compilationId = compilationId, res.uid = uid, res;
+                        };
+                    })
+                }),
+                ...(getCompiler6 = getCompiler8, {
+                    registerRuntimePluginCreateScriptTaps: (createTap5 = createTap7)(binding_default().RegisterJsTapKind.RuntimePluginCreateScript, function() {
+                        return RuntimePlugin.getCompilationHooks(getCompiler6().__internal__get_compilation()).createScript;
                     }, function(queried) {
                         return function(data) {
                             return queried.call(data.code, data.chunk);
                         };
                     }),
-                    registerRuntimePluginLinkPreloadTaps: createTap4(binding_default().RegisterJsTapKind.RuntimePluginLinkPreload, function() {
-                        return RuntimePlugin.getCompilationHooks(getCompiler5().__internal__get_compilation()).linkPreload;
+                    registerRuntimePluginLinkPreloadTaps: createTap5(binding_default().RegisterJsTapKind.RuntimePluginLinkPreload, function() {
+                        return RuntimePlugin.getCompilationHooks(getCompiler6().__internal__get_compilation()).linkPreload;
                     }, function(queried) {
                         return function(data) {
                             return queried.call(data.code, data.chunk);
                         };
                     }),
-                    registerRuntimePluginLinkPrefetchTaps: createTap4(binding_default().RegisterJsTapKind.RuntimePluginLinkPrefetch, function() {
-                        return RuntimePlugin.getCompilationHooks(getCompiler5().__internal__get_compilation()).linkPrefetch;
+                    registerRuntimePluginLinkPrefetchTaps: createTap5(binding_default().RegisterJsTapKind.RuntimePluginLinkPrefetch, function() {
+                        return RuntimePlugin.getCompilationHooks(getCompiler6().__internal__get_compilation()).linkPrefetch;
                     }, function(queried) {
                         return function(data) {
                             return queried.call(data.code, data.chunk);
                         };
                     })
                 }),
-                ...(getCompiler6 = getCompiler7, {
-                    registerRsdoctorPluginModuleGraphTaps: (createTap5 = createTap6)(binding_.RegisterJsTapKind.RsdoctorPluginModuleGraph, function() {
-                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler6().__internal__get_compilation()).moduleGraph;
+                ...(getCompiler7 = getCompiler8, {
+                    registerRsdoctorPluginModuleGraphTaps: (createTap6 = createTap7)(binding_.RegisterJsTapKind.RsdoctorPluginModuleGraph, function() {
+                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler7().__internal__get_compilation()).moduleGraph;
                     }, function(queried) {
                         return async function(data) {
                             return await queried.promise(data);
                         };
                     }),
-                    registerRsdoctorPluginChunkGraphTaps: createTap5(binding_.RegisterJsTapKind.RsdoctorPluginChunkGraph, function() {
-                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler6().__internal__get_compilation()).chunkGraph;
+                    registerRsdoctorPluginChunkGraphTaps: createTap6(binding_.RegisterJsTapKind.RsdoctorPluginChunkGraph, function() {
+                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler7().__internal__get_compilation()).chunkGraph;
                     }, function(queried) {
                         return async function(data) {
                             return await queried.promise(data);
                         };
                     }),
-                    registerRsdoctorPluginModuleIdsTaps: createTap5(binding_.RegisterJsTapKind.RsdoctorPluginModuleIds, function() {
-                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler6().__internal__get_compilation()).moduleIds;
+                    registerRsdoctorPluginModuleIdsTaps: createTap6(binding_.RegisterJsTapKind.RsdoctorPluginModuleIds, function() {
+                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler7().__internal__get_compilation()).moduleIds;
                     }, function(queried) {
                         return async function(data) {
                             return await queried.promise(data);
                         };
                     }),
-                    registerRsdoctorPluginModuleSourcesTaps: createTap5(binding_.RegisterJsTapKind.RsdoctorPluginModuleSources, function() {
-                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler6().__internal__get_compilation()).moduleSources;
+                    registerRsdoctorPluginModuleSourcesTaps: createTap6(binding_.RegisterJsTapKind.RsdoctorPluginModuleSources, function() {
+                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler7().__internal__get_compilation()).moduleSources;
                     }, function(queried) {
                         return async function(data) {
                             return await queried.promise(data);
                         };
                     }),
-                    registerRsdoctorPluginAssetsTaps: createTap5(binding_.RegisterJsTapKind.RsdoctorPluginAssets, function() {
-                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler6().__internal__get_compilation()).assets;
+                    registerRsdoctorPluginAssetsTaps: createTap6(binding_.RegisterJsTapKind.RsdoctorPluginAssets, function() {
+                        return RsdoctorPluginImpl.getCompilationHooks(getCompiler7().__internal__get_compilation()).assets;
                     }, function(queried) {
                         return async function(data) {
                             return await queried.promise(data);
@@ -11598,7 +11581,7 @@ Help:
             obj.children = this.stats.map((stat, idx)=>{
                 let obj = stat.toJson(childOptions.children[idx]), compilationName = stat.compilation.name;
                 return obj.name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root), obj;
-            }), childOptions.version && (obj.rspackVersion = "1.5.9-canary-740cd963-20250929173807", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(""));
+            }), childOptions.version && (obj.rspackVersion = "1.5.9-canary-61eba72c-20251001174057", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(""));
             let mapError = (j, obj)=>({
                     ...obj,
                     compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
@@ -11614,11 +11597,8 @@ Help:
                 forToString: !0
             });
             return this.stats.map((stat, idx)=>{
-                let str = stat.toString(childOptions.children[idx]), compilationName = stat.compilation.name, name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root).replace(/\|/g, " ");
-                return str && name ? `${name}:\n${function(str, prefix) {
-                    let rem = str.replace(/\n([^\n])/g, `\n  $1`);
-                    return "  " + rem;
-                }(str, "  ")}` : str;
+                let rem, str = stat.toString(childOptions.children[idx]), compilationName = stat.compilation.name, name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root).replace(/\|/g, " ");
+                return str ? name ? `${name}:\n${"  " + (rem = str.replace(/\n([^\n])/g, `\n  $1`))}` : str : str;
             }).filter(Boolean).join("\n\n");
         }
     }
@@ -11738,9 +11718,11 @@ Help:
             }, this.compilers = normalizedCompilers, this._options = {
                 parallelism: options?.parallelism || 1 / 0
             }, this.dependencies = new WeakMap(), this.running = !1;
-            let compilerStats = this.compilers.map(()=>null), doneCompilers = 0;
+            const compilerStats = this.compilers.map(()=>null);
+            let doneCompilers = 0;
             for(let index = 0; index < this.compilers.length; index++){
-                let compiler = this.compilers[index], compilerIndex = index, compilerDone = !1;
+                const compiler = this.compilers[index], compilerIndex = index;
+                let compilerDone = !1;
                 compiler.hooks.done.tap("MultiCompiler", (stats)=>{
                     !compilerDone && (compilerDone = !0, doneCompilers++), compilerStats[compilerIndex] = stats, doneCompilers === this.compilers.length && this.hooks.done.call(new MultiStats(compilerStats));
                 }), compiler.hooks.invalid.tap("MultiCompiler", ()=>{
@@ -12495,7 +12477,7 @@ Help:
                 object.hash = context.getStatsCompilation(compilation).hash;
             },
             version: (object)=>{
-                object.version = "5.75.0", object.rspackVersion = "1.5.9-canary-740cd963-20250929173807";
+                object.version = "5.75.0", object.rspackVersion = "1.5.9-canary-61eba72c-20251001174057";
             },
             env: (object, _compilation, _context, { _env })=>{
                 object.env = _env;
@@ -13220,7 +13202,7 @@ Help:
         "chunkOrigin.moduleName": (moduleName, { bold })=>bold(moduleName),
         "chunkOrigin.loc": (loc)=>loc,
         "error.file": (file, { bold })=>bold(file),
-        "error.moduleName": (moduleName, { bold })=>moduleName.includes("!") ? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})` : `${bold(moduleName)}`,
+        "error.moduleName": (moduleName, { bold })=>moduleName.includes("!") ? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})` : bold(moduleName),
         "error.loc": (loc, { green })=>green(loc),
         "error.message": (message, { bold, formatError })=>message.includes("\u001b[") ? message : bold(formatError(message)),
         "error.details": (details, { formatError })=>formatError(details),
@@ -13714,7 +13696,7 @@ Help:
                 return time < times[3] ? `${time}${unit}` : time < times[2] ? bold(`${time}${unit}`) : time < times[1] ? green(`${time}${unit}`) : time < times[0] ? yellow(`${time}${unit}`) : red(`${time}${unit}`);
             }
             let timeStr = time.toString();
-            return time > 1000 && (timeStr = `${(time / 1000).toFixed(2)}`, unit = " s"), `${boldQuantity ? bold(timeStr) : timeStr}${unit}`;
+            return time > 1000 && (timeStr = (time / 1000).toFixed(2), unit = " s"), `${boldQuantity ? bold(timeStr) : timeStr}${unit}`;
         },
         formatError: (msg, { green, yellow, red })=>{
             let message = msg;
@@ -15684,7 +15666,7 @@ Help:
         _provides;
         _enhanced;
         constructor(options){
-            let sharedOptions = parseOptions(options.shared, (item, key)=>{
+            const sharedOptions = parseOptions(options.shared, (item, key)=>{
                 var str;
                 if ("string" != typeof item) throw Error("Unexpected array in shared");
                 return item !== key && (str = item, VERSION_PATTERN_REGEXP.test(str)) ? {
@@ -15820,7 +15802,7 @@ Help:
         let _options = JSON.stringify(options || {});
         return binding_default().transform(source, _options);
     }
-    let exports_rspackVersion = "1.5.9-canary-740cd963-20250929173807", exports_version = "5.75.0", exports_WebpackError = Error, sources = __webpack_require__("webpack-sources"), exports_config = {
+    let exports_rspackVersion = "1.5.9-canary-61eba72c-20251001174057", exports_version = "5.75.0", exports_WebpackError = Error, sources = __webpack_require__("webpack-sources"), exports_config = {
         getNormalizedRspackOptions: getNormalizedRspackOptions,
         applyRspackOptionsDefaults: applyRspackOptionsDefaults,
         getNormalizedWebpackOptions: getNormalizedRspackOptions,
@@ -15867,22 +15849,20 @@ Help:
                 this._options = _options;
             }
             apply(compiler) {
-                let { webpack } = compiler, paths = function(options) {
-                    let runtimeToolsPath = options.implementation ?? require.resolve("@module-federation/runtime-tools"), bundlerRuntimePath = require.resolve("@module-federation/webpack-bundler-runtime", {
-                        paths: [
-                            runtimeToolsPath
-                        ]
-                    }), runtimePath = require.resolve("@module-federation/runtime", {
-                        paths: [
-                            runtimeToolsPath
-                        ]
-                    });
-                    return {
-                        runtimeTools: runtimeToolsPath,
-                        bundlerRuntime: bundlerRuntimePath,
-                        runtime: runtimePath
-                    };
-                }(this._options);
+                var options;
+                let runtimeToolsPath, bundlerRuntimePath, runtimePath, { webpack } = compiler, paths = (runtimeToolsPath = (options = this._options).implementation ?? require.resolve("@module-federation/runtime-tools"), bundlerRuntimePath = require.resolve("@module-federation/webpack-bundler-runtime", {
+                    paths: [
+                        runtimeToolsPath
+                    ]
+                }), runtimePath = require.resolve("@module-federation/runtime", {
+                    paths: [
+                        runtimeToolsPath
+                    ]
+                }), {
+                    runtimeTools: runtimeToolsPath,
+                    bundlerRuntime: bundlerRuntimePath,
+                    runtime: runtimePath
+                });
                 compiler.options.resolve.alias = {
                     "@module-federation/runtime-tools": paths.runtimeTools,
                     "@module-federation/runtime": paths.runtime,