@rsbuild/core 0.0.0-next-20231103091827

package/dist/plugins/preloadOrPrefetch.js

@@ -0,0 +1,61 @@
+"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 preloadOrPrefetch_exports = {};
+__export(preloadOrPrefetch_exports, {
+  pluginPreloadOrPrefetch: () => pluginPreloadOrPrefetch
+});
+module.exports = __toCommonJS(preloadOrPrefetch_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginPreloadOrPrefetch = () => ({
+  name: `plugin-preload-or-prefetch`,
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker, HtmlPlugin }) => {
+        const config = api.getNormalizedConfig();
+        const {
+          performance: { preload, prefetch }
+        } = config;
+        if (isServer || isWebWorker || isServiceWorker) {
+          return;
+        }
+        const HTMLCount = chain.entryPoints.values().length;
+        if (prefetch) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(import_shared.HTMLPreloadOrPrefetchPlugin, [
+            prefetch,
+            "prefetch",
+            HtmlPlugin,
+            HTMLCount
+          ]);
+        }
+        if (preload) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(import_shared.HTMLPreloadOrPrefetchPlugin, [
+            preload,
+            "preload",
+            HtmlPlugin,
+            HTMLCount
+          ]);
+        }
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginPreloadOrPrefetch
+});

package/dist/plugins/rem.d.ts

@@ -0,0 +1,2 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginRem: () => DefaultRsbuildPlugin;

package/dist/plugins/rem.js

@@ -0,0 +1,103 @@
+"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 rem_exports = {};
+__export(rem_exports, {
+  pluginRem: () => pluginRem
+});
+module.exports = __toCommonJS(rem_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_shared = require("@rsbuild/shared");
+const defaultOptions = {
+  enableRuntime: true,
+  rootFontSize: 50
+};
+const pluginRem = () => ({
+  name: "plugin-rem",
+  pre: ["plugin-css", "plugin-less", "plugin-sass", "plugin-stylus"],
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { CHAIN_ID, isServer, isWebWorker, HtmlPlugin }) => {
+        const config = api.getNormalizedConfig();
+        const {
+          output: { convertToRem }
+        } = config;
+        if (!convertToRem || isServer || isWebWorker) {
+          return;
+        }
+        const userOptions = {
+          ...defaultOptions,
+          ...typeof convertToRem === "boolean" ? {} : convertToRem
+        };
+        const { default: PxToRemPlugin } = await Promise.resolve().then(() => __toESM(require((0, import_shared.getSharedPkgCompiledPath)("postcss-pxtorem"))));
+        const applyRules = [
+          CHAIN_ID.RULE.CSS,
+          CHAIN_ID.RULE.LESS,
+          CHAIN_ID.RULE.SASS,
+          CHAIN_ID.RULE.STYLUS
+        ];
+        const getPxToRemPlugin = () => PxToRemPlugin({
+          rootValue: userOptions.rootFontSize,
+          unitPrecision: 5,
+          propList: ["*"],
+          ...import_lodash.default.cloneDeep(userOptions.pxtorem || {})
+        });
+        applyRules.forEach((name) => {
+          chain.module.rules.has(name) && chain.module.rule(name).use(CHAIN_ID.USE.POSTCSS).tap((options = {}) => {
+            var _a;
+            return {
+              ...options,
+              postcssOptions: {
+                ...options.postcssOptions || {},
+                plugins: [
+                  ...((_a = options.postcssOptions) == null ? void 0 : _a.plugins) || [],
+                  getPxToRemPlugin()
+                ]
+              }
+            };
+          });
+        });
+        if (!userOptions.enableRuntime) {
+          return;
+        }
+        const entries = Object.keys(chain.entryPoints.entries() || {});
+        const distDir = (0, import_shared.getDistPath)(config.output, "js");
+        chain.plugin(CHAIN_ID.PLUGIN.AUTO_SET_ROOT_SIZE).use(import_shared.AutoSetRootFontSizePlugin, [
+          userOptions,
+          entries,
+          HtmlPlugin,
+          distDir
+        ]);
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginRem
+});

package/dist/plugins/splitChunks.d.ts

@@ -0,0 +1,4 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+/** Expect to match path just like "./node_modules/react-router/" */
+export declare const createDependenciesRegExp: (...dependencies: (string | RegExp)[]) => RegExp;
+export declare function pluginSplitChunks(): DefaultRsbuildPlugin;

package/dist/plugins/splitChunks.js

@@ -0,0 +1,251 @@
+"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 splitChunks_exports = {};
+__export(splitChunks_exports, {
+  createDependenciesRegExp: () => createDependenciesRegExp,
+  pluginSplitChunks: () => pluginSplitChunks
+});
+module.exports = __toCommonJS(splitChunks_exports);
+var import_assert = __toESM(require("assert"));
+var import_shared = require("@rsbuild/shared");
+function getUserDefinedCacheGroups(forceSplitting) {
+  const cacheGroups = {};
+  const pairs = Array.isArray(forceSplitting) ? forceSplitting.map(
+    (regexp, index) => [`force-split-${index}`, regexp]
+  ) : Object.entries(forceSplitting);
+  pairs.forEach(([key, regexp]) => {
+    cacheGroups[key] = {
+      test: regexp,
+      name: key,
+      chunks: "all",
+      // Ignore minimum size, minimum chunks and maximum requests and always create chunks for user defined cache group.
+      enforce: true
+    };
+  });
+  return cacheGroups;
+}
+const DEPENDENCY_MATCH_TEMPL = /[\\/]node_modules[\\/](<SOURCES>)[\\/]/.source;
+const createDependenciesRegExp = (...dependencies) => {
+  const sources = dependencies.map(
+    (d) => typeof d === "string" ? d : d.source
+  );
+  const expr = DEPENDENCY_MATCH_TEMPL.replace("<SOURCES>", sources.join("|"));
+  return new RegExp(expr);
+};
+function splitByExperience(ctx) {
+  const { override, polyfill, defaultConfig, userDefinedCacheGroups } = ctx;
+  const experienceCacheGroup = {};
+  const packageRegExps = {
+    lodash: createDependenciesRegExp("lodash", "lodash-es"),
+    axios: createDependenciesRegExp("axios", /axios-.+/)
+  };
+  if (polyfill === "entry" || polyfill === "usage") {
+    packageRegExps.polyfill = createDependenciesRegExp(
+      "tslib",
+      "core-js",
+      "@babel/runtime",
+      "@swc/helpers"
+    );
+  }
+  Object.entries(packageRegExps).forEach(([name, test]) => {
+    const key = `lib-${name}`;
+    experienceCacheGroup[key] = {
+      test,
+      priority: 0,
+      name: key,
+      reuseExistingChunk: true
+    };
+  });
+  (0, import_assert.default)(defaultConfig !== false);
+  (0, import_assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...experienceCacheGroup,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function splitByModule(ctx) {
+  const { override, userDefinedCacheGroups, defaultConfig } = ctx;
+  (0, import_assert.default)(defaultConfig !== false);
+  (0, import_assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    minSize: 0,
+    maxInitialRequests: Infinity,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      // Core group
+      vendors: {
+        priority: -10,
+        test: import_shared.NODE_MODULES_REGEX,
+        // todo: not support in rspack
+        name(module2) {
+          return (0, import_shared.getPackageNameFromModulePath)(module2.context);
+        }
+      },
+      ...override.cacheGroups
+    }
+  };
+}
+function splitBySize(ctx) {
+  var _a, _b;
+  const { override, userDefinedCacheGroups, defaultConfig, rsbuildConfig } = ctx;
+  (0, import_assert.default)(defaultConfig !== false);
+  (0, import_assert.default)(override !== false);
+  (0, import_assert.default)(rsbuildConfig.strategy === "split-by-size");
+  return {
+    ...defaultConfig,
+    minSize: (_a = rsbuildConfig.minSize) != null ? _a : 0,
+    maxSize: (_b = rsbuildConfig.maxSize) != null ? _b : Infinity,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function splitCustom(ctx) {
+  const { override, userDefinedCacheGroups, defaultConfig } = ctx;
+  (0, import_assert.default)(defaultConfig !== false);
+  (0, import_assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function allInOne(_ctx) {
+  return false;
+}
+function singleVendor(ctx) {
+  const { override, defaultConfig, userDefinedCacheGroups } = ctx;
+  (0, import_assert.default)(defaultConfig !== false);
+  (0, import_assert.default)(override !== false);
+  const singleVendorCacheGroup = {
+    singleVendor: {
+      test: import_shared.NODE_MODULES_REGEX,
+      priority: 0,
+      chunks: "all",
+      name: "vendor",
+      enforce: true,
+      reuseExistingChunk: true
+    }
+  };
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...singleVendorCacheGroup,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+const SPLIT_STRATEGY_DISPATCHER = {
+  "split-by-experience": splitByExperience,
+  "split-by-module": splitByModule,
+  "split-by-size": splitBySize,
+  custom: splitCustom,
+  "all-in-one": allInOne,
+  "single-vendor": singleVendor
+};
+function pluginSplitChunks() {
+  return {
+    name: "plugin-split-chunks",
+    setup(api) {
+      api.modifyBundlerChain(
+        async (chain, { isServer, isWebWorker, isServiceWorker }) => {
+          var _a;
+          if (isServer || isWebWorker || isServiceWorker) {
+            chain.optimization.splitChunks(false);
+            if (isWebWorker || isServiceWorker) {
+              chain.module.parser.merge({
+                javascript: {
+                  dynamicImportMode: "eager"
+                }
+              });
+            }
+            return;
+          }
+          const config = api.getNormalizedConfig();
+          const defaultConfig = {
+            // Optimize both `initial` and `async` chunks
+            chunks: "all",
+            // When chunk size >= 50000 bytes, split it into separate chunk
+            enforceSizeThreshold: 5e4,
+            cacheGroups: {}
+          };
+          const { chunkSplit } = config.performance;
+          let userDefinedCacheGroups = {};
+          if (chunkSplit.forceSplitting) {
+            userDefinedCacheGroups = getUserDefinedCacheGroups(
+              chunkSplit.forceSplitting
+            );
+          }
+          const override = chunkSplit.strategy === "custom" ? (
+            // `chunkSplit.splitChunks` compat for Eden
+            (_a = chunkSplit.splitChunks) != null ? _a : chunkSplit.override
+          ) : chunkSplit.override;
+          const splitChunksOptions = await SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
+            defaultConfig,
+            override: override || {},
+            userDefinedCacheGroups,
+            rsbuildConfig: chunkSplit,
+            rootPath: api.context.rootPath,
+            polyfill: config.output.polyfill
+          });
+          chain.optimization.splitChunks(splitChunksOptions);
+          if (chunkSplit.strategy !== "all-in-one") {
+            chain.optimization.runtimeChunk({
+              name: import_shared.RUNTIME_CHUNK_NAME
+            });
+          }
+        }
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDependenciesRegExp,
+  pluginSplitChunks
+});

package/dist/plugins/startUrl.d.ts

@@ -0,0 +1,12 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+/**
+ * This method is modified based on source found in
+ * https://github.com/facebook/create-react-app
+ *
+ * MIT Licensed
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+export declare function openBrowser(url: string): Promise<boolean>;
+export declare const replacePlaceholder: (url: string, port: number) => string;
+export declare function pluginStartUrl(): DefaultRsbuildPlugin;

package/dist/plugins/startUrl.js

@@ -0,0 +1,146 @@
+"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 startUrl_exports = {};
+__export(startUrl_exports, {
+  openBrowser: () => openBrowser,
+  pluginStartUrl: () => pluginStartUrl,
+  replacePlaceholder: () => replacePlaceholder
+});
+module.exports = __toCommonJS(startUrl_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+var import_child_process = require("child_process");
+const supportedChromiumBrowsers = [
+  "Google Chrome Canary",
+  "Google Chrome Dev",
+  "Google Chrome Beta",
+  "Google Chrome",
+  "Microsoft Edge",
+  "Brave Browser",
+  "Vivaldi",
+  "Chromium"
+];
+const getTargetBrowser = () => {
+  let targetBrowser = process.env.BROWSER;
+  if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+    const ps = (0, import_child_process.execSync)("ps cax").toString();
+    targetBrowser = supportedChromiumBrowsers.find((b) => ps.includes(b));
+  }
+  return targetBrowser;
+};
+async function openBrowser(url) {
+  const shouldTryOpenChromeWithAppleScript = process.platform === "darwin";
+  if (shouldTryOpenChromeWithAppleScript) {
+    try {
+      const targetBrowser = getTargetBrowser();
+      if (targetBrowser) {
+        (0, import_child_process.execSync)(
+          `osascript openChrome.applescript "${encodeURI(
+            url
+          )}" "${targetBrowser}"`,
+          {
+            stdio: "ignore",
+            cwd: (0, import_path.join)(__dirname, "../../static")
+          }
+        );
+        return true;
+      }
+      return false;
+    } catch (err) {
+      import_shared.logger.error("Failed to open start URL with apple script.");
+      import_shared.logger.error(err);
+      return false;
+    }
+  }
+  try {
+    const { default: open } = await Promise.resolve().then(() => __toESM(require("open")));
+    await open(url);
+    return true;
+  } catch (err) {
+    import_shared.logger.error("Failed to open start URL.");
+    import_shared.logger.error(err);
+    return false;
+  }
+}
+const replacePlaceholder = (url, port) => url.replace(/<port>/g, String(port));
+const openedURLs = [];
+function pluginStartUrl() {
+  return {
+    name: "plugin-start-url",
+    async setup(api) {
+      let port;
+      api.onAfterStartDevServer(async (params) => {
+        ({ port } = params);
+      });
+      api.onDevCompileDone(async ({ isFirstCompile }) => {
+        if (!isFirstCompile || !port) {
+          return;
+        }
+        const config = api.getNormalizedConfig();
+        const { startUrl, beforeStartUrl } = config.dev;
+        const { https } = api.context.devServer || {};
+        if (!startUrl) {
+          return;
+        }
+        const urls = [];
+        if (startUrl === true) {
+          const protocol = https ? "https" : "http";
+          urls.push(`${protocol}://localhost:${port}`);
+        } else {
+          urls.push(
+            ...(0, import_shared.castArray)(startUrl).map(
+              (item) => replacePlaceholder(item, port)
+            )
+          );
+        }
+        const openUrls = () => {
+          for (const url of urls) {
+            if (!openedURLs.includes(url)) {
+              openBrowser(url);
+              openedURLs.push(url);
+            }
+          }
+        };
+        if (beforeStartUrl) {
+          Promise.all((0, import_shared.castArray)(beforeStartUrl).map((fn) => fn())).then(
+            openUrls
+          );
+        } else {
+          openUrls();
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openBrowser,
+  pluginStartUrl,
+  replacePlaceholder
+});

package/dist/plugins/target.d.ts

@@ -0,0 +1,2 @@
+import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginTarget: () => DefaultRsbuildPlugin;

package/dist/plugins/target.js

@@ -0,0 +1,53 @@
+"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 target_exports = {};
+__export(target_exports, {
+  pluginTarget: () => pluginTarget
+});
+module.exports = __toCommonJS(target_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginTarget = () => ({
+  name: "plugin-target",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { target }) => {
+      if (target === "node") {
+        chain.target("node");
+        return;
+      }
+      if (target === "service-worker") {
+        chain.target("webworker");
+        return;
+      }
+      if (target === "web-worker") {
+        chain.target(["webworker", "es5"]);
+        return;
+      }
+      const browserslist = await (0, import_shared.getBrowserslist)(api.context.rootPath);
+      if (browserslist) {
+        chain.merge({ target: ["web", "browserslist"] });
+      } else {
+        chain.merge({ target: ["web", "es5"] });
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginTarget
+});

package/dist/plugins/toml.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginToml: () => DefaultRsbuildPlugin;

package/dist/plugins/toml.js

@@ -0,0 +1,36 @@
+"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 toml_exports = {};
+__export(toml_exports, {
+  pluginToml: () => pluginToml
+});
+module.exports = __toCommonJS(toml_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginToml = () => ({
+  name: "plugin-toml",
+  setup(api) {
+    api.modifyBundlerChain((chain, { CHAIN_ID }) => {
+      chain.module.rule(CHAIN_ID.RULE.TOML).type("javascript/auto").test(/\.toml$/).use(CHAIN_ID.USE.TOML).loader((0, import_shared.getSharedPkgCompiledPath)("toml-loader"));
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginToml
+});

package/dist/plugins/wasm.d.ts

@@ -0,0 +1,2 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginWasm: () => DefaultRsbuildPlugin;