@rsbuild/plugin-babel 1.0.4 → 1.0.5

package/compiled/babel-loader/index.js

@@ -1,6 +1,6 @@
 (() => {
   var __webpack_modules__ = {
-    73: (module) => {
+    272: (module) => {
       const STRIP_FILENAME_RE = /^[^:]+: /;
       const format = (err) => {
         if (err instanceof SyntaxError) {
@@ -26,24 +26,17 @@
       }
       module.exports = LoaderError;
     },
-    805: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    124: (module, __unused_webpack_exports, __nccwpck_require__) => {
       const os = __nccwpck_require__(857);
       const path = __nccwpck_require__(928);
       const zlib = __nccwpck_require__(106);
-      const crypto = __nccwpck_require__(982);
       const { promisify } = __nccwpck_require__(23);
       const { readFile, writeFile, mkdir } = __nccwpck_require__(943);
-      const findCacheDirP = __nccwpck_require__
-        .e(611)
-        .then(__nccwpck_require__.bind(__nccwpck_require__, 611));
-      const transform = __nccwpck_require__(723);
+      const { sync: findUpSync } = __nccwpck_require__(609);
+      const { env } = process;
+      const transform = __nccwpck_require__(790);
+      const serialize = __nccwpck_require__(436);
       let defaultCacheDirectory = null;
-      let hashType = "sha256";
-      try {
-        crypto.createHash(hashType);
-      } catch {
-        hashType = "md5";
-      }
       const gunzip = promisify(zlib.gunzip);
       const gzip = promisify(zlib.gzip);
       const read = async function (filename, compress) {
@@ -56,12 +49,40 @@
         const data = compress ? await gzip(content) : content;
         return await writeFile(filename + (compress ? ".gz" : ""), data);
       };
-      const filename = function (source, identifier, options) {
-        const hash = crypto.createHash(hashType);
-        const contents = JSON.stringify({ source, options, identifier });
-        hash.update(contents);
+      const filename = function (source, identifier, options, hash) {
+        hash.update(serialize([options, source, identifier]));
         return hash.digest("hex") + ".json";
       };
+      const addTimestamps = async function (
+        externalDependencies,
+        getFileTimestamp,
+      ) {
+        for (const depAndEmptyTimestamp of externalDependencies) {
+          try {
+            const [dep] = depAndEmptyTimestamp;
+            const { timestamp } = await getFileTimestamp(dep);
+            depAndEmptyTimestamp.push(timestamp);
+          } catch {}
+        }
+      };
+      const areExternalDependenciesModified = async function (
+        externalDepsWithTimestamp,
+        getFileTimestamp,
+      ) {
+        for (const depAndTimestamp of externalDepsWithTimestamp) {
+          const [dep, timestamp] = depAndTimestamp;
+          let newTimestamp;
+          try {
+            newTimestamp = (await getFileTimestamp(dep)).timestamp;
+          } catch {
+            return true;
+          }
+          if (timestamp !== newTimestamp) {
+            return true;
+          }
+        }
+        return false;
+      };
       const handleCache = async function (directory, params) {
         const {
           source,
@@ -69,15 +90,29 @@
           cacheIdentifier,
           cacheDirectory,
           cacheCompression,
+          hash,
+          getFileTimestamp,
           logger,
         } = params;
         const file = path.join(
           directory,
-          filename(source, cacheIdentifier, options),
+          filename(source, cacheIdentifier, options, hash),
         );
         try {
           logger.debug(`reading cache file '${file}'`);
-          return await read(file, cacheCompression);
+          const result = await read(file, cacheCompression);
+          if (
+            !(await areExternalDependenciesModified(
+              result.externalDependencies,
+              getFileTimestamp,
+            ))
+          ) {
+            logger.debug(`validated cache file '${file}'`);
+            return result;
+          }
+          logger.debug(
+            `discarded cache file '${file}' due to changes in external dependencies`,
+          );
         } catch {
           logger.debug(`discarded cache as it can not be read`);
         }
@@ -94,16 +129,15 @@
         }
         logger.debug(`applying Babel transform`);
         const result = await transform(source, options);
-        if (!result.externalDependencies.length) {
-          try {
-            logger.debug(`writing result to cache file '${file}'`);
-            await write(file, cacheCompression, result);
-          } catch (err) {
-            if (fallback) {
-              return handleCache(os.tmpdir(), params);
-            }
-            throw err;
+        await addTimestamps(result.externalDependencies, getFileTimestamp);
+        try {
+          logger.debug(`writing result to cache file '${file}'`);
+          await write(file, cacheCompression, result);
+        } catch (err) {
+          if (fallback) {
+            return handleCache(os.tmpdir(), params);
           }
+          throw err;
         }
         return result;
       };
@@ -112,17 +146,26 @@
         if (typeof params.cacheDirectory === "string") {
           directory = params.cacheDirectory;
         } else {
-          if (defaultCacheDirectory === null) {
-            const { default: findCacheDir } = await findCacheDirP;
-            defaultCacheDirectory =
-              findCacheDir({ name: "babel-loader" }) || os.tmpdir();
-          }
+          defaultCacheDirectory ??= findCacheDir("babel-loader");
           directory = defaultCacheDirectory;
         }
         return await handleCache(directory, params);
       };
+      function findCacheDir(name) {
+        if (
+          env.CACHE_DIR &&
+          !["true", "false", "1", "0"].includes(env.CACHE_DIR)
+        ) {
+          return path.join(env.CACHE_DIR, name);
+        }
+        const rootPkgJSONPath = path.dirname(findUpSync("package.json"));
+        if (rootPkgJSONPath) {
+          return path.join(rootPkgJSONPath, "node_modules", ".cache", name);
+        }
+        return os.tmpdir();
+      }
     },
-    603: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    674: (module, __unused_webpack_exports, __nccwpck_require__) => {
       let babel;
       try {
         babel = __nccwpck_require__(571);
@@ -141,12 +184,12 @@
         );
       }
       const { version } = __nccwpck_require__(344);
-      const cache = __nccwpck_require__(805);
-      const transform = __nccwpck_require__(723);
-      const injectCaller = __nccwpck_require__(273);
-      const schema = __nccwpck_require__(291);
+      const cache = __nccwpck_require__(124);
+      const transform = __nccwpck_require__(790);
+      const injectCaller = __nccwpck_require__(846);
+      const schema = __nccwpck_require__(348);
       const { isAbsolute } = __nccwpck_require__(928);
-      const validateOptions = __nccwpck_require__(979).validate;
+      const { promisify } = __nccwpck_require__(23);
       function subscribe(subscriber, metadata, context) {
         if (context[subscriber]) {
           context[subscriber](metadata);
@@ -166,18 +209,9 @@
       }
       async function loader(source, inputSourceMap, overrides) {
         const filename = this.resourcePath;
-        const logger =
-          typeof this.getLogger === "function"
-            ? this.getLogger("babel-loader")
-            : { debug: () => {} };
-        let loaderOptions = this.getOptions();
-        validateOptions(schema, loaderOptions, { name: "Babel loader" });
+        const logger = this.getLogger("babel-loader");
+        let loaderOptions = this.getOptions(schema);
         if (loaderOptions.customize != null) {
-          if (typeof loaderOptions.customize !== "string") {
-            throw new Error(
-              "Customized loaders must be implemented as standalone modules.",
-            );
-          }
           if (!isAbsolute(loaderOptions.customize)) {
             throw new Error(
               "Customized loaders must be passed as absolute paths, since " +
@@ -213,17 +247,21 @@
           loaderOptions = result.loader;
         }
         if ("forceEnv" in loaderOptions) {
-          console.warn(
-            "The option `forceEnv` has been removed in favor of `envName` in Babel 7.",
+          this.emitWarning(
+            new Error(
+              "The option `forceEnv` has been removed in favor of `envName` in Babel 7.",
+            ),
           );
         }
         if (typeof loaderOptions.babelrc === "string") {
-          console.warn(
-            "The option `babelrc` should not be set to a string anymore in the babel-loader config. " +
-              "Please update your configuration and set `babelrc` to true or false.\n" +
-              "If you want to specify a specific babel config file to inherit config from " +
-              "please use the `extends` option.\nFor more information about this options see " +
-              "https://babeljs.io/docs/core-packages/#options",
+          this.emitWarning(
+            new Error(
+              "The option `babelrc` should not be set to a string anymore in the babel-loader config. " +
+                "Please update your configuration and set `babelrc` to true or false.\n" +
+                "If you want to specify a specific babel config file to inherit config from " +
+                "please use the `extends` option.\nFor more information about this options see " +
+                "https://babeljs.io/docs/#options",
+            ),
           );
         }
         logger.debug("normalizing loader options");
@@ -269,17 +307,23 @@
           }
           const {
             cacheDirectory = null,
-            cacheIdentifier = JSON.stringify({
-              options,
-              "@babel/core": transform.version,
-              "@babel/loader": version,
-            }),
+            cacheIdentifier = "core" +
+              transform.version +
+              "," +
+              "loader" +
+              version,
             cacheCompression = true,
             metadataSubscribers = [],
           } = loaderOptions;
           let result;
           if (cacheDirectory) {
             logger.debug("cache is enabled");
+            const getFileTimestamp = promisify((path, cb) => {
+              this._compilation.fileSystemInfo.getFileTimestamp(path, cb);
+            });
+            const hash = this.utils.createHash(
+              this._compilation.outputOptions.hashFunction,
+            );
             result = await cache({
               source,
               options,
@@ -287,6 +331,8 @@
               cacheDirectory,
               cacheIdentifier,
               cacheCompression,
+              hash,
+              getFileTimestamp,
               logger,
             });
           } else {
@@ -311,7 +357,7 @@
               });
             }
             const { code, map, metadata, externalDependencies } = result;
-            externalDependencies?.forEach((dep) => {
+            externalDependencies?.forEach(([dep]) => {
               this.addDependency(dep);
               logger.debug(`added '${dep}' to webpack dependencies`);
             });
@@ -327,7 +373,7 @@
         return [source, inputSourceMap];
       }
     },
-    273: (module) => {
+    846: (module) => {
       module.exports = function injectCaller(opts, target) {
         return Object.assign({}, opts, {
           caller: Object.assign(
@@ -343,10 +389,76 @@
         });
       };
     },
-    723: (module, __unused_webpack_exports, __nccwpck_require__) => {
+    436: (module) => {
+      var objToString = Object.prototype.toString;
+      var objKeys = Object.getOwnPropertyNames;
+      function serialize(val, isArrayProp) {
+        var i, max, str, keys, key, propVal, toStr;
+        if (val === true) {
+          return "!0";
+        }
+        if (val === false) {
+          return "!1";
+        }
+        switch (typeof val) {
+          case "object":
+            if (val === null) {
+              return null;
+            } else if (val.toJSON && typeof val.toJSON === "function") {
+              return serialize(val.toJSON(), isArrayProp);
+            } else {
+              toStr = objToString.call(val);
+              if (toStr === "[object Array]") {
+                str = "[";
+                max = val.length - 1;
+                for (i = 0; i < max; i++) {
+                  str += serialize(val[i], true) + ",";
+                }
+                if (max > -1) {
+                  str += serialize(val[i], true);
+                }
+                return str + "]";
+              } else if (toStr === "[object Object]") {
+                keys = objKeys(val).sort();
+                max = keys.length;
+                str = "{";
+                i = 0;
+                while (i < max) {
+                  key = keys[i];
+                  propVal = serialize(val[key], false);
+                  if (propVal !== undefined) {
+                    if (str) {
+                      str += ",";
+                    }
+                    str += '"' + key + '":' + propVal;
+                  }
+                  i++;
+                }
+                return str + "}";
+              } else {
+                return JSON.stringify(val);
+              }
+            }
+          case "function":
+          case "undefined":
+            return isArrayProp ? null : undefined;
+          case "string":
+            return val;
+          default:
+            return isFinite(val) ? val : null;
+        }
+      }
+      module.exports = function (val) {
+        var returnVal = serialize(val, false);
+        if (returnVal !== undefined) {
+          return "" + returnVal;
+        }
+      };
+    },
+    790: (module, __unused_webpack_exports, __nccwpck_require__) => {
       const babel = __nccwpck_require__(571);
       const { promisify } = __nccwpck_require__(23);
-      const LoaderError = __nccwpck_require__(73);
+      const LoaderError = __nccwpck_require__(272);
       const transform = promisify(babel.transform);
       module.exports = async function (source, options) {
         let result;
@@ -367,46 +479,319 @@
           map,
           metadata,
           sourceType,
-          externalDependencies: Array.from(externalDependencies || []),
+          externalDependencies: Array.from(
+            externalDependencies || [],
+            (dep) => [dep],
+          ).sort(),
         };
       };
       module.exports.version = babel.version;
     },
-    344: (module) => {
+    609: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("./package.json");
+      const path = __nccwpck_require__(928);
+      const locatePath = __nccwpck_require__(440);
+      const pathExists = __nccwpck_require__(374);
+      const stop = Symbol("findUp.stop");
+      module.exports = async (name, options = {}) => {
+        let directory = path.resolve(options.cwd || "");
+        const { root } = path.parse(directory);
+        const paths = [].concat(name);
+        const runMatcher = async (locateOptions) => {
+          if (typeof name !== "function") {
+            return locatePath(paths, locateOptions);
+          }
+          const foundPath = await name(locateOptions.cwd);
+          if (typeof foundPath === "string") {
+            return locatePath([foundPath], locateOptions);
+          }
+          return foundPath;
+        };
+        while (true) {
+          const foundPath = await runMatcher({ ...options, cwd: directory });
+          if (foundPath === stop) {
+            return;
+          }
+          if (foundPath) {
+            return path.resolve(directory, foundPath);
+          }
+          if (directory === root) {
+            return;
+          }
+          directory = path.dirname(directory);
+        }
+      };
+      module.exports.sync = (name, options = {}) => {
+        let directory = path.resolve(options.cwd || "");
+        const { root } = path.parse(directory);
+        const paths = [].concat(name);
+        const runMatcher = (locateOptions) => {
+          if (typeof name !== "function") {
+            return locatePath.sync(paths, locateOptions);
+          }
+          const foundPath = name(locateOptions.cwd);
+          if (typeof foundPath === "string") {
+            return locatePath.sync([foundPath], locateOptions);
+          }
+          return foundPath;
+        };
+        while (true) {
+          const foundPath = runMatcher({ ...options, cwd: directory });
+          if (foundPath === stop) {
+            return;
+          }
+          if (foundPath) {
+            return path.resolve(directory, foundPath);
+          }
+          if (directory === root) {
+            return;
+          }
+          directory = path.dirname(directory);
+        }
+      };
+      module.exports.exists = pathExists;
+      module.exports.sync.exists = pathExists.sync;
+      module.exports.stop = stop;
     },
-    979: (module) => {
+    440: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("./schema-utils");
+      const path = __nccwpck_require__(928);
+      const fs = __nccwpck_require__(896);
+      const { promisify } = __nccwpck_require__(23);
+      const pLocate = __nccwpck_require__(601);
+      const fsStat = promisify(fs.stat);
+      const fsLStat = promisify(fs.lstat);
+      const typeMappings = { directory: "isDirectory", file: "isFile" };
+      function checkType({ type }) {
+        if (type in typeMappings) {
+          return;
+        }
+        throw new Error(`Invalid type specified: ${type}`);
+      }
+      const matchType = (type, stat) =>
+        type === undefined || stat[typeMappings[type]]();
+      module.exports = async (paths, options) => {
+        options = {
+          cwd: process.cwd(),
+          type: "file",
+          allowSymlinks: true,
+          ...options,
+        };
+        checkType(options);
+        const statFn = options.allowSymlinks ? fsStat : fsLStat;
+        return pLocate(
+          paths,
+          async (path_) => {
+            try {
+              const stat = await statFn(path.resolve(options.cwd, path_));
+              return matchType(options.type, stat);
+            } catch {
+              return false;
+            }
+          },
+          options,
+        );
+      };
+      module.exports.sync = (paths, options) => {
+        options = {
+          cwd: process.cwd(),
+          allowSymlinks: true,
+          type: "file",
+          ...options,
+        };
+        checkType(options);
+        const statFn = options.allowSymlinks ? fs.statSync : fs.lstatSync;
+        for (const path_ of paths) {
+          try {
+            const stat = statFn(path.resolve(options.cwd, path_));
+            if (matchType(options.type, stat)) {
+              return path_;
+            }
+          } catch {}
+        }
+      };
     },
-    571: (module) => {
+    600: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("@babel/core");
+      const Queue = __nccwpck_require__(179);
+      const pLimit = (concurrency) => {
+        if (
+          !(
+            (Number.isInteger(concurrency) || concurrency === Infinity) &&
+            concurrency > 0
+          )
+        ) {
+          throw new TypeError(
+            "Expected `concurrency` to be a number from 1 and up",
+          );
+        }
+        const queue = new Queue();
+        let activeCount = 0;
+        const next = () => {
+          activeCount--;
+          if (queue.size > 0) {
+            queue.dequeue()();
+          }
+        };
+        const run = async (fn, resolve, ...args) => {
+          activeCount++;
+          const result = (async () => fn(...args))();
+          resolve(result);
+          try {
+            await result;
+          } catch {}
+          next();
+        };
+        const enqueue = (fn, resolve, ...args) => {
+          queue.enqueue(run.bind(null, fn, resolve, ...args));
+          (async () => {
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.size > 0) {
+              queue.dequeue()();
+            }
+          })();
+        };
+        const generator = (fn, ...args) =>
+          new Promise((resolve) => {
+            enqueue(fn, resolve, ...args);
+          });
+        Object.defineProperties(generator, {
+          activeCount: { get: () => activeCount },
+          pendingCount: { get: () => queue.size },
+          clearQueue: {
+            value: () => {
+              queue.clear();
+            },
+          },
+        });
+        return generator;
+      };
+      module.exports = pLimit;
     },
-    982: (module) => {
+    601: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("crypto");
+      const pLimit = __nccwpck_require__(600);
+      class EndError extends Error {
+        constructor(value) {
+          super();
+          this.value = value;
+        }
+      }
+      const testElement = async (element, tester) => tester(await element);
+      const finder = async (element) => {
+        const values = await Promise.all(element);
+        if (values[1] === true) {
+          throw new EndError(values[0]);
+        }
+        return false;
+      };
+      const pLocate = async (iterable, tester, options) => {
+        options = { concurrency: Infinity, preserveOrder: true, ...options };
+        const limit = pLimit(options.concurrency);
+        const items = [...iterable].map((element) => [
+          element,
+          limit(testElement, element, tester),
+        ]);
+        const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
+        try {
+          await Promise.all(
+            items.map((element) => checkLimit(finder, element)),
+          );
+        } catch (error) {
+          if (error instanceof EndError) {
+            return error.value;
+          }
+          throw error;
+        }
+      };
+      module.exports = pLocate;
     },
-    943: (module) => {
+    374: (module, __unused_webpack_exports, __nccwpck_require__) => {
       "use strict";
-      module.exports = require("fs/promises");
+      const fs = __nccwpck_require__(896);
+      const { promisify } = __nccwpck_require__(23);
+      const pAccess = promisify(fs.access);
+      module.exports = async (path) => {
+        try {
+          await pAccess(path);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      };
+      module.exports.sync = (path) => {
+        try {
+          fs.accessSync(path);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      };
+    },
+    179: (module) => {
+      class Node {
+        constructor(value) {
+          this.value = value;
+          this.next = undefined;
+        }
+      }
+      class Queue {
+        constructor() {
+          this.clear();
+        }
+        enqueue(value) {
+          const node = new Node(value);
+          if (this._head) {
+            this._tail.next = node;
+            this._tail = node;
+          } else {
+            this._head = node;
+            this._tail = node;
+          }
+          this._size++;
+        }
+        dequeue() {
+          const current = this._head;
+          if (!current) {
+            return;
+          }
+          this._head = this._head.next;
+          this._size--;
+          return current.value;
+        }
+        clear() {
+          this._head = undefined;
+          this._tail = undefined;
+          this._size = 0;
+        }
+        get size() {
+          return this._size;
+        }
+        *[Symbol.iterator]() {
+          let current = this._head;
+          while (current) {
+            yield current.value;
+            current = current.next;
+          }
+        }
+      }
+      module.exports = Queue;
     },
-    24: (module) => {
+    344: (module) => {
       "use strict";
-      module.exports = require("node:fs");
+      module.exports = require("./package.json");
     },
-    760: (module) => {
+    571: (module) => {
       "use strict";
-      module.exports = require("node:path");
+      module.exports = require("@babel/core");
     },
-    708: (module) => {
+    896: (module) => {
       "use strict";
-      module.exports = require("node:process");
+      module.exports = require("fs");
     },
-    136: (module) => {
+    943: (module) => {
       "use strict";
-      module.exports = require("node:url");
+      module.exports = require("fs/promises");
     },
     857: (module) => {
       "use strict";
@@ -424,10 +809,10 @@
       "use strict";
       module.exports = require("zlib");
     },
-    291: (module) => {
+    348: (module) => {
       "use strict";
       module.exports = JSON.parse(
-        '{"type":"object","properties":{"cacheDirectory":{"oneOf":[{"type":"boolean"},{"type":"string"}],"default":false},"cacheIdentifier":{"type":"string"},"cacheCompression":{"type":"boolean","default":true},"customize":{"type":"string","default":null}},"additionalProperties":true}',
+        '{"title":"Babel Loader options","type":"object","properties":{"cacheDirectory":{"anyOf":[{"type":"boolean"},{"type":"string"}],"default":false},"cacheIdentifier":{"type":"string"},"cacheCompression":{"type":"boolean","default":true},"customize":{"anyOf":[{"type":"null"},{"type":"string"}],"default":null},"metadataSubscribers":{"type":"array"}},"additionalProperties":true}',
       );
     },
   };
@@ -451,72 +836,8 @@
     }
     return module.exports;
   }
-  __nccwpck_require__.m = __webpack_modules__;
-  (() => {
-    __nccwpck_require__.d = (exports, definition) => {
-      for (var key in definition) {
-        if (
-          __nccwpck_require__.o(definition, key) &&
-          !__nccwpck_require__.o(exports, key)
-        ) {
-          Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key],
-          });
-        }
-      }
-    };
-  })();
-  (() => {
-    __nccwpck_require__.f = {};
-    __nccwpck_require__.e = (chunkId) =>
-      Promise.all(
-        Object.keys(__nccwpck_require__.f).reduce((promises, key) => {
-          __nccwpck_require__.f[key](chunkId, promises);
-          return promises;
-        }, []),
-      );
-  })();
-  (() => {
-    __nccwpck_require__.u = (chunkId) => "" + chunkId + ".index.js";
-  })();
-  (() => {
-    __nccwpck_require__.o = (obj, prop) =>
-      Object.prototype.hasOwnProperty.call(obj, prop);
-  })();
-  (() => {
-    __nccwpck_require__.r = (exports) => {
-      if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
-        Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-      }
-      Object.defineProperty(exports, "__esModule", { value: true });
-    };
-  })();
   if (typeof __nccwpck_require__ !== "undefined")
     __nccwpck_require__.ab = __dirname + "/";
-  (() => {
-    var installedChunks = { 792: 1 };
-    var installChunk = (chunk) => {
-      var moreModules = chunk.modules,
-        chunkIds = chunk.ids,
-        runtime = chunk.runtime;
-      for (var moduleId in moreModules) {
-        if (__nccwpck_require__.o(moreModules, moduleId)) {
-          __nccwpck_require__.m[moduleId] = moreModules[moduleId];
-        }
-      }
-      if (runtime) runtime(__nccwpck_require__);
-      for (var i = 0; i < chunkIds.length; i++)
-        installedChunks[chunkIds[i]] = 1;
-    };
-    __nccwpck_require__.f.require = (chunkId, promises) => {
-      if (!installedChunks[chunkId]) {
-        if (true) {
-          installChunk(require("./" + __nccwpck_require__.u(chunkId)));
-        } else installedChunks[chunkId] = 1;
-      }
-    };
-  })();
-  var __webpack_exports__ = __nccwpck_require__(603);
+  var __webpack_exports__ = __nccwpck_require__(674);
   module.exports = __webpack_exports__;
 })();

package/compiled/babel-loader/package.json

@@ -1 +1 @@
-{"name":"babel-loader","author":"Luis Couto <hello@luiscouto.pt>","version":"9.2.1","license":"MIT","types":"index.d.ts","type":"commonjs"}
+{"name":"babel-loader","author":"Luis Couto <hello@luiscouto.pt>","version":"10.0.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/dist/index.cjs

@@ -13,23 +13,17 @@ function __webpack_require__(moduleId) {
     };
     return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
 }
-__webpack_require__.n = function(module) {
-    var getter = module && module.__esModule ? function() {
-        return module.default;
-    } : function() {
-        return module;
-    };
+__webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
     return __webpack_require__.d(getter, {
         a: getter
     }), getter;
-}, __webpack_require__.d = function(exports1, definition) {
+}, __webpack_require__.d = (exports1, definition)=>{
     for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
         enumerable: !0,
         get: definition[key]
     });
-}, __webpack_require__.o = function(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}, __webpack_require__.r = function(exports1) {
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
     'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
         value: 'Module'
     }), Object.defineProperty(exports1, '__esModule', {
@@ -37,13 +31,13 @@ __webpack_require__.n = function(module) {
     });
 };
 var __webpack_exports__ = {};
-(()=>{
+for(var __webpack_i__ in (()=>{
     __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
-        PLUGIN_BABEL_NAME: ()=>PLUGIN_BABEL_NAME,
+        getBabelUtils: ()=>getBabelUtils,
         getDefaultBabelOptions: ()=>getDefaultBabelOptions,
+        pluginBabel: ()=>pluginBabel,
         modifyBabelLoaderOptions: ()=>modifyBabelLoaderOptions,
-        getBabelUtils: ()=>getBabelUtils,
-        pluginBabel: ()=>pluginBabel
+        PLUGIN_BABEL_NAME: ()=>PLUGIN_BABEL_NAME
     });
     let external_node_fs_namespaceObject = require("node:fs");
     var external_node_fs_default = __webpack_require__.n(external_node_fs_namespaceObject);
@@ -126,7 +120,7 @@ var __webpack_exports__ = {};
     };
     async function getCacheIdentifier(options) {
         let identifier = `${process.env.NODE_ENV}${JSON.stringify(options)}`, { version: coreVersion } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@babel/core")), loaderVersion = JSON.parse(await external_node_fs_default().promises.readFile((0, external_node_path_namespaceObject.join)(plugin_dirname, '../compiled/babel-loader/package.json'), 'utf-8')).version ?? '';
-        return identifier + `@babel/core@${coreVersion}babel-loader@${loaderVersion}`;
+        return identifier += `@babel/core@${coreVersion}babel-loader@${loaderVersion}`;
     }
     let getDefaultBabelOptions = (config, context)=>{
         let isLegacyDecorators = 'legacy' === config.source.decorators.version, options = {
@@ -177,9 +171,13 @@ var __webpack_exports__ = {};
                 });
             }
         });
-})();
-var __webpack_export_target__ = exports;
-for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
-__webpack_exports__.__esModule && Object.defineProperty(__webpack_export_target__, '__esModule', {
+})(), exports.PLUGIN_BABEL_NAME = __webpack_exports__.PLUGIN_BABEL_NAME, exports.getBabelUtils = __webpack_exports__.getBabelUtils, exports.getDefaultBabelOptions = __webpack_exports__.getDefaultBabelOptions, exports.modifyBabelLoaderOptions = __webpack_exports__.modifyBabelLoaderOptions, exports.pluginBabel = __webpack_exports__.pluginBabel, __webpack_exports__)-1 === [
+    "PLUGIN_BABEL_NAME",
+    "getBabelUtils",
+    "getDefaultBabelOptions",
+    "modifyBabelLoaderOptions",
+    "pluginBabel"
+].indexOf(__webpack_i__) && (exports[__webpack_i__] = __webpack_exports__[__webpack_i__]);
+Object.defineProperty(exports, '__esModule', {
     value: !0
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-babel",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Babel plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -23,22 +23,22 @@
     "compiled"
   ],
   "dependencies": {
-    "@babel/core": "^7.26.9",
+    "@babel/core": "^7.26.10",
     "@babel/plugin-proposal-decorators": "^7.25.9",
     "@babel/plugin-transform-class-properties": "^7.25.9",
-    "@babel/preset-typescript": "^7.26.0",
+    "@babel/preset-typescript": "^7.27.0",
     "@types/babel__core": "^7.20.5",
     "deepmerge": "^4.3.1",
     "reduce-configs": "^1.1.0",
     "upath": "2.0.1"
   },
   "devDependencies": {
-    "@rslib/core": "0.4.1",
-    "@types/node": "^22.13.4",
-    "babel-loader": "9.2.1",
-    "prebundle": "1.2.7",
-    "typescript": "^5.7.3",
-    "@rsbuild/core": "1.2.9",
+    "@rslib/core": "0.6.1",
+    "@types/node": "^22.14.0",
+    "babel-loader": "10.0.0",
+    "prebundle": "1.3.3",
+    "typescript": "^5.8.3",
+    "@rsbuild/core": "1.3.5",
     "@scripts/test-helper": "1.0.1"
   },
   "peerDependencies": {

package/compiled/babel-loader/611.index.js

@@ -1,411 +0,0 @@
-"use strict";
-exports.id = 611;
-exports.ids = [611];
-exports.modules = {
-
-/***/ 887:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-
-const { sep: DEFAULT_SEPARATOR } = __webpack_require__(928)
-
-const determineSeparator = paths => {
-  for (const path of paths) {
-    const match = /(\/|\\)/.exec(path)
-    if (match !== null) return match[0]
-  }
-
-  return DEFAULT_SEPARATOR
-}
-
-module.exports = function commonPathPrefix (paths, sep = determineSeparator(paths)) {
-  const [first = '', ...remaining] = paths
-  if (first === '' || remaining.length === 0) return ''
-
-  const parts = first.split(sep)
-
-  let endOfPrefix = parts.length
-  for (const path of remaining) {
-    const compare = path.split(sep)
-    for (let i = 0; i < endOfPrefix; i++) {
-      if (compare[i] !== parts[i]) {
-        endOfPrefix = i
-      }
-    }
-
-    if (endOfPrefix === 0) return ''
-  }
-
-  const prefix = parts.slice(0, endOfPrefix).join(sep)
-  return prefix.endsWith(sep) ? prefix : prefix + sep
-}
-
-
-/***/ }),
-
-/***/ 611:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "default": () => (/* binding */ findCacheDirectory)
-});
-
-// EXTERNAL MODULE: external "node:process"
-var external_node_process_ = __webpack_require__(708);
-// EXTERNAL MODULE: external "node:path"
-var external_node_path_ = __webpack_require__(760);
-// EXTERNAL MODULE: external "node:fs"
-var external_node_fs_ = __webpack_require__(24);
-// EXTERNAL MODULE: ../../node_modules/.pnpm/common-path-prefix@3.0.0/node_modules/common-path-prefix/index.js
-var common_path_prefix = __webpack_require__(887);
-// EXTERNAL MODULE: external "node:url"
-var external_node_url_ = __webpack_require__(136);
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
-
-
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
-	}
-}
-
-// The input can also be a promise, so we await it.
-const testElement = async (element, tester) => tester(await element);
-
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
-
-	return false;
-};
-
-async function p_locate_pLocate(
-	iterable,
-	tester,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
-) {
-	const limit = pLimit(concurrency);
-
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
-
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
-
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
-		}
-
-		throw error;
-	}
-}
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
-
-
-
-
-
-
-const typeMappings = {
-	directory: 'isDirectory',
-	file: 'isFile',
-};
-
-function checkType(type) {
-	if (Object.hasOwnProperty.call(typeMappings, type)) {
-		return;
-	}
-
-	throw new Error(`Invalid type specified: ${type}`);
-}
-
-const matchType = (type, stat) => stat[typeMappings[type]]();
-
-const toPath = urlOrPath => urlOrPath instanceof URL ? (0,external_node_url_.fileURLToPath)(urlOrPath) : urlOrPath;
-
-async function locate_path_locatePath(
-	paths,
-	{
-		cwd = process.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-		concurrency,
-		preserveOrder,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath(cwd);
-
-	const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat;
-
-	return pLocate(paths, async path_ => {
-		try {
-			const stat = await statFunction(path.resolve(cwd, path_));
-			return matchType(type, stat);
-		} catch {
-			return false;
-		}
-	}, {concurrency, preserveOrder});
-}
-
-function locatePathSync(
-	paths,
-	{
-		cwd = external_node_process_.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-	} = {},
-) {
-	checkType(type);
-	cwd = toPath(cwd);
-
-	const statFunction = allowSymlinks ? external_node_fs_.statSync : external_node_fs_.lstatSync;
-
-	for (const path_ of paths) {
-		try {
-			const stat = statFunction(external_node_path_.resolve(cwd, path_), {
-				throwIfNoEntry: false,
-			});
-
-			if (!stat) {
-				continue;
-			}
-
-			if (matchType(type, stat)) {
-				return path_;
-			}
-		} catch {}
-	}
-}
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
-
-
-async function pathExists(path) {
-	try {
-		await fsPromises.access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function pathExistsSync(path) {
-	try {
-		fs.accessSync(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
-
-
-
-
-const find_up_toPath = urlOrPath => urlOrPath instanceof URL ? (0,external_node_url_.fileURLToPath)(urlOrPath) : urlOrPath;
-
-const findUpStop = Symbol('findUpStop');
-
-async function findUpMultiple(name, options = {}) {
-	let directory = path.resolve(find_up_toPath(options.cwd) || '');
-	const {root} = path.parse(directory);
-	const stopAt = path.resolve(directory, options.stopAt || root);
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
-
-	const runMatcher = async locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath(paths, locateOptions);
-		}
-
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath([foundPath], locateOptions);
-		}
-
-		return foundPath;
-	};
-
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		// eslint-disable-next-line no-await-in-loop
-		const foundPath = await runMatcher({...options, cwd: directory});
-
-		if (foundPath === findUpStop) {
-			break;
-		}
-
-		if (foundPath) {
-			matches.push(path.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
-			break;
-		}
-
-		directory = path.dirname(directory);
-	}
-
-	return matches;
-}
-
-function findUpMultipleSync(name, options = {}) {
-	let directory = external_node_path_.resolve(find_up_toPath(options.cwd) || '');
-	const {root} = external_node_path_.parse(directory);
-	const stopAt = options.stopAt || root;
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
-
-	const runMatcher = locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePathSync(paths, locateOptions);
-		}
-
-		const foundPath = name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePathSync([foundPath], locateOptions);
-		}
-
-		return foundPath;
-	};
-
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		const foundPath = runMatcher({...options, cwd: directory});
-
-		if (foundPath === findUpStop) {
-			break;
-		}
-
-		if (foundPath) {
-			matches.push(external_node_path_.resolve(directory, foundPath));
-		}
-
-		if (directory === stopAt || matches.length >= limit) {
-			break;
-		}
-
-		directory = external_node_path_.dirname(directory);
-	}
-
-	return matches;
-}
-
-async function find_up_findUp(name, options = {}) {
-	const matches = await findUpMultiple(name, {...options, limit: 1});
-	return matches[0];
-}
-
-function findUpSync(name, options = {}) {
-	const matches = findUpMultipleSync(name, {...options, limit: 1});
-	return matches[0];
-}
-
-
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/pkg-dir@7.0.0/node_modules/pkg-dir/index.js
-
-
-
-async function packageDirectory({cwd} = {}) {
-	const filePath = await findUp('package.json', {cwd});
-	return filePath && path.dirname(filePath);
-}
-
-function packageDirectorySync({cwd} = {}) {
-	const filePath = findUpSync('package.json', {cwd});
-	return filePath && external_node_path_.dirname(filePath);
-}
-
-;// CONCATENATED MODULE: ../../node_modules/.pnpm/find-cache-dir@4.0.0/node_modules/find-cache-dir/index.js
-
-
-
-
-
-
-const {env, cwd} = external_node_process_;
-
-const isWritable = path => {
-	try {
-		external_node_fs_.accessSync(path, external_node_fs_.constants.W_OK);
-		return true;
-	} catch {
-		return false;
-	}
-};
-
-function useDirectory(directory, options) {
-	if (options.create) {
-		external_node_fs_.mkdirSync(directory, {recursive: true});
-	}
-
-	if (options.thunk) {
-		return (...arguments_) => external_node_path_.join(directory, ...arguments_);
-	}
-
-	return directory;
-}
-
-function getNodeModuleDirectory(directory) {
-	const nodeModules = external_node_path_.join(directory, 'node_modules');
-
-	if (
-		!isWritable(nodeModules)
-			&& (external_node_fs_.existsSync(nodeModules) || !isWritable(external_node_path_.join(directory)))
-	) {
-		return;
-	}
-
-	return nodeModules;
-}
-
-function findCacheDirectory(options = {}) {
-	if (env.CACHE_DIR && !['true', 'false', '1', '0'].includes(env.CACHE_DIR)) {
-		return useDirectory(external_node_path_.join(env.CACHE_DIR, options.name), options);
-	}
-
-	let {cwd: directory = cwd()} = options;
-
-	if (options.files) {
-		directory = common_path_prefix(options.files.map(file => external_node_path_.resolve(directory, file)));
-	}
-
-	directory = packageDirectorySync({cwd: directory});
-
-	if (!directory) {
-		return;
-	}
-
-	const nodeModules = getNodeModuleDirectory(directory);
-	if (!nodeModules) {
-		return;
-	}
-
-	return useDirectory(external_node_path_.join(directory, 'node_modules', '.cache', options.name), options);
-}
-
-
-/***/ })
-
-};
-;