@rspack-debug/core 2.0.0-canary-20260116 → 2.0.0-rc.0

package/dist/index.js

@@ -1,15 +1,40 @@
 let createMd4, createXxhash64, service_pool, loadLoader_url;
-import * as __rspack_external_process from "process";
-import { createRequire as __rspack_createRequire, createRequire } from "node:module";
-let __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
-import { __webpack_require__ } from "./rslib-runtime.js";
-import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, HookMap, MultiHook, SyncBailHook, SyncHook, SyncWaterfallHook, maxStage, minStage, safeStage } from "@rspack/lite-tapable";
-import node_util, { format as external_node_util_format, inspect, promisify } from "node:util";
+import node_util, { inspect, promisify } from "node:util";
+import { createRequire, createRequire as __rspack_createRequire } from "node:module";
 import node_path, { isAbsolute, join, relative, resolve as external_node_path_resolve, sep } from "node:path";
 import node_querystring from "node:querystring";
 import node_fs, { readFileSync } from "node:fs";
-__webpack_require__.add({
-    "../../node_modules/.pnpm/enhanced-resolve@5.18.4/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
+let __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+import * as __rspack_external_node_util_1b29d436 from "node:util";
+var RuntimeGlobals, StatsErrorCode, _computedKey, _computedKey1, _computedKey2, ArrayQueue_computedKey, __webpack_modules__ = {}, __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
+}
+__webpack_require__.m = __webpack_modules__, __webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = (exports, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.add = function(modules) {
+    Object.assign(__webpack_require__.m, modules);
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports)=>{
+    "u" > typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports, '__esModule', {
+        value: !0
+    });
+}, __webpack_require__.add({
+    "../../node_modules/.pnpm/enhanced-resolve@5.20.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js" (module, __unused_rspack_exports, __webpack_require__) {
         let { nextTick } = __webpack_require__("process"), dirname = (path)=>{
             let idx = path.length - 1;
             for(; idx >= 0;){
@@ -215,10 +240,10 @@ __webpack_require__.add({
         };
     },
     process (module) {
-        module.exports = __rspack_external_process;
+        module.exports = __rspack_createRequire_require("process");
     }
 });
-var RuntimeGlobals, StatsErrorCode, _computedKey, _computedKey1, _computedKey2, ArrayQueue_computedKey, browserslistTargetHandler_namespaceObject = {};
+var browserslistTargetHandler_namespaceObject = {};
 __webpack_require__.r(browserslistTargetHandler_namespaceObject), __webpack_require__.d(browserslistTargetHandler_namespaceObject, {
     resolve: ()=>browserslistTargetHandler_resolve
 });
@@ -299,15 +324,493 @@ __webpack_require__.r(ModuleFilenameHelpers_namespaceObject), __webpack_require_
     asRegExp: ()=>asRegExp,
     matchObject: ()=>matchObject,
     matchPart: ()=>matchPart
-});
+}), !function() {
+    let { node, bun, deno } = process.versions;
+    if (!node || bun || deno) return;
+    let [majorStr, minorStr] = node.split('.'), major = parseInt(majorStr, 10), minor = parseInt(minorStr || '0', 10);
+    20 === major && minor >= 19 || 22 === major && minor >= 12 || major > 22 || console.error(`Unsupported Node.js version "${node}". Rspack requires Node.js 20.19+ or 22.12+. Please upgrade your Node.js version.\n`);
+}();
 let binding_namespaceObject = __rspack_createRequire_require(process.env.RSPACK_BINDING ? process.env.RSPACK_BINDING : "@rspack/binding");
 var binding_default = __webpack_require__.n(binding_namespaceObject);
+function _define_property(obj, key, value) {
+    return key in obj ? Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : obj[key] = value, obj;
+}
+class HookBase {
+    intercept(interceptor) {
+        if (this.interceptors.push(Object.assign({}, interceptor)), interceptor.register) for(let i = 0; i < this.taps.length; i++)this.taps[i] = interceptor.register(this.taps[i]);
+    }
+    _runRegisterInterceptors(options) {
+        return this.interceptors.reduce((options, interceptor)=>interceptor.register?.(options) ?? options, options);
+    }
+    _runCallInterceptors(...args) {
+        for (let interceptor of this.interceptors)interceptor.call && interceptor.call(...args);
+    }
+    _runErrorInterceptors(e) {
+        for (let interceptor of this.interceptors)interceptor.error && interceptor.error(e);
+    }
+    _runTapInterceptors(tap) {
+        for (let interceptor of this.interceptors)interceptor.tap && interceptor.tap(tap);
+    }
+    _runDoneInterceptors() {
+        for (let interceptor of this.interceptors)interceptor.done && interceptor.done();
+    }
+    _runResultInterceptors(r) {
+        for (let interceptor of this.interceptors)interceptor.result && interceptor.result(r);
+    }
+    withOptions(options) {
+        let mergeOptions = (opt)=>Object.assign({}, options, 'string' == typeof opt ? {
+                name: opt
+            } : opt);
+        return {
+            name: this.name,
+            tap: (opt, fn)=>this.tap(mergeOptions(opt), fn),
+            tapAsync: (opt, fn)=>this.tapAsync(mergeOptions(opt), fn),
+            tapPromise: (opt, fn)=>this.tapPromise(mergeOptions(opt), fn),
+            intercept: (interceptor)=>this.intercept(interceptor),
+            isUsed: ()=>this.isUsed(),
+            withOptions: (opt)=>this.withOptions(mergeOptions(opt)),
+            queryStageRange: (stageRange)=>this.queryStageRange(stageRange)
+        };
+    }
+    isUsed() {
+        return this.taps.length > 0 || this.interceptors.length > 0;
+    }
+    queryStageRange(stageRange) {
+        return new QueriedHook(stageRange, this);
+    }
+    callAsyncStageRange(queried) {
+        throw Error('Hook should implement there own _callAsyncStageRange');
+    }
+    callAsync(...args) {
+        return this.callAsyncStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    promiseStageRange(queried, ...args) {
+        return new Promise((resolve, reject)=>{
+            this.callAsyncStageRange(queried, ...args, (e, r)=>e ? reject(e) : resolve(r));
+        });
+    }
+    promise(...args) {
+        return this.promiseStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    tap(options, fn) {
+        this._tap('sync', options, fn);
+    }
+    tapAsync(options, fn) {
+        this._tap('async', options, fn);
+    }
+    tapPromise(options, fn) {
+        this._tap('promise', options, fn);
+    }
+    _tap(type, options, fn) {
+        let normalizedOptions = options;
+        if ('string' == typeof options) normalizedOptions = {
+            name: options.trim()
+        };
+        else if ('object' != typeof options || null === options) throw Error('Invalid tap options');
+        if ('string' != typeof normalizedOptions.name || '' === normalizedOptions.name) throw Error('Missing name for tap');
+        this._insert(this._runRegisterInterceptors(Object.assign({
+            type,
+            fn
+        }, normalizedOptions)));
+    }
+    _insert(item) {
+        let before;
+        'string' == typeof item.before ? before = new Set([
+            item.before
+        ]) : Array.isArray(item.before) && (before = new Set(item.before));
+        let stage = 0;
+        'number' == typeof item.stage && (stage = item.stage);
+        let i = this.taps.length;
+        for(; i > 0;){
+            i--;
+            let x = this.taps[i];
+            this.taps[i + 1] = x;
+            let xStage = x.stage || 0;
+            if (before) {
+                if (before.has(x.name)) {
+                    before.delete(x.name);
+                    continue;
+                }
+                if (before.size > 0) continue;
+            }
+            if (!(xStage > stage)) {
+                i++;
+                break;
+            }
+        }
+        this.taps[i] = item;
+    }
+    _prepareArgs(args) {
+        let len = this.args.length;
+        return args.length < len ? (args.length = len, args.fill(void 0, args.length, len)) : (args.length > len && (args.length = len), args);
+    }
+    constructor(args = [], name){
+        _define_property(this, "args", void 0), _define_property(this, "name", void 0), _define_property(this, "taps", void 0), _define_property(this, "interceptors", void 0), this.args = args, this.name = name, this.taps = [], this.interceptors = [];
+    }
+}
+let minStage = -1 / 0, maxStage = 1 / 0, allStageRange = [
+    minStage,
+    1 / 0
+], i32MAX = 2147483648 - 1, safeStage = (stage)=>stage < -2147483648 ? -2147483648 : stage > i32MAX ? i32MAX : stage;
+class QueriedHook {
+    isUsed() {
+        return !!(this.tapsInRange.length > 0 || this.stageRange[0] === minStage && this.hook.interceptors.some((i)=>i.call) || this.stageRange[1] === maxStage && this.hook.interceptors.some((i)=>i.done));
+    }
+    call(...args) {
+        if ('function' != typeof this.hook.callStageRange) throw Error('hook is not a SyncHook, call methods only exists on SyncHook');
+        return this.hook.callStageRange(this, ...args);
+    }
+    callAsync(...args) {
+        return this.hook.callAsyncStageRange(this, ...args);
+    }
+    promise(...args) {
+        return this.hook.promiseStageRange(this, ...args);
+    }
+    constructor(stageRange, hook){
+        _define_property(this, "stageRange", void 0), _define_property(this, "hook", void 0), _define_property(this, "tapsInRange", void 0);
+        let tapsInRange = [], [from, to] = stageRange;
+        for (let tap of hook.taps){
+            let stage = tap.stage ?? 0;
+            from <= stage && stage < to ? tapsInRange.push(tap) : to === maxStage && stage === maxStage && tapsInRange.push(tap);
+        }
+        this.stageRange = stageRange, this.hook = hook, this.tapsInRange = tapsInRange;
+    }
+}
+class SyncHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            this._runTapInterceptors(tap);
+            try {
+                tap.fn(...args2);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncHook');
+    }
+}
+class SyncBailHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            let r;
+            this._runTapInterceptors(tap);
+            try {
+                r = tap.fn(...args2);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+            if (void 0 !== r) return this._runResultInterceptors(r), cb(null, r);
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncBailHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncBailHook');
+    }
+}
+class SyncWaterfallHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            this._runTapInterceptors(tap);
+            try {
+                let r = tap.fn(...args2);
+                void 0 !== r && (args2[0] = r);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null, args2[0]));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncWaterfallHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncWaterfallHook');
+    }
+    constructor(args = [], name){
+        if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+        super(args, name);
+    }
+}
+class AsyncParallelHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return done();
+        let counter = tapsInRange.length;
+        for (let tap of tapsInRange){
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then(()=>{
+                    0 == (counter -= 1) && done();
+                }, (e)=>{
+                    counter = 0, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                e ? (counter = 0, error(e)) : 0 == (counter -= 1) && done();
+            });
+            else {
+                let hasError = !1;
+                try {
+                    tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, counter = 0, error(e);
+                }
+                hasError || 0 != --counter || done();
+            }
+            if (counter <= 0) return;
+        }
+    }
+}
+class AsyncSeriesHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return done();
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then(()=>{
+                    (index += 1) === tapsInRange.length ? done() : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1) === tapsInRange.length ? done() : next();
+            });
+            else {
+                let hasError = !1;
+                try {
+                    tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || ((index += 1) === tapsInRange.length ? done() : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+}
+class AsyncSeriesBailHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        }, result = (r)=>{
+            this._runResultInterceptors(r), cb(null, r);
+        };
+        if (0 === tapsInRange.length) return done();
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then((r)=>{
+                    index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+            });
+            else {
+                let r, hasError = !1;
+                try {
+                    r = tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+}
+class AsyncSeriesWaterfallHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let result = (r)=>{
+            this._runResultInterceptors(r), cb(null, r);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return result(args2[0]);
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then((r)=>{
+                    index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next());
+            });
+            else {
+                let hasError = !1;
+                try {
+                    let r = tap.fn(...args2);
+                    void 0 !== r && (args2[0] = r);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || ((index += 1) === tapsInRange.length ? result(args2[0]) : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+    constructor(args = [], name){
+        if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+        super(args, name);
+    }
+}
+let defaultFactory = (key, hook)=>hook;
+class HookMap {
+    get(key) {
+        return this._map.get(key);
+    }
+    for(key) {
+        let hook = this.get(key);
+        if (void 0 !== hook) return hook;
+        let newHook = this._factory(key), interceptors = this._interceptors;
+        for(let i = 0; i < interceptors.length; i++){
+            let factory = interceptors[i].factory;
+            factory && (newHook = factory(key, newHook));
+        }
+        return this._map.set(key, newHook), newHook;
+    }
+    intercept(interceptor) {
+        this._interceptors.push(Object.assign({
+            factory: defaultFactory
+        }, interceptor));
+    }
+    isUsed() {
+        for (let key of this._map.keys()){
+            let hook = this.get(key);
+            if (hook?.isUsed()) return !0;
+        }
+        return !1;
+    }
+    queryStageRange(stageRange) {
+        return new QueriedHookMap(stageRange, this);
+    }
+    constructor(factory, name){
+        _define_property(this, "_map", new Map()), _define_property(this, "_factory", void 0), _define_property(this, "name", void 0), _define_property(this, "_interceptors", void 0), this.name = name, this._factory = factory, this._interceptors = [];
+    }
+}
+class QueriedHookMap {
+    get(key) {
+        return this.hookMap.get(key)?.queryStageRange(this.stageRange);
+    }
+    for(key) {
+        return this.hookMap.for(key).queryStageRange(this.stageRange);
+    }
+    isUsed() {
+        for (let key of this.hookMap._map.keys())if (this.get(key)?.isUsed()) return !0;
+        return !1;
+    }
+    constructor(stageRange, hookMap){
+        _define_property(this, "stageRange", void 0), _define_property(this, "hookMap", void 0), this.stageRange = stageRange, this.hookMap = hookMap;
+    }
+}
+class MultiHook {
+    tap(options, fn) {
+        for (let hook of this.hooks)hook.tap(options, fn);
+    }
+    tapAsync(options, fn) {
+        for (let hook of this.hooks)hook.tapAsync(options, fn);
+    }
+    tapPromise(options, fn) {
+        for (let hook of this.hooks)hook.tapPromise(options, fn);
+    }
+    isUsed() {
+        for (let hook of this.hooks)if (hook.isUsed()) return !0;
+        return !1;
+    }
+    intercept(interceptor) {
+        for (let hook of this.hooks)hook.intercept(interceptor);
+    }
+    withOptions(options) {
+        return new MultiHook(this.hooks.map((h)=>h.withOptions(options)), this.name);
+    }
+    constructor(hooks, name){
+        _define_property(this, "hooks", void 0), _define_property(this, "name", void 0), this.hooks = hooks, this.name = name;
+    }
+}
 let cutOffLoaderExecution = (stack)=>((stack, flag)=>{
         let stacks = stack.split('\n');
         for(let i = 0; i < stacks.length; i++)stacks[i].includes(flag) && (stacks.length = i);
         return stacks.join('\n');
     })(stack, 'LOADER_EXECUTION');
-class WebpackError extends Error {
+class WebpackError_WebpackError extends Error {
     loc;
     file;
     chunk;
@@ -315,14 +818,14 @@ class WebpackError extends Error {
     details;
     hideStack;
 }
-Object.defineProperty(WebpackError.prototype, inspect.custom, {
+Object.defineProperty(WebpackError_WebpackError.prototype, inspect.custom, {
     value: function() {
         return this.stack + (this.details ? `\n${this.details}` : '');
     },
     enumerable: !1,
     configurable: !0
 });
-let lib_WebpackError = WebpackError, LogType = Object.freeze({
+let lib_WebpackError = WebpackError_WebpackError, LogType = Object.freeze({
     error: 'error',
     warn: 'warn',
     info: 'info',
@@ -340,7 +843,7 @@ let lib_WebpackError = WebpackError, LogType = Object.freeze({
     cache: 'cache'
 });
 function getLogTypeBitFlag(type) {
-    return 1 << Object.values(LogType).findIndex((i)=>i === type);
+    return 1 << Object.values(LogType).indexOf(type);
 }
 function getLogTypesBitFlag(types) {
     return types.reduce((acc, cur)=>acc | getLogTypeBitFlag(cur), 0);
@@ -478,6 +981,9 @@ class ModuleGraph {
     getResolvedModule(dependency) {
         return this.#inner.getResolvedModule(dependency);
     }
+    getUsedExports(module, runtime) {
+        return this.#inner.getUsedExports(module, runtime);
+    }
     getParentModule(dependency) {
         return this.#inner.getParentModule(dependency);
     }
@@ -598,6 +1104,17 @@ class Stats {
             compilation: this.compilation,
             getStatsCompilation: (compilation)=>{
                 if (statsCompilationMap.has(compilation)) return statsCompilationMap.get(compilation);
+                if (this.compilation !== this.compilation.compiler._lastCompilation) return {
+                    assets: [],
+                    assetsByChunkName: [],
+                    chunks: [],
+                    entrypoints: [],
+                    errors: [],
+                    hash: 'XXXX',
+                    modules: [],
+                    namedChunkGroups: [],
+                    warnings: []
+                };
                 let innerStats = this.#getInnerByCompilation(compilation);
                 options.warnings = !1;
                 let innerStatsCompilation = innerStats.toJson(options);
@@ -613,6 +1130,17 @@ class Stats {
             compilation: this.compilation,
             getStatsCompilation: (compilation)=>{
                 if (statsCompilationMap.has(compilation)) return statsCompilationMap.get(compilation);
+                if (this.compilation !== this.compilation.compiler._lastCompilation) return {
+                    assets: [],
+                    assetsByChunkName: [],
+                    chunks: [],
+                    entrypoints: [],
+                    errors: [],
+                    hash: 'XXXX',
+                    modules: [],
+                    namedChunkGroups: [],
+                    warnings: []
+                };
                 let innerStatsCompilation = this.#getInnerByCompilation(compilation).toJson(options);
                 return statsCompilationMap.set(compilation, innerStatsCompilation), innerStatsCompilation;
             },
@@ -1055,15 +1583,15 @@ class MergeCaller {
         return this.callArgs;
     }
     push(...data) {
-        0 === this.callArgs.length && queueMicrotask(this.finalCall), this.callArgs.push(...data);
+        0 === this.callArgs.length && queueMicrotask(this.finalCall);
+        for(let i = 0; i < data.length; i++)this.callArgs.push(data[i]);
     }
 }
 function createFakeCompilationDependencies(getDeps, addDeps) {
     let addDepsCaller = new MergeCaller(addDeps), deletedDeps = new Set(), hasDep = (dep)=>!deletedDeps.has(dep) && (addDepsCaller.pendingData().includes(dep) || getDeps().includes(dep)), getAllDeps = ()=>{
-        let deps = new Set([
-            ...getDeps(),
-            ...addDepsCaller.pendingData()
-        ]);
+        let deps = new Set();
+        for (let dep of getDeps())deps.add(dep);
+        for (let dep of addDepsCaller.pendingData())deps.add(dep);
         for (let deleted of deletedDeps)deps.delete(deleted);
         return deps;
     };
@@ -1076,8 +1604,7 @@ function createFakeCompilationDependencies(getDeps, addDeps) {
             deletedDeps.delete(dep), addDepsCaller.push(dep);
         },
         addAll: (deps)=>{
-            for (let dep of deps)deletedDeps.delete(dep);
-            addDepsCaller.push(...deps);
+            for (let dep of deps)deletedDeps.delete(dep), addDepsCaller.push(dep);
         },
         delete: (dep)=>{
             let hadDep = hasDep(dep);
@@ -1295,10 +1822,10 @@ function createDiagnosticArray(adm) {
         reduce: (callbackfn, initialValue)=>adm.values().reduce(callbackfn, initialValue),
         reduceRight: (callbackfn, initialValue)=>adm.values().reduceRight(callbackfn, initialValue)
     }, proxy = new Proxy(array, {
-        get: (target, name)=>'length' === name ? adm.length : 'string' != typeof name || Number.isNaN(Number.parseInt(name)) ? Object.prototype.hasOwnProperty.call(arrayExtensions, name) ? arrayExtensions[name] : target[name] : adm.get(Number.parseInt(name)),
+        get: (target, name)=>'length' === name ? adm.length : 'string' != typeof name || Number.isNaN(Number.parseInt(name, 10)) ? Object.prototype.hasOwnProperty.call(arrayExtensions, name) ? arrayExtensions[name] : target[name] : adm.get(Number.parseInt(name, 10)),
         set (target, name, value) {
             if ('length' === name) throw Error("The 'length' property is read-only and cannot be assigned a new value.");
-            return 'symbol' == typeof name || Number.isNaN(Number.parseInt(name)) ? target[name] = value : adm.set(Number.parseInt(name), value), !0;
+            return 'symbol' == typeof name || Number.isNaN(Number.parseInt(name, 10)) ? target[name] = value : adm.set(Number.parseInt(name, 10), value), !0;
         }
     });
     return adm[$proxy] = proxy, proxy;
@@ -1395,6 +1922,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 'chunks',
                 'modules'
             ]),
+            beforeModuleIds: new SyncHook([
+                'modules'
+            ]),
             finishModules: new AsyncSeriesHook([
                 'modules'
             ]),
@@ -1453,7 +1983,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             seal: new SyncHook([]),
             afterSeal: new AsyncSeriesHook([]),
             needAdditionalPass: new SyncBailHook([])
-        }, this.compiler = compiler, this.resolverFactory = compiler.resolverFactory, this.inputFileSystem = compiler.inputFileSystem, this.options = compiler.options, this.outputOptions = compiler.options.output, this.logging = new Map(), this.childrenCounters = {}, this.children = [], this.needAdditionalPass = !1, this.chunkGraph = inner.chunkGraph, this.moduleGraph = ModuleGraph.__from_binding(inner.moduleGraph), this.#addIncludeDispatcher = new AddEntryItemDispatcher(inner.addInclude.bind(inner)), this.#addEntryDispatcher = new AddEntryItemDispatcher(inner.addEntry.bind(inner)), this[binding_default().COMPILATION_HOOKS_MAP_SYMBOL] = new WeakMap();
+        };
+        let availableHooks = Object.keys(this.hooks);
+        this.hooks = new Proxy(this.hooks, {
+            get (target, prop, receiver) {
+                let value = Reflect.get(target, prop, receiver);
+                if (void 0 === value && 'string' == typeof prop) {
+                    let hooksList = availableHooks.join(', ');
+                    throw Error(`Compilation.hooks.${prop} is not supported in rspack. This typically happens when using webpack plugins that rely on webpack-specific hooks. Consider using an rspack-compatible alternative or removing the incompatible plugin.\n\nAvailable compilation hooks: ${hooksList}`);
+                }
+                return value;
+            }
+        }), this.compiler = compiler, this.resolverFactory = compiler.resolverFactory, this.inputFileSystem = compiler.inputFileSystem, this.options = compiler.options, this.outputOptions = compiler.options.output, this.logging = new Map(), this.childrenCounters = {}, this.children = [], this.needAdditionalPass = !1, this.chunkGraph = inner.chunkGraph, this.moduleGraph = ModuleGraph.__from_binding(inner.moduleGraph), this.#addIncludeDispatcher = new AddEntryItemDispatcher(inner.addInclude.bind(inner)), this.#addEntryDispatcher = new AddEntryItemDispatcher(inner.addEntry.bind(inner)), this[binding_default().COMPILATION_HOOKS_MAP_SYMBOL] = new WeakMap();
     }
     get hash() {
         return this.#inner.hash;
@@ -1848,6 +2389,12 @@ class Entries {
     delete(key) {
         return this.#data.delete(key);
     }
+    getOrInsert(key, defaultValue) {
+        return this.has(key) || this.set(key, defaultValue), this.get(key);
+    }
+    getOrInsertComputed(key, callback) {
+        return this.has(key) || this.set(key, callback(key)), this.get(key);
+    }
     get(key) {
         let binding = this.#data.get(key);
         return binding ? EntryData.__from_binding(binding) : void 0;
@@ -2141,6 +2688,75 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
         }
     }
 }
+class JsSplitChunkSizes {
+    static __to_binding(sizes) {
+        return 'number' == typeof sizes ? sizes : sizes && 'object' == typeof sizes ? {
+            sizes: sizes
+        } : sizes;
+    }
+}
+class SplitChunksPlugin extends RspackBuiltinPlugin {
+    options;
+    name = binding_namespaceObject.BuiltinPluginName.SplitChunksPlugin;
+    affectedHooks = 'thisCompilation';
+    constructor(options){
+        super(), this.options = options;
+    }
+    raw(compiler) {
+        let rawOptions = SplitChunksPlugin_toRawSplitChunksOptions(this.options, compiler);
+        if (void 0 === rawOptions) throw Error('rawOptions should not be undefined');
+        return createBuiltinPlugin(this.name, rawOptions);
+    }
+}
+function SplitChunksPlugin_toRawSplitChunksOptions(sc, compiler) {
+    if (!sc) return;
+    function getName(name) {
+        return 'function' == typeof name ? (ctx)=>void 0 === ctx.module ? name(void 0) : name(ctx.module, getChunks(ctx.chunks), ctx.cacheGroupKey) : name;
+    }
+    function getChunks(chunks) {
+        return 'function' == typeof chunks ? (chunk)=>chunks(chunk) : chunks;
+    }
+    let { name, chunks, defaultSizeTypes, cacheGroups = {}, fallbackCacheGroup, minSize, minSizeReduction, maxSize, maxAsyncSize, maxInitialSize, ...passThrough } = sc;
+    return {
+        name: getName(name),
+        chunks: getChunks(chunks),
+        defaultSizeTypes: defaultSizeTypes || [
+            "javascript",
+            'unknown'
+        ],
+        cacheGroups: Object.entries(cacheGroups).filter(([_key, group])=>!1 !== group).map(([key, group])=>{
+            let { test, name, chunks, minSize, minSizeReduction, maxSize, maxAsyncSize, maxInitialSize, ...passThrough } = group;
+            return {
+                key,
+                test: 'function' == typeof test ? (ctx)=>{
+                    let info = {
+                        moduleGraph: compiler._lastCompilation.moduleGraph,
+                        chunkGraph: compiler._lastCompilation.chunkGraph
+                    };
+                    return test(ctx.module, info);
+                } : test,
+                name: getName(name),
+                chunks: getChunks(chunks),
+                minSize: JsSplitChunkSizes.__to_binding(minSize),
+                minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
+                maxSize: JsSplitChunkSizes.__to_binding(maxSize),
+                maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
+                maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),
+                ...passThrough
+            };
+        }),
+        fallbackCacheGroup: {
+            chunks: getChunks(chunks),
+            ...fallbackCacheGroup
+        },
+        minSize: JsSplitChunkSizes.__to_binding(minSize),
+        minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
+        maxSize: JsSplitChunkSizes.__to_binding(maxSize),
+        maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
+        maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),
+        ...passThrough
+    };
+}
 let EnableLibraryPlugin_enabledTypes = new WeakMap(), EnableLibraryPlugin_getEnabledTypes = (compiler)=>{
     let set = EnableLibraryPlugin_enabledTypes.get(compiler);
     return void 0 === set && (set = new Set(), EnableLibraryPlugin_enabledTypes.set(compiler, set)), set;
@@ -2159,32 +2775,15 @@ class EnableLibraryPlugin extends RspackBuiltinPlugin {
     }
     raw(compiler) {
         let type = this.type, enabled = EnableLibraryPlugin_getEnabledTypes(compiler);
-        if (!enabled.has(type)) return enabled.add(type), createBuiltinPlugin(this.name, type);
-    }
-}
-let EnableWasmLoadingPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnableWasmLoadingPlugin, (type)=>type), EnsureChunkConditionsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnsureChunkConditionsPlugin, ()=>{}), RemoveDuplicateModulesPlugin = base_create(binding_namespaceObject.BuiltinPluginName.RemoveDuplicateModulesPlugin, ()=>({}));
-class EsmLibraryPlugin {
-    static PLUGIN_NAME = 'EsmLibraryPlugin';
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    apply(compiler) {
-        var config;
-        let err, logger = compiler.getInfrastructureLogger(EsmLibraryPlugin.PLUGIN_NAME);
-        if (!function(options, logger) {
-            options.optimization.concatenateModules = !1, options.optimization.removeEmptyChunks = !1, options.output.chunkFormat = !1, options.output.module = !0, options.output.chunkLoading && 'import' !== options.output.chunkLoading && (logger.warn(`\`output.chunkLoading\` should be \`"import"\` or \`false\`, but got ${options.output.chunkLoading}, changed it to \`"import"\``), options.output.chunkLoading = 'import'), void 0 === options.output.chunkLoading && (options.output.chunkLoading = 'import'), options.output.library && (options.output.library = void 0);
-            let { splitChunks } = options.optimization;
-            void 0 === splitChunks && (splitChunks = options.optimization.splitChunks = {}), !1 !== splitChunks && (splitChunks.chunks = 'all', splitChunks.minSize = 0, splitChunks.maxAsyncRequests = 1 / 0, splitChunks.maxInitialRequests = 1 / 0, splitChunks.cacheGroups ??= {}, splitChunks.cacheGroups.default = !1, splitChunks.cacheGroups.defaultVendors = !1);
-        }(compiler.options, logger), new RemoveDuplicateModulesPlugin().apply(compiler), err = (config = compiler.options).optimization.concatenateModules ? 'You should disable `config.optimization.concatenateModules`' : !1 !== config.output.chunkFormat ? 'You should disable default chunkFormat by `config.output.chunkFormat = false`' : void 0) throw new lib_WebpackError(`Conflicted config for ${EsmLibraryPlugin.PLUGIN_NAME}: ${err}`);
-        compiler.__internal__registerBuiltinPlugin({
-            name: binding_namespaceObject.BuiltinPluginName.EsmLibraryPlugin,
-            options: {
-                preserveModules: this.options?.preserveModules
-            }
+        if (!enabled.has(type)) return enabled.add(type), createBuiltinPlugin(this.name, {
+            libraryType: type,
+            preserveModules: compiler.options.output.library?.preserveModules,
+            splitChunks: SplitChunksPlugin_toRawSplitChunksOptions(compiler.options.optimization.splitChunks ?? !1, compiler)
         });
     }
 }
+let EnableWasmLoadingPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnableWasmLoadingPlugin, (type)=>type), EnsureChunkConditionsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnsureChunkConditionsPlugin, ()=>{}), RemoveDuplicateModulesPlugin_RemoveDuplicateModulesPlugin = base_create(binding_namespaceObject.BuiltinPluginName.RemoveDuplicateModulesPlugin, ()=>({}));
+base_create(binding_namespaceObject.BuiltinPluginName.EsmNodeTargetPlugin, ()=>void 0);
 let EvalDevToolModulePlugin = base_create(binding_namespaceObject.BuiltinPluginName.EvalDevToolModulePlugin, (options)=>options, 'compilation'), EvalSourceMapDevToolPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EvalSourceMapDevToolPlugin, (options)=>options, 'compilation');
 function isNil(value) {
     return null == value;
@@ -2285,6 +2884,45 @@ let unsupported = (name, issue)=>{
         query: match[2] ? match[2].replace(/\u200b(.)/g, '$1') : ''
     };
 });
+function isStatsColorSupported() {
+    if ("u" < typeof process) return !1;
+    let env = process.env ?? {}, argv = process.argv ?? [];
+    return !('NO_COLOR' in env || argv.includes('--no-color')) && ('FORCE_COLOR' in env || argv.includes('--color') || 'win32' === process.platform || process.stdout?.isTTY && 'dumb' !== env.TERM || 'CI' in env);
+}
+function encodeVersion(version) {
+    let [major, minor = 0, patch = 0] = version.split('-')[0].split('.').map((v)=>parseInt(v, 10));
+    return Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) ? null : major << 16 | minor << 8 | patch;
+}
+function decodeVersion(n) {
+    return `${n >> 16 & 0xff}.${n >> 8 & 0xff}.${0xff & n}`;
+}
+function encodeTargets(targets) {
+    return Object.fromEntries(Object.entries(targets).map(([k, v])=>[
+            k,
+            encodeVersion(v)
+        ]));
+}
+function defaultTargetsFromRspackTargets(targets) {
+    let REMAP = {
+        and_chr: 'chrome',
+        and_ff: 'firefox',
+        ie_mob: 'ie',
+        op_mob: 'opera',
+        and_qq: null,
+        and_uc: null,
+        baidu: null,
+        bb: null,
+        kaios: null,
+        op_mini: null
+    }, result = {};
+    for (let [k, v] of Object.entries(targets)){
+        let remap = REMAP[k];
+        if (null === remap) continue;
+        let name = remap || k, version = encodeVersion(v);
+        null !== version && (result[name] = version);
+    }
+    return result;
+}
 function toFeatures(featureOptions) {
     let feature = 0;
     for (let key of Reflect.ownKeys(featureOptions))if (!0 === featureOptions[key]) switch(key){
@@ -2359,6 +2997,25 @@ function toFeatures(featureOptions) {
     }
     return feature;
 }
+function resolvePluginImport(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;
+    });
+}
 let $assets = Symbol('assets');
 Object.defineProperty(binding_default().KnownBuildInfo.prototype, node_util.inspect.custom, {
     enumerable: !0,
@@ -2442,8 +3099,7 @@ Object.defineProperty(binding_default().NormalModule.prototype, 'identifier', {
     value (filename, source, assetInfo) {
         return this._emitFile(filename, SourceAdapter.toBinding(source), assetInfo);
     }
-});
-Object.defineProperty(binding_default().NormalModule, 'getCompilationHooks', {
+}), Object.defineProperty(binding_default().NormalModule, 'getCompilationHooks', {
     enumerable: !0,
     configurable: !0,
     value (compilation) {
@@ -2454,40 +3110,6 @@ Object.defineProperty(binding_default().NormalModule, 'getCompilationHooks', {
                 'loaderContext',
                 'module'
             ]),
-            readResourceForScheme: new HookMap((scheme)=>{
-                let fakeHook, message, code, hook = hooks.readResource.for(scheme);
-                return fakeHook = {
-                    tap: (options, fn)=>hook.tap(options, (loaderContext)=>fn(loaderContext.resource)),
-                    tapAsync: (options, fn)=>hook.tapAsync(options, (loaderContext, callback)=>fn(loaderContext.resource, callback)),
-                    tapPromise: (options, fn)=>hook.tapPromise(options, (loaderContext)=>fn(loaderContext.resource))
-                }, Object.freeze(Object.assign(message && code ? ((obj, message, code)=>{
-                    let newObj = {}, descriptors = Object.getOwnPropertyDescriptors(obj);
-                    for (let name of Object.keys(descriptors)){
-                        let descriptor = descriptors[name];
-                        if ('function' == typeof descriptor.value) Object.defineProperty(newObj, name, {
-                            ...descriptor,
-                            value: node_util.deprecate(descriptor.value, message, code)
-                        });
-                        else if (descriptor.get || descriptor.set) Object.defineProperty(newObj, name, {
-                            ...descriptor,
-                            get: descriptor.get && node_util.deprecate(descriptor.get, message, code),
-                            set: descriptor.set && node_util.deprecate(descriptor.set, message, code)
-                        });
-                        else {
-                            let value = descriptor.value;
-                            Object.defineProperty(newObj, name, {
-                                configurable: descriptor.configurable,
-                                enumerable: descriptor.enumerable,
-                                get: node_util.deprecate(()=>value, message, code),
-                                set: descriptor.writable ? node_util.deprecate((v)=>value = v, message, code) : void 0
-                            });
-                        }
-                    }
-                    return newObj;
-                })(fakeHook, message, code) : fakeHook, {
-                    _fakeHook: !0
-                }));
-            }),
             readResource: new HookMap(()=>new AsyncSeriesBailHook([
                     'loaderContext'
                 ]))
@@ -2742,20 +3364,6 @@ class BulkUpdateDecorator extends Hash {
         return void 0 !== digestCache && 'string' == typeof result && digestCache.set(buffer, result), result;
     }
 }
-class DebugHash extends Hash {
-    string;
-    constructor(){
-        super(), this.string = '';
-    }
-    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;
-    }
-    digest(encoding) {
-        let result = `debug-digest-${Buffer.from(this.string).toString('hex')}`;
-        return encoding ? result : Buffer.from(result);
-    }
-}
 class WasmHashAdapter extends Hash {
     wasmHash;
     constructor(wasmHash){
@@ -2771,8 +3379,6 @@ class WasmHashAdapter extends Hash {
 let createHash_createHash = (algorithm)=>{
     if ('function' == typeof algorithm) return new BulkUpdateDecorator(()=>new algorithm());
     switch(algorithm){
-        case 'debug':
-            return new DebugHash();
         case 'xxhash64':
             return new WasmHashAdapter((()=>{
                 if (!createXxhash64) {
@@ -3332,7 +3938,7 @@ async function runLoaders(compiler, context) {
                     _compiler: {
                         options: {
                             experiments: {
-                                css: compiler.options.experiments.css
+                                css: !0
                             }
                         }
                     },
@@ -3575,41 +4181,53 @@ function createRawModuleRuleUses(uses, path, options) {
         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`)) return ((options, _)=>{
-                    if (options && 'object' == typeof options) {
+                if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}swc-loader`)) return ((o, composeOptions)=>{
+                    let options = o ?? {};
+                    if ('object' == typeof options) {
                         var options1;
-                        options.jsc ??= {}, options.jsc.experimental ??= {}, options.jsc.experimental.disableAllLints ??= !0, options.collectTypeScriptInfo && (options.collectTypeScriptInfo = {
+                        if (options.jsc ??= {}, options.jsc.experimental ??= {}, options.jsc.experimental.disableAllLints ??= !0, options.env?.targets === void 0 && options.jsc?.target === void 0) {
+                            if (composeOptions.compiler.target?.targets) options.env ??= {}, options.env.targets ??= function(targets) {
+                                let REMAP = {
+                                    and_chr: 'chrome',
+                                    and_ff: 'firefox',
+                                    ie_mob: 'ie',
+                                    ios_saf: 'ios',
+                                    op_mob: 'opera',
+                                    and_qq: null,
+                                    and_uc: null,
+                                    baidu: null,
+                                    bb: null,
+                                    kaios: null,
+                                    op_mini: null
+                                }, result = {};
+                                for (let [k, version] of Object.entries(targets)){
+                                    let remap = REMAP[k];
+                                    null !== remap && (result[remap || k] = version);
+                                }
+                                return result;
+                            }(composeOptions.compiler.target.targets);
+                            else if (composeOptions.compiler.target?.esVersion) {
+                                let { esVersion } = composeOptions.compiler.target;
+                                options.jsc.target ??= esVersion >= 2015 ? `es${esVersion}` : 'es5';
+                            }
+                        }
+                        options.collectTypeScriptInfo && (options.collectTypeScriptInfo = {
                             typeExports: (options1 = options.collectTypeScriptInfo).typeExports,
                             exportedEnum: !0 === options1.exportedEnum ? 'all' : !1 === options1.exportedEnum || void 0 === options1.exportedEnum ? 'none' : 'const-only'
-                        });
+                        }), options.transformImport && (options.transformImport = resolvePluginImport(options.transformImport));
                         let { rspackExperiments } = options;
-                        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;
-                            });
-                        }(rspackExperiments.import || rspackExperiments.pluginImport));
+                        rspackExperiments && (rspackExperiments.import || rspackExperiments.pluginImport) && (rspackExperiments.import = resolvePluginImport(rspackExperiments.import || rspackExperiments.pluginImport));
                     }
                     return options;
-                })(o, 0);
-                if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}lightningcss-loader`)) return o && 'object' == typeof o && ('string' == typeof o.targets && (o.targets = [
-                    o.targets
-                ]), o.include && 'object' == typeof o.include && (o.include = toFeatures(o.include)), o.exclude && 'object' == typeof o.exclude && (o.exclude = toFeatures(o.exclude))), o;
+                })(o, options);
+                if (identifier.startsWith(`${BUILTIN_LOADER_PREFIX}lightningcss-loader`)) {
+                    let options1;
+                    return 'object' == typeof (options1 = o ?? {}) && ('string' == typeof options1.targets ? options1.targets = [
+                        options1.targets
+                    ] : 'object' != typeof options1.targets || Array.isArray(options1.targets) ? void 0 === options1.targets && options.compiler.target?.targets && (options1.targets = defaultTargetsFromRspackTargets(options.compiler.target.targets)) : options1.targets = encodeTargets(options1.targets), options1.include && 'object' == typeof options1.include && (options1.include = toFeatures(options1.include)), options1.exclude && 'object' == typeof options1.exclude && (options1.exclude = toFeatures(options1.exclude))), options1;
+                }
                 return o;
-            }(use.loader, use.options, 0);
+            }(use.loader, use.options, options1);
             o = isNil(temp) ? void 0 : 'string' == typeof temp ? temp : JSON.stringify(temp, null, 2), isBuiltin = !0;
         }
         return {
@@ -3826,16 +4444,16 @@ function getRawJavascriptParserOptions(parser) {
         dynamicImportPreload: parser.dynamicImportPreload?.toString(),
         dynamicImportPrefetch: parser.dynamicImportPrefetch?.toString(),
         dynamicImportFetchPriority: parser.dynamicImportFetchPriority,
-        importMeta: parser.importMeta,
+        importMeta: 'boolean' == typeof parser.importMeta ? String(parser.importMeta) : parser.importMeta,
         url: parser.url?.toString(),
         exprContextCritical: parser.exprContextCritical,
         unknownContextCritical: parser.unknownContextCritical,
         wrappedContextCritical: parser.wrappedContextCritical,
+        strictThisContextOnImports: parser.strictThisContextOnImports,
         wrappedContextRegExp: parser.wrappedContextRegExp,
         exportsPresence: !1 === parser.exportsPresence ? 'false' : parser.exportsPresence,
         importExportsPresence: !1 === parser.importExportsPresence ? 'false' : parser.importExportsPresence,
         reexportExportsPresence: !1 === parser.reexportExportsPresence ? 'false' : parser.reexportExportsPresence,
-        strictExportPresence: parser.strictExportPresence,
         worker: 'boolean' == typeof parser.worker ? parser.worker ? [
             '...'
         ] : [] : parser.worker,
@@ -3849,13 +4467,15 @@ function getRawJavascriptParserOptions(parser) {
         commonjsMagicComments: parser.commonjsMagicComments,
         typeReexportsPresence: parser.typeReexportsPresence,
         jsx: parser.jsx,
-        deferImport: parser.deferImport
+        deferImport: parser.deferImport,
+        importMetaResolve: parser.importMetaResolve
     };
 }
 function getRawCssParserOptions(parser) {
     return {
         namedExports: parser.namedExports,
-        url: parser.url
+        url: parser.url,
+        resolveImport: parser.resolveImport
     };
 }
 function getRawGeneratorOptions(generator, type) {
@@ -4277,9 +4897,13 @@ let JsLoaderRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName
         path,
         type
     };
-}), LightningCssMinimizerRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName.LightningCssMinimizerRspackPlugin, (options)=>{
-    let { include, exclude, nonStandard, pseudoClasses, drafts } = options?.minimizerOptions ?? {}, targets = options?.minimizerOptions?.targets ?? 'fully supports es6';
-    return {
+}), LightningCssMinimizerRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName.LightningCssMinimizerRspackPlugin, function(options) {
+    let { include, exclude, nonStandard, pseudoClasses, drafts } = options?.minimizerOptions ?? {}, targets = [
+        'fully supports es6'
+    ];
+    return options?.minimizerOptions?.targets ? 'string' == typeof options.minimizerOptions.targets ? targets = [
+        options.minimizerOptions.targets
+    ] : Array.isArray(options.minimizerOptions.targets) ? targets = options.minimizerOptions.targets : 'object' == typeof options.minimizerOptions.targets && (targets = encodeTargets(options.minimizerOptions.targets)) : this.target.targets && (targets = defaultTargetsFromRspackTargets(this.target.targets)), {
         test: options?.test,
         include: options?.include,
         exclude: options?.exclude,
@@ -4289,9 +4913,7 @@ let JsLoaderRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName
             unusedSymbols: options?.minimizerOptions?.unusedSymbols ?? [],
             include: include ? toFeatures(include) : void 0,
             exclude: exclude ? toFeatures(exclude) : void 0,
-            targets: 'string' == typeof targets ? [
-                targets
-            ] : targets,
+            targets,
             drafts: drafts ? {
                 customMedia: drafts.customMedia ?? !1
             } : void 0,
@@ -4307,7 +4929,7 @@ let JsLoaderRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName
         test,
         client,
         currentActiveModules
-    }), 'thisCompilation'), middleware_require = createRequire(import.meta.url), LAZY_COMPILATION_PREFIX = '/lazy-compilation-using-', noop = (_req, _res, next)=>{
+    }), 'thisCompilation'), middleware_require = createRequire(import.meta.url), LAZY_COMPILATION_PREFIX = '/_rspack/lazy/trigger', noop = (_req, _res, next)=>{
     'function' == typeof next && next();
 }, lazyCompilationMiddleware = (compiler)=>{
     if (compiler instanceof MultiCompiler) {
@@ -4348,16 +4970,44 @@ function applyPlugin(compiler, options, activeModules) {
 }
 let lazyCompilationMiddlewareInternal = (compiler, activeModules, lazyCompilationPrefix)=>{
     let logger = compiler.getInfrastructureLogger('LazyCompilation');
-    return (req, res, next)=>{
-        if (!req.url?.startsWith(lazyCompilationPrefix)) return next?.();
-        let modules = req.url.slice(lazyCompilationPrefix.length).split('@').map(decodeURIComponent);
-        req.socket.setNoDelay(!0), res.setHeader('content-type', 'text/event-stream'), res.writeHead(200), res.write('\n');
+    return async (req, res, next)=>{
+        if (!req.url?.startsWith(lazyCompilationPrefix) || 'POST' !== req.method) return next?.();
+        let modules = [];
+        try {
+            modules = await function(req) {
+                if (void 0 !== req.body) {
+                    if (Array.isArray(req.body)) return Promise.resolve(req.body);
+                    if ('string' == typeof req.body) return Promise.resolve(req.body.split('\n').filter(Boolean));
+                    throw Error('Invalid body type');
+                }
+                return new Promise((resolve, reject)=>{
+                    if (req.aborted || req.destroyed) return void reject(Error('Request was aborted before body could be read'));
+                    let cleanup = ()=>{
+                        req.removeListener('data', onData), req.removeListener('end', onEnd), req.removeListener('error', onError), req.removeListener('close', onClose), req.removeListener('aborted', onAborted);
+                    }, chunks = [], onData = (chunk)=>{
+                        chunks.push(chunk);
+                    }, onEnd = ()=>{
+                        cleanup(), resolve(Buffer.concat(chunks).toString('utf8').split('\n').filter(Boolean));
+                    }, onError = (err)=>{
+                        cleanup(), reject(err);
+                    }, onClose = ()=>{
+                        cleanup(), reject(Error('Request was closed before body could be read'));
+                    }, onAborted = ()=>{
+                        cleanup(), reject(Error('Request was aborted before body could be read'));
+                    };
+                    req.on('data', onData), req.on('end', onEnd), req.on('error', onError), req.on('close', onClose), req.on('aborted', onAborted);
+                });
+            }(req);
+        } catch (err) {
+            logger.error(`Failed to parse request body: ${err}`), res.writeHead(400), res.end('Bad Request');
+            return;
+        }
         let moduleActivated = [];
         for (let key of modules){
             let activated = activeModules.has(key);
             activeModules.add(key), activated || (logger.log(`${key} is now in use and will be compiled.`), moduleActivated.push(key));
         }
-        moduleActivated.length && compiler.watching && compiler.watching.invalidate();
+        moduleActivated.length && compiler.watching && compiler.watching.invalidate(), res.writeHead(200), res.write('\n'), res.end();
     };
 };
 class MangleExportsPlugin extends RspackBuiltinPlugin {
@@ -4400,8 +5050,8 @@ let NodeTargetPlugin = base_create(binding_namespaceObject.BuiltinPluginName.Nod
     })), OccurrenceChunkIdsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.OccurrenceChunkIdsPlugin, (options)=>({
         ...options
     }), 'compilation'), ProgressPlugin = base_create(binding_namespaceObject.BuiltinPluginName.ProgressPlugin, (progress = {})=>'function' == typeof progress ? {
-        handler: (percentage, msg, items)=>{
-            progress(percentage, msg, ...items);
+        handler: (percentage, msg, info)=>{
+            progress(percentage, msg, info);
         }
     } : progress), ProvidePlugin = base_create(binding_namespaceObject.BuiltinPluginName.ProvidePlugin, (provide)=>Object.fromEntries(Object.entries(provide).map(([key, value])=>('string' == typeof value && (value = [
             value
@@ -4462,82 +5112,77 @@ RuntimePlugin.getCompilationHooks = (compilation)=>{
         ])
     }, RuntimePlugin_compilationHooksMap.set(compilation, hooks)), hooks;
 };
-let SideEffectsFlagPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SideEffectsFlagPlugin, ()=>{}, 'compilation'), SizeLimitsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SizeLimitsPlugin, (options)=>{
-    let hints = !1 === options.hints ? void 0 : options.hints;
-    return {
-        ...options,
-        hints
-    };
-}), SourceMapDevToolPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SourceMapDevToolPlugin, (options)=>options, 'compilation');
-class JsSplitChunkSizes {
-    static __to_binding(sizes) {
-        return 'number' == typeof sizes ? sizes : sizes && 'object' == typeof sizes ? {
-            sizes: sizes
-        } : sizes;
+let Coordinator_PLUGIN_NAME = 'RscPlugin', GET_OR_INIT_BINDING = Symbol('GET_OR_INIT_BINDING');
+class Coordinator {
+    #serverCompiler;
+    #clientCompiler;
+    #clientLastCompilation;
+    #isProxyingClientWatching = !1;
+    #binding;
+    constructor(){
+        Object.defineProperty(this, GET_OR_INIT_BINDING, {
+            enumerable: !1,
+            configurable: !1,
+            writable: !1,
+            value: ()=>(this.#binding || (this.#binding = new binding_namespaceObject.JsCoordinator(()=>{
+                    if (!this.#serverCompiler) throw Error("[RscPlugin] Coordinator.getOrInitBinding() called before the server compiler was attached. Call coordinator.applyServerCompiler(serverCompiler) first.");
+                    return this.#serverCompiler[GET_COMPILER_ID]();
+                })), this.#binding)
+        });
+    }
+    applyServerCompiler(serverCompiler) {
+        this.#serverCompiler = serverCompiler, serverCompiler.hooks.done.tap(Coordinator_PLUGIN_NAME, (stats)=>{
+            this.#isProxyingClientWatching = !0, this.#clientLastCompilation && (stats.compilation.fileDependencies.addAll(this.#clientLastCompilation.fileDependencies), stats.compilation.contextDependencies.addAll(this.#clientLastCompilation.contextDependencies), stats.compilation.missingDependencies.addAll(this.#clientLastCompilation.missingDependencies));
+        }), serverCompiler.hooks.watchRun.tap(Coordinator_PLUGIN_NAME, ()=>{
+            this.#isProxyingClientWatching && this.#clientCompiler.watching.invalidateWithChangesAndRemovals(new Set(this.#serverCompiler.modifiedFiles), new Set(this.#serverCompiler.removedFiles));
+        });
+    }
+    applyClientCompiler(clientCompiler) {
+        this.#clientCompiler = clientCompiler;
+        let originalWatch = clientCompiler.watch;
+        clientCompiler.watch = function(watchOptions, handler) {
+            return watchOptions.ignored = ()=>!0, originalWatch.call(this, watchOptions, handler);
+        }, clientCompiler.hooks.done.tap(Coordinator_PLUGIN_NAME, (stats)=>{
+            this.#clientLastCompilation = stats.compilation;
+        });
     }
 }
-class SplitChunksPlugin extends RspackBuiltinPlugin {
-    options;
-    name = binding_namespaceObject.BuiltinPluginName.SplitChunksPlugin;
-    affectedHooks = 'thisCompilation';
+class RscClientPlugin extends RspackBuiltinPlugin {
+    name = 'RscClientPlugin';
+    #options;
     constructor(options){
-        super(), this.options = options;
+        super(), this.#options = options;
     }
     raw(compiler) {
-        let rawOptions = function(sc, compiler) {
-            if (!sc) return;
-            function getName(name) {
-                return 'function' == typeof name ? (ctx)=>void 0 === ctx.module ? name(void 0) : name(ctx.module, getChunks(ctx.chunks), ctx.cacheGroupKey) : name;
-            }
-            function getChunks(chunks) {
-                return 'function' == typeof chunks ? (chunk)=>chunks(chunk) : chunks;
-            }
-            let { name, chunks, defaultSizeTypes, cacheGroups = {}, fallbackCacheGroup, minSize, minSizeReduction, maxSize, maxAsyncSize, maxInitialSize, ...passThrough } = sc;
-            return {
-                name: getName(name),
-                chunks: getChunks(chunks),
-                defaultSizeTypes: defaultSizeTypes || [
-                    "javascript",
-                    'unknown'
-                ],
-                cacheGroups: Object.entries(cacheGroups).filter(([_key, group])=>!1 !== group).map(([key, group])=>{
-                    let { test, name, chunks, minSize, minSizeReduction, maxSize, maxAsyncSize, maxInitialSize, ...passThrough } = group;
-                    return {
-                        key,
-                        test: 'function' == typeof test ? (ctx)=>{
-                            let info = {
-                                moduleGraph: compiler._lastCompilation.moduleGraph,
-                                chunkGraph: compiler._lastCompilation.chunkGraph
-                            };
-                            return test(ctx.module, info);
-                        } : test,
-                        name: getName(name),
-                        chunks: getChunks(chunks),
-                        minSize: JsSplitChunkSizes.__to_binding(minSize),
-                        minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
-                        maxSize: JsSplitChunkSizes.__to_binding(maxSize),
-                        maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
-                        maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),
-                        ...passThrough
-                    };
-                }),
-                fallbackCacheGroup: {
-                    chunks: getChunks(chunks),
-                    ...fallbackCacheGroup
-                },
-                minSize: JsSplitChunkSizes.__to_binding(minSize),
-                minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
-                maxSize: JsSplitChunkSizes.__to_binding(maxSize),
-                maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
-                maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),
-                ...passThrough
-            };
-        }(this.options, compiler);
-        if (void 0 === rawOptions) throw Error('rawOptions should not be undefined');
-        return createBuiltinPlugin(this.name, rawOptions);
+        return this.#options.coordinator.applyClientCompiler(compiler), createBuiltinPlugin(this.name, {
+            coordinator: this.#options.coordinator[GET_OR_INIT_BINDING]()
+        });
+    }
+}
+class RscServerPlugin extends RspackBuiltinPlugin {
+    name = 'RscServerPlugin';
+    #options;
+    constructor(options){
+        super(), this.#options = options;
+    }
+    raw(compiler) {
+        let onManifest;
+        this.#options.coordinator.applyServerCompiler(compiler);
+        let { coordinator, onServerComponentChanges } = this.#options;
+        return this.#options.onManifest && (onManifest = (json)=>Promise.resolve(this.#options.onManifest(JSON.parse(json)))), createBuiltinPlugin(this.name, {
+            coordinator: coordinator[GET_OR_INIT_BINDING](),
+            onServerComponentChanges,
+            onManifest
+        });
     }
 }
-let SubresourceIntegrityPlugin_require = createRequire(import.meta.url), SubresourceIntegrityPlugin_PLUGIN_NAME = 'SubresourceIntegrityPlugin', NATIVE_HTML_PLUGIN = 'HtmlRspackPlugin', HTTP_PROTOCOL_REGEX = /^https?:/, NativeSubresourceIntegrityPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SubresourceIntegrityPlugin, function(options) {
+let SideEffectsFlagPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SideEffectsFlagPlugin, ()=>{}, 'compilation'), SizeLimitsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SizeLimitsPlugin, (options)=>{
+    let hints = !1 === options.hints ? void 0 : options.hints;
+    return {
+        ...options,
+        hints
+    };
+}), SourceMapDevToolPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SourceMapDevToolPlugin, (options)=>options, 'compilation'), SubresourceIntegrityPlugin_require = createRequire(import.meta.url), SubresourceIntegrityPlugin_PLUGIN_NAME = 'SubresourceIntegrityPlugin', NATIVE_HTML_PLUGIN = 'HtmlRspackPlugin', HTTP_PROTOCOL_REGEX = /^https?:/, NativeSubresourceIntegrityPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SubresourceIntegrityPlugin, function(options) {
     let htmlPlugin = 'Disabled';
     return options.htmlPlugin === NATIVE_HTML_PLUGIN ? htmlPlugin = 'Native' : 'string' == typeof options.htmlPlugin && (htmlPlugin = 'JavaScript'), {
         hashFuncNames: options.hashFuncNames,
@@ -4607,13 +5252,11 @@ class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin {
         }
         let src = '';
         if (isUrlSrc) {
-            if (!publicPath) return;
+            if (!publicPath || '/' === publicPath || './' === publicPath) return;
             let protocolRelativePublicPath = publicPath.replace(HTTP_PROTOCOL_REGEX, ''), protocolRelativeTagSrc = tagSrc.replace(HTTP_PROTOCOL_REGEX, '');
             if (!protocolRelativeTagSrc.startsWith(protocolRelativePublicPath)) return;
-            {
-                let tagSrcWithScheme = `http:${protocolRelativeTagSrc}`;
-                src = relative(protocolRelativePublicPath.startsWith('//') ? `http:${protocolRelativePublicPath}` : protocolRelativePublicPath, decodeURIComponent(tagSrcWithScheme));
-            }
+            let tagSrcWithScheme = `http:${protocolRelativeTagSrc}`;
+            src = relative(protocolRelativePublicPath.startsWith('//') ? `http:${protocolRelativePublicPath}` : protocolRelativePublicPath, decodeURIComponent(tagSrcWithScheme));
         } else src = relative(publicPath, decodeURIComponent(tagSrc));
         tag.attributes.integrity = this.getIntegrityChecksumForAsset(src) || function(hashFuncNames, source) {
             let { createHash } = SubresourceIntegrityPlugin_require('node:crypto');
@@ -4661,8 +5304,8 @@ class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin {
 function normalizePath(path) {
     return path.replace(/\?.*$/, '').split(sep).join('/');
 }
-let SwcJsMinimizerRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SwcJsMinimizerRspackPlugin, (options)=>{
-    let compress = options?.minimizerOptions?.compress ?? !0, mangle = options?.minimizerOptions?.mangle ?? !0, ecma = options?.minimizerOptions?.ecma ?? 5, format = {
+let SwcJsMinimizerRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SwcJsMinimizerRspackPlugin, function(options) {
+    let compress = options?.minimizerOptions?.compress ?? !0, mangle = options?.minimizerOptions?.mangle ?? !0, ecma = options?.minimizerOptions?.ecma ?? (this.target?.esVersion && this.target.esVersion > 2022 ? 2022 : this.target.esVersion) ?? 5, format = {
         comments: !1,
         ...options?.minimizerOptions?.format
     };
@@ -4677,23 +5320,37 @@ let SwcJsMinimizerRspackPlugin = base_create(binding_namespaceObject.BuiltinPlug
         exclude: options?.exclude,
         extractComments: function(extractComments) {
             let type, conditionStr = (condition)=>{
-                if (void 0 === condition || !0 === condition) return '@preserve|@lic|@cc_on|^\\**!';
+                if (void 0 === condition || !0 === condition) return {
+                    source: '@preserve|@lic|@cc_on|^\\**!',
+                    flags: ''
+                };
                 if (!1 === condition) throw Error('unreachable');
-                return condition.source;
+                return {
+                    source: condition.source,
+                    flags: condition.flags
+                };
             };
             if ('boolean' == typeof extractComments) {
                 if (!extractComments) return;
+                let { source, flags } = conditionStr(extractComments);
                 return {
-                    condition: conditionStr(extractComments)
+                    condition: source,
+                    conditionFlags: flags
+                };
+            }
+            if (extractComments instanceof RegExp) {
+                let { source, flags } = conditionStr(extractComments);
+                return {
+                    condition: source,
+                    conditionFlags: flags
                 };
             }
-            if (extractComments instanceof RegExp) return {
-                condition: extractComments.source
-            };
             if (type = typeof extractComments, null != extractComments && ('object' === type || 'function' === type)) {
                 if (!1 === extractComments.condition) return;
+                let { source, flags } = conditionStr(extractComments.condition);
                 return {
-                    condition: conditionStr(extractComments.condition),
+                    condition: source,
+                    conditionFlags: flags,
                     banner: extractComments.banner
                 };
             }
@@ -4720,6 +5377,7 @@ class WorkerPlugin extends RspackBuiltinPlugin {
     module;
     workerPublicPath;
     name = binding_namespaceObject.BuiltinPluginName.WorkerPlugin;
+    affectedHooks = 'compilation';
     constructor(chunkLoading, wasmLoading, module, workerPublicPath){
         super(), this.chunkLoading = chunkLoading, this.wasmLoading = wasmLoading, this.module = module, this.workerPublicPath = workerPublicPath;
     }
@@ -4740,7 +5398,7 @@ class ContextModuleFactory {
         };
     }
 }
-let 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 FUNCTION_CONTENT_REGEX = /^function(?:\s+[\w$]+)?\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');
@@ -4968,7 +5626,140 @@ let DYNAMIC_INFO = Symbol('cleverMerge dynamic info'), mergeCache = new WeakMap(
         default:
             throw Error('Not implemented');
     }
-}, browserslistTargetHandler_resolve = (browsers)=>{
+};
+class BrowserslistError extends Error {
+    constructor(message){
+        var key, value;
+        super(message), value = void 0, (key = "browserslist") in this ? Object.defineProperty(this, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : this[key] = value, this.name = 'BrowserslistError', this.browserslist = !0, Error.captureStackTrace && Error.captureStackTrace(this, BrowserslistError);
+    }
+}
+let isFileCache = {};
+function isFile(file) {
+    if (file in isFileCache) return isFileCache[file];
+    let result = node_fs.existsSync(file) && node_fs.statSync(file).isFile();
+    return isFileCache[file] = result, result;
+}
+function parsePackage(file) {
+    let config = JSON.parse(node_fs.readFileSync(file).toString().replace(/^\uFEFF/m, ''));
+    if (config.browserlist && !config.browserslist) throw new BrowserslistError(`\`browserlist\` key instead of \`browserslist\` in ${file}`);
+    let list = config.browserslist;
+    for(let i in Array.isArray(list) && (list = {
+        defaults: list
+    }), 'string' == typeof list && (list = parseConfig(list)), list)!function(section) {
+        let FORMAT = 'Browserslist config should be a string or an array of strings with browser queries';
+        if (Array.isArray(section)) {
+            for(let i = 0; i < section.length; i++)if ('string' != typeof section[i]) throw new BrowserslistError(FORMAT);
+        } else if ('string' != typeof section) throw new BrowserslistError(FORMAT);
+    }(list[i]);
+    return list;
+}
+let IS_SECTION = /^\s*\[(.+)]\s*$/;
+function parseConfig(string) {
+    let result = {
+        defaults: []
+    }, sections = [
+        'defaults'
+    ];
+    return string.toString().replace(/#[^\n]*/g, '').split(/\n|,/).map((line)=>line.trim()).filter((line)=>'' !== line).forEach((line)=>{
+        let matched = line.match(IS_SECTION);
+        matched ? (sections = matched[1].trim().split(' ')).forEach((section)=>{
+            if (result[section]) throw new BrowserslistError(`Duplicate section ${section} in Browserslist config`);
+            result[section] = [];
+        }) : sections.forEach((section)=>{
+            result[section].push(line);
+        });
+    }), result;
+}
+function eachParent(file, callback) {
+    let dir = isFile(file) ? node_path.dirname(file) : file, loc = node_path.resolve(dir);
+    do {
+        let result = callback(loc);
+        if (void 0 !== result) return result;
+    }while (loc !== (loc = node_path.dirname(loc)));
+}
+let configCache = {}, ES_VERSIONS_MAP = {
+    chrome: [
+        51,
+        52,
+        57,
+        64,
+        73,
+        80,
+        85,
+        94,
+        110,
+        119
+    ],
+    edge: [
+        15,
+        15,
+        15,
+        79,
+        79,
+        80,
+        85,
+        94,
+        110,
+        119
+    ],
+    safari: [
+        10,
+        10.3,
+        11,
+        16.4,
+        17,
+        17,
+        17,
+        17,
+        17,
+        17.4
+    ],
+    firefox: [
+        54,
+        54,
+        54,
+        78,
+        78,
+        80,
+        80,
+        93,
+        115,
+        145
+    ],
+    opera: [
+        38,
+        39,
+        44,
+        51,
+        60,
+        67,
+        71,
+        80,
+        96,
+        105
+    ],
+    samsung: [
+        5,
+        6.2,
+        6.2,
+        8.2,
+        11.1,
+        13,
+        14,
+        17,
+        21,
+        25
+    ]
+}, aliases = {
+    ios_saf: 'safari',
+    and_chr: 'chrome',
+    and_ff: 'firefox'
+}, renameBrowser = (name)=>aliases[name] || name, browserslistTargetHandler_resolve = (browsers)=>{
     let rawChecker = (versions)=>browsers.every((v)=>{
             let [name, parsedVersion] = v.split(' ');
             if (!name) return !1;
@@ -5400,10 +6191,32 @@ let DYNAMIC_INFO = Symbol('cleverMerge dynamic info'), mergeCache = new WeakMap(
         }),
         require: nodeProperty
     };
-}, target_require = createRequire(import.meta.url), getBrowserslistTargetHandler = memoize(()=>browserslistTargetHandler_namespaceObject), hasBrowserslistConfig = (context)=>{
-    let { findConfig } = target_require('browserslist-load-config');
-    return !!findConfig(context);
-}, versionDependent = (major, minor)=>{
+}, getBrowserslistTargetHandler = memoize(()=>browserslistTargetHandler_namespaceObject), hasBrowserslistConfig = (context)=>!!function(from) {
+        let resolved, fromDir = isFile(from = node_path.resolve(from)) ? node_path.dirname(from) : from;
+        if (fromDir in configCache) return configCache[fromDir];
+        let configFile = eachParent(from, (dir)=>{
+            let pkgBrowserslist, config = node_path.join(dir, 'browserslist'), pkg = node_path.join(dir, 'package.json'), rc = node_path.join(dir, '.browserslistrc');
+            if (isFile(pkg)) try {
+                pkgBrowserslist = parsePackage(pkg);
+            } catch (e) {
+                if (e instanceof BrowserslistError) throw e;
+                console.warn(`[Browserslist] Could not parse ${pkg}. Ignoring it.`);
+            }
+            if (isFile(config) && pkgBrowserslist) throw new BrowserslistError(`${dir} contains both browserslist and package.json with browsers`);
+            if (isFile(rc) && pkgBrowserslist) throw new BrowserslistError(`${dir} contains both .browserslistrc and package.json with browsers`);
+            if (isFile(config) && isFile(rc)) throw new BrowserslistError(`${dir} contains both .browserslistrc and browserslist`);
+            return isFile(config) ? config : isFile(rc) ? rc : pkgBrowserslist ? pkg : void 0;
+        });
+        configFile && (resolved = function(file) {
+            if ('package.json' === node_path.basename(file)) return parsePackage(file);
+            if (!isFile(file)) throw new BrowserslistError(`Can't read ${file} config`);
+            return parseConfig(node_fs.readFileSync(file, 'utf-8'));
+        }(configFile));
+        let configDir = configFile && node_path.dirname(configFile);
+        return eachParent(from, (dir)=>{
+            if (resolved && (configCache[dir] = resolved), dir === configDir) return null;
+        }), resolved;
+    }(context), versionDependent = (major, minor)=>{
     if (!major) return ()=>void 0;
     let nMajor = +major, nMinor = minor ? +minor : 0;
     return (vMajor, vMinor = 0)=>nMajor > vMajor || nMajor === vMajor && nMinor >= vMinor;
@@ -5419,7 +6232,35 @@ See https://github.com/browserslist/browserslist#queries for possible ways to pr
 The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
 You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
             if (Array.isArray(browsers) && 0 === browsers.length) throw Error('Rspack cannot parse the browserslist query. This may happen when the query contains version requirements that exceed the supported range in the browserslist-rs database. Check your browserslist configuration for invalid version numbers.');
-            return getBrowserslistTargetHandler().resolve(browsers);
+            let browserslistTargetHandler = getBrowserslistTargetHandler(), encodedTargets = {};
+            for (let p of browsers){
+                let [name, v] = p.split(' '), version = encodeVersion(v);
+                null !== version && (!encodedTargets[name] || version < encodedTargets[name]) && (encodedTargets[name] = version);
+            }
+            let targets = Object.fromEntries(Object.entries(encodedTargets).map(([k, v])=>[
+                    k,
+                    decodeVersion(v)
+                ]));
+            return {
+                ...browserslistTargetHandler.resolve(browsers),
+                targets,
+                esVersion: function(browsers) {
+                    let esVersion = 2024;
+                    for (let item of browsers){
+                        let pairs = item.split(' ');
+                        if (pairs.length < 2) continue;
+                        let browser = renameBrowser(pairs[0]), version = Number(pairs[1].split('-')[0]);
+                        if (Number.isNaN(version)) continue;
+                        if ('ie' === browser || 'android' === browser && version < 6) {
+                            esVersion = 5;
+                            break;
+                        }
+                        let versions = ES_VERSIONS_MAP[browser];
+                        versions && (version < versions[0] ? esVersion = Math.min(5, esVersion) : version < versions[1] ? esVersion = Math.min(2015, esVersion) : version < versions[2] ? esVersion = Math.min(2016, esVersion) : version < versions[3] ? esVersion = Math.min(2017, esVersion) : version < versions[4] ? esVersion = Math.min(2018, esVersion) : version < versions[5] ? esVersion = Math.min(2019, esVersion) : version < versions[6] ? esVersion = Math.min(2020, esVersion) : version < versions[7] ? esVersion = Math.min(2021, esVersion) : version < versions[8] ? esVersion = Math.min(2022, esVersion) : version < versions[9] && (esVersion = Math.min(2023, esVersion)));
+                    }
+                    return esVersion;
+                }(browsers)
+            };
         }
     ],
     [
@@ -5475,6 +6316,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 web: !1,
                 webworker: !1,
                 browser: !1,
+                targets: major ? {
+                    node: `${major}${minor ? `.${minor}` : ''}`
+                } : {},
+                esVersion: v(18) ? 2022 : v(16) ? 2021 : v(14) ? 2020 : v(12) ? 2019 : v(10) ? 2018 : v(8) ? 2017 : v(7) ? 2016 : v(6, 5) ? 2015 : 5,
                 require: !asyncFlag,
                 nodeBuiltins: !0,
                 nodePrefixForCoreModules: 15 > +major ? v(14, 18) : v(16),
@@ -5516,6 +6361,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 electronMain: 'main' === context,
                 electronPreload: 'preload' === context,
                 electronRenderer: 'renderer' === context,
+                targets: major ? {
+                    electron: `${major}${minor ? `.${minor}` : ''}`
+                } : {},
+                esVersion: v(23) ? 2022 : v(15) ? 2021 : v(12) ? 2020 : v(5) ? 2019 : v(3) ? 2018 : v(1, 8) ? 2017 : v(1, 5) ? 2016 : v(1, 4) ? 2015 : 5,
                 global: !0,
                 nodeBuiltins: !0,
                 nodePrefixForCoreModules: v(15),
@@ -5554,6 +6403,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 webworker: null,
                 browser: !1,
                 electron: !1,
+                targets: major ? {
+                    nwjs: `${major}${minor ? `.${minor}` : ''}`
+                } : {},
+                esVersion: v(0, 65) ? 2022 : v(0, 54) ? 2021 : v(0, 46) ? 2020 : v(0, 39) ? 2019 : v(0, 31) ? 2018 : v(0, 23) ? 2017 : v(0, 20) ? 2016 : v(0, 17) ? 2015 : 5,
                 global: !0,
                 nodeBuiltins: !0,
                 document: !1,
@@ -5583,7 +6436,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         /^es(\d+)$/,
         (version)=>{
             let v = +version;
-            return v < 1000 && (v += 2009), {
+            return 5 < v && v < 1000 && (v += 2009), {
+                esVersion: v > 2022 ? 2022 : v,
                 const: v >= 2015,
                 templateLiteral: v >= 2015,
                 optionalChaining: v >= 2020,
@@ -5619,6 +6473,24 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         for (let tp of targetProperties)for (let key of Object.keys(tp))keys.add(key);
         let result = {};
         for (let key of keys){
+            if ('esVersion' === key) {
+                let minVersion;
+                for (let tp of targetProperties)'number' == typeof tp.esVersion && (minVersion = void 0 === minVersion ? tp.esVersion : Math.min(minVersion, tp.esVersion));
+                void 0 !== minVersion && (result[key] = minVersion);
+                continue;
+            }
+            if ('targets' === key) {
+                let merged = {};
+                for (let tp of targetProperties)if (tp.targets) for (let [name, version] of Object.entries(tp.targets)){
+                    let v = encodeVersion(version);
+                    null !== v && (!merged[name] || v < merged[name]) && (merged[name] = v);
+                }
+                Object.keys(merged).length > 0 && (result[key] = Object.fromEntries(Object.entries(merged).map(([k, v])=>[
+                        k,
+                        decodeVersion(v)
+                    ])));
+                continue;
+            }
             let hasTrue = !1, hasFalse = !1;
             for (let tp of targetProperties)switch(tp[key]){
                 case !0:
@@ -5634,29 +6506,27 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     if ('function' != typeof options.entry) for (let key of Object.keys(options.entry))F(options.entry[key], 'import', ()=>[
             './src'
         ]);
-    return F(options, 'devtool', ()=>!!development && 'eval'), D(options, 'watch', !1), D(options, 'lazyCompilation', !1), D(options, 'bail', !1), F(options, 'cache', ()=>development), applyExperimentsDefaults(options.experiments), applyOptimizationDefaults(options.optimization, {
+    return F(options, 'devtool', ()=>!!development && 'cheap-module-source-map'), D(options, 'watch', !1), D(options, 'lazyCompilation', !1), D(options, 'bail', !1), F(options, 'cache', ()=>development), applyIncrementalDefaults(options), applyExperimentsDefaults(options.experiments), applyOptimizationDefaults(options.optimization, {
         production,
-        development,
-        css: options.experiments.css
+        development
     }), applySnapshotDefaults(options.snapshot, {
         production
     }), applyModuleDefaults(options.module, {
-        cache: !!options.cache,
         asyncWebAssembly: options.experiments.asyncWebAssembly,
-        css: options.experiments.css,
         targetProperties,
         mode: options.mode,
         uniqueName: options.output.uniqueName,
-        deferImport: options.experiments.deferImport
-    }), applyOutputDefaults(options.output, {
+        deferImport: options.experiments.deferImport,
+        outputModule: options.output.module
+    }), applyOutputDefaults(options, {
         context: options.context,
         targetProperties,
         isAffectedByBrowserslist: void 0 === target || 'string' == typeof target && target.startsWith('browserslist') || Array.isArray(target) && target.some((target)=>target.startsWith('browserslist')),
-        outputModule: options.experiments.outputModule,
         entry: options.entry
     }), applyExternalsPresetsDefaults(options.externalsPresets, {
         targetProperties,
-        buildHttp: !!options.experiments.buildHttp
+        buildHttp: !!options.experiments.buildHttp,
+        outputModule: options.output.module
     }), F(options, 'externalsType', ()=>options.output.library ? options.output.library.type : options.output.module ? 'module-import' : 'var'), applyNodeDefaults(options.node, {
         targetProperties,
         outputModule: options.output.module
@@ -5666,43 +6536,43 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }), F(options, 'performance', ()=>!!production && !!targetProperties && (!!targetProperties.browser || null === targetProperties.browser) && {}), applyPerformanceDefaults(options.performance, {
         production
     }), options.resolve = cleverMerge(getResolveDefaults({
-        context: options.context,
         targetProperties,
-        mode: options.mode,
-        css: options.experiments.css
-    }), options.resolve), options.resolveLoader = cleverMerge(getResolveLoaderDefaults(), options.resolveLoader), {
-        platform: !1 === targetProperties ? targetProperties : {
+        mode: options.mode
+    }), options.resolve), options.resolveLoader = cleverMerge(getResolveLoaderDefaults(), options.resolveLoader), !1 === targetProperties ? targetProperties : {
+        platform: {
             web: targetProperties.web,
             browser: targetProperties.browser,
             webworker: targetProperties.webworker,
             node: targetProperties.node,
             nwjs: targetProperties.nwjs,
             electron: targetProperties.electron
-        }
+        },
+        esVersion: targetProperties.esVersion,
+        targets: targetProperties.targets
     };
 }, applyExperimentsDefaults = (experiments)=>{
-    D(experiments, 'futureDefaults', !1), D(experiments, 'asyncWebAssembly', experiments.futureDefaults), D(experiments, 'css', !!experiments.futureDefaults || void 0), D(experiments, 'deferImport', !1), 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, 'useInputFileSystem', !1);
+    D(experiments, 'futureDefaults', !1), D(experiments, 'asyncWebAssembly', !0), D(experiments, 'deferImport', !1), D(experiments, 'buildHttp', void 0), experiments.buildHttp && 'object' == typeof experiments.buildHttp && D(experiments.buildHttp, 'upgrade', !1), D(experiments, 'useInputFileSystem', !1);
+}, applyIncrementalDefaults = (options)=>{
+    D(options, 'incremental', {}), 'object' == typeof options.incremental && (D(options.incremental, 'silent', !0), D(options.incremental, 'buildModuleGraph', !0), D(options.incremental, 'finishModules', !0), D(options.incremental, 'optimizeDependencies', !0), D(options.incremental, 'buildChunkGraph', !0), D(options.incremental, 'optimizeChunkModules', !0), D(options.incremental, 'moduleIds', !0), D(options.incremental, 'chunkIds', !0), D(options.incremental, 'modulesHashes', !0), D(options.incremental, 'modulesCodegen', !0), D(options.incremental, 'modulesRuntimeRequirements', !0), D(options.incremental, 'chunksRuntimeRequirements', !0), D(options.incremental, 'chunksHashes', !0), D(options.incremental, 'chunkAsset', !0), D(options.incremental, 'emitAssets', !0));
 }, applySnapshotDefaults = (_snapshot, _env)=>{}, applyCssGeneratorOptionsDefaults = (generatorOptions, { targetProperties })=>{
     D(generatorOptions, 'exportsOnly', !targetProperties || !1 === targetProperties.document), D(generatorOptions, 'esModule', !0);
-}, applyModuleDefaults = (module, { cache, asyncWebAssembly, css, targetProperties, mode, uniqueName, deferImport })=>{
-    if (assertNotNill(module.parser), assertNotNill(module.generator), cache ? D(module, 'unsafeCache', /[\\/]node_modules[\\/]/) : D(module, 'unsafeCache', !1), F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), F(module.parser.asset, 'dataUrlCondition', ()=>({})), 'object' == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, 'maxSize', 8096), F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { deferImport })=>{
-        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, 'requireAlias', !1), D(parserOptions, 'requireDynamic', !0), D(parserOptions, 'requireResolve', !0), D(parserOptions, 'commonjs', !0), D(parserOptions, 'importDynamic', !0), D(parserOptions, 'worker', [
+}, applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode, uniqueName, deferImport, outputModule })=>{
+    assertNotNill(module.parser), assertNotNill(module.generator), F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), F(module.parser.asset, 'dataUrlCondition', ()=>({})), 'object' == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, 'maxSize', 8096), F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { deferImport, outputModule })=>{
+        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, 'strictThisContextOnImports', !1), D(parserOptions, 'wrappedContextRegExp', /.*/), D(parserOptions, 'exportsPresence', 'error'), D(parserOptions, 'requireAsExpression', !0), D(parserOptions, 'requireAlias', !1), D(parserOptions, 'requireDynamic', !0), D(parserOptions, 'requireResolve', !0), D(parserOptions, 'commonjs', !0), D(parserOptions, 'importDynamic', !0), D(parserOptions, 'worker', [
             '...'
-        ]), D(parserOptions, 'importMeta', !0), D(parserOptions, 'typeReexportsPresence', 'no-tolerant'), D(parserOptions, 'jsx', !1), D(parserOptions, 'deferImport', deferImport);
+        ]), D(parserOptions, 'importMeta', !outputModule || 'preserve-unknown'), D(parserOptions, 'typeReexportsPresence', 'no-tolerant'), D(parserOptions, 'jsx', !1), D(parserOptions, 'deferImport', deferImport), D(parserOptions, 'importMetaResolve', !1);
     })(module.parser.javascript, {
-        deferImport
-    }), F(module.parser, "json", ()=>({})), assertNotNill(module.parser.json), D(module.parser.json, 'exportsDepth', 'development' === mode ? 1 : Number.MAX_SAFE_INTEGER), F(module.generator, 'json', ()=>({})), assertNotNill(module.generator.json), D(module.generator.json, 'JSONParse', !0), css) {
-        F(module.parser, 'css', ()=>({})), assertNotNill(module.parser.css), D(module.parser.css, 'namedExports', !0), D(module.parser.css, 'url', !0), F(module.parser, 'css/auto', ()=>({})), assertNotNill(module.parser['css/auto']), D(module.parser['css/auto'], 'namedExports', !0), D(module.parser['css/auto'], 'url', !0), F(module.parser, 'css/module', ()=>({})), assertNotNill(module.parser['css/module']), D(module.parser['css/module'], 'namedExports', !0), D(module.parser['css/module'], 'url', !0), F(module.generator, 'css', ()=>({})), assertNotNill(module.generator.css), applyCssGeneratorOptionsDefaults(module.generator.css, {
-            targetProperties
-        }), F(module.generator, 'css/auto', ()=>({})), assertNotNill(module.generator['css/auto']), applyCssGeneratorOptionsDefaults(module.generator['css/auto'], {
-            targetProperties
-        }), D(module.generator['css/auto'], 'exportsConvention', 'as-is');
-        let localIdentName = 'development' === mode ? uniqueName && uniqueName.length > 0 ? '[uniqueName]-[id]-[local]' : '[id]-[local]' : '[fullhash]';
-        D(module.generator['css/auto'], 'localIdentName', localIdentName), F(module.generator, 'css/module', ()=>({})), assertNotNill(module.generator['css/module']), applyCssGeneratorOptionsDefaults(module.generator['css/module'], {
-            targetProperties
-        }), D(module.generator['css/module'], 'exportsConvention', 'as-is'), D(module.generator['css/module'], 'localIdentName', localIdentName);
-    }
-    A(module, 'defaultRules', ()=>{
+        deferImport,
+        outputModule
+    }), F(module.parser, "json", ()=>({})), assertNotNill(module.parser.json), D(module.parser.json, 'exportsDepth', 'development' === mode ? 1 : Number.MAX_SAFE_INTEGER), F(module.generator, 'json', ()=>({})), assertNotNill(module.generator.json), D(module.generator.json, 'JSONParse', !0), F(module.parser, 'css', ()=>({})), assertNotNill(module.parser.css), D(module.parser.css, 'namedExports', !0), D(module.parser.css, 'url', !0), F(module.parser, 'css/auto', ()=>({})), assertNotNill(module.parser['css/auto']), D(module.parser['css/auto'], 'namedExports', !0), D(module.parser['css/auto'], 'url', !0), F(module.parser, 'css/module', ()=>({})), assertNotNill(module.parser['css/module']), D(module.parser['css/module'], 'namedExports', !0), D(module.parser['css/module'], 'url', !0), F(module.generator, 'css', ()=>({})), assertNotNill(module.generator.css), applyCssGeneratorOptionsDefaults(module.generator.css, {
+        targetProperties
+    }), F(module.generator, 'css/auto', ()=>({})), assertNotNill(module.generator['css/auto']), applyCssGeneratorOptionsDefaults(module.generator['css/auto'], {
+        targetProperties
+    }), D(module.generator['css/auto'], 'exportsConvention', 'as-is');
+    let localIdentName = 'development' === mode ? uniqueName && uniqueName.length > 0 ? '[uniqueName]-[id]-[local]' : '[id]-[local]' : '[fullhash]';
+    D(module.generator['css/auto'], 'localIdentName', localIdentName), F(module.generator, 'css/module', ()=>({})), assertNotNill(module.generator['css/module']), applyCssGeneratorOptionsDefaults(module.generator['css/module'], {
+        targetProperties
+    }), D(module.generator['css/module'], 'exportsConvention', 'as-is'), D(module.generator['css/module'], 'localIdentName', localIdentName), A(module, 'defaultRules', ()=>{
         let esm = {
             type: "javascript/esm",
             resolve: {
@@ -5720,7 +6590,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 type: "javascript/auto"
             },
             {
-                test: /\.json$/i,
+                test: /\.json$/,
                 type: 'json'
             },
             {
@@ -5728,22 +6598,22 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 type: 'json'
             },
             {
-                test: /\.mjs$/i,
+                test: /\.mjs$/,
                 ...esm
             },
             {
-                test: /\.js$/i,
+                test: /\.js$/,
                 descriptionData: {
                     type: 'module'
                 },
                 ...esm
             },
             {
-                test: /\.cjs$/i,
+                test: /\.cjs$/,
                 ...commonjs
             },
             {
-                test: /\.js$/i,
+                test: /\.js$/,
                 descriptionData: {
                     type: 'commonjs'
                 },
@@ -5774,32 +6644,13 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 ]
             };
             rules.push({
-                test: /\.wasm$/i,
+                test: /\.wasm$/,
                 ...wasm
             }), rules.push({
                 mimetype: 'application/wasm',
                 ...wasm
             });
         }
-        if (css) {
-            let resolve = {
-                fullySpecified: !0,
-                preferRelative: !0
-            };
-            rules.push({
-                test: /\.css$/i,
-                type: 'css/auto',
-                resolve
-            }), rules.push({
-                mimetype: 'text/css+module',
-                type: 'css/module',
-                resolve
-            }), rules.push({
-                mimetype: 'text/css',
-                type: 'css',
-                resolve
-            });
-        }
         return rules.push({
             dependency: 'url',
             oneOf: [
@@ -5828,8 +6679,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             type: 'asset/bytes'
         }), rules;
     });
-}, applyOutputDefaults = (output, { context, outputModule, targetProperties: tp, isAffectedByBrowserslist, entry })=>{
-    let getLibraryName = (library)=>{
+}, applyOutputDefaults = (options, { context, targetProperties: tp, isAffectedByBrowserslist, entry })=>{
+    let { output } = options, getLibraryName = (library)=>{
         let libraryName = 'object' == typeof library && library && !Array.isArray(library) ? library.name : library;
         return Array.isArray(libraryName) ? libraryName.join('.') : 'object' == typeof libraryName ? getLibraryName(libraryName.root) : 'string' == typeof libraryName ? libraryName : '';
     };
@@ -5846,9 +6697,25 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             if ('ENOENT' !== err.code) throw err.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`, err;
             return '';
         }
-    }), F(output, 'devtoolNamespace', ()=>output.uniqueName), F(output, 'module', ()=>!!outputModule);
+    }), F(output, 'devtoolNamespace', ()=>output.uniqueName), output.library && F(output.library, 'type', ()=>output.module ? 'modern-module' : 'var');
+    let forEachEntry = (fn)=>{
+        if ('function' != typeof entry) for (let name of Object.keys(entry))fn(entry[name]);
+    };
+    A(output, 'enabledLibraryTypes', ()=>{
+        let enabledLibraryTypes = [];
+        return output.library && enabledLibraryTypes.push(output.library.type), forEachEntry((desc)=>{
+            desc.library && enabledLibraryTypes.push(desc.library.type);
+        }), enabledLibraryTypes.includes('modern-module') && function(options) {
+            options.optimization.concatenateModules = !1, options.optimization.removeEmptyChunks = !1, options.output.chunkFormat = !1, options.output.module = !0, options.output.chunkLoading && 'import' !== options.output.chunkLoading && (options.output.chunkLoading = 'import'), void 0 === options.output.chunkLoading && (options.output.chunkLoading = 'import');
+            let { splitChunks } = options.optimization;
+            void 0 === splitChunks && (splitChunks = options.optimization.splitChunks = {}), !1 !== splitChunks && (splitChunks.chunks = 'all', splitChunks.minSize = 0, splitChunks.maxAsyncRequests = 1 / 0, splitChunks.maxInitialRequests = 1 / 0, splitChunks.cacheGroups ??= {}, splitChunks.cacheGroups.default = !1, splitChunks.cacheGroups.defaultVendors = !1);
+        }(options), enabledLibraryTypes;
+    }), D(output, 'module', [
+        'modern-module',
+        'module'
+    ].some((ty)=>output.enabledLibraryTypes.includes(ty)));
     let environment = output.environment, conditionallyOptimistic = (v, c)=>void 0 === v && c || v;
-    F(environment, 'globalThis', ()=>tp?.globalThis), F(environment, 'bigIntLiteral', ()=>{
+    F(environment, 'globalThis', ()=>tp && tp.globalThis), F(environment, 'bigIntLiteral', ()=>{
         let v;
         return tp && ((v = tp.bigIntLiteral) || void 0 === v);
     }), F(environment, 'const', ()=>{
@@ -5875,10 +6742,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }), F(environment, 'nodePrefixForCoreModules', ()=>{
         let v;
         return tp && ((v = tp.nodePrefixForCoreModules) || void 0 === v);
-    }), F(environment, 'importMetaDirnameAndFilename', ()=>tp?.importMetaDirnameAndFilename), F(environment, 'templateLiteral', ()=>{
+    }), F(environment, 'importMetaDirnameAndFilename', ()=>tp && tp.importMetaDirnameAndFilename), F(environment, 'templateLiteral', ()=>{
         let v;
         return tp && ((v = tp.templateLiteral) || void 0 === v);
-    }), F(environment, 'dynamicImport', ()=>conditionallyOptimistic(tp?.dynamicImport, output.module)), F(environment, 'dynamicImportInWorker', ()=>conditionallyOptimistic(tp?.dynamicImportInWorker, output.module)), F(environment, 'module', ()=>conditionallyOptimistic(tp?.module, output.module)), F(environment, 'document', ()=>{
+    }), F(environment, 'dynamicImport', ()=>tp && conditionallyOptimistic(tp.dynamicImport, output.module)), F(environment, 'dynamicImportInWorker', ()=>tp && conditionallyOptimistic(tp.dynamicImportInWorker, output.module)), F(environment, 'module', ()=>tp && conditionallyOptimistic(tp.module, output.module)), F(environment, 'document', ()=>{
         let v;
         return tp && ((v = tp.document) || void 0 === v);
     }), D(output, 'filename', output.module ? '[name].mjs' : '[name].js'), F(output, 'iife', ()=>!output.module), F(output, 'chunkFilename', ()=>{
@@ -5896,7 +6763,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return 'function' != typeof chunkFilename ? chunkFilename.replace(/\.[mc]?js(\?|$)/, '.css$1') : '[id].css';
     }), D(output, 'hotUpdateChunkFilename', `[id].[fullhash].hot-update.${output.module ? 'mjs' : 'js'}`), F(output, 'hotUpdateMainFilename', ()=>`[runtime].[fullhash].hot-update.${output.module ? 'json.mjs' : 'json'}`);
     let uniqueNameId = Template.toIdentifier(output.uniqueName);
-    F(output, 'hotUpdateGlobal', ()=>`webpackHotUpdate${uniqueNameId}`), F(output, 'chunkLoadingGlobal', ()=>`webpackChunk${uniqueNameId}`), D(output, 'assetModuleFilename', '[hash][ext][query]'), D(output, 'webassemblyModuleFilename', '[hash].module.wasm'), D(output, 'compareBeforeEmit', !0), F(output, 'path', ()=>node_path.join(process.cwd(), 'dist')), F(output, 'pathinfo', ()=>!1), D(output, 'publicPath', tp && (tp.document || tp.importScripts) ? 'auto' : ''), D(output, 'hashFunction', 'xxhash64'), D(output, 'hashDigest', 'hex'), D(output, 'hashDigestLength', 16), D(output, 'strictModuleErrorHandling', !1), output.library && F(output.library, 'type', ()=>output.module ? 'module' : 'var'), F(output, 'chunkFormat', ()=>{
+    F(output, 'hotUpdateGlobal', ()=>`rspackHotUpdate${uniqueNameId}`), F(output, 'chunkLoadingGlobal', ()=>`rspackChunk${uniqueNameId}`), D(output, 'assetModuleFilename', '[hash][ext][query]'), D(output, 'webassemblyModuleFilename', '[hash].module.wasm'), D(output, 'compareBeforeEmit', !0), F(output, 'path', ()=>node_path.join(process.cwd(), 'dist')), F(output, 'pathinfo', ()=>!1), D(output, 'publicPath', tp && (tp.document || tp.importScripts) ? 'auto' : ''), D(output, 'hashFunction', 'xxhash64'), D(output, 'hashDigest', 'hex'), D(output, 'hashDigestLength', 16), D(output, 'strictModuleErrorHandling', !1), F(output, 'chunkFormat', ()=>{
         if (tp) {
             let helpMessage = isAffectedByBrowserslist ? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly." : "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
             if (output.module) {
@@ -5958,16 +6825,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return 'self';
     }), D(output, 'importFunctionName', 'import'), D(output, 'importMetaName', 'import.meta'), F(output, 'clean', ()=>!!output.clean), D(output, 'crossOriginLoading', !1), D(output, 'workerPublicPath', ''), D(output, 'sourceMapFilename', '[file].map[query]'), F(output, "scriptType", ()=>!!output.module && 'module'), D(output, 'chunkLoadTimeout', 120000);
     let { trustedTypes } = output;
-    trustedTypes && (F(trustedTypes, 'policyName', ()=>output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, '_') || 'webpack'), D(trustedTypes, 'onPolicyCreationFailure', 'stop'));
-    let forEachEntry = (fn)=>{
-        if ('function' != typeof entry) for (let name of Object.keys(entry))fn(entry[name]);
-    };
-    A(output, 'enabledLibraryTypes', ()=>{
-        let enabledLibraryTypes = [];
-        return output.library && enabledLibraryTypes.push(output.library.type), forEachEntry((desc)=>{
-            desc.library && enabledLibraryTypes.push(desc.library.type);
-        }), enabledLibraryTypes;
-    }), A(output, 'enabledChunkLoadingTypes', ()=>{
+    trustedTypes && (F(trustedTypes, 'policyName', ()=>output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, '_') || 'rspack'), D(trustedTypes, 'onPolicyCreationFailure', 'stop')), A(output, 'enabledChunkLoadingTypes', ()=>{
         let enabledChunkLoadingTypes = new Set();
         return output.chunkLoading && enabledChunkLoadingTypes.add(output.chunkLoading), output.workerChunkLoading && enabledChunkLoadingTypes.add(output.workerChunkLoading), forEachEntry((desc)=>{
             desc.chunkLoading && enabledChunkLoadingTypes.add(desc.chunkLoading);
@@ -5977,9 +6835,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return output.wasmLoading && enabledWasmLoadingTypes.add(output.wasmLoading), output.workerWasmLoading && enabledWasmLoadingTypes.add(output.workerWasmLoading), forEachEntry((desc)=>{
             desc.wasmLoading && enabledWasmLoadingTypes.add(desc.wasmLoading);
         }), Array.from(enabledWasmLoadingTypes);
-    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-canary-20260116"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
-}, applyExternalsPresetsDefaults = (externalsPresets, { targetProperties, buildHttp })=>{
-    D(externalsPresets, 'web', !buildHttp && targetProperties?.web), D(externalsPresets, 'node', targetProperties?.node), D(externalsPresets, 'electron', targetProperties?.electron), D(externalsPresets, 'electronMain', targetProperties?.electron && targetProperties.electronMain), D(externalsPresets, 'electronPreload', targetProperties?.electron && targetProperties.electronPreload), D(externalsPresets, 'electronRenderer', targetProperties?.electron && targetProperties.electronRenderer), D(externalsPresets, 'nwjs', targetProperties?.nwjs);
+    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-rc.0"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
+}, applyExternalsPresetsDefaults = (externalsPresets, { targetProperties, buildHttp, outputModule })=>{
+    let isUniversal = (key)=>!!(outputModule && targetProperties && null === targetProperties[key]);
+    D(externalsPresets, 'web', !buildHttp && targetProperties && (targetProperties.web || isUniversal('node'))), D(externalsPresets, 'node', targetProperties && (targetProperties.node || isUniversal('node'))), D(externalsPresets, 'electron', targetProperties && targetProperties.electron || isUniversal('electron')), D(externalsPresets, 'electronMain', targetProperties && !!targetProperties.electron && (targetProperties.electronMain || isUniversal('electronMain'))), D(externalsPresets, 'electronPreload', targetProperties && !!targetProperties.electron && (targetProperties.electronPreload || isUniversal('electronPreload'))), D(externalsPresets, 'electronRenderer', targetProperties && !!targetProperties.electron && (targetProperties.electronRenderer || isUniversal('electronRenderer'))), D(externalsPresets, 'nwjs', targetProperties && (targetProperties.nwjs || isUniversal('nwjs')));
 }, applyLoaderDefaults = (loader, { targetProperties, environment })=>{
     F(loader, 'target', ()=>{
         if (targetProperties) {
@@ -5990,23 +6849,20 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         }
     }), D(loader, 'environment', environment);
 }, applyNodeDefaults = (node, { outputModule, targetProperties })=>{
-    !1 !== node && (F(node, 'global', ()=>!targetProperties?.global && 'warn'), F(node, '__dirname', ()=>targetProperties?.node ? outputModule ? 'node-module' : 'eval-only' : 'warn-mock'), F(node, '__filename', ()=>targetProperties?.node ? outputModule ? 'node-module' : 'eval-only' : 'warn-mock'));
+    !1 !== node && (F(node, 'global', ()=>(!targetProperties || !targetProperties.global) && 'warn'), F(node, '__dirname', ()=>targetProperties && targetProperties.node ? outputModule ? 'node-module' : 'eval-only' : 'warn-mock'), F(node, '__filename', ()=>targetProperties && targetProperties.node ? outputModule ? 'node-module' : 'eval-only' : 'warn-mock'));
 }, applyPerformanceDefaults = (performance, { production })=>{
     !1 !== performance && (D(performance, 'maxAssetSize', 250000), D(performance, 'maxEntrypointSize', 250000), F(performance, 'hints', ()=>!!production && 'warning'));
-}, applyOptimizationDefaults = (optimization, { production, development, css })=>{
-    D(optimization, 'removeAvailableModules', !0), D(optimization, 'removeEmptyChunks', !0), D(optimization, 'mergeDuplicateChunks', !0), F(optimization, 'moduleIds', ()=>production ? 'deterministic' : development ? 'named' : 'natural'), F(optimization, 'chunkIds', ()=>production ? 'deterministic' : development ? 'named' : 'natural'), F(optimization, 'sideEffects', ()=>!!production || 'flag'), D(optimization, 'mangleExports', production), D(optimization, 'inlineExports', production), D(optimization, 'providedExports', !0), D(optimization, 'usedExports', production), D(optimization, 'innerGraph', production), D(optimization, 'emitOnErrors', !production), D(optimization, 'runtimeChunk', !1), D(optimization, 'realContentHash', production), D(optimization, 'avoidEntryIife', !1), D(optimization, 'minimize', production), D(optimization, 'concatenateModules', production), A(optimization, 'minimizer', ()=>[
+}, applyOptimizationDefaults = (optimization, { production, development })=>{
+    D(optimization, 'removeEmptyChunks', !0), D(optimization, 'mergeDuplicateChunks', !0), F(optimization, 'moduleIds', ()=>production ? 'deterministic' : development ? 'named' : 'natural'), F(optimization, 'chunkIds', ()=>production ? 'deterministic' : development ? 'named' : 'natural'), F(optimization, 'sideEffects', ()=>!!production || 'flag'), D(optimization, 'mangleExports', production), D(optimization, 'inlineExports', production), D(optimization, 'providedExports', !0), D(optimization, 'usedExports', production), D(optimization, 'innerGraph', production), D(optimization, 'emitOnErrors', !production), D(optimization, 'runtimeChunk', !1), D(optimization, 'realContentHash', production), D(optimization, 'avoidEntryIife', !1), D(optimization, 'minimize', production), D(optimization, 'concatenateModules', production), A(optimization, 'minimizer', ()=>[
             new SwcJsMinimizerRspackPlugin(),
             new LightningCssMinimizerRspackPlugin()
         ]), F(optimization, 'nodeEnv', ()=>production ? 'production' : !!development && 'development');
     let { splitChunks } = optimization;
     if (splitChunks) {
-        A(splitChunks, 'defaultSizeTypes', ()=>css ? [
+        A(splitChunks, 'defaultSizeTypes', ()=>[
                 "javascript",
                 'css',
                 'unknown'
-            ] : [
-                "javascript",
-                'unknown'
             ]), D(splitChunks, 'hidePathInfo', production), D(splitChunks, 'chunks', 'async'), D(splitChunks, 'usedExports', !0 === optimization.usedExports), D(splitChunks, 'minChunks', 1), F(splitChunks, 'minSize', ()=>production ? 20000 : 10000), F(splitChunks, 'maxAsyncRequests', ()=>production ? 30 : 1 / 0), F(splitChunks, 'maxInitialRequests', ()=>production ? 30 : 1 / 0), D(splitChunks, 'automaticNameDelimiter', '-');
         let { cacheGroups } = splitChunks;
         cacheGroups && (F(cacheGroups, 'default', ()=>({
@@ -6017,7 +6873,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             })), F(cacheGroups, 'defaultVendors', ()=>({
                 idHint: 'vendors',
                 reuseExistingChunk: !0,
-                test: /[\\/]node_modules[\\/]/i,
+                test: /[\\/]node_modules[\\/]/,
                 priority: -10
             })));
     }
@@ -6040,16 +6896,15 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         mainFiles: [
             'index'
         ]
-    }), getResolveDefaults = ({ context, targetProperties, mode, css })=>{
+    }), getResolveDefaults = ({ targetProperties, mode })=>{
     let conditions = [
         'webpack'
     ];
     conditions.push('development' === mode ? 'development' : 'production'), targetProperties && (targetProperties.webworker && conditions.push('worker'), targetProperties.node && conditions.push('node'), targetProperties.web && conditions.push('browser'), targetProperties.electron && conditions.push('electron'), targetProperties.nwjs && conditions.push('nwjs'));
     let jsExtensions = [
         '.js',
-        '.json',
-        '.wasm'
-    ], browserField = targetProperties?.web && (!targetProperties.node || targetProperties.electron && targetProperties.electronRenderer), aliasFields = browserField ? [
+        '.json'
+    ], browserField = targetProperties && targetProperties.web && (!targetProperties.node || targetProperties.electron && targetProperties.electronRenderer), aliasFields = browserField ? [
         'browser'
     ] : [], mainFields = browserField ? [
         'browser',
@@ -6094,9 +6949,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         exportsFields: [
             'exports'
         ],
-        roots: [
-            context
-        ],
+        roots: [],
         mainFields: [
             'main'
         ],
@@ -6120,22 +6973,21 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             unknown: cjsDeps()
         }
     };
-    if (css) {
-        let styleConditions = [];
-        styleConditions.push('webpack'), styleConditions.push('development' === mode ? 'development' : 'production'), styleConditions.push('style'), resolveOptions.byDependency['css-import'] = {
-            mainFiles: [],
-            mainFields: [
-                'style',
-                '...'
-            ],
-            conditionNames: styleConditions,
-            extensions: [
-                '.css'
-            ],
-            preferRelative: !0
-        };
-    }
-    return resolveOptions;
+    return resolveOptions.byDependency['css-import'] = {
+        mainFiles: [],
+        mainFields: [
+            'style',
+            '...'
+        ],
+        conditionNames: [
+            'development' === mode ? 'development' : 'production',
+            'style'
+        ],
+        extensions: [
+            '.css'
+        ],
+        preferRelative: !0
+    }, resolveOptions;
 }, D = (obj, prop, value)=>{
     void 0 === obj[prop] && (obj[prop] = value);
 }, F = (obj, prop, factory)=>{
@@ -6264,8 +7116,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                     ]),
                 rules: nestedArray(module.rules, (r)=>[
                         ...r
-                    ]),
-                unsafeCache: module.unsafeCache
+                    ])
             })),
         target: config.target,
         externals: config.externals,
@@ -6301,7 +7152,9 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 storage: {
                     type: 'filesystem',
                     directory: node_path.resolve(config.context || process.cwd(), cache.storage?.directory || 'node_modules/.cache/rspack')
-                }
+                },
+                portable: cache.portable,
+                readonly: cache.readonly
             };
         }),
         stats: nestedConfig(config.stats, (stats)=>!1 === stats ? {
@@ -6332,7 +7185,6 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             ]),
         experiments: nestedConfig(config.experiments, (experiments)=>({
                 ...experiments,
-                incremental: optionalNestedConfig(experiments.incremental, (options)=>getNormalizedIncrementalOptions(options)),
                 buildHttp: experiments.buildHttp,
                 useInputFileSystem: experiments.useInputFileSystem
             })),
@@ -6341,7 +7193,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         devServer: config.devServer,
         amd: config.amd,
         bail: config.bail,
-        lazyCompilation: optionalNestedConfig(config.lazyCompilation, (options)=>!0 === options ? {} : options)
+        lazyCompilation: optionalNestedConfig(config.lazyCompilation, (options)=>!0 === options ? {} : options),
+        incremental: optionalNestedConfig(config.incremental, (options)=>getNormalizedIncrementalOptions(options))
     };
 }, getNormalizedEntryStatic = (entry)=>{
     if ('string' == typeof entry) return {
@@ -6398,12 +7251,11 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }
 }, getNormalizedIncrementalOptions = (incremental)=>!1 !== incremental && 'none' !== incremental && ('safe' === incremental ? {
         silent: !0,
-        make: !0,
-        inferAsyncModules: !1,
-        providedExports: !1,
-        dependenciesDiagnostics: !1,
-        sideEffects: !1,
-        buildChunkGraph: !1,
+        buildModuleGraph: !0,
+        finishModules: !1,
+        optimizeDependencies: !1,
+        buildChunkGraph: !0,
+        optimizeChunkModules: !1,
         moduleIds: !1,
         chunkIds: !1,
         modulesHashes: !1,
@@ -6411,7 +7263,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         modulesRuntimeRequirements: !1,
         chunksRuntimeRequirements: !1,
         chunksHashes: !1,
-        chunksRender: !1,
+        chunkAsset: !1,
         emitAssets: !0
     } : !0 === incremental || 'advance-silent' === incremental ? {} : 'advance' === incremental ? {
         silent: !1
@@ -7207,10 +8059,10 @@ class MultiStats {
     hasWarnings() {
         return this.stats.some((stat)=>stat.hasWarnings());
     }
-    #createChildOptions(options = {}, context) {
+    #createChildOptions(options, context) {
         let { children: childrenOptions, ...baseOptions } = 'string' == typeof options || 'boolean' == typeof options ? {
             preset: options
-        } : options, children = this.stats.map((stat, idx)=>{
+        } : options ?? {}, children = this.stats.map((stat, idx)=>{
             let childOptions = Array.isArray(childrenOptions) ? childrenOptions[idx] : childrenOptions;
             return stat.compilation.createStatsOptions({
                 ...baseOptions,
@@ -7237,7 +8089,7 @@ class MultiStats {
         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 = "2.0.0-canary-20260116", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
+        }), childOptions.version && (obj.rspackVersion = "2.0.0-rc.0", 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
@@ -7644,7 +8496,7 @@ class NodeWatchFileSystem {
         if ('number' != typeof startTime && startTime) throw Error("Invalid arguments: 'startTime'");
         if ('object' != typeof options) throw Error("Invalid arguments: 'options'");
         if ('function' != typeof callbackUndelayed && callbackUndelayed) throw Error("Invalid arguments: 'callbackUndelayed'");
-        let oldWatcher = this.watcher, Watchpack = NodeWatchFileSystem_require('watchpack');
+        let oldWatcher = this.watcher, Watchpack = NodeWatchFileSystem_require('../compiled/watchpack/index.js');
         this.watcher = new Watchpack(options), callbackUndelayed && this.watcher?.once('change', callbackUndelayed);
         let fetchTimeInfo = ()=>{
             let fileTimeInfoEntries = new Map(), contextTimeInfoEntries = new Map();
@@ -7734,7 +8586,7 @@ let arraySum = (array)=>{
         let str = `${a}`, length = lengths[i];
         return str.length === length ? str : length > 5 ? `...${str.slice(-length + 3)}` : length > 0 ? str.slice(-length) : '';
     });
-}, CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.18.4/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
+}, CachedInputFileSystem = __webpack_require__("../../node_modules/.pnpm/enhanced-resolve@5.20.1/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js");
 var CachedInputFileSystem_default = __webpack_require__.n(CachedInputFileSystem);
 class NodeEnvironmentPlugin {
     options;
@@ -7836,7 +8688,7 @@ class NodeEnvironmentPlugin {
                             if ('' === str) return str;
                             let prefixWithIndent = currentIndent + prefix;
                             return colors ? prefixWithIndent + colorPrefix + str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) + colorSuffix : prefixWithIndent + str.replace(/\n/g, `\n${prefix}`);
-                        })(external_node_util_format(...args), prefix, colorPrefix, colorSuffix);
+                        })(__rspack_external_node_util_1b29d436.format(...args), prefix, colorPrefix, colorSuffix);
                         stream.write(`${str}\n`), writeStatusMessage();
                     }, writeGroupMessage = writeColored('<-> ', '\u001b[1m\u001b[36m', '\u001b[39m\u001b[22m'), writeGroupCollapsedMessage = writeColored('<+> ', '\u001b[1m\u001b[36m', '\u001b[39m\u001b[22m');
                 return {
@@ -8393,15 +9245,21 @@ let iterateConfig = (config, options, fn)=>{
             if (context.makePathsRelative || (context.makePathsRelative = makePathsRelative.bindContextCache(compilation.compiler.context, compilation.compiler.root)), !context.cachedGetErrors) {
                 let map = new WeakMap();
                 context.cachedGetErrors = (compilation)=>{
-                    var errors;
-                    return map.get(compilation) || (errors = statsCompilation.errors, map.set(compilation, errors), errors);
+                    if (compilation.compiler._lastCompilation !== compilation) return [];
+                    let cache = map.get(compilation);
+                    if (cache) return cache;
+                    let errors = statsCompilation.errors;
+                    return map.set(compilation, errors), errors;
                 };
             }
             if (!context.cachedGetWarnings) {
                 let map = new WeakMap();
                 context.cachedGetWarnings = (compilation)=>{
-                    var warnings;
-                    return map.get(compilation) || (warnings = compilation.__internal_getInner().createStatsWarnings(compilation.getWarnings(), !!options.colors), map.set(compilation, warnings), warnings);
+                    if (compilation.compiler._lastCompilation !== compilation) return [];
+                    let cache = map.get(compilation);
+                    if (cache) return cache;
+                    let warnings = compilation.__internal_getInner().createStatsWarnings(compilation.getWarnings(), !!options.colors);
+                    return map.set(compilation, warnings), warnings;
                 };
             }
             compilation.name && (object.name = compilation.name);
@@ -8469,7 +9327,7 @@ let iterateConfig = (config, options, fn)=>{
                             let [label, first, second] = entry.args;
                             'number' == typeof first && 'number' == typeof second && (message = `${label}: ${1000 * first + second / 1000000} ms`);
                         }
-                        message || (message = entry.args?.length ? external_node_util_format(entry.args[0], ...entry.args.slice(1)) : '');
+                        message || (message = entry.args?.length ? __rspack_external_node_util_1b29d436.format(entry.args[0], ...entry.args.slice(1)) : '');
                         let newEntry = {
                             type,
                             message: message || '',
@@ -8490,7 +9348,7 @@ let iterateConfig = (config, options, fn)=>{
             object.hash = context.getStatsCompilation(compilation).hash;
         },
         version: (object)=>{
-            object.version = "5.75.0", object.rspackVersion = "2.0.0-canary-20260116";
+            object.version = "5.75.0", object.rspackVersion = "2.0.0-rc.0";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -8793,6 +9651,7 @@ let applyDefaults = (options, defaults)=>{
         entrypoints: !0,
         chunkGroups: !0,
         ids: !0,
+        assets: !0,
         modules: !1,
         chunks: !0,
         chunkRelations: !0,
@@ -8823,11 +9682,13 @@ let applyDefaults = (options, defaults)=>{
     detailed: {
         hash: !0,
         builtAt: !0,
+        assets: !0,
         relatedAssets: !0,
         entrypoints: !0,
         chunkGroups: !0,
         ids: !0,
         chunks: !0,
+        modules: !0,
         chunkRelations: !0,
         chunkModules: !1,
         chunkOrigins: !0,
@@ -8889,26 +9750,26 @@ let applyDefaults = (options, defaults)=>{
     none: {
         all: !1
     }
-}, NORMAL_ON = ({ all })=>!1 !== all, NORMAL_OFF = ({ all })=>!0 === all, ON_FOR_TO_STRING = ({ all }, { forToString })=>forToString ? !1 !== all : !0 === all, OFF_FOR_TO_STRING = ({ all }, { forToString })=>forToString ? !0 === all : !1 !== all, AUTO_FOR_TO_STRING = ({ all }, { forToString })=>!1 !== all && (!0 === all || !forToString || 'auto'), DEFAULTS = {
+}, NORMAL_ON = ({ all })=>!1 !== all, NORMAL_OFF = ({ all })=>!0 === all, ON_FOR_TO_STRING = ({ all }, { forToString })=>forToString ? !1 !== all : !0 === all, OFF_FOR_TO_STRING = ({ all }, { forToString })=>forToString ? !0 === all : !1 !== all, DEFAULTS = {
     performance: NORMAL_ON,
     hash: OFF_FOR_TO_STRING,
     env: NORMAL_OFF,
     version: NORMAL_ON,
     timings: NORMAL_ON,
     builtAt: OFF_FOR_TO_STRING,
-    assets: NORMAL_ON,
-    entrypoints: AUTO_FOR_TO_STRING,
-    chunkGroups: OFF_FOR_TO_STRING,
+    assets: NORMAL_OFF,
+    entrypoints: NORMAL_OFF,
+    chunkGroups: NORMAL_OFF,
     chunkGroupAuxiliary: OFF_FOR_TO_STRING,
     chunkGroupChildren: OFF_FOR_TO_STRING,
     chunkGroupMaxAssets: (_, { forToString })=>forToString ? 5 : 1 / 0,
-    chunks: OFF_FOR_TO_STRING,
+    chunks: NORMAL_OFF,
     chunkRelations: OFF_FOR_TO_STRING,
     chunkModules: ({ all, modules })=>!1 !== all && (!0 === all || !modules),
     dependentModules: OFF_FOR_TO_STRING,
     chunkOrigins: OFF_FOR_TO_STRING,
     ids: OFF_FOR_TO_STRING,
-    modules: ({ all, chunks, chunkModules }, { forToString })=>!1 !== all && (!0 === all || !forToString || !chunks || !chunkModules),
+    modules: NORMAL_OFF,
     nestedModules: OFF_FOR_TO_STRING,
     groupModulesByType: ON_FOR_TO_STRING,
     groupModulesByCacheStatus: ON_FOR_TO_STRING,
@@ -8943,7 +9804,7 @@ let applyDefaults = (options, defaults)=>{
     moduleTrace: NORMAL_ON,
     errors: NORMAL_ON,
     errorsCount: NORMAL_ON,
-    errorDetails: AUTO_FOR_TO_STRING,
+    errorDetails: ({ all }, { forToString })=>!1 !== all && (!0 === all || !forToString || 'auto'),
     errorStack: OFF_FOR_TO_STRING,
     warnings: NORMAL_ON,
     warningsCount: NORMAL_ON,
@@ -8959,7 +9820,7 @@ let applyDefaults = (options, defaults)=>{
     chunksSort: ()=>!1,
     assetsSort: ()=>'!size',
     outputPath: OFF_FOR_TO_STRING,
-    colors: ()=>!1
+    colors: ()=>isStatsColorSupported()
 }, normalizeFilter = (item)=>{
     if ('string' == typeof item) {
         let regExp = RegExp(`[\\\\/]${item.replace(/[-[\]{}()*+?.\\^$|]/g, '\\$&')}([\\\\/]|$|!|\\?)`);
@@ -9716,7 +10577,7 @@ class RspackOptionsApply {
             if (!options.externalsType) throw Error('options.externalsType should have a value after `applyRspackOptionsDefaults`');
             new ExternalsPlugin(options.externalsType, options.externals, !1).apply(compiler);
         }
-        if (options.externalsPresets.node && new NodeTargetPlugin().apply(compiler), options.externalsPresets.electronMain && new ElectronTargetPlugin('main').apply(compiler), options.externalsPresets.electronPreload && new ElectronTargetPlugin('preload').apply(compiler), options.externalsPresets.electronRenderer && new ElectronTargetPlugin('renderer').apply(compiler), !options.externalsPresets.electron || options.externalsPresets.electronMain || options.externalsPresets.electronPreload || options.externalsPresets.electronRenderer || new ElectronTargetPlugin().apply(compiler), options.externalsPresets.nwjs && new ExternalsPlugin('node-commonjs', 'nw.gui', !1).apply(compiler), (options.externalsPresets.web || options.externalsPresets.webAsync || options.externalsPresets.node && options.experiments.css) && new HttpExternalsRspackPlugin(!!options.experiments.css, !!options.externalsPresets.webAsync).apply(compiler), new ChunkPrefetchPreloadPlugin().apply(compiler), options.output.pathinfo && new ModuleInfoHeaderPlugin('verbose' === options.output.pathinfo).apply(compiler), 'string' == typeof options.output.chunkFormat) switch(options.output.chunkFormat){
+        if (options.externalsPresets.node && new NodeTargetPlugin().apply(compiler), options.externalsPresets.electronMain && new ElectronTargetPlugin('main').apply(compiler), options.externalsPresets.electronPreload && new ElectronTargetPlugin('preload').apply(compiler), options.externalsPresets.electronRenderer && new ElectronTargetPlugin('renderer').apply(compiler), !options.externalsPresets.electron || options.externalsPresets.electronMain || options.externalsPresets.electronPreload || options.externalsPresets.electronRenderer || new ElectronTargetPlugin().apply(compiler), options.externalsPresets.nwjs && new ExternalsPlugin('node-commonjs', 'nw.gui', !1).apply(compiler), (options.externalsPresets.web || options.externalsPresets.webAsync || options.externalsPresets.node) && new HttpExternalsRspackPlugin(!0, !!options.externalsPresets.webAsync).apply(compiler), new ChunkPrefetchPreloadPlugin().apply(compiler), options.output.pathinfo && new ModuleInfoHeaderPlugin('verbose' === options.output.pathinfo).apply(compiler), 'string' == typeof options.output.chunkFormat) switch(options.output.chunkFormat){
             case 'array-push':
                 new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
                 break;
@@ -9749,8 +10610,13 @@ class RspackOptionsApply {
             moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
             namespace: options.output.devtoolNamespace
         }).apply(compiler);
-        if (new JavascriptModulesPlugin().apply(compiler), new URLPlugin().apply(compiler), new JsonModulesPlugin().apply(compiler), new AssetModulesPlugin().apply(compiler), options.experiments.asyncWebAssembly && new AsyncWebAssemblyModulesPlugin().apply(compiler), options.experiments.css && new CssModulesPlugin().apply(compiler), new lib_EntryOptionPlugin().apply(compiler), assertNotNill(options.context), compiler.hooks.entryOption.call(options.context, options.entry), new RuntimePlugin().apply(compiler), options.output.bundlerInfo && new BundlerInfoRspackPlugin(options.output.bundlerInfo).apply(compiler), new InferAsyncModulesPlugin().apply(compiler), new APIPlugin().apply(compiler), new DataUriPlugin().apply(compiler), new FileUriPlugin().apply(compiler), options.experiments.buildHttp && new HttpUriPlugin(options.experiments.buildHttp).apply(compiler), new EnsureChunkConditionsPlugin().apply(compiler), options.optimization.mergeDuplicateChunks && new MergeDuplicateChunksPlugin().apply(compiler), options.optimization.sideEffects && new SideEffectsFlagPlugin().apply(compiler), options.optimization.providedExports && new FlagDependencyExportsPlugin().apply(compiler), options.optimization.usedExports && new FlagDependencyUsagePlugin('global' === options.optimization.usedExports).apply(compiler), options.optimization.concatenateModules && new ModuleConcatenationPlugin().apply(compiler), options.optimization.inlineExports && new InlineExportsPlugin().apply(compiler), options.optimization.mangleExports && new MangleExportsPlugin('size' !== options.optimization.mangleExports).apply(compiler), options.output.enabledLibraryTypes && options.output.enabledLibraryTypes.length > 0) for (let type of options.output.enabledLibraryTypes)new EnableLibraryPlugin(type).apply(compiler);
-        options.optimization.splitChunks && new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler), options.optimization.removeEmptyChunks && new RemoveEmptyChunksPlugin().apply(compiler), options.optimization.realContentHash && new RealContentHashPlugin().apply(compiler);
+        new JavascriptModulesPlugin().apply(compiler), new URLPlugin().apply(compiler), new JsonModulesPlugin().apply(compiler), new AssetModulesPlugin().apply(compiler), options.experiments.asyncWebAssembly && new AsyncWebAssemblyModulesPlugin().apply(compiler), new CssModulesPlugin().apply(compiler), new lib_EntryOptionPlugin().apply(compiler), assertNotNill(options.context), compiler.hooks.entryOption.call(options.context, options.entry), new RuntimePlugin().apply(compiler), options.output.bundlerInfo && new BundlerInfoRspackPlugin(options.output.bundlerInfo).apply(compiler), new InferAsyncModulesPlugin().apply(compiler), new APIPlugin().apply(compiler), new DataUriPlugin().apply(compiler), new FileUriPlugin().apply(compiler), options.experiments.buildHttp && new HttpUriPlugin(options.experiments.buildHttp).apply(compiler), new EnsureChunkConditionsPlugin().apply(compiler), options.optimization.mergeDuplicateChunks && new MergeDuplicateChunksPlugin().apply(compiler), options.optimization.sideEffects && new SideEffectsFlagPlugin().apply(compiler), options.optimization.providedExports && new FlagDependencyExportsPlugin().apply(compiler), options.optimization.usedExports && new FlagDependencyUsagePlugin('global' === options.optimization.usedExports).apply(compiler), options.optimization.concatenateModules && new ModuleConcatenationPlugin().apply(compiler), options.optimization.inlineExports && new InlineExportsPlugin().apply(compiler), options.optimization.mangleExports && new MangleExportsPlugin('size' !== options.optimization.mangleExports).apply(compiler);
+        let enableLibSplitChunks = !1;
+        if (options.output.enabledLibraryTypes && options.output.enabledLibraryTypes.length > 0) {
+            let hasModernModule = options.output.enabledLibraryTypes.includes('modern-module'), hasNonModernModule = options.output.enabledLibraryTypes.some((t)=>'modern-module' !== t);
+            for (let type of (options.output.library?.preserveModules && !hasModernModule && compiler.getInfrastructureLogger('rspack.RspackOptionsApply').warn('`preserveModules` only works for `modern-module` library type and will be ignored for other library types.'), hasModernModule && hasNonModernModule && compiler.getInfrastructureLogger('rspack.RspackOptionsApply').warn('`modern-module` is used together with other library types. ESM format has impact on chunkLoading and chunkFormat, which may not be compatible with other library types.'), options.output.enabledLibraryTypes))'modern-module' === type && (enableLibSplitChunks = !0), new EnableLibraryPlugin(type).apply(compiler);
+        }
+        !enableLibSplitChunks && options.optimization.splitChunks && new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler), options.optimization.removeEmptyChunks && new RemoveEmptyChunksPlugin().apply(compiler), options.optimization.realContentHash && new RealContentHashPlugin().apply(compiler);
         let moduleIds = options.optimization.moduleIds;
         if (moduleIds) switch(moduleIds){
             case 'named':
@@ -9833,13 +10699,16 @@ function createCompiler(userOptions) {
     if (new NodeEnvironmentPlugin({
         infrastructureLogging: options.infrastructureLogging
     }).apply(compiler), Array.isArray(options.plugins)) for (let plugin of options.plugins)'function' == typeof plugin ? plugin.call(compiler, compiler) : plugin && plugin.apply(compiler);
-    let { platform } = applyRspackOptionsDefaults(compiler.options);
-    return platform && (compiler.platform = platform), compiler.hooks.environment.call(), compiler.hooks.afterEnvironment.call(), new RspackOptionsApply().process(compiler.options, compiler), compiler.hooks.initialize.call(), compiler;
+    let tp = applyRspackOptionsDefaults(compiler.options);
+    return tp && (compiler.platform = tp.platform, compiler.target = {
+        esVersion: tp.esVersion,
+        targets: tp.targets
+    }), compiler.hooks.environment.call(), compiler.hooks.afterEnvironment.call(), new RspackOptionsApply().process(compiler.options, compiler), compiler.hooks.initialize.call(), compiler;
 }
 function isMultiRspackOptions(o) {
     return Array.isArray(o);
 }
-function rspack(options, callback) {
+function rspack_rspack(options, callback) {
     try {
         if (isMultiRspackOptions(options)) for (let option of options)validateRspackConfig(option);
         else validateRspackConfig(options);
@@ -10136,7 +11005,7 @@ class TraceHookPlugin {
         });
     }
 }
-let CORE_VERSION = "2.0.0-canary-20260116", VFILES_BY_COMPILER = new WeakMap();
+let CORE_VERSION = "2.0.0-rc.0", VFILES_BY_COMPILER = new WeakMap();
 class VirtualModulesPlugin {
     #staticModules;
     #compiler;
@@ -10281,22 +11150,23 @@ class Watching {
         let startTime = this.startTime;
         this.startTime = void 0, compilation.startTime = startTime, compilation.endTime = Date.now();
         let cbs = this.callbacks;
-        this.callbacks = [];
-        let fileDependencies = new Set([
-            ...compilation.fileDependencies
-        ]);
-        fileDependencies.added = new Set(compilation.__internal__addedFileDependencies), fileDependencies.removed = new Set(compilation.__internal__removedFileDependencies);
-        let contextDependencies = new Set([
-            ...compilation.contextDependencies
-        ]);
-        contextDependencies.added = new Set(compilation.__internal__addedContextDependencies), contextDependencies.removed = new Set(compilation.__internal__removedContextDependencies);
-        let missingDependencies = new Set([
-            ...compilation.missingDependencies
-        ]);
-        missingDependencies.added = new Set(compilation.__internal__addedMissingDependencies), missingDependencies.removed = new Set(compilation.__internal__removedMissingDependencies), this.compiler.hooks.done.callAsync(stats, (err)=>{
+        this.callbacks = [], this.compiler.hooks.done.callAsync(stats, (err)=>{
             if (err) return handleError(err, cbs);
             for (let cb of (this.handler(null, stats), process.nextTick(()=>{
-                this.#closed || this.watch(fileDependencies, contextDependencies, missingDependencies);
+                if (!this.#closed) {
+                    let fileDependencies = new Set([
+                        ...compilation.fileDependencies
+                    ]);
+                    fileDependencies.added = new Set(compilation.__internal__addedFileDependencies), fileDependencies.removed = new Set(compilation.__internal__removedFileDependencies);
+                    let contextDependencies = new Set([
+                        ...compilation.contextDependencies
+                    ]);
+                    contextDependencies.added = new Set(compilation.__internal__addedContextDependencies), contextDependencies.removed = new Set(compilation.__internal__removedContextDependencies);
+                    let missingDependencies = new Set([
+                        ...compilation.missingDependencies
+                    ]);
+                    missingDependencies.added = new Set(compilation.__internal__addedMissingDependencies), missingDependencies.removed = new Set(compilation.__internal__removedMissingDependencies), this.watch(fileDependencies, contextDependencies, missingDependencies);
+                }
             }), cbs))cb(null);
             this.compiler.hooks.afterDone.call(stats);
         });
@@ -10316,7 +11186,7 @@ class Watching {
         this.suspended && (this.suspended = !1, this.#invalidate());
     }
 }
-let Compiler_require = createRequire(import.meta.url);
+let Compiler_require = createRequire(import.meta.url), GET_COMPILER_ID = Symbol('getCompilerId');
 class Compiler {
     #instance;
     #initial;
@@ -10355,6 +11225,7 @@ class Compiler {
     cache;
     compilerPath;
     #platform;
+    #target;
     options;
     unsafeFastDrop = !1;
     __internal_browser_require;
@@ -10446,8 +11317,19 @@ class Compiler {
             ]),
             additionalPass: new AsyncSeriesHook([])
         };
+        let availableCompilerHooks = Object.keys(this.hooks);
+        this.hooks = new Proxy(this.hooks, {
+            get (target, prop, receiver) {
+                let value = Reflect.get(target, prop, receiver);
+                if (void 0 === value && 'string' == typeof prop) {
+                    let hooksList = availableCompilerHooks.join(', ');
+                    throw Error(`Compiler.hooks.${prop} is not supported in rspack. This typically happens when using webpack plugins that rely on webpack-specific hooks. Consider using an rspack-compatible alternative or removing the incompatible plugin.\n\nAvailable compiler hooks: ${hooksList}`);
+                }
+                return value;
+            }
+        });
         let compilerRspack = Object.assign(function(...params) {
-            return rspack(...params);
+            return rspack_rspack(...params);
         }, exports_namespaceObject, {
             RuntimeGlobals: createCompilerRuntimeGlobals(options)
         });
@@ -10458,9 +11340,14 @@ class Compiler {
             node: null,
             nwjs: null,
             electron: null
-        }, this.__internal_browser_require = ()=>{
+        }, this.#target = {}, this.__internal_browser_require = ()=>{
             throw Error('Cannot execute user defined code in browser without `BrowserRequirePlugin`');
-        }, 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);
+        }, 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), Object.defineProperty(this, GET_COMPILER_ID, {
+            writable: !1,
+            configurable: !1,
+            enumerable: !1,
+            value: ()=>this.#instance.getCompilerId()
+        });
     }
     get recordsInputPath() {
         return unsupported('Compiler.recordsInputPath');
@@ -10483,6 +11370,12 @@ class Compiler {
     set platform(platform) {
         this.#platform = platform;
     }
+    get target() {
+        return this.#target;
+    }
+    set target(target) {
+        this.#target = target;
+    }
     get __internal__builtinPlugins() {
         return this.#builtinPlugins;
     }
@@ -10613,7 +11506,8 @@ class Compiler {
         }) : this.hooks.shutdown.callAsync((err)=>{
             if (err) return callback(err);
             this.cache.shutdown(()=>{
-                this.#instance?.close(), callback();
+                let closePromise = this.#instance?.close();
+                closePromise ? closePromise.then(()=>callback(), callback) : callback();
             });
         });
     }
@@ -10654,7 +11548,7 @@ class Compiler {
     }
     #getInstance(callback) {
         var output;
-        let coreVersion, expectedCoreVersion, mode, experiments, error = CORE_VERSION === binding_default().EXPECTED_RSPACK_CORE_VERSION || CORE_VERSION.includes('canary') ? null : Error((coreVersion = CORE_VERSION, expectedCoreVersion = binding_default().EXPECTED_RSPACK_CORE_VERSION, process.env.RSPACK_BINDING ? `Unmatched version @rspack/core@${coreVersion} and binding version.
+        let coreVersion, expectedCoreVersion, statsOptions, mode, experiments, error = CORE_VERSION === binding_default().EXPECTED_RSPACK_CORE_VERSION || CORE_VERSION.includes('canary') ? null : Error((coreVersion = CORE_VERSION, expectedCoreVersion = binding_default().EXPECTED_RSPACK_CORE_VERSION, 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}').
@@ -10715,8 +11609,7 @@ Help:
                             k,
                             getRawGeneratorOptions(v, k)
                         ]).filter(([_, v])=>void 0 !== v)),
-                    noParse: module.noParse,
-                    unsafeCache: module.unsafeCache
+                    noParse: module.noParse
                 };
             }(options.module, {
                 compiler: this,
@@ -10726,7 +11619,7 @@ Help:
             }),
             optimization: options.optimization,
             stats: {
-                colors: !!function(options) {
+                colors: void 0 === (statsOptions = function(options) {
                     if ('boolean' == typeof options || 'string' == typeof options) return presetToOptions(options);
                     if (!options) return {};
                     let obj = {
@@ -10734,10 +11627,11 @@ Help:
                         ...options
                     };
                     return delete obj.preset, obj;
-                }(options.stats).colors
+                }(options.stats)).colors ? isStatsColorSupported() : !!statsOptions.colors
             },
             cache: options.cache || !1,
             experiments,
+            incremental: options.incremental,
             node: function(node) {
                 if (!1 !== node) {
                     if (isNil(node.__dirname) || isNil(node.global) || isNil(node.__filename)) throw Error('node.__dirname, node.global, node.__filename should not be nil');
@@ -10997,6 +11891,29 @@ Help:
                         return queried.promise(getCompiler().__internal__get_compilation().chunks, getCompiler().__internal__get_compilation().modules);
                     };
                 }),
+                registerCompilationBeforeModuleIdsTaps: createTap(binding_default().RegisterJsTapKind.CompilationBeforeModuleIds, function() {
+                    return getCompiler().__internal__get_compilation().hooks.beforeModuleIds;
+                }, function(queried) {
+                    return function(arg) {
+                        let compilation = getCompiler().__internal__get_compilation(), assignments = new Map(), modulesByIdentifier = new Map();
+                        for (let module of compilation.modules)modulesByIdentifier.set(module.identifier(), module);
+                        let proxiedModules = arg.modules.map((m)=>new Proxy(modulesByIdentifier.get(m.identifier), {
+                                get (target, prop) {
+                                    if ('id' === prop) return assignments.get(m.identifier) ?? null;
+                                    if ('identifier' === prop) return m.identifier;
+                                    let value = Reflect.get(target, prop);
+                                    return 'function' == typeof value ? value.bind(target) : value;
+                                },
+                                set: (_target, prop, value)=>'id' === prop && null !== value && (assignments.set(m.identifier, value), !0)
+                            }));
+                        return queried.call(proxiedModules), {
+                            assignments: Object.fromEntries(Array.from(assignments.entries()).map(([k, v])=>[
+                                    k,
+                                    String(v)
+                                ]))
+                        };
+                    };
+                }),
                 registerCompilationChunkHashTaps: createTap(binding_default().RegisterJsTapKind.CompilationChunkHash, function() {
                     return getCompiler().__internal__get_compilation().hooks.chunkHash;
                 }, function(queried) {
@@ -11539,68 +12456,7 @@ class LoaderTargetPlugin {
         });
     }
 }
-let VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
-function isRequiredVersion(str) {
-    return VERSION_PATTERN_REGEXP.test(str);
-}
-let MANIFEST_FILE_NAME = 'mf-manifest.json', STATS_FILE_NAME = 'mf-stats.json', JSON_EXT = '.json';
-function isPlainObject(value) {
-    return !!value && 'object' == typeof value && !Array.isArray(value);
-}
-class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
-    name = binding_namespaceObject.BuiltinPluginName.ModuleFederationManifestPlugin;
-    opts;
-    constructor(opts){
-        super(), this.opts = opts;
-    }
-    raw(compiler) {
-        var isDev;
-        let pkg, buildVersion, { fileName, filePath, disableAssetsAnalyze, remoteAliasMap, exposes, shared } = this.opts, { statsFileName, manifestFileName } = function(manifestOptions) {
-            if (!manifestOptions) return {
-                statsFileName: STATS_FILE_NAME,
-                manifestFileName: MANIFEST_FILE_NAME
-            };
-            let filePath = 'boolean' == typeof manifestOptions ? '' : manifestOptions.filePath || '', fileName = 'boolean' == typeof manifestOptions ? '' : manifestOptions.fileName || '', manifestFileName = fileName ? fileName.endsWith(JSON_EXT) ? fileName : `${fileName}${JSON_EXT}` : MANIFEST_FILE_NAME;
-            return {
-                statsFileName: join(filePath, fileName ? manifestFileName.replace(JSON_EXT, `-stats${JSON_EXT}`) : STATS_FILE_NAME),
-                manifestFileName: join(filePath, manifestFileName)
-            };
-        }(this.opts), rawOptions = {
-            name: this.opts.name,
-            globalName: this.opts.globalName,
-            fileName,
-            filePath,
-            manifestFileName,
-            statsFileName,
-            disableAssetsAnalyze,
-            remoteAliasMap,
-            exposes,
-            shared,
-            buildInfo: (isDev = 'development' === compiler.options.mode, pkg = function(root) {
-                let pkgPath = join(root ? external_node_path_resolve(root) : process.cwd(), 'package.json');
-                try {
-                    let content = readFileSync(pkgPath, 'utf-8'), parsed = function(input, guard) {
-                        try {
-                            let parsed = JSON.parse(input);
-                            if (guard(parsed)) return parsed;
-                        } catch  {}
-                    }(content, isPlainObject);
-                    if (parsed) {
-                        let filtered = {};
-                        for (let [key, value] of Object.entries(parsed))'string' == typeof value && (filtered[key] = value);
-                        if (Object.keys(filtered).length > 0) return filtered;
-                    }
-                } catch  {}
-                return {};
-            }(compiler.context || process.cwd()), buildVersion = isDev ? 'local' : pkg?.version, {
-                buildVersion: process.env.MF_BUILD_VERSION || buildVersion || 'UNKNOWN',
-                buildName: process.env.MF_BUILD_NAME || pkg?.name || 'UNKNOWN'
-            })
-        };
-        return createBuiltinPlugin(this.name, rawOptions);
-    }
-}
-let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinPluginName.ModuleFederationRuntimePlugin, (options = {})=>options), parseOptions = (options, normalizeSimple, normalizeOptions)=>{
+let parseOptions = (options, normalizeSimple, normalizeOptions)=>{
     let items = [];
     var fn = (key, value)=>{
         items.push([
@@ -11617,63 +12473,7 @@ let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinP
     else if ('object' == typeof options) object(options);
     else throw Error('Unexpected options format');
     return items;
-}, ModuleFederationPlugin_require = createRequire(import.meta.url);
-function getRemoteInfos(options) {
-    if (!options.remotes) return {};
-    let remoteType = options.remoteType || (options.library ? options.library.type : "script"), remotes = parseOptions(options.remotes, (item)=>({
-            external: Array.isArray(item) ? item : [
-                item
-            ],
-            shareScope: options.shareScope || 'default'
-        }), (item)=>({
-            external: Array.isArray(item.external) ? item.external : [
-                item.external
-            ],
-            shareScope: item.shareScope || options.shareScope || 'default'
-        })), remoteInfos = {};
-    for (let [key, config] of remotes)for (let external of config.external){
-        let [externalType, externalRequest] = function(external) {
-            let result = function(external) {
-                if (/^[a-z0-9-]+ /.test(external)) {
-                    let idx = external.indexOf(' ');
-                    return [
-                        external.slice(0, idx),
-                        external.slice(idx + 1)
-                    ];
-                }
-                return null;
-            }(external);
-            return null === result ? [
-                remoteType,
-                external
-            ] : result;
-        }(external);
-        if (remoteInfos[key] ??= [], "script" === externalType) {
-            let [url, global] = function(urlAndGlobal) {
-                let index = urlAndGlobal.indexOf('@');
-                return index <= 0 || index === urlAndGlobal.length - 1 ? null : [
-                    urlAndGlobal.substring(index + 1),
-                    urlAndGlobal.substring(0, index)
-                ];
-            }(externalRequest);
-            remoteInfos[key].push({
-                alias: key,
-                name: global,
-                entry: url,
-                externalType,
-                shareScope: config.shareScope
-            });
-        } else remoteInfos[key].push({
-            alias: key,
-            name: void 0,
-            entry: void 0,
-            externalType,
-            shareScope: config.shareScope
-        });
-    }
-    return remoteInfos;
-}
-let compilerSet = new WeakSet();
+}, compilerSet = new WeakSet();
 class ShareRuntimePlugin extends RspackBuiltinPlugin {
     enhanced;
     name = binding_namespaceObject.BuiltinPluginName.ShareRuntimePlugin;
@@ -11684,42 +12484,55 @@ class ShareRuntimePlugin extends RspackBuiltinPlugin {
         if (!compilerSet.has(compiler)) return compilerSet.add(compiler), createBuiltinPlugin(this.name, this.enhanced);
     }
 }
+let VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+function isRequiredVersion(str) {
+    return VERSION_PATTERN_REGEXP.test(str);
+}
+let encodeName = function(name, prefix = '', withExt = !1) {
+    return `${prefix}${name.replace(/@/g, 'scope_').replace(/-/g, '_').replace(/\//g, '__').replace(/\./g, '')}${withExt ? '.js' : ''}`;
+};
+function normalizeConsumeShareOptions(consumes, shareScope) {
+    return parseOptions(consumes, (item, key)=>{
+        if (Array.isArray(item)) throw Error('Unexpected array in options');
+        return item !== key && isRequiredVersion(item) ? {
+            import: key,
+            shareScope: shareScope || 'default',
+            shareKey: key,
+            requiredVersion: item,
+            strictVersion: !0,
+            packageName: void 0,
+            singleton: !1,
+            eager: !1,
+            treeShakingMode: void 0
+        } : {
+            import: key,
+            shareScope: shareScope || 'default',
+            shareKey: key,
+            requiredVersion: void 0,
+            packageName: void 0,
+            strictVersion: !1,
+            singleton: !1,
+            eager: !1,
+            treeShakingMode: void 0
+        };
+    }, (item, key)=>({
+            import: !1 === item.import ? void 0 : item.import || key,
+            shareScope: item.shareScope || shareScope || 'default',
+            shareKey: item.shareKey || key,
+            requiredVersion: item.requiredVersion,
+            strictVersion: 'boolean' == typeof item.strictVersion ? item.strictVersion : !1 !== item.import && !item.singleton,
+            packageName: item.packageName,
+            singleton: !!item.singleton,
+            eager: !!item.eager,
+            treeShakingMode: item.treeShakingMode
+        }));
+}
 class ConsumeSharedPlugin extends RspackBuiltinPlugin {
     name = binding_namespaceObject.BuiltinPluginName.ConsumeSharedPlugin;
     _options;
     constructor(options){
         super(), this._options = {
-            consumes: parseOptions(options.consumes, (item, key)=>{
-                if (Array.isArray(item)) throw Error('Unexpected array in options');
-                return item !== key && isRequiredVersion(item) ? {
-                    import: key,
-                    shareScope: options.shareScope || 'default',
-                    shareKey: key,
-                    requiredVersion: item,
-                    strictVersion: !0,
-                    packageName: void 0,
-                    singleton: !1,
-                    eager: !1
-                } : {
-                    import: key,
-                    shareScope: options.shareScope || 'default',
-                    shareKey: key,
-                    requiredVersion: void 0,
-                    packageName: void 0,
-                    strictVersion: !1,
-                    singleton: !1,
-                    eager: !1
-                };
-            }, (item, key)=>({
-                    import: !1 === item.import ? void 0 : item.import || key,
-                    shareScope: item.shareScope || options.shareScope || 'default',
-                    shareKey: item.shareKey || key,
-                    requiredVersion: item.requiredVersion,
-                    strictVersion: 'boolean' == typeof item.strictVersion ? item.strictVersion : !1 !== item.import && !item.singleton,
-                    packageName: item.packageName,
-                    singleton: !!item.singleton,
-                    eager: !!item.eager
-                })),
+            consumes: normalizeConsumeShareOptions(options.consumes, options.shareScope),
             enhanced: options.enhanced ?? !1
         };
     }
@@ -11740,28 +12553,30 @@ class ProvideSharedPlugin extends RspackBuiltinPlugin {
     _provides;
     _enhanced;
     constructor(options){
-        super(), this._provides = parseOptions(options.provides, (item)=>{
+        var options1, shareScope, enhanced;
+        super(), this._provides = (options1 = options.provides, shareScope = options.shareScope, enhanced = options.enhanced, parseOptions(options1, (item)=>{
             if (Array.isArray(item)) throw Error('Unexpected array of provides');
             return {
                 shareKey: item,
                 version: void 0,
-                shareScope: options.shareScope || 'default',
+                shareScope: shareScope || 'default',
                 eager: !1
             };
         }, (item)=>{
             let raw = {
                 shareKey: item.shareKey,
                 version: item.version,
-                shareScope: item.shareScope || options.shareScope || 'default',
+                shareScope: item.shareScope || shareScope || 'default',
                 eager: !!item.eager
             };
-            return options.enhanced ? {
+            return enhanced ? {
                 ...raw,
                 singleton: item.singleton,
                 requiredVersion: item.requiredVersion,
-                strictVersion: item.strictVersion
+                strictVersion: item.strictVersion,
+                treeShakingMode: item.treeShakingMode
             } : raw;
-        }), this._enhanced = options.enhanced;
+        })), this._enhanced = options.enhanced;
     }
     raw(compiler) {
         new ShareRuntimePlugin(this._enhanced ?? !1).apply(compiler);
@@ -11772,32 +12587,43 @@ class ProvideSharedPlugin extends RspackBuiltinPlugin {
         return createBuiltinPlugin(this.name, rawOptions);
     }
 }
+function validateShareScope(shareScope, enhanced, pluginName) {
+    if (Array.isArray(shareScope) && shareScope.length > 1 && !enhanced) throw Error(`[${pluginName}] shareScope as an array with multiple entries requires enhanced=true, got: ${JSON.stringify(shareScope)}`);
+}
+function normalizeSharedOptions(shared) {
+    return parseOptions(shared, (item, key)=>{
+        if ('string' != typeof item) throw Error('Unexpected array in shared');
+        return item !== key && isRequiredVersion(item) ? {
+            import: key,
+            requiredVersion: item
+        } : {
+            import: item
+        };
+    }, (item)=>item);
+}
+function createConsumeShareOptions(normalizedSharedOptions) {
+    return normalizedSharedOptions.map(([key, options])=>({
+            [key]: {
+                import: options.import,
+                shareKey: options.shareKey || key,
+                shareScope: options.shareScope,
+                requiredVersion: options.requiredVersion,
+                strictVersion: options.strictVersion,
+                singleton: options.singleton,
+                packageName: options.packageName,
+                eager: options.eager,
+                treeShakingMode: options.treeShaking?.mode
+            }
+        }));
+}
 class SharePlugin {
     _shareScope;
     _consumes;
     _provides;
     _enhanced;
+    _sharedOptions;
     constructor(options){
-        let sharedOptions = parseOptions(options.shared, (item, key)=>{
-            if ('string' != typeof item) throw Error('Unexpected array in shared');
-            return item !== key && isRequiredVersion(item) ? {
-                import: key,
-                requiredVersion: item
-            } : {
-                import: item
-            };
-        }, (item)=>item), consumes = sharedOptions.map(([key, options])=>({
-                [key]: {
-                    import: options.import,
-                    shareKey: options.shareKey || key,
-                    shareScope: options.shareScope,
-                    requiredVersion: options.requiredVersion,
-                    strictVersion: options.strictVersion,
-                    singleton: options.singleton,
-                    packageName: options.packageName,
-                    eager: options.eager
-                }
-            })), provides = sharedOptions.filter(([, options])=>!1 !== options.import).map(([key, options])=>({
+        let sharedOptions = normalizeSharedOptions(options.shared), consumes = createConsumeShareOptions(sharedOptions), provides = sharedOptions.filter(([, options])=>!1 !== options.import).map(([key, options])=>({
                 [options.import || key]: {
                     shareKey: options.shareKey || key,
                     shareScope: options.shareScope,
@@ -11805,10 +12631,11 @@ class SharePlugin {
                     eager: options.eager,
                     singleton: options.singleton,
                     requiredVersion: options.requiredVersion,
-                    strictVersion: options.strictVersion
+                    strictVersion: options.strictVersion,
+                    treeShakingMode: options.treeShaking?.mode
                 }
             }));
-        this._shareScope = options.shareScope, this._consumes = consumes, this._provides = provides, this._enhanced = options.enhanced ?? !1;
+        this._shareScope = options.shareScope, this._consumes = consumes, this._provides = provides, this._enhanced = options.enhanced ?? !1, this._sharedOptions = sharedOptions;
     }
     apply(compiler) {
         new ConsumeSharedPlugin({
@@ -11822,15 +12649,566 @@ class SharePlugin {
         }).apply(compiler);
     }
 }
+let MANIFEST_FILE_NAME = 'mf-manifest.json', STATS_FILE_NAME = 'mf-stats.json', JSON_EXT = '.json';
+function isPlainObject(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function getFileName(manifestOptions) {
+    if (!manifestOptions) return {
+        statsFileName: '',
+        manifestFileName: ''
+    };
+    if ('boolean' == typeof manifestOptions) return {
+        statsFileName: STATS_FILE_NAME,
+        manifestFileName: MANIFEST_FILE_NAME
+    };
+    let filePath = 'boolean' == typeof manifestOptions ? '' : manifestOptions.filePath || '', fileName = 'boolean' == typeof manifestOptions ? '' : manifestOptions.fileName || '', manifestFileName = fileName ? fileName.endsWith(JSON_EXT) ? fileName : `${fileName}${JSON_EXT}` : MANIFEST_FILE_NAME;
+    return {
+        statsFileName: join(filePath, fileName ? manifestFileName.replace(JSON_EXT, `-stats${JSON_EXT}`) : STATS_FILE_NAME),
+        manifestFileName: join(filePath, manifestFileName)
+    };
+}
+class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.ModuleFederationManifestPlugin;
+    rawOpts;
+    constructor(opts){
+        super(), this.rawOpts = opts;
+    }
+    raw(compiler) {
+        var mfConfig, isDev, mfConfig1;
+        let manifestOptions, containerName, globalName, remoteAliasMap, manifestExposes, manifestShared, pkg, buildVersion, statsBuildInfo, opts = (manifestOptions = !0 === (mfConfig = this.rawOpts).manifest ? {} : {
+            ...mfConfig.manifest
+        }, containerName = mfConfig.name, globalName = function(library) {
+            if (!library) return;
+            let libName = library.name;
+            if (libName) {
+                if ('string' == typeof libName) return libName;
+                if (Array.isArray(libName)) return libName[0];
+                if ('object' == typeof libName) return libName.root?.[0] ?? libName.amd ?? libName.commonjs ?? void 0;
+            }
+        }(mfConfig.library) ?? containerName, remoteAliasMap = Object.entries(getRemoteInfos(mfConfig)).reduce((sum, cur)=>{
+            if (cur[1].length > 1) return sum;
+            let { entry, alias, name } = cur[1][0];
+            return entry && name && (sum[alias] = {
+                name,
+                entry
+            }), sum;
+        }, {}), manifestExposes = function(exposes) {
+            if (!exposes) return;
+            let result = parseOptions(exposes, (value)=>({
+                    import: Array.isArray(value) ? value : [
+                        value
+                    ],
+                    name: void 0
+                }), (value)=>({
+                    import: Array.isArray(value.import) ? value.import : [
+                        value.import
+                    ],
+                    name: value.name ?? void 0
+                })).map(([exposeKey, info])=>{
+                let exposeName = info.name ?? exposeKey.replace(/^\.\//, '');
+                return {
+                    path: exposeKey,
+                    name: exposeName
+                };
+            });
+            return result.length > 0 ? result : void 0;
+        }(mfConfig.exposes), void 0 === manifestOptions.exposes && manifestExposes && (manifestOptions.exposes = manifestExposes), manifestShared = function(shared) {
+            if (!shared) return;
+            let result = parseOptions(shared, (item, key)=>{
+                if ('string' != typeof item) throw Error('Unexpected array in shared');
+                return item !== key && isRequiredVersion(item) ? {
+                    import: key,
+                    requiredVersion: item
+                } : {
+                    import: item
+                };
+            }, (item)=>item).map(([key, config])=>{
+                let name = config.shareKey || key;
+                return {
+                    name,
+                    version: 'string' == typeof config.version ? config.version : void 0,
+                    requiredVersion: 'string' == typeof config.requiredVersion ? config.requiredVersion : void 0,
+                    singleton: config.singleton
+                };
+            });
+            return result.length > 0 ? result : void 0;
+        }(mfConfig.shared), void 0 === manifestOptions.shared && manifestShared && (manifestOptions.shared = manifestShared), {
+            ...manifestOptions,
+            remoteAliasMap,
+            globalName,
+            name: containerName
+        }), { fileName, filePath, disableAssetsAnalyze, remoteAliasMap: remoteAliasMap1, exposes, shared } = opts, { statsFileName, manifestFileName } = getFileName(opts), rawOptions = {
+            name: opts.name,
+            globalName: opts.globalName,
+            fileName,
+            filePath,
+            manifestFileName,
+            statsFileName,
+            disableAssetsAnalyze,
+            remoteAliasMap: remoteAliasMap1,
+            exposes,
+            shared,
+            buildInfo: (isDev = 'development' === compiler.options.mode, mfConfig1 = this.rawOpts, pkg = function(root) {
+                let pkgPath = join(root ? external_node_path_resolve(root) : process.cwd(), 'package.json');
+                try {
+                    let content = readFileSync(pkgPath, 'utf-8'), parsed = function(input, guard) {
+                        try {
+                            let parsed = JSON.parse(input);
+                            if (guard(parsed)) return parsed;
+                        } catch  {}
+                    }(content, isPlainObject);
+                    if (parsed) {
+                        let filtered = {};
+                        for (let [key, value] of Object.entries(parsed))'string' == typeof value && (filtered[key] = value);
+                        if (Object.keys(filtered).length > 0) return filtered;
+                    }
+                } catch  {}
+                return {};
+            }(compiler.options.context || process.cwd()), buildVersion = isDev ? 'local' : pkg?.version, statsBuildInfo = {
+                buildVersion: process.env.MF_BUILD_VERSION || buildVersion || 'UNKNOWN',
+                buildName: process.env.MF_BUILD_NAME || pkg?.name || 'UNKNOWN'
+            }, Object.values(normalizeSharedOptions(mfConfig1.shared || {})).some((config)=>config[1].treeShaking) && (statsBuildInfo.target = Array.isArray(compiler.options.target) ? compiler.options.target : [], statsBuildInfo.plugins = mfConfig1.treeShakingSharedPlugins || [], statsBuildInfo.excludePlugins = mfConfig1.treeShakingSharedExcludePlugins || []), statsBuildInfo)
+        };
+        return createBuiltinPlugin(this.name, rawOptions);
+    }
+}
+let SHARE_ENTRY_ASSET = 'collect-shared-entries.json';
+class CollectSharedEntryPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.CollectSharedEntryPlugin;
+    sharedOptions;
+    _collectedEntries;
+    constructor(options){
+        super();
+        let { sharedOptions } = options;
+        this.sharedOptions = sharedOptions, this._collectedEntries = {};
+    }
+    getData() {
+        return this._collectedEntries;
+    }
+    getFilename() {
+        return SHARE_ENTRY_ASSET;
+    }
+    apply(compiler) {
+        super.apply(compiler), compiler.hooks.thisCompilation.tap('Collect shared entry', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'CollectSharedEntry',
+                stage: compiler.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
+            }, ()=>{
+                compilation.getAssets().forEach((asset)=>{
+                    asset.name === SHARE_ENTRY_ASSET && (this._collectedEntries = JSON.parse(asset.source.source().toString())), compilation.deleteAsset(asset.name);
+                });
+            });
+        });
+    }
+    raw() {
+        let rawOptions = {
+            consumes: normalizeConsumeShareOptions(createConsumeShareOptions(this.sharedOptions)).map(([key, v])=>({
+                    key,
+                    ...v
+                })),
+            filename: this.getFilename()
+        };
+        return createBuiltinPlugin(this.name, rawOptions);
+    }
+}
+function assert(condition, msg) {
+    if (!condition) throw Error(msg);
+}
+class SharedContainerPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.SharedContainerPlugin;
+    filename = '';
+    _options;
+    _shareName;
+    _globalName;
+    constructor(options){
+        super();
+        let { shareName, library, request, independentShareFileName, mfName } = options, version = options.version || '0.0.0';
+        this._globalName = encodeName(`${mfName}_${shareName}_${version}`);
+        let fileName = independentShareFileName || `${version}/share-entry.js`;
+        this._shareName = shareName, this._options = {
+            name: shareName,
+            request: request,
+            library: (library ? {
+                ...library,
+                name: this._globalName
+            } : void 0) || {
+                type: 'global',
+                name: this._globalName
+            },
+            version,
+            fileName
+        };
+    }
+    getData() {
+        return [
+            this._options.fileName,
+            this._globalName,
+            this._options.version
+        ];
+    }
+    raw(compiler) {
+        let { library } = this._options;
+        return compiler.options.output.enabledLibraryTypes.includes(library.type) || compiler.options.output.enabledLibraryTypes.push(library.type), createBuiltinPlugin(this.name, this._options);
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        let shareName = this._shareName;
+        compiler.hooks.thisCompilation.tap(this.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'getShareContainerFile'
+            }, ()=>{
+                assert(compilation.entrypoints.get(shareName), `Can not get shared ${shareName} entryPoint!`);
+                let remoteEntryNameChunk = compilation.namedChunks.get(shareName);
+                assert(remoteEntryNameChunk, `Can not get shared ${shareName} chunk!`);
+                let files = Array.from(remoteEntryNameChunk.files).filter((f)=>!f.includes('.hot-update') && !f.endsWith('.css'));
+                assert(files.length > 0, `no files found for shared ${shareName} chunk`), assert(1 === files.length, `shared ${shareName} chunk should not have multiple files!, current files: ${files.join(',')}`), this.filename = files[0];
+            });
+        });
+    }
+}
+class SharedUsedExportsOptimizerPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.SharedUsedExportsOptimizerPlugin;
+    sharedOptions;
+    injectTreeShakingUsedExports;
+    manifestOptions;
+    constructor(sharedOptions, injectTreeShakingUsedExports, manifestOptions){
+        super(), this.sharedOptions = sharedOptions, this.injectTreeShakingUsedExports = injectTreeShakingUsedExports ?? !0, this.manifestOptions = manifestOptions ?? {};
+    }
+    buildOptions() {
+        let shared = this.sharedOptions.map(([shareKey, config])=>({
+                shareKey,
+                treeShaking: !!config.treeShaking,
+                usedExports: config.treeShaking?.usedExports
+            })), { manifestFileName, statsFileName } = getFileName(this.manifestOptions);
+        return {
+            shared,
+            injectTreeShakingUsedExports: this.injectTreeShakingUsedExports,
+            manifestFileName,
+            statsFileName
+        };
+    }
+    raw() {
+        if (this.sharedOptions.length) return createBuiltinPlugin(this.name, this.buildOptions());
+    }
+}
+let VIRTUAL_ENTRY = './virtual-entry.js', VIRTUAL_ENTRY_NAME = 'virtual-entry';
+class VirtualEntryPlugin {
+    sharedOptions;
+    collectShared = !1;
+    constructor(sharedOptions, collectShared){
+        this.sharedOptions = sharedOptions, this.collectShared = collectShared;
+    }
+    createEntry() {
+        let { sharedOptions, collectShared } = this;
+        return sharedOptions.reduce((acc, cur, index)=>acc + `import shared_${index} from '${cur[0]}';\n` + (collectShared ? `console.log(shared_${index});\n` : ''), '');
+    }
+    static entry() {
+        return {
+            [VIRTUAL_ENTRY_NAME]: VIRTUAL_ENTRY
+        };
+    }
+    apply(compiler) {
+        new compiler.rspack.experiments.VirtualModulesPlugin({
+            [VIRTUAL_ENTRY]: this.createEntry()
+        }).apply(compiler), compiler.hooks.thisCompilation.tap('RemoveVirtualEntryAsset', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'RemoveVirtualEntryAsset',
+                stage: compiler.rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+            }, ()=>{
+                try {
+                    let chunk = compilation.namedChunks.get(VIRTUAL_ENTRY_NAME);
+                    chunk?.files.forEach((f)=>{
+                        compilation.deleteAsset(f);
+                    });
+                } catch (_e) {
+                    console.error('Failed to remove virtual entry file!');
+                }
+            });
+        });
+    }
+}
+let resolveOutputDir = (outputDir, shareName)=>shareName ? join(outputDir, encodeName(shareName)) : outputDir;
+class IndependentSharedPlugin {
+    mfName;
+    shared;
+    library;
+    sharedOptions;
+    outputDir;
+    plugins;
+    treeShaking;
+    manifest;
+    buildAssets = {};
+    injectTreeShakingUsedExports;
+    treeShakingSharedExcludePlugins;
+    name = 'IndependentSharedPlugin';
+    constructor(options){
+        let { outputDir, plugins, treeShaking, shared, name, manifest, injectTreeShakingUsedExports, library, treeShakingSharedExcludePlugins } = options;
+        this.shared = shared, this.mfName = name, this.outputDir = outputDir || 'independent-packages', this.plugins = plugins || [], this.treeShaking = treeShaking, this.manifest = manifest, this.injectTreeShakingUsedExports = injectTreeShakingUsedExports ?? !0, this.library = library, this.treeShakingSharedExcludePlugins = treeShakingSharedExcludePlugins || [], this.sharedOptions = parseOptions(shared, (item, key)=>{
+            if ('string' != typeof item) throw Error(`Unexpected array in shared configuration for key "${key}"`);
+            return item !== key && isRequiredVersion(item) ? {
+                import: key,
+                requiredVersion: item
+            } : {
+                import: item
+            };
+        }, (item)=>item);
+    }
+    apply(compiler) {
+        let { manifest } = this, runCount = 0;
+        compiler.hooks.beforeRun.tapPromise('IndependentSharedPlugin', async ()=>{
+            !runCount && (await this.createIndependentCompilers(compiler), runCount++);
+        }), compiler.hooks.watchRun.tapPromise('IndependentSharedPlugin', async ()=>{
+            !runCount && (await this.createIndependentCompilers(compiler), runCount++);
+        }), manifest && compiler.hooks.compilation.tap('IndependentSharedPlugin', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'injectBuildAssets',
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+            }, ()=>{
+                let { statsFileName, manifestFileName } = getFileName(manifest), injectBuildAssetsIntoStatsOrManifest = (filename)=>{
+                    let stats = compilation.getAsset(filename);
+                    if (!stats) return;
+                    let statsContent = JSON.parse(stats.source.source().toString()), { shared } = statsContent;
+                    Object.entries(this.buildAssets).forEach(([key, item])=>{
+                        let targetShared = shared.find((s)=>s.name === key);
+                        targetShared && item.forEach(([entry, version, globalName])=>{
+                            version === targetShared.version && (targetShared.fallback = entry, targetShared.fallbackName = globalName);
+                        });
+                    }), compilation.updateAsset(filename, new compiler.rspack.sources.RawSource(JSON.stringify(statsContent)));
+                };
+                injectBuildAssetsIntoStatsOrManifest(statsFileName), injectBuildAssetsIntoStatsOrManifest(manifestFileName);
+            });
+        });
+    }
+    async createIndependentCompilers(parentCompiler) {
+        let { sharedOptions, buildAssets, outputDir } = this;
+        console.log('Start building shared fallback resources ...');
+        let shareRequestsMap = await this.createIndependentCompiler(parentCompiler);
+        await Promise.all(sharedOptions.map(async ([shareName, shareConfig])=>{
+            if (!shareConfig.treeShaking || !1 === shareConfig.import) return;
+            let shareRequests = shareRequestsMap[shareName].requests;
+            await Promise.all(shareRequests.map(async ([request, version])=>{
+                let sharedConfig = sharedOptions.find(([name])=>name === shareName)?.[1], [shareFileName, globalName, sharedVersion] = await this.createIndependentCompiler(parentCompiler, {
+                    shareRequestsMap,
+                    currentShare: {
+                        shareName,
+                        version,
+                        request,
+                        independentShareFileName: sharedConfig?.treeShaking?.filename
+                    }
+                });
+                'string' == typeof shareFileName && (buildAssets[shareName] ||= [], buildAssets[shareName].push([
+                    join(resolveOutputDir(outputDir, shareName), shareFileName),
+                    sharedVersion,
+                    globalName
+                ]));
+            }));
+        })), console.log('All shared fallback have been compiled successfully!');
+    }
+    async createIndependentCompiler(parentCompiler, extraOptions) {
+        let extraPlugin, { mfName, plugins, outputDir, sharedOptions, treeShaking, library, treeShakingSharedExcludePlugins } = this, outputDirWithShareName = resolveOutputDir(outputDir, extraOptions?.currentShare?.shareName || ''), parentConfig = parentCompiler.options, finalPlugins = [], rspack = parentCompiler.rspack;
+        extraPlugin = extraOptions ? new SharedContainerPlugin({
+            mfName: `${mfName}_${treeShaking ? 't' : 'f'}`,
+            library,
+            ...extraOptions.currentShare
+        }) : new CollectSharedEntryPlugin({
+            sharedOptions,
+            shareScope: 'default'
+        }), (parentConfig.plugins || []).forEach((plugin)=>{
+            void 0 !== plugin && 'string' != typeof plugin && ((plugin, excludedPlugins = [])=>{
+                if (!plugin) return !0;
+                let pluginName = plugin.name || plugin.constructor?.name;
+                return !pluginName || ![
+                    'TreeShakingSharedPlugin',
+                    'IndependentSharedPlugin',
+                    'ModuleFederationPlugin',
+                    'SharedUsedExportsOptimizerPlugin',
+                    'HtmlWebpackPlugin',
+                    'HtmlRspackPlugin',
+                    'RsbuildHtmlPlugin',
+                    ...excludedPlugins
+                ].includes(pluginName);
+            })(plugin, treeShakingSharedExcludePlugins) && finalPlugins.push(plugin);
+        }), plugins.forEach((plugin)=>{
+            finalPlugins.push(plugin);
+        }), finalPlugins.push(extraPlugin), finalPlugins.push(new ConsumeSharedPlugin({
+            consumes: sharedOptions.filter(([key, options])=>extraOptions?.currentShare.shareName !== (options.shareKey || key)).map(([key, options])=>({
+                    [key]: {
+                        import: !extraOptions && options.import,
+                        shareKey: options.shareKey || key,
+                        shareScope: options.shareScope,
+                        requiredVersion: options.requiredVersion,
+                        strictVersion: options.strictVersion,
+                        singleton: options.singleton,
+                        packageName: options.packageName,
+                        eager: options.eager
+                    }
+                })),
+            enhanced: !0
+        })), treeShaking && finalPlugins.push(new SharedUsedExportsOptimizerPlugin(sharedOptions, this.injectTreeShakingUsedExports)), finalPlugins.push(new VirtualEntryPlugin(sharedOptions, !extraOptions));
+        let fullOutputDir = external_node_path_resolve(parentCompiler.outputPath, outputDirWithShareName), compilerConfig = {
+            ...parentConfig,
+            module: {
+                ...parentConfig.module,
+                rules: [
+                    {
+                        test: /virtual-entry\.js$/,
+                        type: "javascript/auto",
+                        resolve: {
+                            fullySpecified: !1
+                        },
+                        use: {
+                            loader: 'builtin:swc-loader'
+                        }
+                    },
+                    ...parentConfig.module?.rules || []
+                ]
+            },
+            mode: parentConfig.mode || 'development',
+            entry: VirtualEntryPlugin.entry,
+            output: {
+                path: fullOutputDir,
+                clean: !0,
+                publicPath: parentConfig.output?.publicPath || 'auto'
+            },
+            plugins: finalPlugins,
+            optimization: {
+                ...parentConfig.optimization,
+                splitChunks: !1
+            }
+        }, compiler = rspack.rspack(compilerConfig);
+        compiler.inputFileSystem = parentCompiler.inputFileSystem, compiler.outputFileSystem = parentCompiler.outputFileSystem, compiler.intermediateFileSystem = parentCompiler.intermediateFileSystem;
+        let { currentShare } = extraOptions || {};
+        return new Promise((resolve, reject)=>{
+            compiler.run((err, stats)=>{
+                if (err || stats?.hasErrors()) {
+                    let target = currentShare ? currentShare.shareName : 'Collect deps';
+                    console.error(`${target} Compile failed:`, err || stats.toJson().errors.map((e)=>e.message).join('\n')), reject(err || Error(`${target} Compile failed`));
+                    return;
+                }
+                currentShare && console.log(`${currentShare.shareName} Compile success`), resolve(extraPlugin.getData());
+            });
+        });
+    }
+}
+let TreeShakingSharedPlugin_require = createRequire(import.meta.url);
+class TreeShakingSharedPlugin {
+    mfConfig;
+    outputDir;
+    secondary;
+    _independentSharePlugin;
+    name = 'TreeShakingSharedPlugin';
+    constructor(options){
+        let { mfConfig, secondary } = options;
+        this.mfConfig = mfConfig, this.outputDir = mfConfig.treeShakingSharedDir || 'independent-packages', this.secondary = !!secondary;
+    }
+    apply(compiler) {
+        let { mfConfig, outputDir, secondary } = this, { name, shared, library, treeShakingSharedPlugins } = mfConfig;
+        if (!shared) return;
+        let sharedOptions = normalizeSharedOptions(shared);
+        sharedOptions.length && sharedOptions.some(([_, config])=>config.treeShaking && !1 !== config.import) && (secondary || new SharedUsedExportsOptimizerPlugin(sharedOptions, mfConfig.injectTreeShakingUsedExports, mfConfig.manifest).apply(compiler), this._independentSharePlugin = new IndependentSharedPlugin({
+            name: name,
+            shared: shared,
+            outputDir,
+            plugins: treeShakingSharedPlugins?.map((p)=>new (TreeShakingSharedPlugin_require(p))()) || [],
+            treeShaking: secondary,
+            library,
+            manifest: mfConfig.manifest,
+            treeShakingSharedExcludePlugins: mfConfig.treeShakingSharedExcludePlugins
+        }), this._independentSharePlugin.apply(compiler));
+    }
+    get buildAssets() {
+        return this._independentSharePlugin?.buildAssets || {};
+    }
+}
+let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinPluginName.ModuleFederationRuntimePlugin, (options = {})=>options), ModuleFederationPlugin_require = createRequire(import.meta.url);
+function getRemoteInfos(options) {
+    if (!options.remotes) return {};
+    let remoteType = options.remoteType || (options.library ? options.library.type : "script"), remotes = parseOptions(options.remotes, (item)=>({
+            external: Array.isArray(item) ? item : [
+                item
+            ],
+            shareScope: options.shareScope ?? 'default'
+        }), (item)=>({
+            external: Array.isArray(item.external) ? item.external : [
+                item.external
+            ],
+            shareScope: item.shareScope || options.shareScope || 'default'
+        })), remoteInfos = {};
+    for (let [key, config] of remotes)for (let external of config.external){
+        let [externalType, externalRequest] = function(external) {
+            let result = function(external) {
+                if (/^[a-z0-9-]+ /.test(external)) {
+                    let idx = external.indexOf(' ');
+                    return [
+                        external.slice(0, idx),
+                        external.slice(idx + 1)
+                    ];
+                }
+                return null;
+            }(external);
+            return null === result ? [
+                remoteType,
+                external
+            ] : result;
+        }(external);
+        if (remoteInfos[key] ??= [], "script" === externalType) {
+            let [url, global] = function(urlAndGlobal) {
+                let index = urlAndGlobal.indexOf('@');
+                return index <= 0 || index === urlAndGlobal.length - 1 ? null : [
+                    urlAndGlobal.substring(index + 1),
+                    urlAndGlobal.substring(0, index)
+                ];
+            }(externalRequest);
+            remoteInfos[key].push({
+                alias: key,
+                name: global,
+                entry: url,
+                externalType,
+                shareScope: config.shareScope
+            });
+        } else remoteInfos[key].push({
+            alias: key,
+            name: void 0,
+            entry: void 0,
+            externalType,
+            shareScope: config.shareScope
+        });
+    }
+    return remoteInfos;
+}
+function getDefaultEntryRuntime(paths, options, compiler, treeShakingShareFallbacks) {
+    let runtimePlugins = options.runtimePlugins ?? [], remoteInfos = getRemoteInfos(options), runtimePluginImports = [], runtimePluginVars = [], libraryType = options.library?.type || 'var';
+    for(let i = 0; i < runtimePlugins.length; i++){
+        let runtimePluginVar = `__module_federation_runtime_plugin_${i}__`, pluginSpec = runtimePlugins[i], pluginPath = Array.isArray(pluginSpec) ? pluginSpec[0] : pluginSpec, pluginParams = Array.isArray(pluginSpec) ? pluginSpec[1] : void 0;
+        runtimePluginImports.push(`import ${runtimePluginVar} from ${JSON.stringify(pluginPath)}`);
+        let paramsCode = void 0 === pluginParams ? 'undefined' : JSON.stringify(pluginParams);
+        runtimePluginVars.push(`{ plugin: ${runtimePluginVar}, params: ${paramsCode} }`);
+    }
+    let content = [
+        `import __module_federation_bundler_runtime__ from ${JSON.stringify(paths.bundlerRuntime)}`,
+        ...runtimePluginImports,
+        `const __module_federation_runtime_plugins__ = [${runtimePluginVars.join(', ')}].filter(({ plugin }) => plugin).map(({ plugin, params }) => plugin(params))`,
+        `const __module_federation_remote_infos__ = ${JSON.stringify(remoteInfos)}`,
+        `const __module_federation_container_name__ = ${JSON.stringify(options.name ?? compiler.options.output.uniqueName)}`,
+        `const __module_federation_share_strategy__ = ${JSON.stringify(options.shareStrategy ?? 'version-first')}`,
+        `const __module_federation_share_fallbacks__ = ${JSON.stringify(treeShakingShareFallbacks)}`,
+        `const __module_federation_library_type__ = ${JSON.stringify(libraryType)}`,
+        compiler.rspack.Template.getFunctionContent(ModuleFederationPlugin_require('./moduleFederationDefaultRuntime.js').default)
+    ].join(';');
+    return `@module-federation/runtime/rspack.js!=!data:text/javascript,${encodeURIComponent(content)}`;
+}
 class ContainerPlugin extends RspackBuiltinPlugin {
     name = binding_namespaceObject.BuiltinPluginName.ContainerPlugin;
     _options;
     constructor(options){
-        super(), this._options = {
+        super();
+        let shareScope = options.shareScope || 'default', enhanced = options.enhanced ?? !1;
+        validateShareScope(shareScope, enhanced, 'ContainerPlugin'), this._options = {
             name: options.name,
-            shareScope: options.shareScope || 'default',
+            shareScope,
             library: options.library || {
-                type: 'var',
+                type: 'global',
                 name: options.name
             },
             runtime: options.runtime,
@@ -11846,7 +13224,7 @@ class ContainerPlugin extends RspackBuiltinPlugin {
                     ],
                     name: item.name || void 0
                 })),
-            enhanced: options.enhanced ?? !1
+            enhanced
         };
     }
     raw(compiler) {
@@ -11871,29 +13249,38 @@ class ContainerReferencePlugin extends RspackBuiltinPlugin {
     name = binding_namespaceObject.BuiltinPluginName.ContainerReferencePlugin;
     _options;
     constructor(options){
-        super(), this._options = {
+        super();
+        let enhanced = options.enhanced ?? !1;
+        options.shareScope && validateShareScope(options.shareScope, enhanced, 'ContainerReferencePlugin');
+        let remotes = parseOptions(options.remotes, (item)=>({
+                external: Array.isArray(item) ? item : [
+                    item
+                ],
+                shareScope: options.shareScope || 'default'
+            }), (item)=>({
+                external: Array.isArray(item.external) ? item.external : [
+                    item.external
+                ],
+                shareScope: item.shareScope || options.shareScope || 'default'
+            }));
+        for (let [, config] of remotes)validateShareScope(config.shareScope, enhanced, 'ContainerReferencePlugin');
+        this._options = {
             remoteType: options.remoteType,
-            remotes: parseOptions(options.remotes, (item)=>({
-                    external: Array.isArray(item) ? item : [
-                        item
-                    ],
-                    shareScope: options.shareScope || 'default'
-                }), (item)=>({
-                    external: Array.isArray(item.external) ? item.external : [
-                        item.external
-                    ],
-                    shareScope: item.shareScope || options.shareScope || 'default'
-                })),
-            enhanced: options.enhanced ?? !1
+            remotes,
+            enhanced
         };
     }
     raw(compiler) {
-        let { remoteType, remotes } = this._options, remoteExternals = {};
+        let { remoteType, remotes } = this._options, remoteExternals = {}, importExternals = {};
         for (let [key, config] of remotes){
             let i = 0;
-            for (let external of config.external)!external.startsWith('internal ') && (remoteExternals[`webpack/container/reference/${key}${i ? `/fallback-${i}` : ''}`] = external, i++);
+            for (let external of config.external){
+                if (external.startsWith('internal ')) continue;
+                let request = `webpack/container/reference/${key}${i ? `/fallback-${i}` : ''}`;
+                ('module' === remoteType || 'module-import' === remoteType) && external.startsWith('.') ? importExternals[request] = external : remoteExternals[request] = external, i++;
+            }
         }
-        new ExternalsPlugin(remoteType, remoteExternals, !0).apply(compiler), new ShareRuntimePlugin(this._options.enhanced).apply(compiler);
+        new ExternalsPlugin(remoteType, remoteExternals, !0).apply(compiler), Object.keys(importExternals).length > 0 && new ExternalsPlugin('import', importExternals, !0).apply(compiler), new ShareRuntimePlugin(this._options.enhanced).apply(compiler);
         let rawOptions = {
             remoteType: this._options.remoteType,
             remotes: this._options.remotes.map(([key, r])=>({
@@ -11913,7 +13300,7 @@ async function transform(source, options) {
     let _options = JSON.stringify(options || {});
     return binding_default().transform(source, _options);
 }
-let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
+let exports_rspackVersion = "2.0.0-rc.0", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
     getNormalizedRspackOptions: getNormalizedRspackOptions,
     applyRspackOptionsDefaults: applyRspackOptionsDefaults,
     getNormalizedWebpackOptions: getNormalizedRspackOptions,
@@ -11956,10 +13343,12 @@ let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0",
     ContainerReferencePlugin: ContainerReferencePlugin,
     ModuleFederationPlugin: class {
         _options;
+        _treeShakingSharedPlugin;
         constructor(_options){
             this._options = _options;
         }
         apply(compiler) {
+            var options;
             let { webpack } = compiler, paths = function(options, compiler) {
                 let runtimeToolsPath;
                 if (options.implementation) runtimeToolsPath = options.implementation;
@@ -11988,101 +13377,55 @@ let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0",
                     runtime: runtimePath
                 };
             }(this._options, compiler);
-            if (compiler.options.resolve.alias = {
+            compiler.options.resolve.alias = {
                 '@module-federation/runtime-tools': paths.runtimeTools,
                 '@module-federation/runtime': paths.runtime,
                 ...compiler.options.resolve.alias
-            }, new ModuleFederationRuntimePlugin({
-                entryRuntime: function(paths, options, compiler) {
-                    let runtimePlugins = options.runtimePlugins ?? [], remoteInfos = getRemoteInfos(options), runtimePluginImports = [], runtimePluginVars = [];
-                    for(let i = 0; i < runtimePlugins.length; i++){
-                        let runtimePluginVar = `__module_federation_runtime_plugin_${i}__`, pluginSpec = runtimePlugins[i], pluginPath = Array.isArray(pluginSpec) ? pluginSpec[0] : pluginSpec, pluginParams = Array.isArray(pluginSpec) ? pluginSpec[1] : void 0;
-                        runtimePluginImports.push(`import ${runtimePluginVar} from ${JSON.stringify(pluginPath)}`);
-                        let paramsCode = void 0 === pluginParams ? 'undefined' : JSON.stringify(pluginParams);
-                        runtimePluginVars.push(`${runtimePluginVar}(${paramsCode})`);
-                    }
-                    let content = [
-                        `import __module_federation_bundler_runtime__ from ${JSON.stringify(paths.bundlerRuntime)}`,
-                        ...runtimePluginImports,
-                        `const __module_federation_runtime_plugins__ = [${runtimePluginVars.join(', ')}]`,
-                        `const __module_federation_remote_infos__ = ${JSON.stringify(remoteInfos)}`,
-                        `const __module_federation_container_name__ = ${JSON.stringify(options.name ?? compiler.options.output.uniqueName)}`,
-                        `const __module_federation_share_strategy__ = ${JSON.stringify(options.shareStrategy ?? 'version-first')}`,
-                        compiler.webpack.Template.getFunctionContent(ModuleFederationPlugin_require('./moduleFederationDefaultRuntime.js').default)
-                    ].join(';');
-                    return `@module-federation/runtime/rspack.js!=!data:text/javascript,${content}`;
-                }(paths, this._options, compiler)
-            }).apply(compiler), new webpack.container.ModuleFederationPluginV1({
-                ...this._options,
+            }, ((options = this._options).shared ? parseOptions(options.shared, (item, key)=>{
+                if ('string' != typeof item) throw Error('Unexpected array in shared');
+                return item !== key && isRequiredVersion(item) ? {
+                    import: key,
+                    requiredVersion: item
+                } : {
+                    import: item
+                };
+            }, (item)=>item) : []).filter(([, config])=>config.treeShaking).length > 0 && (this._treeShakingSharedPlugin = new TreeShakingSharedPlugin({
+                mfConfig: this._options,
+                secondary: !1
+            }), this._treeShakingSharedPlugin.apply(compiler));
+            let runtimeExperiments = {
+                asyncStartup: this._options.experiments?.asyncStartup ?? !1
+            }, runtimePluginApplied = !1;
+            compiler.hooks.beforeRun.tap({
+                name: 'ModuleFederationPlugin',
+                stage: 100
+            }, ()=>{
+                runtimePluginApplied || (runtimePluginApplied = !0, new ModuleFederationRuntimePlugin({
+                    entryRuntime: getDefaultEntryRuntime(paths, this._options, compiler, this._treeShakingSharedPlugin?.buildAssets),
+                    experiments: runtimeExperiments
+                }).apply(compiler));
+            }), compiler.hooks.watchRun.tap({
+                name: 'ModuleFederationPlugin',
+                stage: 100
+            }, ()=>{
+                runtimePluginApplied || (runtimePluginApplied = !0, new ModuleFederationRuntimePlugin({
+                    entryRuntime: getDefaultEntryRuntime(paths, this._options, compiler, this._treeShakingSharedPlugin?.buildAssets || {}),
+                    experiments: runtimeExperiments
+                }).apply(compiler));
+            });
+            let v1Options = {
+                name: this._options.name,
+                exposes: this._options.exposes,
+                filename: this._options.filename,
+                library: this._options.library,
+                remoteType: this._options.remoteType,
+                remotes: this._options.remotes,
+                runtime: this._options.runtime,
+                shareScope: this._options.shareScope,
+                shared: this._options.shared,
                 enhanced: !0
-            }).apply(compiler), this._options.manifest) {
-                let manifestOptions = !0 === this._options.manifest ? {} : {
-                    ...this._options.manifest
-                }, containerName = manifestOptions.name ?? this._options.name, globalName = manifestOptions.globalName ?? function(library) {
-                    if (!library) return;
-                    let libName = library.name;
-                    if (libName) {
-                        if ('string' == typeof libName) return libName;
-                        if (Array.isArray(libName)) return libName[0];
-                        if ('object' == typeof libName) return libName.root?.[0] ?? libName.amd ?? libName.commonjs ?? void 0;
-                    }
-                }(this._options.library) ?? containerName, remoteAliasMap = Object.entries(getRemoteInfos(this._options)).reduce((sum, cur)=>{
-                    if (cur[1].length > 1) return sum;
-                    let { entry, alias, name } = cur[1][0];
-                    return entry && name && (sum[alias] = {
-                        name,
-                        entry
-                    }), sum;
-                }, {}), manifestExposes = function(exposes) {
-                    if (!exposes) return;
-                    let result = parseOptions(exposes, (value)=>({
-                            import: Array.isArray(value) ? value : [
-                                value
-                            ],
-                            name: void 0
-                        }), (value)=>({
-                            import: Array.isArray(value.import) ? value.import : [
-                                value.import
-                            ],
-                            name: value.name ?? void 0
-                        })).map(([exposeKey, info])=>{
-                        let exposeName = info.name ?? exposeKey.replace(/^\.\//, '');
-                        return {
-                            path: exposeKey,
-                            name: exposeName
-                        };
-                    });
-                    return result.length > 0 ? result : void 0;
-                }(this._options.exposes);
-                void 0 === manifestOptions.exposes && manifestExposes && (manifestOptions.exposes = manifestExposes);
-                let manifestShared = function(shared) {
-                    if (!shared) return;
-                    let result = parseOptions(shared, (item, key)=>{
-                        if ('string' != typeof item) throw Error('Unexpected array in shared');
-                        return item !== key && isRequiredVersion(item) ? {
-                            import: key,
-                            requiredVersion: item
-                        } : {
-                            import: item
-                        };
-                    }, (item)=>item).map(([key, config])=>{
-                        let name = config.shareKey || key;
-                        return {
-                            name,
-                            version: 'string' == typeof config.version ? config.version : void 0,
-                            requiredVersion: 'string' == typeof config.requiredVersion ? config.requiredVersion : void 0,
-                            singleton: config.singleton
-                        };
-                    });
-                    return result.length > 0 ? result : void 0;
-                }(this._options.shared);
-                void 0 === manifestOptions.shared && manifestShared && (manifestOptions.shared = manifestShared), new ModuleFederationManifestPlugin({
-                    ...manifestOptions,
-                    name: containerName,
-                    globalName,
-                    remoteAliasMap
-                }).apply(compiler);
-            }
+            };
+            new webpack.container.ModuleFederationPluginV1(v1Options).apply(compiler), this._options.manifest && new ModuleFederationManifestPlugin(this._options).apply(compiler);
         }
     },
     ModuleFederationPluginV1: class {
@@ -12119,6 +13462,7 @@ let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0",
     }
 }, sharing = {
     ProvideSharedPlugin: ProvideSharedPlugin,
+    TreeShakingSharedPlugin: TreeShakingSharedPlugin,
     ConsumeSharedPlugin: ConsumeSharedPlugin,
     SharePlugin: SharePlugin
 }, exports_experiments = {
@@ -12130,8 +13474,7 @@ let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0",
             await JavaScriptTracer.cleanupJavaScriptTrace(), (0, binding_namespaceObject.syncTraceEvent)(JavaScriptTracer.events), (0, binding_namespaceObject.cleanupGlobalTrace)();
         }
     },
-    RemoveDuplicateModulesPlugin: RemoveDuplicateModulesPlugin,
-    EsmLibraryPlugin: EsmLibraryPlugin,
+    RemoveDuplicateModulesPlugin: RemoveDuplicateModulesPlugin_RemoveDuplicateModulesPlugin,
     RsdoctorPlugin: RsdoctorPluginImpl,
     RstestPlugin: RstestPlugin,
     RslibPlugin: RslibPlugin,
@@ -12158,12 +13501,36 @@ let exports_rspackVersion = "2.0.0-canary-20260116", exports_version = "5.75.0",
         if (INTERNAL_PLUGIN_NAMES.includes(name)) throw Error(`Cannot register native plugin with name '${name}', it conflicts with internal plugin names.`);
         return base_create(name, resolve, affectedHooks);
     },
-    VirtualModulesPlugin: VirtualModulesPlugin
-}, src_fn = Object.assign(rspack, exports_namespaceObject);
+    VirtualModulesPlugin: VirtualModulesPlugin,
+    rsc: {
+        createPlugins: ()=>{
+            let coordinator = new Coordinator();
+            return {
+                ServerPlugin: class extends RscServerPlugin {
+                    constructor(options = {}){
+                        super({
+                            coordinator,
+                            ...options
+                        });
+                    }
+                },
+                ClientPlugin: class extends RscClientPlugin {
+                    constructor(){
+                        super({
+                            coordinator
+                        });
+                    }
+                }
+            };
+        },
+        Layers: {
+            rsc: 'react-server-components',
+            ssr: 'server-side-rendering'
+        }
+    }
+}, src_fn = Object.assign(rspack_rspack, exports_namespaceObject);
 src_fn.rspack = src_fn, src_fn.webpack = src_fn;
 let src_rspack_0 = src_fn;
 var AsyncDependenciesBlock = binding_namespaceObject.AsyncDependenciesBlock, ConcatenatedModule = binding_namespaceObject.ConcatenatedModule, ContextModule = binding_namespaceObject.ContextModule, Dependency = binding_namespaceObject.Dependency, EntryDependency = binding_namespaceObject.EntryDependency, ExternalModule = binding_namespaceObject.ExternalModule, Module = binding_namespaceObject.Module, NormalModule = binding_namespaceObject.NormalModule;
 export default src_rspack_0;
-export { AsyncDependenciesBlock, BannerPlugin, CaseSensitivePlugin, CircularDependencyRspackPlugin, Compilation, Compiler, ConcatenatedModule, ContextModule, ContextReplacementPlugin, CopyRspackPlugin, CssExtractRspackPlugin, DefaultRuntimeGlobals as RuntimeGlobals, DefinePlugin, Dependency, DllPlugin, DllReferencePlugin, DynamicEntryPlugin, EntryDependency, EntryPlugin, EnvironmentPlugin, EvalDevToolModulePlugin, EvalSourceMapDevToolPlugin, ExternalModule, ExternalsPlugin, HotModuleReplacementPlugin, HtmlRspackPlugin, IgnorePlugin, LightningCssMinimizerRspackPlugin, LoaderOptionsPlugin, LoaderTargetPlugin, Module, ModuleFilenameHelpers_namespaceObject as ModuleFilenameHelpers, MultiCompiler, MultiStats, NoEmitOnErrorsPlugin, NormalModule, NormalModuleReplacementPlugin, ProgressPlugin, ProvidePlugin, RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply, RuntimeModule, RuntimePlugin, SourceMapDevToolPlugin, Stats, SubresourceIntegrityPlugin, SwcJsMinimizerRspackPlugin, Template, ValidationError, container, electron, exports_WebpackError as WebpackError, exports_config as config, exports_experiments as experiments, exports_library as library, exports_node as node, exports_rspackVersion as rspackVersion, exports_version as version, exports_wasm as wasm, index_js_namespaceObject as sources, javascript, lazyCompilationMiddleware, lib_EntryOptionPlugin as EntryOptionPlugin, optimize, sharing, src_rspack_0 as rspack, statsFactoryUtils_StatsErrorCode as StatsErrorCode, util, web, webworker };
-
-export { src_rspack_0 as 'module.exports' }
+export { AsyncDependenciesBlock, BannerPlugin, CaseSensitivePlugin, CircularDependencyRspackPlugin, Compilation, Compiler, ConcatenatedModule, ContextModule, ContextReplacementPlugin, CopyRspackPlugin, CssExtractRspackPlugin, DefaultRuntimeGlobals as RuntimeGlobals, DefinePlugin, Dependency, DllPlugin, DllReferencePlugin, DynamicEntryPlugin, EntryDependency, EntryPlugin, EnvironmentPlugin, EvalDevToolModulePlugin, EvalSourceMapDevToolPlugin, ExternalModule, ExternalsPlugin, HotModuleReplacementPlugin, HtmlRspackPlugin, IgnorePlugin, LightningCssMinimizerRspackPlugin, LoaderOptionsPlugin, LoaderTargetPlugin, Module, ModuleFilenameHelpers_namespaceObject as ModuleFilenameHelpers, MultiCompiler, MultiStats, NoEmitOnErrorsPlugin, NormalModule, NormalModuleReplacementPlugin, ProgressPlugin, ProvidePlugin, RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply, RuntimeModule, RuntimePlugin, SourceMapDevToolPlugin, Stats, SubresourceIntegrityPlugin, SwcJsMinimizerRspackPlugin, Template, ValidationError, container, electron, exports_WebpackError as WebpackError, exports_config as config, exports_experiments as experiments, exports_library as library, exports_node as node, exports_rspackVersion as rspackVersion, exports_version as version, exports_wasm as wasm, index_js_namespaceObject as sources, javascript, lazyCompilationMiddleware, lib_EntryOptionPlugin as EntryOptionPlugin, optimize, sharing, src_rspack_0 as "module.exports", src_rspack_0 as rspack, statsFactoryUtils_StatsErrorCode as StatsErrorCode, util, web, webworker };