@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/plugins/css.js

@@ -0,0 +1,123 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_exports = {};
+__export(css_exports, {
+  applyBaseCSSRule: () => applyBaseCSSRule,
+  pluginCss: () => pluginCss
+});
+module.exports = __toCommonJS(css_exports);
+var import_shared = require("@rsbuild/shared");
+async function applyBaseCSSRule({
+  rule,
+  config,
+  context,
+  utils: { target, isProd, isServer, CHAIN_ID, isWebWorker, getCompiledPath },
+  importLoaders = 1
+}) {
+  const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
+    context.rootPath,
+    config,
+    target
+  );
+  const enableExtractCSS = (0, import_shared.isUseCssExtract)(config, target);
+  const enableCssMinify = !enableExtractCSS && isProd;
+  const enableSourceMap = (0, import_shared.isUseCssSourceMap)(config);
+  const enableCSSModuleTS = Boolean(config.output.enableCssModuleTSDeclaration);
+  const extraCSSOptions = typeof config.tools.cssExtract === "object" ? config.tools.cssExtract : {
+    loaderOptions: {},
+    pluginOptions: {}
+  };
+  const styleLoaderOptions = (0, import_shared.mergeChainedOptions)(
+    {},
+    config.tools.styleLoader
+  );
+  const localIdentName = (0, import_shared.getCssModuleLocalIdentName)(config, isProd);
+  const cssLoaderOptions = await (0, import_shared.getCssLoaderOptions)({
+    config,
+    enableSourceMap,
+    importLoaders,
+    isServer,
+    isWebWorker,
+    localIdentName
+  });
+  if (!isServer && !isWebWorker) {
+    if (enableExtractCSS) {
+      rule.use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(require("mini-css-extract-plugin").loader).options(extraCSSOptions.loaderOptions).end();
+    } else {
+      rule.use(CHAIN_ID.USE.STYLE).loader(require.resolve("style-loader")).options(styleLoaderOptions).end();
+    }
+    if (enableCSSModuleTS && cssLoaderOptions.modules) {
+      rule.use(CHAIN_ID.USE.CSS_MODULES_TS).loader(
+        (0, import_shared.resolvePackage)(
+          "@rsbuild/shared/css-modules-typescript-loader",
+          __dirname
+        )
+      ).options({
+        modules: cssLoaderOptions.modules
+      }).end();
+    }
+  } else {
+    rule.use(CHAIN_ID.USE.IGNORE_CSS).loader((0, import_shared.resolvePackage)("@rsbuild/shared/ignore-css-loader", __dirname)).end();
+  }
+  rule.use(CHAIN_ID.USE.CSS).loader(getCompiledPath("css-loader")).options(cssLoaderOptions).end();
+  if (!isServer && !isWebWorker) {
+    const postcssLoaderOptions = await (0, import_shared.getPostcssConfig)({
+      enableSourceMap,
+      browserslist,
+      config,
+      enableCssMinify
+    });
+    rule.use(CHAIN_ID.USE.POSTCSS).loader(getCompiledPath("postcss-loader")).options(postcssLoaderOptions).end();
+  }
+  rule.merge({ sideEffects: true });
+  rule.resolve.preferRelative(true);
+}
+const pluginCss = () => {
+  return {
+    name: "plugin-css",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, utils) => {
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.CSS);
+        const config = api.getNormalizedConfig();
+        rule.test(import_shared.CSS_REGEX);
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context
+        });
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyBaseCSSRule,
+  pluginCss
+});

package/dist/plugins/fallback.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginFallback: () => RsbuildPlugin;

package/dist/plugins/fallback.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fallback_exports = {};
+__export(fallback_exports, {
+  pluginFallback: () => pluginFallback
+});
+module.exports = __toCommonJS(fallback_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+const pluginFallback = () => ({
+  name: "plugin-fallback",
+  setup(api) {
+    api.modifyWebpackChain((chain, { isProd }) => {
+      const rsbuildConfig = api.getNormalizedConfig();
+      if (rsbuildConfig.output.enableAssetFallback) {
+        const distDir = (0, import_shared.getDistPath)(rsbuildConfig.output, "media");
+        const filename = (0, import_shared.getFilename)(rsbuildConfig.output, "media", isProd);
+        chain.output.merge({
+          assetModuleFilename: (0, import_path.join)(distDir, filename)
+        });
+      }
+    });
+    api.modifyWebpackConfig((config) => {
+      const rsbuildConfig = api.getNormalizedConfig();
+      if (!rsbuildConfig.output.enableAssetFallback || !config.module) {
+        return;
+      }
+      config.module.rules = (0, import_shared.resourceRuleFallback)(config.module.rules);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginFallback
+});

package/dist/plugins/hmr.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginHMR: () => RsbuildPlugin;

package/dist/plugins/hmr.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hmr_exports = {};
+__export(hmr_exports, {
+  pluginHMR: () => pluginHMR
+});
+module.exports = __toCommonJS(hmr_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginHMR = () => ({
+  name: "plugin-hmr",
+  setup(api) {
+    api.modifyWebpackChain((chain, utils) => {
+      const config = api.getNormalizedConfig();
+      if (!(0, import_shared.isUsingHMR)(config, utils)) {
+        return;
+      }
+      const { webpack, CHAIN_ID } = utils;
+      chain.plugin(CHAIN_ID.PLUGIN.HMR).use(webpack.HotModuleReplacementPlugin);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginHMR
+});

package/dist/plugins/lazyCompilation.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginLazyCompilation: () => RsbuildPlugin;

package/dist/plugins/lazyCompilation.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazyCompilation_exports = {};
+__export(lazyCompilation_exports, {
+  pluginLazyCompilation: () => pluginLazyCompilation
+});
+module.exports = __toCommonJS(lazyCompilation_exports);
+const pluginLazyCompilation = () => ({
+  name: "plugin-lazy-compilation",
+  setup(api) {
+    api.modifyWebpackChain((chain, { isProd, isServer, isWebWorker }) => {
+      const config = api.getNormalizedConfig();
+      if (isProd || isServer || isWebWorker || !config.experiments.lazyCompilation) {
+        return;
+      }
+      chain.optimization.splitChunks(false);
+      chain.experiments({
+        ...chain.get("experiments"),
+        lazyCompilation: config.experiments.lazyCompilation
+      });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginLazyCompilation
+});

package/dist/plugins/less.d.ts

@@ -0,0 +1,6 @@
+import { FileFilterUtil } from '@rsbuild/shared';
+import type { RsbuildPlugin } from '../types';
+export type LessLoaderUtils = {
+  addExcludes: FileFilterUtil;
+};
+export declare function pluginLess(): RsbuildPlugin;

package/dist/plugins/less.js

@@ -0,0 +1,65 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var less_exports = {};
+__export(less_exports, {
+  pluginLess: () => pluginLess
+});
+module.exports = __toCommonJS(less_exports);
+var import_shared = require("@rsbuild/shared");
+function pluginLess() {
+  return {
+    name: "plugin-less",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, utils) => {
+        const config = api.getNormalizedConfig();
+        const { applyBaseCSSRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const { options, excludes } = await (0, import_shared.getLessLoaderOptions)(
+          config.tools.less,
+          (0, import_shared.isUseCssSourceMap)(config)
+        );
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.LESS).test(import_shared.LESS_REGEX);
+        excludes.forEach((item) => {
+          rule.exclude.add(item);
+        });
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context,
+          importLoaders: 2
+        });
+        rule.use(utils.CHAIN_ID.USE.LESS).loader(utils.getCompiledPath("less-loader")).options(options);
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginLess
+});

package/dist/plugins/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginManifest: () => RsbuildPlugin;

package/dist/plugins/manifest.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var manifest_exports = {};
+__export(manifest_exports, {
+  pluginManifest: () => pluginManifest
+});
+module.exports = __toCommonJS(manifest_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginManifest = () => ({
+  name: "plugin-manifest",
+  setup(api) {
+    api.modifyWebpackChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      if (!config.output.enableAssetManifest) {
+        return;
+      }
+      const { WebpackManifestPlugin } = await Promise.resolve().then(() => __toESM(require("../../compiled/webpack-manifest-plugin")));
+      const publicPath = chain.output.get("publicPath");
+      chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(WebpackManifestPlugin, [
+        {
+          fileName: "asset-manifest.json",
+          publicPath,
+          generate: import_shared.generateManifest
+        }
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginManifest
+});

package/dist/plugins/minimize.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginMinimize: () => RsbuildPlugin;

package/dist/plugins/minimize.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var minimize_exports = {};
+__export(minimize_exports, {
+  pluginMinimize: () => pluginMinimize
+});
+module.exports = __toCommonJS(minimize_exports);
+var import_shared = require("@rsbuild/shared");
+var import_plugin_css_minimizer = require("@rsbuild/plugin-css-minimizer");
+async function applyJSMinimizer(chain, config) {
+  const { default: TerserPlugin } = await Promise.resolve().then(() => __toESM(require("terser-webpack-plugin")));
+  const finalOptions = await (0, import_shared.getJSMinifyOptions)(config);
+  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.JS).use(TerserPlugin, [
+    // Due to terser-webpack-plugin has changed the type of class, which using a generic type in
+    // constructor, leading auto inference of parameters of plugin constructor is not possible, using any instead
+    finalOptions
+  ]).end();
+}
+const pluginMinimize = () => ({
+  name: "plugin-minimize",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { isProd, CHAIN_ID: CHAIN_ID2 }) => {
+      const config = api.getNormalizedConfig();
+      const isMinimize = isProd && !config.output.disableMinimize;
+      chain.optimization.minimize(isMinimize);
+      if (isMinimize) {
+        await applyJSMinimizer(chain, config);
+        await (0, import_plugin_css_minimizer.applyCSSMinimizer)(chain, CHAIN_ID2, {
+          pluginOptions: config.tools.minifyCss
+        });
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginMinimize
+});

package/dist/plugins/moduleScopes.d.ts

@@ -0,0 +1,5 @@
+import { type ChainedConfig } from '@rsbuild/shared';
+import type { RsbuildPlugin, ModuleScopes } from '../types';
+export declare const isPrimitiveScope: (items: unknown[]) => items is (string | RegExp)[];
+export declare const applyScopeChain: (defaults: ModuleScopes, options: ChainedConfig<ModuleScopes>) => ModuleScopes;
+export declare const pluginModuleScopes: () => RsbuildPlugin;

package/dist/plugins/moduleScopes.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var moduleScopes_exports = {};
+__export(moduleScopes_exports, {
+  applyScopeChain: () => applyScopeChain,
+  isPrimitiveScope: () => isPrimitiveScope,
+  pluginModuleScopes: () => pluginModuleScopes
+});
+module.exports = __toCommonJS(moduleScopes_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+const isPrimitiveScope = (items) => items.every(
+  (item) => typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]"
+);
+const applyScopeChain = (defaults, options) => {
+  if (Array.isArray(options)) {
+    if (isPrimitiveScope(options)) {
+      return defaults.concat(options);
+    }
+    return options.reduce(applyScopeChain, defaults);
+  }
+  return options(defaults) || defaults;
+};
+const pluginModuleScopes = () => ({
+  name: "plugin-module-scopes",
+  setup(api) {
+    api.modifyWebpackChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      const scopeOptions = config.source.moduleScopes;
+      if (!scopeOptions) {
+        return;
+      }
+      const { ModuleScopePlugin } = await Promise.resolve().then(() => __toESM(require("../webpackPlugins/ModuleScopePlugin")));
+      const scopes = applyScopeChain([], scopeOptions);
+      const rootPackageJson = import_path.default.resolve(
+        api.context.rootPath,
+        "./package.json"
+      );
+      const formattedScopes = scopes.map((scope) => {
+        if (typeof scope === "string") {
+          return (0, import_shared.ensureAbsolutePath)(api.context.rootPath, scope);
+        }
+        return scope;
+      });
+      chain.resolve.plugin(CHAIN_ID.RESOLVE_PLUGIN.MODULE_SCOPE).use(ModuleScopePlugin, [
+        {
+          scopes: formattedScopes,
+          allowedFiles: [rootPackageJson]
+        }
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyScopeChain,
+  isPrimitiveScope,
+  pluginModuleScopes
+});

package/dist/plugins/output.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginOutput: () => RsbuildPlugin;

package/dist/plugins/output.js

@@ -0,0 +1,66 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var output_exports = {};
+__export(output_exports, {
+  pluginOutput: () => pluginOutput
+});
+module.exports = __toCommonJS(output_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+const pluginOutput = () => ({
+  name: "plugin-output",
+  setup(api) {
+    (0, import_shared.applyOutputPlugin)(api);
+    api.modifyWebpackChain(async (chain, { isProd, target, CHAIN_ID }) => {
+      var _a;
+      const config = api.getNormalizedConfig();
+      const cssPath = (0, import_shared.getDistPath)(config.output, "css");
+      if ((0, import_shared.isUseCssExtract)(config, target)) {
+        const { default: MiniCssExtractPlugin } = await Promise.resolve().then(() => __toESM(require("mini-css-extract-plugin")));
+        const extractPluginOptions = (0, import_shared.mergeChainedOptions)(
+          {},
+          ((_a = config.tools.cssExtract) == null ? void 0 : _a.pluginOptions) || {}
+        );
+        const cssFilename = (0, import_shared.getFilename)(config.output, "css", isProd);
+        chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).use(MiniCssExtractPlugin, [
+          {
+            filename: import_path.posix.join(cssPath, cssFilename),
+            chunkFilename: import_path.posix.join(cssPath, `async/${cssFilename}`),
+            ignoreOrder: true,
+            ...extractPluginOptions
+          }
+        ]);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginOutput
+});

package/dist/plugins/progress.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare const pluginProgress: () => RsbuildPlugin;