@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/core/webpackConfig.js

@@ -0,0 +1,164 @@
+"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 webpackConfig_exports = {};
+__export(webpackConfig_exports, {
+  generateWebpackConfig: () => generateWebpackConfig
+});
+module.exports = __toCommonJS(webpackConfig_exports);
+var import_shared = require("@rsbuild/shared");
+var import_shared2 = require("../shared");
+async function modifyWebpackChain(context, utils, chain) {
+  var _a;
+  (0, import_shared.debug)("modify webpack chain");
+  const [modifiedChain] = await context.hooks.modifyWebpackChainHook.call(
+    chain,
+    utils
+  );
+  if ((_a = context.config.tools) == null ? void 0 : _a.webpackChain) {
+    (0, import_shared.castArray)(context.config.tools.webpackChain).forEach((item) => {
+      item(modifiedChain, utils);
+    });
+  }
+  (0, import_shared.debug)("modify webpack chain done");
+  return modifiedChain;
+}
+async function modifyWebpackConfig(context, webpackConfig, utils) {
+  var _a;
+  (0, import_shared.debug)("modify webpack config");
+  let [modifiedConfig] = await context.hooks.modifyWebpackConfigHook.call(
+    webpackConfig,
+    utils
+  );
+  if ((_a = context.config.tools) == null ? void 0 : _a.webpack) {
+    modifiedConfig = (0, import_shared.mergeChainedOptions)(
+      modifiedConfig,
+      context.config.tools.webpack,
+      utils,
+      utils.mergeConfig
+    );
+  }
+  (0, import_shared.debug)("modify webpack config done");
+  return modifiedConfig;
+}
+async function getChainUtils(target) {
+  const { default: webpack } = await Promise.resolve().then(() => __toESM(require("webpack")));
+  const { default: HtmlPlugin } = await Promise.resolve().then(() => __toESM(require("html-webpack-plugin")));
+  const nodeEnv = process.env.NODE_ENV;
+  const nameMap = {
+    web: "client",
+    node: "server",
+    "web-worker": "web-worker",
+    "service-worker": "service-worker"
+  };
+  return {
+    env: nodeEnv,
+    name: nameMap[target] || "",
+    target,
+    webpack,
+    isProd: nodeEnv === "production",
+    isServer: target === "node",
+    isServiceWorker: target === "service-worker",
+    isWebWorker: target === "web-worker",
+    CHAIN_ID: import_shared.CHAIN_ID,
+    getCompiledPath: import_shared2.getCompiledPath,
+    HtmlPlugin,
+    HtmlWebpackPlugin: HtmlPlugin
+  };
+}
+async function getConfigUtils(config, chainUtils) {
+  const { merge } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/webpack-merge")));
+  return {
+    ...chainUtils,
+    mergeConfig: merge,
+    addRules(rules) {
+      const ruleArr = (0, import_shared.castArray)(rules);
+      if (!config.module) {
+        config.module = {};
+      }
+      if (!config.module.rules) {
+        config.module.rules = [];
+      }
+      config.module.rules.unshift(...ruleArr);
+    },
+    prependPlugins(plugins) {
+      const pluginArr = (0, import_shared.castArray)(plugins);
+      if (!config.plugins) {
+        config.plugins = [];
+      }
+      config.plugins.unshift(...pluginArr);
+    },
+    appendPlugins(plugins) {
+      const pluginArr = (0, import_shared.castArray)(plugins);
+      if (!config.plugins) {
+        config.plugins = [];
+      }
+      config.plugins.push(...pluginArr);
+    },
+    removePlugin(pluginName) {
+      if (config.plugins) {
+        config.plugins = config.plugins.filter(
+          (item) => (item == null ? void 0 : item.constructor.name) !== pluginName
+        );
+      }
+    }
+  };
+}
+async function generateWebpackConfig({
+  target,
+  context
+}) {
+  const chainUtils = await getChainUtils(target);
+  const { BannerPlugin, DefinePlugin, ProvidePlugin } = await Promise.resolve().then(() => __toESM(require("webpack")));
+  const bundlerChain = await (0, import_shared.modifyBundlerChain)(context, {
+    ...chainUtils,
+    bundler: {
+      BannerPlugin,
+      DefinePlugin,
+      ProvidePlugin
+    }
+  });
+  const chain = await modifyWebpackChain(
+    context,
+    chainUtils,
+    // module rules not support merge
+    // need a special rule merge or use bundlerChain as WebpackChain
+    bundlerChain
+  );
+  let webpackConfig = chain.toConfig();
+  webpackConfig = await modifyWebpackConfig(
+    context,
+    webpackConfig,
+    await getConfigUtils(webpackConfig, chainUtils)
+  );
+  return webpackConfig;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateWebpackConfig
+});

package/dist/exports/webpack.d.ts

@@ -0,0 +1,2 @@
+import webpack from 'webpack';
+export default webpack;

package/dist/exports/webpack.js

@@ -0,0 +1,35 @@
+"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 webpack_exports = {};
+__export(webpack_exports, {
+  default: () => webpack_default
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_webpack = __toESM(require("webpack"));
+var webpack_default = import_webpack.default;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { webpackProvider } from './provider';
+export type { WebpackProvider } from './provider';
+export { webpackBuild } from './core/build';
+export { createDefaultConfig } from './config/defaults';
+export type { LessLoaderOptions, SassLoaderOptions, PostCSSLoaderOptions, CSSLoaderOptions, StyleLoaderOptions } from '@rsbuild/shared';
+export type { RsbuildPlugin, RsbuildPluginAPI, DevConfig, HtmlConfig, ToolsConfig, OutputConfig, SourceConfig, RsbuildConfig, SecurityConfig, NormalizedConfig, PerformanceConfig, ExperimentsConfig, ModifyWebpackChainFn, ModifyWebpackConfigFn, ModifyWebpackChainUtils, ModifyWebpackConfigUtils, webpack, WebpackChain, WebpackConfig, CSSExtractOptions, HTMLPluginOptions } from './types';

package/dist/index.js

@@ -0,0 +1,34 @@
+"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 src_exports = {};
+__export(src_exports, {
+  createDefaultConfig: () => import_defaults.createDefaultConfig,
+  webpackBuild: () => import_build.webpackBuild,
+  webpackProvider: () => import_provider.webpackProvider
+});
+module.exports = __toCommonJS(src_exports);
+var import_provider = require("./provider");
+var import_build = require("./core/build");
+var import_defaults = require("./config/defaults");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDefaultConfig,
+  webpackBuild,
+  webpackProvider
+});

package/dist/plugins/babel.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
+export declare const getUseBuiltIns: (config: NormalizedConfig) => false | "usage" | "entry";
+export declare const pluginBabel: () => RsbuildPlugin;

package/dist/plugins/babel.js

@@ -0,0 +1,171 @@
+"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 babel_exports = {};
+__export(babel_exports, {
+  getUseBuiltIns: () => getUseBuiltIns,
+  pluginBabel: () => pluginBabel
+});
+module.exports = __toCommonJS(babel_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_web = require("@rsbuild/babel-preset/web");
+var import_node = require("@rsbuild/babel-preset/node");
+var import_shared = require("@rsbuild/shared");
+var import_plugin_babel = require("@rsbuild/plugin-babel");
+var import_shared2 = require("../shared");
+const getUseBuiltIns = (config) => {
+  const { polyfill } = config.output;
+  if (polyfill === "ua" || polyfill === "off") {
+    return false;
+  }
+  return polyfill;
+};
+const pluginBabel = () => ({
+  name: "plugin-babel",
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { CHAIN_ID, target, isProd, isServer, isServiceWorker }) => {
+        const config = api.getNormalizedConfig();
+        const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
+          api.context.rootPath,
+          config,
+          target
+        );
+        const getBabelOptions = (config2) => {
+          const includes2 = [];
+          const excludes2 = [];
+          const babelUtils = {
+            addIncludes(items) {
+              if (Array.isArray(items)) {
+                includes2.push(...items);
+              } else {
+                includes2.push(items);
+              }
+            },
+            addExcludes(items) {
+              if (Array.isArray(items)) {
+                excludes2.push(...items);
+              } else {
+                excludes2.push(items);
+              }
+            }
+          };
+          const decoratorConfig = {
+            version: config2.output.enableLatestDecorators ? "2018-09" : "legacy"
+          };
+          const baseBabelConfig = isServer || isServiceWorker ? (0, import_node.getBabelConfigForNode)({
+            pluginDecorators: decoratorConfig
+          }) : (0, import_web.getBabelConfigForWeb)({
+            presetEnv: {
+              targets: browserslist,
+              useBuiltIns: getUseBuiltIns(config2)
+            },
+            pluginDecorators: decoratorConfig
+          });
+          applyPluginImport(baseBabelConfig, config2.source.transformImport);
+          applyPluginLodash(
+            baseBabelConfig,
+            config2.performance.transformLodash
+          );
+          const babelConfig = (0, import_shared.mergeChainedOptions)(
+            baseBabelConfig,
+            config2.tools.babel,
+            {
+              ...(0, import_plugin_babel.getBabelUtils)(baseBabelConfig),
+              ...babelUtils
+            }
+          );
+          const finalOptions = {
+            babelrc: false,
+            configFile: false,
+            compact: isProd,
+            ...babelConfig
+          };
+          if (config2.output.charset === "utf8") {
+            finalOptions.generatorOpts = {
+              jsescOption: { minimal: true }
+            };
+          }
+          return {
+            babelOptions: finalOptions,
+            includes: includes2,
+            excludes: excludes2
+          };
+        };
+        const { babelOptions, includes, excludes } = getBabelOptions(config);
+        const useTsLoader = Boolean(config.tools.tsLoader);
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS);
+        (0, import_shared.applyScriptCondition)({
+          rule,
+          config,
+          context: api.context,
+          includes,
+          excludes
+        });
+        rule.test(useTsLoader ? import_shared.JS_REGEX : (0, import_shared.mergeRegex)(import_shared.JS_REGEX, import_shared.TS_REGEX)).use(CHAIN_ID.USE.BABEL).loader(require.resolve("babel-loader")).options(babelOptions);
+        if (config.source.compileJsDataURI) {
+          chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
+            or: ["text/javascript", "application/javascript"]
+          }).use(CHAIN_ID.USE.BABEL).loader(require.resolve("babel-loader")).options(import_lodash.default.cloneDeep(babelOptions));
+        }
+        (0, import_shared.addCoreJsEntry)({ chain, config, isServer, isServiceWorker });
+      }
+    );
+  }
+});
+function applyPluginLodash(config, transformLodash) {
+  var _a;
+  if (transformLodash) {
+    (_a = config.plugins) == null ? void 0 : _a.push([(0, import_shared2.getCompiledPath)("babel-plugin-lodash"), {}]);
+  }
+}
+function applyPluginImport(config, pluginImport) {
+  var _a, _b;
+  if (pluginImport !== false && pluginImport) {
+    for (const item of pluginImport) {
+      const name = item.libraryName;
+      const option = {
+        ...item
+      };
+      if (option.camelToDashComponentName !== void 0 || option.camel2DashComponentName !== void 0) {
+        option.camel2DashComponentName = (_a = option.camel2DashComponentName) != null ? _a : option.camelToDashComponentName;
+        delete option.camelToDashComponentName;
+      }
+      (_b = config.plugins) == null ? void 0 : _b.push([
+        require.resolve("babel-plugin-import"),
+        option,
+        name
+      ]);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUseBuiltIns,
+  pluginBabel
+});

package/dist/plugins/basic.d.ts

@@ -0,0 +1,5 @@
+import type { RsbuildPlugin } from '../types';
+/**
+ * Provide some basic configs of webpack
+ */
+export declare const pluginBasic: () => RsbuildPlugin;

package/dist/plugins/basic.js

@@ -0,0 +1,60 @@
+"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 basic_exports = {};
+__export(basic_exports, {
+  pluginBasic: () => pluginBasic
+});
+module.exports = __toCommonJS(basic_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+const pluginBasic = () => ({
+  name: "plugin-basic",
+  setup(api) {
+    (0, import_shared.applyBasicPlugin)(api);
+    api.modifyWebpackChain(async (chain, { env, isServer, isWebWorker }) => {
+      const maxAssetSize = isServer || isWebWorker ? 30 * 1e3 * 1e3 : 3 * 1e3 * 1e3;
+      chain.performance.maxAssetSize(maxAssetSize);
+      chain.performance.maxEntrypointSize(maxAssetSize);
+      chain.module.parser.merge({
+        javascript: {
+          exportsPresence: "error"
+        }
+      });
+      if (env === "development") {
+        chain.output.devtoolModuleFilenameTemplate(
+          (info) => import_path.default.resolve(info.absoluteResourcePath).replace(/\\/g, "/")
+        );
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginBasic
+});

package/dist/plugins/copy.d.ts

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

package/dist/plugins/copy.js

@@ -0,0 +1,69 @@
+"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 copy_exports = {};
+__export(copy_exports, {
+  pluginCopy: () => pluginCopy
+});
+module.exports = __toCommonJS(copy_exports);
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+const pluginCopy = () => ({
+  name: "plugin-copy",
+  setup(api) {
+    api.modifyWebpackChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      const { copy } = config.output;
+      if (!copy) {
+        return;
+      }
+      const { default: CopyPlugin } = await Promise.resolve().then(() => __toESM(require("../../compiled/copy-webpack-plugin")));
+      const options = Array.isArray(copy) ? { patterns: copy } : copy;
+      chain.plugin(CHAIN_ID.PLUGIN.COPY).use(CopyPlugin, [options]);
+    });
+    api.modifyWebpackConfig(async (config) => {
+      var _a, _b;
+      const copyPlugin = (_a = config.plugins) == null ? void 0 : _a.find(
+        (item) => (item == null ? void 0 : item.constructor.name) === "CopyPlugin"
+      );
+      if (copyPlugin) {
+        const isContextNotExists = copyPlugin.patterns.every(
+          (pattern) => typeof pattern !== "string" && pattern.context && !import_fs_extra.fs.existsSync(pattern.context)
+        );
+        if (isContextNotExists) {
+          config.plugins = (_b = config.plugins) == null ? void 0 : _b.filter(
+            (item) => (item == null ? void 0 : item.constructor.name) !== "CopyPlugin"
+          );
+        }
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginCopy
+});

package/dist/plugins/css.d.ts

@@ -0,0 +1,23 @@
+import { ModifyChainUtils, type Context, type BundlerChainRule } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
+export declare function applyBaseCSSRule({
+  rule,
+  config,
+  context,
+  utils: {
+    target,
+    isProd,
+    isServer,
+    CHAIN_ID,
+    isWebWorker,
+    getCompiledPath
+  },
+  importLoaders
+}: {
+  rule: BundlerChainRule;
+  config: NormalizedConfig;
+  context: Context;
+  utils: ModifyChainUtils;
+  importLoaders?: number;
+}): Promise<void>;
+export declare const pluginCss: () => RsbuildPlugin;