@rspack-debug/core 1.4.11 → 1.6.2

package/dist/worker.js

@@ -1,8 +1,33 @@
 "use strict";
 var __webpack_modules__ = {
+    "./src/swc.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+            minify: ()=>minify,
+            minifySync: ()=>minifySync,
+            transform: ()=>transform,
+            transformSync: ()=>transformSync
+        });
+        var _rspack_binding__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@rspack/binding"), _rspack_binding__WEBPACK_IMPORTED_MODULE_0___default = __webpack_require__.n(_rspack_binding__WEBPACK_IMPORTED_MODULE_0__);
+        async function minify(source, options) {
+            let _options = JSON.stringify(options || {});
+            return _rspack_binding__WEBPACK_IMPORTED_MODULE_0___default().minify(source, _options);
+        }
+        function minifySync(source, options) {
+            let _options = JSON.stringify(options || {});
+            return _rspack_binding__WEBPACK_IMPORTED_MODULE_0___default().minifySync(source, _options);
+        }
+        async function transform(source, options) {
+            let _options = JSON.stringify(options || {});
+            return _rspack_binding__WEBPACK_IMPORTED_MODULE_0___default().transform(source, _options);
+        }
+        function transformSync(source, options) {
+            let _options = JSON.stringify(options || {});
+            return _rspack_binding__WEBPACK_IMPORTED_MODULE_0___default().transformSync(source, _options);
+        }
+    },
     "./src/util/cleverMerge.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            R_: ()=>cleverMerge
+            ks: ()=>cleverMerge
         });
         let DYNAMIC_INFO = Symbol("cleverMerge dynamic info"), mergeCache = new WeakMap(), DELETE = Symbol("DELETE"), cachedCleverMerge = (first, second)=>{
             if (void 0 === second) return first;
@@ -181,11 +206,10 @@ var __webpack_modules__ = {
     "./src/util/createHash.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         let createMd4, createXxhash64;
         __webpack_require__.d(__webpack_exports__, {
-            j: ()=>createHash
+            n: ()=>createHash_createHash
         });
-        let external_node_crypto_namespaceObject = require("node:crypto");
-        var external_node_crypto_default = __webpack_require__.n(external_node_crypto_namespaceObject), external_node_util_ = __webpack_require__("node:util");
-        class WebpackError_WebpackError extends Error {
+        var external_node_util_ = __webpack_require__("node:util");
+        class WebpackError extends Error {
             loc;
             file;
             chunk;
@@ -193,34 +217,34 @@ var __webpack_modules__ = {
             details;
             hideStack;
         }
-        Object.defineProperty(WebpackError_WebpackError.prototype, external_node_util_.inspect.custom, {
+        Object.defineProperty(WebpackError.prototype, external_node_util_.inspect.custom, {
             value: function() {
                 return this.stack + (this.details ? `\n${this.details}` : "");
             },
             enumerable: !1,
             configurable: !0
         });
-        let WebpackError = WebpackError_WebpackError, CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
+        let lib_WebpackError = WebpackError, CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
         function createMessage(method) {
             return `Abstract method${method ? ` ${method}` : ""}. Must be overridden.`;
         }
         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();
             }
         }
-        class AbstractMethodError extends WebpackError {
+        class AbstractMethodError extends lib_WebpackError {
             constructor(){
                 super(new Message().message), this.name = "AbstractMethodError";
             }
         }
         class Hash {
-            update(data, inputEncoding) {
+            update() {
                 throw new AbstractMethodError();
             }
-            digest(encoding) {
+            digest() {
                 throw new AbstractMethodError();
             }
         }
@@ -233,7 +257,7 @@ var __webpack_modules__ = {
             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() {
@@ -337,7 +361,7 @@ var __webpack_modules__ = {
             constructor(){
                 super(), this.string = "";
             }
-            update(data, inputEncoding) {
+            update(data) {
                 let normalizedData;
                 return (normalizedData = Buffer.isBuffer(data) ? data.toString("utf-8") : data).startsWith("debug-digest-") && (normalizedData = Buffer.from(normalizedData.slice(13), "hex").toString()), this.string += `[${normalizedData}](${Error().stack?.split("\n", 3)[2]})\n`, this;
             }
@@ -358,7 +382,7 @@ var __webpack_modules__ = {
                 return encoding ? this.wasmHash.digest(encoding) : this.wasmHash.digest();
             }
         }
-        let createHash = (algorithm)=>{
+        let createHash_createHash = (algorithm)=>{
             if ("function" == typeof algorithm) return new BulkUpdateDecorator(()=>new algorithm());
             switch(algorithm){
                 case "debug":
@@ -380,12 +404,24 @@ var __webpack_modules__ = {
                         return createMd4();
                     })());
                 case "native-md4":
-                    return new BulkUpdateDecorator(()=>external_node_crypto_default().createHash("md4"), "md4");
+                    return new BulkUpdateDecorator(()=>{
+                        let { createHash } = __webpack_require__("node:crypto");
+                        return createHash("md4");
+                    }, "md4");
                 default:
-                    return new BulkUpdateDecorator(()=>external_node_crypto_default().createHash(algorithm), algorithm);
+                    return new BulkUpdateDecorator(()=>{
+                        let { createHash } = __webpack_require__("node:crypto");
+                        return createHash(algorithm);
+                    }, algorithm);
             }
         };
     },
+    "@rspack/binding": function(module) {
+        module.exports = require("@rspack/binding");
+    },
+    "node:crypto": function(module) {
+        module.exports = require("node:crypto");
+    },
     "node:fs": function(module) {
         module.exports = require("node:fs");
     },
@@ -397,11 +433,6 @@ var __webpack_modules__ = {
     },
     "node:util": function(module) {
         module.exports = require("node:util");
-    },
-    tinypool: function(module) {
-        module.exports = import("../compiled/tinypool/dist/index.js").then(function(module) {
-            return module;
-        });
     }
 }, __webpack_module_cache__ = {};
 function __webpack_require__(moduleId) {
@@ -436,9 +467,9 @@ for(var __webpack_i__ in (()=>{
         default: ()=>loader_runner_worker
     });
     let external_node_querystring_namespaceObject = require("node:querystring");
-    var RequestType, RequestSyncType, external_node_querystring_default = __webpack_require__.n(external_node_querystring_namespaceObject), external_node_util_ = __webpack_require__("node:util");
-    let external_node_worker_threads_namespaceObject = require("node:worker_threads"), binding_namespaceObject = require("@rspack/binding");
-    var createHash = __webpack_require__("./src/util/createHash.ts");
+    var external_node_querystring_default = __webpack_require__.n(external_node_querystring_namespaceObject), external_node_util_ = __webpack_require__("node:util");
+    let external_node_worker_threads_namespaceObject = require("node:worker_threads");
+    var binding_ = __webpack_require__("@rspack/binding"), createHash = __webpack_require__("./src/util/createHash.ts");
     let external_node_path_namespaceObject = require("node:path");
     var external_node_path_default = __webpack_require__.n(external_node_path_namespaceObject);
     let WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/, SEGMENTS_SPLIT_REGEXP = /([|!])/, WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g, relativePathToRequest = (relativePath)=>"" === relativePath ? "./." : ".." === relativePath ? "../." : relativePath.startsWith("../") ? relativePath : `./${relativePath}`, absoluteToRequest = (context, maybeAbsolutePath)=>{
@@ -536,7 +567,7 @@ for(var __webpack_i__ in (()=>{
             super(message), this.name = "LoaderRunnerError", Error.captureStackTrace(this, this.constructor);
         }
     };
-    function loadLoader(loader, callback) {
+    function loadLoader(loader, compiler, callback) {
         if ("module" === loader.type) try {
             void 0 === url && (url = __webpack_require__("node:url")), import(url.pathToFileURL(loader.path).toString()).then((module)=>{
                 handleResult(loader, module, callback);
@@ -550,7 +581,7 @@ for(var __webpack_i__ in (()=>{
             try {
                 module = require(loader.path);
             } catch (e) {
-                if (e instanceof Error && "EMFILE" === e.code) return void setImmediate(loadLoader.bind(null, loader, callback));
+                if (e instanceof Error && "EMFILE" === e.code) return void setImmediate(loadLoader.bind(null, loader, compiler, callback));
                 return callback(e);
             }
             return handleResult(loader, module, callback);
@@ -562,7 +593,6 @@ for(var __webpack_i__ in (()=>{
     function isWorkerResponseMessage(message) {
         return "response" === message.type;
     }
-    var service_RequestType = ((RequestType = {}).AddDependency = "AddDependency", RequestType.AddContextDependency = "AddContextDependency", RequestType.AddMissingDependency = "AddMissingDependency", RequestType.AddBuildDependency = "AddBuildDependency", RequestType.GetDependencies = "GetDependencies", RequestType.GetContextDependencies = "GetContextDependencies", RequestType.GetMissingDependencies = "GetMissingDependencies", RequestType.ClearDependencies = "ClearDependencies", RequestType.Resolve = "Resolve", RequestType.GetResolve = "GetResolve", RequestType.GetLogger = "GetLogger", RequestType.EmitError = "EmitError", RequestType.EmitWarning = "EmitWarning", RequestType.EmitFile = "EmitFile", RequestType.EmitDiagnostic = "EmitDiagnostic", RequestType.SetCacheable = "SetCacheable", RequestType.ImportModule = "ImportModule", RequestType.UpdateLoaderObjects = "UpdateLoaderObjects", RequestType.CompilationGetPath = "CompilationGetPath", RequestType.CompilationGetPathWithInfo = "CompilationGetPathWithInfo", RequestType.CompilationGetAssetPath = "CompilationGetAssetPath", RequestType.CompilationGetAssetPathWithInfo = "CompilationGetAssetPathWithInfo", RequestType), service_RequestSyncType = ((RequestSyncType = {}).WaitForPendingRequest = "WaitForPendingRequest", RequestSyncType);
     function serializeError(error) {
         if (error instanceof Error || error && "object" == typeof error && "message" in error) return {
             ...error,
@@ -627,21 +657,21 @@ for(var __webpack_i__ in (()=>{
             return idx < 0 ? path : idx === idx2 ? path.slice(0, idx + 1) : path.slice(0, idx);
         }(resourcePath) : null, pendingDependencyRequest = [];
         loaderContext.parallel = !0, loaderContext.dependency = loaderContext.addDependency = function(file) {
-            pendingDependencyRequest.push(sendRequest(service_RequestType.AddDependency, file));
+            pendingDependencyRequest.push(sendRequest("AddDependency", file));
         }, loaderContext.addContextDependency = function(context) {
-            pendingDependencyRequest.push(sendRequest(service_RequestType.AddContextDependency, context));
+            pendingDependencyRequest.push(sendRequest("AddContextDependency", context));
         }, loaderContext.addBuildDependency = function(file) {
-            pendingDependencyRequest.push(sendRequest(service_RequestType.AddBuildDependency, file));
+            pendingDependencyRequest.push(sendRequest("AddBuildDependency", file));
         }, loaderContext.getDependencies = function() {
-            return waitForPendingRequest(pendingDependencyRequest), sendRequest(service_RequestType.GetDependencies).wait();
+            return waitForPendingRequest(pendingDependencyRequest), sendRequest("GetDependencies").wait();
         }, loaderContext.getContextDependencies = function() {
-            return waitForPendingRequest(pendingDependencyRequest), sendRequest(service_RequestType.GetContextDependencies).wait();
+            return waitForPendingRequest(pendingDependencyRequest), sendRequest("GetContextDependencies").wait();
         }, loaderContext.getMissingDependencies = function() {
-            return waitForPendingRequest(pendingDependencyRequest), sendRequest(service_RequestType.GetMissingDependencies).wait();
+            return waitForPendingRequest(pendingDependencyRequest), sendRequest("GetMissingDependencies").wait();
         }, loaderContext.clearDependencies = function() {
-            pendingDependencyRequest.push(sendRequest(service_RequestType.ClearDependencies));
+            pendingDependencyRequest.push(sendRequest("ClearDependencies"));
         }, loaderContext.resolve = function(context, request, callback) {
-            sendRequest(service_RequestType.Resolve, context, request).then((result)=>{
+            sendRequest("Resolve", context, request).then((result)=>{
                 callback(null, result);
             }, (err)=>{
                 callback(err);
@@ -649,13 +679,13 @@ for(var __webpack_i__ in (()=>{
         }, loaderContext.getResolve = function(options) {
             return (context, request, callback)=>{
                 if (!callback) return new Promise((resolve, reject)=>{
-                    sendRequest(service_RequestType.GetResolve, options, context, request).then((result)=>{
+                    sendRequest("GetResolve", options, context, request).then((result)=>{
                         resolve(result);
                     }, (err)=>{
                         reject(err);
                     });
                 });
-                sendRequest(service_RequestType.GetResolve, options, context, request).then((result)=>{
+                sendRequest("GetResolve", options, context, request).then((result)=>{
                     callback(null, result);
                 }, (err)=>{
                     callback(err);
@@ -664,110 +694,115 @@ for(var __webpack_i__ in (()=>{
         }, loaderContext.getLogger = function(name) {
             return {
                 error (...args) {
-                    sendRequest(service_RequestType.GetLogger, "error", name, args);
+                    sendRequest("GetLogger", "error", name, args);
                 },
                 warn (...args) {
-                    sendRequest(service_RequestType.GetLogger, "warn", name, args);
+                    sendRequest("GetLogger", "warn", name, args);
                 },
                 info (...args) {
-                    sendRequest(service_RequestType.GetLogger, "info", name, args);
+                    sendRequest("GetLogger", "info", name, args);
                 },
                 log (...args) {
-                    sendRequest(service_RequestType.GetLogger, "log", name, args);
+                    sendRequest("GetLogger", "log", name, args);
                 },
                 debug (...args) {
-                    sendRequest(service_RequestType.GetLogger, "debug", name, args);
+                    sendRequest("GetLogger", "debug", name, args);
                 },
                 assert (assertion, ...args) {
-                    assertion || sendRequest(service_RequestType.GetLogger, "error", name, args);
+                    assertion || sendRequest("GetLogger", "error", name, args);
                 },
                 trace () {
-                    sendRequest(service_RequestType.GetLogger, "trace", name, [
+                    sendRequest("GetLogger", "trace", name, [
                         "Trace"
                     ]);
                 },
                 clear () {
-                    sendRequest(service_RequestType.GetLogger, "clear", name);
+                    sendRequest("GetLogger", "clear", name);
                 },
                 status (...args) {
-                    sendRequest(service_RequestType.GetLogger, "status", name, args);
+                    sendRequest("GetLogger", "status", name, args);
                 },
                 group (...args) {
-                    sendRequest(service_RequestType.GetLogger, "group", name, args);
+                    sendRequest("GetLogger", "group", name, args);
                 },
                 groupCollapsed (...args) {
-                    sendRequest(service_RequestType.GetLogger, "groupCollapsed", name, args);
+                    sendRequest("GetLogger", "groupCollapsed", name, args);
                 },
                 groupEnd (...args) {
-                    sendRequest(service_RequestType.GetLogger, "groupEnd", name, args);
+                    sendRequest("GetLogger", "groupEnd", name, args);
                 },
                 profile (label) {
-                    sendRequest(service_RequestType.GetLogger, "profile", name, [
+                    sendRequest("GetLogger", "profile", name, [
                         label
                     ]);
                 },
                 profileEnd (label) {
-                    sendRequest(service_RequestType.GetLogger, "profileEnd", name, [
+                    sendRequest("GetLogger", "profileEnd", name, [
                         label
                     ]);
                 },
                 time (label) {
-                    sendRequest(service_RequestType.GetLogger, "time", name, [
+                    sendRequest("GetLogger", "time", name, [
                         label
                     ]);
                 },
                 timeEnd (label) {
-                    sendRequest(service_RequestType.GetLogger, "timeEnd", name, [
+                    sendRequest("GetLogger", "timeEnd", name, [
                         label
                     ]);
                 },
                 timeLog (label, ...args) {
-                    sendRequest(service_RequestType.GetLogger, "timeLog", name, [
+                    sendRequest("GetLogger", "timeLog", name, [
                         label,
                         ...args
                     ]);
                 },
                 timeAggregate (label) {
-                    sendRequest(service_RequestType.GetLogger, "timeAggregate", name, [
+                    sendRequest("GetLogger", "timeAggregate", name, [
                         label
                     ]);
                 },
                 timeAggregateEnd (label) {
-                    sendRequest(service_RequestType.GetLogger, "timeAggregateEnd", name, [
+                    sendRequest("GetLogger", "timeAggregateEnd", name, [
                         label
                     ]);
                 }
             };
         }, loaderContext.emitError = function(err) {
-            sendRequest(service_RequestType.EmitError, serializeError(err));
+            sendRequest("EmitError", serializeError(err));
         }, loaderContext.emitWarning = function(warning) {
-            sendRequest(service_RequestType.EmitWarning, serializeError(warning));
+            sendRequest("EmitWarning", serializeError(warning));
         }, loaderContext.emitFile = function(name, content, sourceMap, assetInfo) {
-            sendRequest(service_RequestType.EmitFile, name, content, sourceMap, assetInfo);
+            sendRequest("EmitFile", name, content, sourceMap, assetInfo);
         }, loaderContext.experiments = {
             emitDiagnostic (diagnostic) {
-                sendRequest(service_RequestType.EmitDiagnostic, diagnostic);
+                sendRequest("EmitDiagnostic", diagnostic);
             }
         };
         let getAbsolutify = memoize(()=>absolutify.bindCache({})), getAbsolutifyInContext = memoize(()=>absolutify.bindContextCache(contextDirectory, {})), getContextify = memoize(()=>contextify.bindCache({})), getContextifyInContext = memoize(()=>contextify.bindContextCache(contextDirectory, {}));
         loaderContext.utils = {
             absolutify: (context, request)=>context === contextDirectory ? getAbsolutifyInContext()(request) : getAbsolutify()(context, request),
             contextify: (context, request)=>context === contextDirectory ? getContextifyInContext()(request) : getContextify()(context, request),
-            createHash: (type)=>(0, createHash.j)(type || loaderContext._compilation.outputOptions.hashFunction)
+            createHash: (type)=>(0, createHash.n)(type || loaderContext._compilation.outputOptions.hashFunction)
         }, loaderContext._compiler = {
             ...loaderContext._compiler,
+            rspack: {
+                experiments: {
+                    swc: __webpack_require__("./src/swc.ts")
+                }
+            },
             webpack: {
                 util: {
-                    createHash: __webpack_require__("./src/util/createHash.ts").j,
-                    cleverMerge: __webpack_require__("./src/util/cleverMerge.ts").R_
+                    createHash: __webpack_require__("./src/util/createHash.ts").n,
+                    cleverMerge: __webpack_require__("./src/util/cleverMerge.ts").ks
                 }
             }
         }, loaderContext._compilation = {
             ...loaderContext._compilation,
-            getPath: (filename, data)=>sendRequest(service_RequestType.CompilationGetPath, filename, data).wait(),
-            getPathWithInfo: (filename, data)=>sendRequest(service_RequestType.CompilationGetPathWithInfo, filename, data).wait(),
-            getAssetPath: (filename, data)=>sendRequest(service_RequestType.CompilationGetAssetPath, filename, data).wait(),
-            getAssetPathWithInfo: (filename, data)=>sendRequest(service_RequestType.CompilationGetAssetPathWithInfo, filename, data).wait()
+            getPath: (filename, data)=>sendRequest("CompilationGetPath", filename, data).wait(),
+            getPathWithInfo: (filename, data)=>sendRequest("CompilationGetPathWithInfo", filename, data).wait(),
+            getAssetPath: (filename, data)=>sendRequest("CompilationGetAssetPath", filename, data).wait(),
+            getAssetPathWithInfo: (filename, data)=>sendRequest("CompilationGetAssetPathWithInfo", filename, data).wait()
         };
         let _module = loaderContext._module;
         loaderContext._module = {
@@ -779,13 +814,13 @@ for(var __webpack_i__ in (()=>{
             rawRequest: _module.rawRequest
         }, loaderContext.importModule = function(request, options, callback) {
             if (!callback) return new Promise((resolve, reject)=>{
-                sendRequest(service_RequestType.ImportModule, request, options).then((result)=>{
+                sendRequest("ImportModule", request, options).then((result)=>{
                     resolve(result);
                 }, (err)=>{
                     reject(err);
                 });
             });
-            sendRequest(service_RequestType.ImportModule, request, options).then((result)=>{
+            sendRequest("ImportModule", request, options).then((result)=>{
                 callback(null, result);
             }, (err)=>{
                 callback(err);
@@ -820,7 +855,7 @@ for(var __webpack_i__ in (()=>{
             else options = external_node_querystring_default().parse(options);
             return null == options && (options = {}), options;
         }, loaderContext.cacheable = function(flag) {
-            !1 === flag && sendRequest(service_RequestType.SetCacheable, !1);
+            !1 === flag && sendRequest("SetCacheable", !1);
         }, Object.defineProperty(loaderContext, "data", {
             enumerable: !0,
             get: ()=>loaderContext.loaders[loaderContext.loaderIndex].loaderItem.data,
@@ -830,7 +865,7 @@ for(var __webpack_i__ in (()=>{
         });
         let shouldYieldToMainThread = (currentLoaderObject)=>!!(!currentLoaderObject?.parallel || currentLoaderObject?.request.startsWith("builtin:"));
         switch(loaderState){
-            case binding_namespaceObject.JsLoaderState.Pitching:
+            case binding_.JsLoaderState.Pitching:
                 for(; loaderContext.loaderIndex < loaderContext.loaders.length;){
                     let currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
                     if (shouldYieldToMainThread(currentLoaderObject)) break;
@@ -838,7 +873,7 @@ for(var __webpack_i__ in (()=>{
                         loaderContext.loaderIndex += 1;
                         continue;
                     }
-                    await loadLoaderAsync(currentLoaderObject);
+                    await loadLoaderAsync(currentLoaderObject, loaderContext._compiler);
                     let fn = currentLoaderObject.pitch;
                     if ((currentLoaderObject.pitchExecuted = !0, fn) && (args = await utils_runSyncOrAsync(fn, loaderContext, [
                         loaderContext.remainingRequest,
@@ -846,24 +881,28 @@ for(var __webpack_i__ in (()=>{
                         currentLoaderObject.loaderItem.data
                     ]) || []).some((value)=>void 0 !== value)) break;
                 }
-            case binding_namespaceObject.JsLoaderState.Normal:
+                break;
+            case binding_.JsLoaderState.Normal:
                 for(; loaderContext.loaderIndex >= 0;){
-                    var args1, raw;
                     let currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
                     if (shouldYieldToMainThread(currentLoaderObject)) break;
                     if (currentLoaderObject.normalExecuted) {
                         loaderContext.loaderIndex--;
                         continue;
                     }
-                    await loadLoaderAsync(currentLoaderObject);
+                    await loadLoaderAsync(currentLoaderObject, loaderContext._compiler);
                     let fn = currentLoaderObject.normal;
-                    currentLoaderObject.normalExecuted = !0, fn && (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)), args = await utils_runSyncOrAsync(fn, loaderContext, args) || []);
+                    currentLoaderObject.normalExecuted = !0, fn && (!function(args, raw) {
+                        if (!raw && args[0] instanceof Uint8Array) {
+                            var buf;
+                            let isShared, str;
+                            args[0] = (isShared = (buf = args[0]).buffer instanceof SharedArrayBuffer || buf.buffer.constructor?.name === "SharedArrayBuffer", 0xfeff === (str = decoder.decode(isShared ? 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), args = await utils_runSyncOrAsync(fn, loaderContext, args) || []);
                 }
         }
-        return sendRequest(service_RequestType.UpdateLoaderObjects, loaderContext.loaders.map((item)=>({
+        return sendRequest("UpdateLoaderObjects", loaderContext.loaders.map((item)=>({
                 data: item.loaderItem.data,
                 normalExecuted: item.normalExecuted,
                 pitchExecuted: item.pitchExecuted
@@ -882,47 +921,42 @@ for(var __webpack_i__ in (()=>{
         }
     }
     let loader_runner_worker = function(workerOptions) {
-        var sendRequest;
-        let workerData = workerOptions.workerData;
+        var workerPort, workerSyncPort, sendRequest, workerSyncPort1;
+        let sendRequest1, workerData = workerOptions.workerData;
         delete workerOptions.workerData, workerData.workerPort.on("message", handleIncomingResponses);
-        let sendRequest1 = function(workerPort, workerSyncPort) {
-            var workerSyncPort1;
-            let sendRequest = (requestType, ...args)=>{
-                let id = nextId++;
-                workerPort.postMessage({
-                    type: "request",
-                    id,
-                    requestType,
-                    data: args
-                });
-                let result = new Promise((resolve, reject)=>{
-                    responseCallbacks[id] = (err, data)=>{
-                        if (err) return void reject(err);
-                        resolve(data);
-                    };
-                });
-                return result.wait = ()=>sendRequest.sync(service_RequestSyncType.WaitForPendingRequest, id), result.id = id, result;
-            };
-            return sendRequest.sync = (workerSyncPort1 = workerSyncPort, (requestType, ...args)=>{
-                let id = nextId++, sharedBuffer = new SharedArrayBuffer(8), sharedBufferView = new Int32Array(sharedBuffer);
-                workerSyncPort1.postMessage({
-                    type: "request-sync",
-                    id,
-                    requestType,
-                    data: args,
-                    sharedBuffer
-                });
-                let status = Atomics.wait(sharedBufferView, 0, 0);
-                if ("ok" !== status && "not-equal" !== status) throw Error(`Internal error: Atomics.wait() failed: ${status}`);
-                let { message } = (0, external_node_worker_threads_namespaceObject.receiveMessageOnPort)(workerSyncPort1);
-                if (id !== message.id) throw Error(`Unexpected response id: ${message.id}, expected: ${id}`);
-                if (isWorkerResponseMessage(message)) return message.data;
-                throw message.error;
-            }), sendRequest;
-        }(workerData.workerPort, workerData.workerSyncPort), waitFor = (sendRequest = sendRequest1, (requests)=>sendRequest.sync(service_RequestSyncType.WaitForPendingRequest, (Array.isArray(requests) ? requests : [
+        let sendRequest2 = (workerPort = workerData.workerPort, workerSyncPort = workerData.workerSyncPort, (sendRequest1 = (requestType, ...args)=>{
+            let id = nextId++;
+            workerPort.postMessage({
+                type: "request",
+                id,
+                requestType,
+                data: args
+            });
+            let result = new Promise((resolve, reject)=>{
+                responseCallbacks[id] = (err, data)=>{
+                    err ? reject(err) : resolve(data);
+                };
+            });
+            return result.wait = ()=>sendRequest1.sync("WaitForPendingRequest", id), result.id = id, result;
+        }).sync = (workerSyncPort1 = workerSyncPort, (requestType, ...args)=>{
+            let id = nextId++, sharedBuffer = new SharedArrayBuffer(8), sharedBufferView = new Int32Array(sharedBuffer);
+            workerSyncPort1.postMessage({
+                type: "request-sync",
+                id,
+                requestType,
+                data: args,
+                sharedBuffer
+            });
+            let status = Atomics.wait(sharedBufferView, 0, 0);
+            if ("ok" !== status && "not-equal" !== status) throw Error(`Internal error: Atomics.wait() failed: ${status}`);
+            let { message } = (0, external_node_worker_threads_namespaceObject.receiveMessageOnPort)(workerSyncPort1);
+            if (id !== message.id) throw Error(`Unexpected response id: ${message.id}, expected: ${id}`);
+            if (isWorkerResponseMessage(message)) return message.data;
+            throw message.error;
+        }), sendRequest1), waitFor = (sendRequest = sendRequest2, (requests)=>sendRequest.sync("WaitForPendingRequest", (Array.isArray(requests) ? requests : [
                 requests
             ]).map((request)=>request.id)));
-        loaderImpl(workerOptions, sendRequest1, waitFor).then(async (data)=>{
+        loaderImpl(workerOptions, sendRequest2, waitFor).then(async (data)=>{
             workerData.workerPort.postMessage({
                 type: "done",
                 data

package/hot/lazy-compilation-node.js

@@ -1,5 +1,3 @@
-
-
 var urlBase = decodeURIComponent(__resourceQuery.slice(1));
 
 /**
@@ -16,7 +14,7 @@ exports.activate = function (options) {
 	var request = (
 		urlBase.startsWith("https") ? require("https") : require("http")
 	).request(
-		urlBase + data,
+		urlBase + encodeURIComponent(data),
 		{
 			agent: false,
 			headers: { accept: "text/event-stream" }

package/hot/lazy-compilation-web.js

@@ -1,5 +1,3 @@
-
-
 if (typeof EventSource !== "function") {
 	throw new Error(
 		"Environment doesn't support lazy compilation (requires EventSource)"
@@ -16,7 +14,10 @@ var updateEventSource = function updateEventSource() {
 	if (activeEventSource) activeEventSource.close();
 	if (compiling.size) {
 		activeEventSource = new EventSource(
-			urlBase + Array.from(compiling).join("@")
+			urlBase +
+				Array.from(compiling, function (module) {
+					return encodeURIComponent(module);
+				}).join("@")
 		);
 		/**
 		 * @this {EventSource}

package/module.d.ts

@@ -111,16 +111,15 @@ declare namespace Rspack {
 		onErrored?: (event: ErroredEvent) => void;
 	}
 
-	enum HotUpdateStatus {
-		idle = "idle",
-		check = "check",
-		prepare = "prepare",
-		ready = "ready",
-		dispose = "dispose",
-		apply = "apply",
-		abort = "abort",
-		fail = "fail"
-	}
+	type HotUpdateStatus =
+		| "idle"
+		| "check"
+		| "prepare"
+		| "ready"
+		| "dispose"
+		| "apply"
+		| "abort"
+		| "fail";
 
 	interface Hot {
 		accept: {
@@ -178,7 +177,7 @@ declare namespace Rspack {
 		loaded: boolean;
 		parents: NodeJS.Module["id"][] | null | undefined;
 		children: NodeJS.Module["id"][];
-		hot?: Hot | undefined;
+		hot?: Hot;
 	}
 
 	interface RequireResolve {
@@ -218,9 +217,7 @@ declare namespace Rspack {
 
 interface ImportMeta {
 	url: string;
-	// TODO: unsupported
-	// webpack: number;
-	webpackHot: Rspack.Hot;
+	webpackHot?: Rspack.Hot;
 	webpackContext: (
 		request: string,
 		options?: {