@unpackjs/core 1.5.4 → 1.6.0

package/compiled/webpack-merge/license

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Juho Vepsalainen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/compiled/webpack-merge/package.json

@@ -0,0 +1 @@
+{"name":"webpack-merge","author":"Juho Vepsalainen <bebraw@gmail.com>","version":"6.0.1","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/dist/bundleRequire.cjs

@@ -0,0 +1,200 @@
+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 bundleRequire_exports = {};
+__export(bundleRequire_exports, {
+  bundleRequire: () => bundleRequire,
+  isBuiltin: () => isBuiltin,
+  isFilePathESM: () => isFilePathESM,
+  isNodeBuiltin: () => isNodeBuiltin
+});
+module.exports = __toCommonJS(bundleRequire_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var import_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_node_util = require("node:util");
+var import_esbuild = require("esbuild");
+const promisifiedRealpath = (0, import_node_util.promisify)(import_node_fs.default.realpath);
+async function bundleRequire(resolvedPath) {
+  const isESM = isFilePathESM(resolvedPath);
+  const bundled = await bundleConfigFile(resolvedPath, isESM);
+  const userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code, isESM);
+  return userConfig;
+}
+async function bundleConfigFile(fileName, isESM) {
+  const dirnameVarName = "__injected_original_dirname";
+  const filenameVarName = "__injected_original_filename";
+  const importMetaUrlVarName = "__injected_original_import_meta_url";
+  const result = await (0, import_esbuild.build)({
+    absWorkingDir: process.cwd(),
+    entryPoints: [fileName],
+    write: false,
+    target: ["node18"],
+    platform: "node",
+    bundle: true,
+    format: isESM ? "esm" : "cjs",
+    mainFields: ["main"],
+    sourcemap: "inline",
+    metafile: true,
+    define: {
+      __dirname: dirnameVarName,
+      __filename: filenameVarName,
+      "import.meta.url": importMetaUrlVarName,
+      "import.meta.dirname": dirnameVarName,
+      "import.meta.filename": filenameVarName
+    },
+    plugins: [
+      {
+        name: "externalize-deps",
+        setup(build2) {
+          build2.onResolve({ filter: /^[^.].*/ }, async ({ path: id, kind }) => {
+            if (kind === "entry-point" || import_node_path.default.isAbsolute(id) || isNodeBuiltin(id)) {
+              return;
+            }
+            if (isBuiltin(id)) {
+              return { external: true };
+            }
+            const isImport = isESM || kind === "dynamic-import";
+            let idFsPath;
+            if (!isImport) {
+              const canResolveWithImport = false;
+              if (canResolveWithImport) {
+                throw new Error(
+                  `Failed to resolve ${JSON.stringify(
+                    id
+                  )}. This package is ESM only but it was tried to load by \`require\`.`
+                );
+              }
+            }
+            if (idFsPath && isImport) {
+              idFsPath = (0, import_node_url.pathToFileURL)(idFsPath).href;
+            }
+            if (idFsPath && !isImport && isFilePathESM(idFsPath)) {
+              throw new Error(
+                `${JSON.stringify(
+                  id
+                )} resolved to an ESM file. ESM file cannot be loaded by \`require\`.`
+              );
+            }
+            return {
+              path: idFsPath,
+              external: true
+            };
+          });
+        }
+      },
+      {
+        name: "inject-file-scope-variables",
+        setup(build2) {
+          build2.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
+            const contents = import_node_fs.default.readFileSync(args.path, "utf-8");
+            const injectValues = `const ${dirnameVarName} = ${JSON.stringify(import_node_path.default.dirname(args.path))};const ${filenameVarName} = ${JSON.stringify(args.path)};const ${importMetaUrlVarName} = ${JSON.stringify((0, import_node_url.pathToFileURL)(args.path).href)};`;
+            return {
+              loader: args.path.endsWith("ts") ? "ts" : "js",
+              contents: injectValues + contents
+            };
+          });
+        }
+      }
+    ]
+  });
+  const { text } = result.outputFiles[0];
+  return {
+    code: text,
+    dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+  };
+}
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+  if (isESM) {
+    const fileBase = `${fileName}.timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const fileNameTmp = `${fileBase}.mjs`;
+    const fileUrl = `${(0, import_node_url.pathToFileURL)(fileBase)}.mjs`;
+    import_node_fs.default.writeFileSync(fileNameTmp, bundledCode);
+    try {
+      return (await import(fileUrl)).default;
+    } finally {
+      import_node_fs.default.unlink(fileNameTmp, () => {
+      });
+    }
+  } else {
+    const extension = import_node_path.default.extname(fileName);
+    const realFileName = await promisifiedRealpath(fileName);
+    const loaderExt = extension in require.extensions ? extension : ".js";
+    const defaultLoader = require.extensions[loaderExt];
+    require.extensions[loaderExt] = (module2, filename) => {
+      if (filename === realFileName) {
+        ;
+        module2._compile(bundledCode, filename);
+      } else {
+        defaultLoader(module2, filename);
+      }
+    };
+    delete require.cache[require.resolve(fileName)];
+    const raw = require(fileName);
+    require.extensions[loaderExt] = defaultLoader;
+    return raw.__esModule ? raw.default : raw;
+  }
+}
+function isFilePathESM(filePath) {
+  if (/\.m[jt]s$/.test(filePath)) {
+    return true;
+  }
+  if (/\.c[jt]s$/.test(filePath)) {
+    return false;
+  }
+  try {
+    const pkgPath = import_node_path.default.join(import_node_path.default.dirname(filePath), "package.json");
+    const pkgData = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf-8"));
+    return pkgData.type === "module";
+  } catch {
+    return false;
+  }
+}
+const NODE_BUILTIN_NAMESPACE = "node:";
+const NPM_BUILTIN_NAMESPACE = "npm:";
+const BUN_BUILTIN_NAMESPACE = "bun:";
+const nodeBuiltins = import_node_module.builtinModules.filter((id) => !id.includes(":"));
+function isBuiltin(id) {
+  if (process.versions.deno && id.startsWith(NPM_BUILTIN_NAMESPACE))
+    return true;
+  if (process.versions.bun && id.startsWith(BUN_BUILTIN_NAMESPACE))
+    return true;
+  return isNodeBuiltin(id);
+}
+function isNodeBuiltin(id) {
+  if (id.startsWith(NODE_BUILTIN_NAMESPACE))
+    return true;
+  return nodeBuiltins.includes(id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bundleRequire,
+  isBuiltin,
+  isFilePathESM,
+  isNodeBuiltin
+});

package/dist/bundleRequire.d.ts

@@ -0,0 +1,5 @@
+export declare function bundleRequire(resolvedPath: string): Promise<any>;
+export declare function isFilePathESM(filePath: string): boolean;
+export declare function isBuiltin(id: string): boolean;
+export declare function isNodeBuiltin(id: string): boolean;
+//# sourceMappingURL=bundleRequire.d.ts.map

package/dist/bundleRequire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleRequire.d.ts","sourceRoot":"","sources":["../src/bundleRequire.ts"],"names":[],"mappings":"AAQA,wBAAsB,aAAa,CAAC,YAAY,EAAE,MAAM,gBAKvD;AAgJD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAevD;AAWD,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAI7C;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAGjD"}

package/dist/bundleRequire.js

@@ -0,0 +1,173 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import path2 from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { build } from "esbuild";
+const promisifiedRealpath = promisify(fs.realpath);
+async function bundleRequire(resolvedPath) {
+  const isESM = isFilePathESM(resolvedPath);
+  const bundled = await bundleConfigFile(resolvedPath, isESM);
+  const userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code, isESM);
+  return userConfig;
+}
+async function bundleConfigFile(fileName, isESM) {
+  const dirnameVarName = "__injected_original_dirname";
+  const filenameVarName = "__injected_original_filename";
+  const importMetaUrlVarName = "__injected_original_import_meta_url";
+  const result = await build({
+    absWorkingDir: process.cwd(),
+    entryPoints: [fileName],
+    write: false,
+    target: ["node18"],
+    platform: "node",
+    bundle: true,
+    format: isESM ? "esm" : "cjs",
+    mainFields: ["main"],
+    sourcemap: "inline",
+    metafile: true,
+    define: {
+      __dirname: dirnameVarName,
+      __filename: filenameVarName,
+      "import.meta.url": importMetaUrlVarName,
+      "import.meta.dirname": dirnameVarName,
+      "import.meta.filename": filenameVarName
+    },
+    plugins: [
+      {
+        name: "externalize-deps",
+        setup(build2) {
+          build2.onResolve({ filter: /^[^.].*/ }, async ({ path: id, kind }) => {
+            if (kind === "entry-point" || path2.isAbsolute(id) || isNodeBuiltin(id)) {
+              return;
+            }
+            if (isBuiltin(id)) {
+              return { external: true };
+            }
+            const isImport = isESM || kind === "dynamic-import";
+            let idFsPath;
+            if (!isImport) {
+              const canResolveWithImport = false;
+              if (canResolveWithImport) {
+                throw new Error(
+                  `Failed to resolve ${JSON.stringify(
+                    id
+                  )}. This package is ESM only but it was tried to load by \`require\`.`
+                );
+              }
+            }
+            if (idFsPath && isImport) {
+              idFsPath = pathToFileURL(idFsPath).href;
+            }
+            if (idFsPath && !isImport && isFilePathESM(idFsPath)) {
+              throw new Error(
+                `${JSON.stringify(
+                  id
+                )} resolved to an ESM file. ESM file cannot be loaded by \`require\`.`
+              );
+            }
+            return {
+              path: idFsPath,
+              external: true
+            };
+          });
+        }
+      },
+      {
+        name: "inject-file-scope-variables",
+        setup(build2) {
+          build2.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
+            const contents = fs.readFileSync(args.path, "utf-8");
+            const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path2.dirname(args.path))};const ${filenameVarName} = ${JSON.stringify(args.path)};const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
+            return {
+              loader: args.path.endsWith("ts") ? "ts" : "js",
+              contents: injectValues + contents
+            };
+          });
+        }
+      }
+    ]
+  });
+  const { text } = result.outputFiles[0];
+  return {
+    code: text,
+    dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+  };
+}
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+  if (isESM) {
+    const fileBase = `${fileName}.timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const fileNameTmp = `${fileBase}.mjs`;
+    const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
+    fs.writeFileSync(fileNameTmp, bundledCode);
+    try {
+      return (await import(fileUrl)).default;
+    } finally {
+      fs.unlink(fileNameTmp, () => {
+      });
+    }
+  } else {
+    const extension = path2.extname(fileName);
+    const realFileName = await promisifiedRealpath(fileName);
+    const loaderExt = extension in require.extensions ? extension : ".js";
+    const defaultLoader = require.extensions[loaderExt];
+    require.extensions[loaderExt] = (module, filename) => {
+      if (filename === realFileName) {
+        ;
+        module._compile(bundledCode, filename);
+      } else {
+        defaultLoader(module, filename);
+      }
+    };
+    delete require.cache[require.resolve(fileName)];
+    const raw = require(fileName);
+    require.extensions[loaderExt] = defaultLoader;
+    return raw.__esModule ? raw.default : raw;
+  }
+}
+function isFilePathESM(filePath) {
+  if (/\.m[jt]s$/.test(filePath)) {
+    return true;
+  }
+  if (/\.c[jt]s$/.test(filePath)) {
+    return false;
+  }
+  try {
+    const pkgPath = path2.join(path2.dirname(filePath), "package.json");
+    const pkgData = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return pkgData.type === "module";
+  } catch {
+    return false;
+  }
+}
+const NODE_BUILTIN_NAMESPACE = "node:";
+const NPM_BUILTIN_NAMESPACE = "npm:";
+const BUN_BUILTIN_NAMESPACE = "bun:";
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+function isBuiltin(id) {
+  if (process.versions.deno && id.startsWith(NPM_BUILTIN_NAMESPACE))
+    return true;
+  if (process.versions.bun && id.startsWith(BUN_BUILTIN_NAMESPACE))
+    return true;
+  return isNodeBuiltin(id);
+}
+function isNodeBuiltin(id) {
+  if (id.startsWith(NODE_BUILTIN_NAMESPACE))
+    return true;
+  return nodeBuiltins.includes(id);
+}
+export {
+  bundleRequire,
+  isBuiltin,
+  isFilePathESM,
+  isNodeBuiltin
+};

package/dist/bundler-config/chunkSplit.cjs

@@ -0,0 +1,151 @@
+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 chunkSplit_exports = {};
+__export(chunkSplit_exports, {
+  addChunkSplitSupport: () => addChunkSplitSupport
+});
+module.exports = __toCommonJS(chunkSplit_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_constants = require("../constants.cjs");
+var import_utils = require("../utils.cjs");
+function getForceSplittingGroups(forceSplitting) {
+  const cacheGroups = {};
+  const pairs = Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index) => [`force-split-${index}`, regexp]) : Object.entries(forceSplitting);
+  for (const [key, regexp] of pairs) {
+    cacheGroups[key] = {
+      test: regexp,
+      name: key,
+      chunks: "all",
+      priority: 0,
+      // Ignore minimum size, minimum chunks and maximum requests and always create chunks.
+      enforce: true
+    };
+  }
+  return cacheGroups;
+}
+function splitByExperience(ctx) {
+  const { defaultConfig, forceSplittingGroups } = ctx;
+  const experienceCacheGroup = {};
+  const packageRegExps = {
+    axios: /node_modules[\\/]axios(-.+)?[\\/]/
+  };
+  packageRegExps.polyfill = /node_modules[\\/](?:tslib|core-js|@swc[\\/]helpers)[\\/]/;
+  for (const [name, test] of Object.entries(packageRegExps)) {
+    const key = `lib-${name}`;
+    experienceCacheGroup[key] = {
+      test,
+      priority: 0,
+      name: key
+    };
+  }
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...experienceCacheGroup,
+      ...forceSplittingGroups
+    }
+  };
+}
+function splitBySize(ctx) {
+  const { forceSplittingGroups, defaultConfig, chunkSplit } = ctx;
+  (0, import_node_assert.default)(chunkSplit.strategy === "split-by-size");
+  return {
+    ...defaultConfig,
+    minSize: chunkSplit.minSize ?? 0,
+    maxSize: chunkSplit.maxSize ?? Number.POSITIVE_INFINITY,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...forceSplittingGroups
+    }
+  };
+}
+function splitCustom(ctx) {
+  const { forceSplittingGroups, defaultConfig } = ctx;
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...forceSplittingGroups
+    }
+  };
+}
+function singleVendor(ctx) {
+  const { defaultConfig, forceSplittingGroups } = ctx;
+  const singleVendorCacheGroup = {
+    singleVendor: {
+      test: import_constants.NODE_MODULES_REGEX,
+      priority: 0,
+      chunks: "all",
+      name: "vendor",
+      enforce: true
+    }
+  };
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...singleVendorCacheGroup,
+      ...forceSplittingGroups
+    }
+  };
+}
+const SPLIT_STRATEGY_DISPATCHER = {
+  "split-by-experience": splitByExperience,
+  "split-by-size": splitBySize,
+  custom: splitCustom,
+  "single-vendor": singleVendor
+};
+const addChunkSplitSupport = ({
+  config,
+  unpackConfig
+}) => {
+  const defaultConfig = {};
+  const { chunkSplit } = unpackConfig.performance || {};
+  if (chunkSplit?.strategy) {
+    let forceSplittingGroups = {};
+    if (chunkSplit?.forceSplitting) {
+      forceSplittingGroups = getForceSplittingGroups(chunkSplit.forceSplitting);
+    }
+    const splitChunksOptions = SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
+      defaultConfig,
+      forceSplittingGroups,
+      chunkSplit
+    });
+    (0, import_utils.setValueByPath)(config, ["optimization", "splitChunks"], splitChunksOptions);
+  }
+  return config;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addChunkSplitSupport
+});

package/dist/bundler-config/chunkSplit.d.ts

@@ -0,0 +1,6 @@
+import type { BundlerConfiguration, UnpackConfig } from '../types/index';
+export declare const addChunkSplitSupport: ({ config, unpackConfig, }: {
+    config: BundlerConfiguration;
+    unpackConfig: UnpackConfig;
+}) => BundlerConfiguration;
+//# sourceMappingURL=chunkSplit.d.ts.map

package/dist/bundler-config/chunkSplit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkSplit.d.ts","sourceRoot":"","sources":["../../src/bundler-config/chunkSplit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EAKpB,YAAY,EACb,MAAM,iBAAiB,CAAA;AAmIxB,eAAO,MAAM,oBAAoB,8BAG9B;IACD,MAAM,EAAE,oBAAoB,CAAA;IAC5B,YAAY,EAAE,YAAY,CAAA;CAC3B,KAAG,oBAgBH,CAAA"}

package/dist/bundler-config/chunkSplit.js

@@ -0,0 +1,127 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+import assert from "node:assert";
+import { NODE_MODULES_REGEX } from "../constants.js";
+import { setValueByPath } from "../utils.js";
+function getForceSplittingGroups(forceSplitting) {
+  const cacheGroups = {};
+  const pairs = Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index) => [`force-split-${index}`, regexp]) : Object.entries(forceSplitting);
+  for (const [key, regexp] of pairs) {
+    cacheGroups[key] = {
+      test: regexp,
+      name: key,
+      chunks: "all",
+      priority: 0,
+      // Ignore minimum size, minimum chunks and maximum requests and always create chunks.
+      enforce: true
+    };
+  }
+  return cacheGroups;
+}
+function splitByExperience(ctx) {
+  const { defaultConfig, forceSplittingGroups } = ctx;
+  const experienceCacheGroup = {};
+  const packageRegExps = {
+    axios: /node_modules[\\/]axios(-.+)?[\\/]/
+  };
+  packageRegExps.polyfill = /node_modules[\\/](?:tslib|core-js|@swc[\\/]helpers)[\\/]/;
+  for (const [name, test] of Object.entries(packageRegExps)) {
+    const key = `lib-${name}`;
+    experienceCacheGroup[key] = {
+      test,
+      priority: 0,
+      name: key
+    };
+  }
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...experienceCacheGroup,
+      ...forceSplittingGroups
+    }
+  };
+}
+function splitBySize(ctx) {
+  const { forceSplittingGroups, defaultConfig, chunkSplit } = ctx;
+  assert(chunkSplit.strategy === "split-by-size");
+  return {
+    ...defaultConfig,
+    minSize: chunkSplit.minSize ?? 0,
+    maxSize: chunkSplit.maxSize ?? Number.POSITIVE_INFINITY,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...forceSplittingGroups
+    }
+  };
+}
+function splitCustom(ctx) {
+  const { forceSplittingGroups, defaultConfig } = ctx;
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...forceSplittingGroups
+    }
+  };
+}
+function singleVendor(ctx) {
+  const { defaultConfig, forceSplittingGroups } = ctx;
+  const singleVendorCacheGroup = {
+    singleVendor: {
+      test: NODE_MODULES_REGEX,
+      priority: 0,
+      chunks: "all",
+      name: "vendor",
+      enforce: true
+    }
+  };
+  return {
+    ...defaultConfig,
+    // @ts-ignore
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...singleVendorCacheGroup,
+      ...forceSplittingGroups
+    }
+  };
+}
+const SPLIT_STRATEGY_DISPATCHER = {
+  "split-by-experience": splitByExperience,
+  "split-by-size": splitBySize,
+  custom: splitCustom,
+  "single-vendor": singleVendor
+};
+const addChunkSplitSupport = ({
+  config,
+  unpackConfig
+}) => {
+  const defaultConfig = {};
+  const { chunkSplit } = unpackConfig.performance || {};
+  if (chunkSplit?.strategy) {
+    let forceSplittingGroups = {};
+    if (chunkSplit?.forceSplitting) {
+      forceSplittingGroups = getForceSplittingGroups(chunkSplit.forceSplitting);
+    }
+    const splitChunksOptions = SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
+      defaultConfig,
+      forceSplittingGroups,
+      chunkSplit
+    });
+    setValueByPath(config, ["optimization", "splitChunks"], splitChunksOptions);
+  }
+  return config;
+};
+export {
+  addChunkSplitSupport
+};