@rspack-canary/browser 1.4.12-canary-4f117639-20250801102630 → 1.4.12-canary-becf0a0e-20250808091433

package/dist/index.mjs

@@ -39735,7 +39735,7 @@ async function runLoaders(compiler, context) {
             resource: loaderContext.resource,
             mode: loaderContext.mode,
             sourceMap: loaderContext.sourceMap,
-            rootContext: loaderContext.context,
+            rootContext: loaderContext.rootContext,
             loaderIndex: loaderContext.loaderIndex,
             loaders: loaderContext.loaders.map((item)=>{
                 let options = item.options;
@@ -40173,19 +40173,21 @@ function getRawOutputEnvironment(environment = {}) {
     };
 }
 function getRawExtensionAlias(alias = {}) {
-    const entries = Object.entries(alias).map(([key, value])=>{
-        if (Array.isArray(value)) return [
-            key,
-            value
-        ];
-        return [
-            key,
-            [
+    if ("object" == typeof alias && null !== alias) {
+        const entries = Object.entries(alias).map(([key, value])=>{
+            if (Array.isArray(value)) return [
+                key,
                 value
-            ]
-        ];
-    });
-    return Object.fromEntries(entries);
+            ];
+            return [
+                key,
+                [
+                    value
+                ]
+            ];
+        });
+        return Object.fromEntries(entries);
+    }
 }
 function getRawAlias(alias = {}) {
     if ("object" == typeof alias && null !== alias && !Array.isArray(alias)) return Object.entries(alias).map(([key, value])=>({
@@ -40592,6 +40594,14 @@ function ExternalsPlugin_class_private_field_set(receiver, privateMap, value) {
     ExternalsPlugin_class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
+function ExternalsPlugin_class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function ExternalsPlugin_class_private_method_init(obj, privateSet) {
+    ExternalsPlugin_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 function ExternalsPlugin_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -40602,7 +40612,7 @@ function ExternalsPlugin_define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
-var _resolveRequestCache = /*#__PURE__*/ new WeakMap(), _processResolveResult = /*#__PURE__*/ new WeakMap(), _getRawExternalItem = /*#__PURE__*/ new WeakMap();
+var _resolveRequestCache = /*#__PURE__*/ new WeakMap(), _processResolveResult = /*#__PURE__*/ new WeakMap(), _processRequest = /*#__PURE__*/ new WeakSet(), _getRawExternalItem = /*#__PURE__*/ new WeakMap();
 class ExternalsPlugin extends RspackBuiltinPlugin {
     raw() {
         const type = this.type;
@@ -40616,7 +40626,7 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
         return createBuiltinPlugin(this.name, raw);
     }
     constructor(type, externals){
-        super(), ExternalsPlugin_define_property(this, "type", void 0), ExternalsPlugin_define_property(this, "externals", void 0), ExternalsPlugin_define_property(this, "name", void 0), ExternalsPlugin_class_private_field_init(this, _resolveRequestCache, {
+        super(), ExternalsPlugin_class_private_method_init(this, _processRequest), ExternalsPlugin_define_property(this, "type", void 0), ExternalsPlugin_define_property(this, "externals", void 0), ExternalsPlugin_define_property(this, "name", void 0), ExternalsPlugin_class_private_field_init(this, _resolveRequestCache, {
             writable: true,
             value: void 0
         }), ExternalsPlugin_class_private_field_init(this, _processResolveResult, {
@@ -40647,7 +40657,7 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
                                 issuer: data.contextInfo.issuer,
                                 issuerLayer: data.contextInfo.issuerLayer ?? null
                             },
-                            getResolve (options) {
+                            getResolve: (options)=>{
                                 const rawResolve = options ? getRawResolve(options) : void 0;
                                 const resolve = ctx.getResolve(rawResolve);
                                 return (context, request, callback)=>{
@@ -40656,7 +40666,7 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
                                             if (error) promiseReject(error);
                                             else {
                                                 const req = processResolveResult(text);
-                                                promiseResolve(null == req ? void 0 : req.path);
+                                                promiseResolve(req ? ExternalsPlugin_class_private_method_get(this, _processRequest, processRequest).call(this, req) : void 0);
                                             }
                                         });
                                     });
@@ -40664,7 +40674,7 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
                                         if (error) callback(error);
                                         else {
                                             const req = processResolveResult(text);
-                                            callback(null, (null == req ? void 0 : req.path) ?? false, req);
+                                            callback(null, req ? ExternalsPlugin_class_private_method_get(this, _processRequest, processRequest).call(this, req) : false, req);
                                         }
                                     });
                                 };
@@ -40694,6 +40704,9 @@ class ExternalsPlugin extends RspackBuiltinPlugin {
         });
     }
 }
+function processRequest(req) {
+    return `${req.path.replace(/#/g, "\u200b#")}${req.query.replace(/#/g, "\u200b#")}${req.fragment}`;
+}
 function getRawExternalItemValueFormFnResult(result) {
     return void 0 === result ? result : getRawExternalItemValue(result);
 }
@@ -46972,7 +46985,8 @@ const applyRspackOptionsDefaults = (options)=>{
         css: options.experiments.css,
         targetProperties,
         mode: options.mode,
-        uniqueName: options.output.uniqueName
+        uniqueName: options.output.uniqueName,
+        inlineConst: options.experiments.inlineConst
     });
     applyOutputDefaults(options.output, {
         context: options.context,
@@ -47034,6 +47048,7 @@ const applyExperimentsDefaults = (experiments, { production, development })=>{
     D(experiments, "asyncWebAssembly", experiments.futureDefaults);
     D(experiments, "css", experiments.futureDefaults ? true : void 0);
     D(experiments, "layers", false);
+    if (false === 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", true);
     D(experiments, "buildHttp", void 0);
     if (experiments.buildHttp && "object" == typeof experiments.buildHttp) D(experiments.buildHttp, "upgrade", false);
@@ -47063,19 +47078,20 @@ const applyExperimentsDefaults = (experiments, { production, development })=>{
     D(experiments, "inlineConst", false);
     D(experiments, "inlineEnum", false);
     D(experiments, "typeReexportsPresence", false);
+    D(experiments, "lazyBarrel", false);
 };
 const applybundlerInfoDefaults = (rspackFuture, library)=>{
     if ("object" == typeof rspackFuture) {
         D(rspackFuture, "bundlerInfo", {});
         if ("object" == typeof rspackFuture.bundlerInfo) {
-            D(rspackFuture.bundlerInfo, "version", "1.4.12-canary-4f117639-20250801102630");
+            D(rspackFuture.bundlerInfo, "version", "1.4.12-canary-becf0a0e-20250808091433");
             D(rspackFuture.bundlerInfo, "bundler", "rspack");
             D(rspackFuture.bundlerInfo, "force", !library);
         }
     }
 };
 const applySnapshotDefaults = (_snapshot, _env)=>{};
-const applyJavascriptParserOptionsDefaults = (parserOptions)=>{
+const applyJavascriptParserOptionsDefaults = (parserOptions, { inlineConst })=>{
     D(parserOptions, "dynamicImportMode", "lazy");
     D(parserOptions, "dynamicImportPrefetch", false);
     D(parserOptions, "dynamicImportPreload", false);
@@ -47092,13 +47108,13 @@ const applyJavascriptParserOptionsDefaults = (parserOptions)=>{
         "..."
     ]);
     D(parserOptions, "importMeta", true);
-    D(parserOptions, "inlineConst", false);
+    D(parserOptions, "inlineConst", inlineConst);
     D(parserOptions, "typeReexportsPresence", "no-tolerant");
 };
 const applyJsonGeneratorOptionsDefaults = (generatorOptions)=>{
     D(generatorOptions, "JSONParse", true);
 };
-const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName })=>{
+const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName, inlineConst })=>{
     assertNotNill(module.parser);
     assertNotNill(module.generator);
     defaults_F(module.parser, ASSET_MODULE_TYPE, ()=>({}));
@@ -47107,7 +47123,9 @@ const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties,
     if ("object" == typeof module.parser.asset.dataUrlCondition) D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
     defaults_F(module.parser, "javascript", ()=>({}));
     assertNotNill(module.parser.javascript);
-    applyJavascriptParserOptionsDefaults(module.parser.javascript);
+    applyJavascriptParserOptionsDefaults(module.parser.javascript, {
+        inlineConst
+    });
     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);
@@ -48825,7 +48843,7 @@ function Resolver_class_private_field_set(receiver, privateMap, value) {
     Resolver_class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
-var _binding = /*#__PURE__*/ new WeakMap(), _childCache = /*#__PURE__*/ new WeakMap();
+var _binding = /*#__PURE__*/ new WeakMap();
 class Resolver {
     resolveSync(context, path, request) {
         return Resolver_class_private_field_get(this, _binding).resolveSync(path, request) ?? false;
@@ -48837,29 +48855,11 @@ class Resolver {
             callback(error, req ? `${req.path.replace(/#/g, "\u200b#")}${req.query.replace(/#/g, "\u200b#")}${req.fragment}` : false, req);
         });
     }
-    withOptions(options) {
-        const cacheEntry = Resolver_class_private_field_get(this, _childCache).get(options);
-        if (void 0 !== cacheEntry) return cacheEntry;
-        const { dependencyCategory, resolveToContext, ...resolve } = options;
-        const rawResolve = getRawResolve(resolve);
-        const binding = Resolver_class_private_field_get(this, _binding).withOptions({
-            dependencyCategory,
-            resolveToContext,
-            ...rawResolve
-        });
-        const resolver = new Resolver(binding);
-        Resolver_class_private_field_get(this, _childCache).set(options, resolver);
-        return resolver;
-    }
     constructor(binding){
         Resolver_class_private_field_init(this, _binding, {
             writable: true,
             value: void 0
         });
-        Resolver_class_private_field_init(this, _childCache, {
-            writable: true,
-            value: new WeakMap()
-        });
         Resolver_class_private_field_set(this, _binding, binding);
     }
 }
@@ -48894,28 +48894,74 @@ function ResolverFactory_class_private_field_set(receiver, privateMap, value) {
     ResolverFactory_class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
-var ResolverFactory_binding = /*#__PURE__*/ new WeakMap();
+function ResolverFactory_class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function ResolverFactory_class_private_method_init(obj, privateSet) {
+    ResolverFactory_check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const EMPTY_RESOLVE_OPTIONS = {};
+var ResolverFactory_binding = /*#__PURE__*/ new WeakMap(), _cache = /*#__PURE__*/ new WeakMap(), _create = /*#__PURE__*/ new WeakSet();
 class ResolverFactory {
     static __to_binding(resolver_factory) {
         return ResolverFactory_class_private_field_get(resolver_factory, ResolverFactory_binding);
     }
-    get(type, resolveOptions) {
-        const { dependencyCategory, resolveToContext, ...resolve } = resolveOptions || {};
-        const binding = ResolverFactory_class_private_field_get(this, ResolverFactory_binding).get(type, {
-            ...getRawResolve(resolve),
-            dependencyCategory,
-            resolveToContext
-        });
-        return new Resolver(binding);
-    }
-    constructor(pnp){
+    get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
+        let typedCaches = ResolverFactory_class_private_field_get(this, _cache).get(type);
+        if (!typedCaches) {
+            typedCaches = {
+                direct: new WeakMap(),
+                stringified: new Map()
+            };
+            ResolverFactory_class_private_field_get(this, _cache).set(type, typedCaches);
+        }
+        const cachedResolver = typedCaches.direct.get(resolveOptions);
+        if (cachedResolver) return cachedResolver;
+        const ident = JSON.stringify(resolveOptions);
+        const resolver = typedCaches.stringified.get(ident);
+        if (resolver) {
+            typedCaches.direct.set(resolveOptions, resolver);
+            return resolver;
+        }
+        const newResolver = ResolverFactory_class_private_method_get(this, _create, ResolverFactory_create).call(this, type, resolveOptions);
+        typedCaches.direct.set(resolveOptions, newResolver);
+        typedCaches.stringified.set(ident, newResolver);
+        return newResolver;
+    }
+    constructor(pnp, resolveOptions, loaderResolveOptions){
+        ResolverFactory_class_private_method_init(this, _create);
         ResolverFactory_class_private_field_init(this, ResolverFactory_binding, {
             writable: true,
             value: void 0
         });
-        ResolverFactory_class_private_field_set(this, ResolverFactory_binding, new external_rspack_wasi_browser_js_["default"].JsResolverFactory(pnp));
+        ResolverFactory_class_private_field_init(this, _cache, {
+            writable: true,
+            value: new Map()
+        });
+        ResolverFactory_class_private_field_set(this, ResolverFactory_binding, new external_rspack_wasi_browser_js_["default"].JsResolverFactory(pnp, getRawResolve(resolveOptions), getRawResolve(loaderResolveOptions)));
     }
 }
+function ResolverFactory_create(type, resolveOptionsWithDepType) {
+    const { dependencyType, resolveToContext, ...resolve } = resolveOptionsWithDepType;
+    const binding = ResolverFactory_class_private_field_get(this, ResolverFactory_binding).get(type, {
+        ...getRawResolve(resolve),
+        dependencyType,
+        resolveToContext
+    });
+    const resolver = new Resolver(binding);
+    const childCache = new WeakMap();
+    resolver.withOptions = (options)=>{
+        const cacheEntry = childCache.get(options);
+        if (void 0 !== cacheEntry) return cacheEntry;
+        const mergedOptions = cachedCleverMerge(resolveOptionsWithDepType, options);
+        const newResolver = this.get(type, mergedOptions);
+        childCache.set(options, newResolver);
+        return newResolver;
+    };
+    return resolver;
+}
 function RuleSetCompiler_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -50734,7 +50780,7 @@ class Compiler {
         this.running = false;
         this.idle = false;
         this.watchMode = false;
-        this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault());
+        this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault(), options.resolve, options.resolveLoader);
         new JsLoaderRspackPlugin(this).apply(this);
         new ExecuteModulePlugin().apply(this);
         new TraceHookPlugin().apply(this);
@@ -50931,7 +50977,7 @@ class MultiStats {
             return obj;
         });
         if (childOptions.version) {
-            obj.rspackVersion = "1.4.12-canary-4f117639-20250801102630";
+            obj.rspackVersion = "1.4.12-canary-becf0a0e-20250808091433";
             obj.version = "5.75.0";
         }
         if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join("");
@@ -52241,7 +52287,7 @@ const SIMPLE_EXTRACTORS = {
         },
         version: (object)=>{
             object.version = "5.75.0";
-            object.rspackVersion = "1.4.12-canary-4f117639-20250801102630";
+            object.rspackVersion = "1.4.12-canary-becf0a0e-20250808091433";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -54462,9 +54508,8 @@ function NativeWatchFileSystem_class_private_field_set(receiver, privateMap, val
 const toJsWatcherIgnored = (ignored)=>{
     if (Array.isArray(ignored) || "string" == typeof ignored || ignored instanceof RegExp) return ignored;
     if ("function" == typeof ignored) throw new Error("NativeWatcher does not support using a function for the 'ignored' option");
-    if (ignored) throw new Error(`Invalid option for 'ignored': ${ignored}`);
 };
-var NativeWatchFileSystem_inner = /*#__PURE__*/ new WeakMap();
+var NativeWatchFileSystem_inner = /*#__PURE__*/ new WeakMap(), _inputFileSystem = /*#__PURE__*/ new WeakMap();
 class NativeWatchFileSystem {
     watch(files, directories, missing, _startTime, options, callback, callbackUndelayed) {
         if ((!files.added || "function" != typeof files.added[Symbol.iterator]) && (!files.removed || "function" != typeof files.removed[Symbol.iterator])) throw new Error("Invalid arguments: 'files'");
@@ -54483,14 +54528,33 @@ class NativeWatchFileSystem {
             Array.from(missing.added),
             Array.from(missing.removed)
         ], (err, result)=>{
-            const { changedFiles, removedFiles } = result;
+            var _class_private_field_get1;
+            if (err) return void callback(err, new Map(), new Map(), new Set(), new Set());
+            nativeWatcher.pause();
+            const changedFiles = result.changedFiles;
+            const removedFiles = result.removedFiles;
+            if (null == (_class_private_field_get1 = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem)) ? void 0 : _class_private_field_get1.purge) {
+                const fs = NativeWatchFileSystem_class_private_field_get(this, _inputFileSystem);
+                for (const item of changedFiles){
+                    var _fs_purge;
+                    null == (_fs_purge = fs.purge) || _fs_purge.call(fs, item);
+                }
+                for (const item of removedFiles){
+                    var _fs_purge1;
+                    null == (_fs_purge1 = fs.purge) || _fs_purge1.call(fs, item);
+                }
+            }
             callback(err, new Map(), new Map(), new Set(changedFiles), new Set(removedFiles));
         }, (fileName)=>{
             callbackUndelayed(fileName, Date.now());
         });
         return {
             close: ()=>{
-                nativeWatcher.close();
+                nativeWatcher.close().then(()=>{
+                    NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, void 0);
+                }, (err)=>{
+                    console.error("Error closing native watcher:", err);
+                });
             },
             pause: ()=>{
                 nativeWatcher.pause();
@@ -54517,11 +54581,16 @@ class NativeWatchFileSystem {
         NativeWatchFileSystem_class_private_field_set(this, NativeWatchFileSystem_inner, nativeWatcher);
         return nativeWatcher;
     }
-    constructor(){
+    constructor(inputFileSystem){
         NativeWatchFileSystem_class_private_field_init(this, NativeWatchFileSystem_inner, {
             writable: true,
             value: void 0
         });
+        NativeWatchFileSystem_class_private_field_init(this, _inputFileSystem, {
+            writable: true,
+            value: void 0
+        });
+        NativeWatchFileSystem_class_private_field_set(this, _inputFileSystem, inputFileSystem);
     }
 }
 function NodeWatchFileSystem_define_property(obj, key, value) {
@@ -54818,7 +54887,7 @@ class NodeEnvironmentPlugin {
         compiler.inputFileSystem = inputFileSystem;
         compiler.outputFileSystem = browser_fs["default"];
         compiler.intermediateFileSystem = null;
-        if (compiler.options.experiments.nativeWatcher) compiler.watchFileSystem = new NativeWatchFileSystem();
+        if (compiler.options.experiments.nativeWatcher) compiler.watchFileSystem = new NativeWatchFileSystem(inputFileSystem);
         else compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
         compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", (compiler)=>{
             if (compiler.inputFileSystem === inputFileSystem) {
@@ -56213,6 +56282,7 @@ const getRspackOptionsSchema = memoize(()=>{
         inlineConst: schemas_boolean(),
         inlineEnum: schemas_boolean(),
         typeReexportsPresence: schemas_boolean(),
+        lazyBarrel: schemas_boolean(),
         nativeWatcher: schemas_boolean()
     }).partial();
     const watch = schemas_boolean();
@@ -56828,7 +56898,7 @@ function transformSync(source, options) {
     const _options = JSON.stringify(options || {});
     return external_rspack_wasi_browser_js_["default"].transformSync(source, _options);
 }
-const exports_rspackVersion = "1.4.12-canary-4f117639-20250801102630";
+const exports_rspackVersion = "1.4.12-canary-becf0a0e-20250808091433";
 const exports_version = "5.75.0";
 const exports_WebpackError = Error;
 const sources = __webpack_require__("../../node_modules/.pnpm/webpack-sources@3.3.3_patch_hash=b2a26650f08a2359d0a3cd81fa6fa272aa7441a28dd7e601792da5ed5d2b4aee/node_modules/webpack-sources/lib/index.js");