@rsbuild/plugin-babel 1.0.4 → 1.0.6

package/compiled/babel-loader/index.js

@@ -1,6 +1,6 @@
 (() => {
   var __webpack_modules__ = {
-    73: (module) => {
+    698: (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__) => {
+    846: (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__(80);
+      const serialize = __nccwpck_require__(786);
       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__) => {
+    448: (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__(846);
+      const transform = __nccwpck_require__(80);
+      const injectCaller = __nccwpck_require__(976);
+      const schema = __nccwpck_require__(690);
       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) => {
+    976: (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__) => {
+    786: (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;
+        }
+      };
+    },
+    80: (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__(698);
       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) => {
+    690: (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__(448);
   module.exports = __webpack_exports__;
 })();