@unpackjs/core 1.7.4 → 1.7.6

package/dist/prebundleDeps.cjs

@@ -1,350 +1,340 @@
-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 prebundleDeps_exports = {};
-__export(prebundleDeps_exports, {
-  prebundleDeps: () => prebundleDeps
-});
-module.exports = __toCommonJS(prebundleDeps_exports);
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
-var import_core = require("@rspack/core");
-var import_cors = __toESM(require("cors"));
-var import_express = __toESM(require("express"));
-var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
-var import_tinyglobby = require("tinyglobby");
-var import_colors = __toESM(require("./colors.cjs"));
-var import_constants = require("./constants.cjs");
-var import_logger = require("./logger.cjs");
-var import_utils = require("./utils.cjs");
-const app = (0, import_express.default)();
-app.use((0, import_cors.default)());
-const CACHE_DIR = "umd";
-const externalAlias = {
-  react: "React",
-  "react-dom": "ReactDOM",
-  "react-router": "ReactRouter",
-  "react-router-dom": "ReactRouterDOM"
-};
-const count = {
-  total: 0,
-  bundled: 0
-};
-const failedDeps = [];
-const noEntryDeps = [];
-const updateProgress = () => {
-  (0, import_utils.logUpdate)(
-    `${import_colors.default.magenta(import_colors.default.bold("»"))} Optimizing dependencies (${count.bundled}/${count.total})`
-  );
-  if (count.total === count.bundled + failedDeps.length) {
-    console.log();
-  }
-};
-const getExternalLibraryName = (pkgName) => {
-  return externalAlias[pkgName] || pkgName;
-};
-const getExternalValue = (pkgName) => {
-  return `window ${getExternalLibraryName(pkgName)}`;
-};
-const bundleDep = ({
-  root,
-  name,
-  entry,
-  version
-}) => {
-  return new Promise((resolve) => {
-    const pkgDir = import_node_path.default.resolve(root, import_constants.TEMP_DIR, CACHE_DIR, name);
-    const outDir = import_node_path.default.resolve(pkgDir, version);
-    const getResult = () => {
-      const assets = (0, import_tinyglobby.globSync)("**/index.{js,css}", {
-        cwd: outDir,
-        absolute: true
-      });
-      return {
-        name,
-        assets
-      };
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
     };
-    if (import_node_fs.default.existsSync(outDir)) {
-      resolve(getResult());
-      return;
-    }
-    (0, import_utils.removeDir)(pkgDir);
-    count.total++;
-    updateProgress();
-    const getSwcOptions = ({ tsx }) => {
-      return {
-        jsc: {
-          parser: {
-            tsx,
-            syntax: "typescript",
-            dynamicImport: true,
-            decorators: true
-          },
-          transform: {
-            react: {
-              runtime: "automatic"
-            }
-          }
-        }
-      };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
     };
-    const compiler = (0, import_core.rspack)({
-      entry: {
-        index: entry
-      },
-      context: root,
-      mode: "development",
-      output: {
-        clean: true,
-        path: outDir,
-        pathinfo: false,
-        library: {
-          name: getExternalLibraryName(name),
-          type: "umd",
-          umdNamedDefine: true
-        },
-        globalObject: "this"
-      },
-      devtool: false,
-      module: {
-        rules: [
-          {
-            test: /\.(j|t)s$/,
-            use: [
-              {
-                loader: "builtin:swc-loader",
-                options: getSwcOptions({ tsx: false })
-              }
-            ]
-          },
-          {
-            test: /\.(j|t)sx$/,
-            use: [
-              {
-                loader: "builtin:swc-loader",
-                options: getSwcOptions({ tsx: true })
-              }
-            ]
-          },
-          {
-            test: /\.less$/,
-            type: "css/auto",
-            use: [
-              {
-                loader: (0, import_utils.getCompiledPkgPath)("less-loader"),
-                options: {
-                  lessOptions: {
-                    javascriptEnabled: true
-                  },
-                  implementation: (0, import_utils.getUserDepPath)(root, "less")
-                }
-              }
-            ]
-          },
-          {
-            test: /\.s[ac]ss$/i,
-            type: "css/auto",
-            use: [
-              {
-                loader: (0, import_utils.getCompiledPkgPath)("sass-loader"),
-                options: {
-                  api: "modern-compiler",
-                  implementation: (0, import_utils.getUserDepPath)(root, ["sass-embedded", "sass"])
-                }
-              }
-            ]
-          }
-        ]
-      },
-      optimization: {
-        splitChunks: false
-      },
-      experiments: {
-        css: true
-      },
-      externals: {
-        react: getExternalValue("react"),
-        "react-dom": getExternalValue("react-dom")
-      }
-    });
-    compiler.run((_, stats) => {
-      let isFailed = false;
-      if (stats?.hasErrors()) {
-        isFailed = true;
-        failedDeps.push(name);
-        (0, import_utils.removeDir)(outDir);
-      } else {
-        count.bundled++;
-      }
-      updateProgress();
-      compiler.close(() => {
-        resolve(!isFailed ? getResult() : void 0);
-      });
-    });
-  });
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    prebundleDeps: ()=>prebundleDeps
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const core_namespaceObject = require("@rspack/core");
+const external_cors_namespaceObject = require("cors");
+var external_cors_default = /*#__PURE__*/ __webpack_require__.n(external_cors_namespaceObject);
+const external_express_namespaceObject = require("express");
+var external_express_default = /*#__PURE__*/ __webpack_require__.n(external_express_namespaceObject);
+const external_html_webpack_plugin_namespaceObject = require("html-webpack-plugin");
+var external_html_webpack_plugin_default = /*#__PURE__*/ __webpack_require__.n(external_html_webpack_plugin_namespaceObject);
+const external_tinyglobby_namespaceObject = require("tinyglobby");
+const external_colors_cjs_namespaceObject = require("./colors.cjs");
+var external_colors_cjs_default = /*#__PURE__*/ __webpack_require__.n(external_colors_cjs_namespaceObject);
+const external_constants_cjs_namespaceObject = require("./constants.cjs");
+const external_global_cjs_namespaceObject = require("./global.cjs");
+const external_logger_cjs_namespaceObject = require("./logger.cjs");
+const external_utils_cjs_namespaceObject = require("./utils.cjs");
+const CACHE_DIR = 'umd';
+const getExternalLibraryName = (pkgName)=>{
+    const externalAlias = {
+        react: 'React',
+        'react-dom': 'ReactDOM',
+        'react-router': 'ReactRouter',
+        'react-router-dom': 'ReactRouterDOM'
+    };
+    return externalAlias[pkgName] || pkgName;
 };
-const getExistExternals = (externals) => {
-  const existExternals = /* @__PURE__ */ new Set();
-  if (Array.isArray(externals)) {
-    externals.forEach((item) => {
-      if ((0, import_utils.isPlainObject)(item)) {
-        Object.keys(item).forEach((key) => existExternals.add(key));
-      }
+const getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`;
+const getExistExternals = (externals)=>{
+    const existExternals = new Set();
+    if (Array.isArray(externals)) externals.forEach((item)=>{
+        if ((0, external_utils_cjs_namespaceObject.isPlainObject)(item)) Object.keys(item).forEach((key)=>existExternals.add(key));
     });
-  } else if ((0, import_utils.isPlainObject)(externals)) {
-    Object.keys(externals).forEach((key) => existExternals.add(key));
-  }
-  return Array.from(existExternals);
+    else if ((0, external_utils_cjs_namespaceObject.isPlainObject)(externals)) Object.keys(externals).forEach((key)=>existExternals.add(key));
+    return Array.from(existExternals);
 };
-const getPkgEntry = (packageJson) => {
-  if (packageJson.module)
-    return packageJson.module;
-  if (packageJson.exports) {
-    if ((0, import_utils.isString)(packageJson.exports))
-      return packageJson.exports;
-    const defaultExport = packageJson.exports["."];
-    if (defaultExport) {
-      if ((0, import_utils.isString)(defaultExport))
-        return defaultExport;
-      if ((0, import_utils.isString)(defaultExport.import))
-        return defaultExport.import;
-      if ((0, import_utils.isString)(defaultExport.browser))
-        return defaultExport.browser;
-      if ((0, import_utils.isString)(defaultExport.default))
-        return defaultExport.default;
+const getPkgEntry = (packageJson)=>{
+    if (packageJson.module) return packageJson.module;
+    if (packageJson.exports) {
+        if ((0, external_utils_cjs_namespaceObject.isString)(packageJson.exports)) return packageJson.exports;
+        const defaultExport = packageJson.exports['.'];
+        if (defaultExport) {
+            if ((0, external_utils_cjs_namespaceObject.isString)(defaultExport)) return defaultExport;
+            if ((0, external_utils_cjs_namespaceObject.isString)(defaultExport.import)) return defaultExport.import;
+            if ((0, external_utils_cjs_namespaceObject.isString)(defaultExport.browser)) return defaultExport.browser;
+            if ((0, external_utils_cjs_namespaceObject.isString)(defaultExport.default)) return defaultExport.default;
+        }
+        if ((0, external_utils_cjs_namespaceObject.isString)(packageJson.exports.default)) return packageJson.exports.default;
     }
-    if ((0, import_utils.isString)(packageJson.exports.default))
-      return packageJson.exports.default;
-  }
-  if (packageJson.main)
-    return packageJson.main;
+    if (packageJson.main) return packageJson.main;
 };
-const prebundleDeps = async ({
-  unpackConfig
-}) => {
-  const userOptions = (0, import_utils.isPlainObject)(unpackConfig.dev?.prebundle) ? unpackConfig.dev.prebundle : {};
-  const { root } = unpackConfig;
-  const packageJson = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.resolve(root, "package.json"), "utf-8"));
-  const existExternals = getExistExternals(unpackConfig.externals);
-  const excludeDeps = [...existExternals || [], ...userOptions.exclude || []];
-  const shouldIncludeDeps = Object.keys(packageJson.dependencies).filter(
-    (pkgName) => !excludeDeps.includes(pkgName)
-  );
-  const needBundleDeps = shouldIncludeDeps.map((pkgName) => {
-    const packageJson2 = JSON.parse(
-      import_node_fs.default.readFileSync(import_node_path.default.resolve(root, "node_modules", pkgName, "package.json"), "utf-8")
-    );
-    const entry = getPkgEntry(packageJson2);
-    if (!entry) {
-      noEntryDeps.push(pkgName);
-      return;
-    }
-    return {
-      name: pkgName,
-      entry: import_node_path.default.resolve(root, "node_modules", pkgName, entry),
-      version: packageJson2.version
+const prebundleDeps = async ({ unpackConfig })=>{
+    var _unpackConfig_dev;
+    const count = {
+        total: 0,
+        bundled: 0
+    };
+    const failedDeps = [];
+    const updateProgress = ()=>{
+        (0, external_utils_cjs_namespaceObject.logUpdate)(`${external_colors_cjs_default().magenta(external_colors_cjs_default().bold('»'))} Optimizing dependencies (${count.bundled}/${count.total})`);
+        if (count.total === count.bundled + failedDeps.length) console.log();
     };
-  }).filter(Boolean);
-  if (noEntryDeps[0]) {
-    import_logger.logger.warn(`Could not find entry for "${import_colors.default.bold(noEntryDeps.join(", "))}"`);
-  }
-  const bundledDeps = await Promise.all(
-    needBundleDeps.map((depInfo) => bundleDep({ root, ...depInfo }))
-  );
-  if (failedDeps[0]) {
-    import_logger.logger.warn(`Something went wrong while optimizing "${import_colors.default.bold(failedDeps.join(", "))}"`);
-  }
-  const cachePath = import_node_path.default.resolve(root, import_constants.TEMP_DIR, CACHE_DIR);
-  app.use(`/${CACHE_DIR}`, import_express.default.static(cachePath));
-  const port = await (0, import_utils.getPort)(3200);
-  app.listen(port, () => {
-  });
-  const externals = {};
-  const jsAssets = [];
-  const cssAssets = [];
-  const preJsAssets = [];
-  const ipv4Interfaces = (0, import_utils.getIpv4Interfaces)();
-  bundledDeps.filter(Boolean).forEach((dep) => {
-    externals[dep.name] = getExternalValue(dep.name);
-    dep.assets.forEach((absPath) => {
-      const relativePath = import_node_path.default.relative(cachePath, absPath);
-      const preDeps = ["react", "react-dom", "react-router", "react-router-dom"];
-      const serverPath = `//${ipv4Interfaces[1].address}:${port}/${CACHE_DIR}/${relativePath}`;
-      switch (import_node_path.default.extname(relativePath)) {
-        case ".js":
-          if (preDeps.includes(dep.name)) {
-            preJsAssets.push({
-              path: serverPath,
-              order: preDeps.indexOf(dep.name)
+    const { root } = unpackConfig;
+    const bundleDep = ({ name, entry, version })=>new Promise((resolve)=>{
+            const pkgDir = external_node_path_default().resolve(root, external_constants_cjs_namespaceObject.TEMP_DIR, CACHE_DIR, name);
+            const outDir = external_node_path_default().resolve(pkgDir, version);
+            const getResult = ()=>{
+                const assets = (0, external_tinyglobby_namespaceObject.globSync)('**/index.{js,css}', {
+                    cwd: outDir,
+                    absolute: true
+                });
+                return {
+                    name,
+                    assets
+                };
+            };
+            if (external_node_fs_default().existsSync(outDir)) {
+                resolve(getResult());
+                return;
+            }
+            (0, external_utils_cjs_namespaceObject.removeDir)(pkgDir);
+            count.total++;
+            updateProgress();
+            const getSwcOptions = ({ tsx })=>({
+                    jsc: {
+                        parser: {
+                            tsx,
+                            syntax: "typescript",
+                            dynamicImport: true,
+                            decorators: true
+                        },
+                        transform: {
+                            react: {
+                                runtime: 'automatic'
+                            }
+                        }
+                    }
+                });
+            const compiler = (0, core_namespaceObject.rspack)({
+                entry: {
+                    index: entry
+                },
+                context: root,
+                mode: 'development',
+                output: {
+                    clean: true,
+                    path: outDir,
+                    pathinfo: false,
+                    library: {
+                        name: getExternalLibraryName(name),
+                        type: 'umd',
+                        umdNamedDefine: true
+                    },
+                    globalObject: 'this'
+                },
+                devtool: false,
+                module: {
+                    rules: [
+                        {
+                            test: /\.(j|t)s$/,
+                            use: [
+                                {
+                                    loader: 'builtin:swc-loader',
+                                    options: getSwcOptions({
+                                        tsx: false
+                                    })
+                                }
+                            ]
+                        },
+                        {
+                            test: /\.(j|t)sx$/,
+                            use: [
+                                {
+                                    loader: 'builtin:swc-loader',
+                                    options: getSwcOptions({
+                                        tsx: true
+                                    })
+                                }
+                            ]
+                        },
+                        {
+                            test: /\.less$/,
+                            type: 'css/auto',
+                            use: [
+                                {
+                                    loader: (0, external_utils_cjs_namespaceObject.getCompiledPkgPath)('less-loader'),
+                                    options: {
+                                        lessOptions: {
+                                            javascriptEnabled: true
+                                        },
+                                        implementation: (0, external_utils_cjs_namespaceObject.getUserDepPath)(root, 'less')
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            test: /\.s[ac]ss$/i,
+                            type: 'css/auto',
+                            use: [
+                                {
+                                    loader: (0, external_utils_cjs_namespaceObject.getCompiledPkgPath)('sass-loader'),
+                                    options: {
+                                        api: 'modern-compiler',
+                                        implementation: (0, external_utils_cjs_namespaceObject.getUserDepPath)(root, [
+                                            'sass-embedded',
+                                            'sass'
+                                        ])
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                optimization: {
+                    splitChunks: false
+                },
+                experiments: {
+                    css: true
+                },
+                externals: {
+                    react: getExternalValue('react'),
+                    'react-dom': getExternalValue('react-dom'),
+                    'react-router': getExternalValue('react-router'),
+                    'react-router-dom': getExternalValue('react-router-dom')
+                }
             });
-          } else {
-            jsAssets.push(serverPath);
-          }
-          break;
-        case ".css":
-          cssAssets.push(serverPath);
-          break;
-        default:
-          break;
-      }
+            compiler.run((_, stats)=>{
+                let isFailed = false;
+                if (null == stats ? void 0 : stats.hasErrors()) {
+                    isFailed = true;
+                    failedDeps.push(name);
+                    (0, external_utils_cjs_namespaceObject.removeDir)(outDir);
+                } else count.bundled++;
+                updateProgress();
+                compiler.close(()=>{
+                    resolve(isFailed ? void 0 : getResult());
+                });
+            });
+        });
+    const userOptions = (0, external_utils_cjs_namespaceObject.isPlainObject)(null === (_unpackConfig_dev = unpackConfig.dev) || void 0 === _unpackConfig_dev ? void 0 : _unpackConfig_dev.prebundle) ? unpackConfig.dev.prebundle : {};
+    const packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().resolve(root, 'package.json'), 'utf-8'));
+    const existExternals = getExistExternals(unpackConfig.externals);
+    const excludeDeps = [
+        ...existExternals || [],
+        ...userOptions.exclude || []
+    ];
+    const shouldIncludeDeps = Object.keys(packageJson.dependencies).filter((pkgName)=>!excludeDeps.includes(pkgName));
+    const noEntryDeps = [];
+    const needBundleDeps = shouldIncludeDeps.map((pkgName)=>{
+        const packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8'));
+        const entry = getPkgEntry(packageJson);
+        if (!entry) {
+            noEntryDeps.push(pkgName);
+            return;
+        }
+        return {
+            name: pkgName,
+            entry: external_node_path_default().resolve(root, 'node_modules', pkgName, entry),
+            version: packageJson.version
+        };
+    }).filter(Boolean);
+    if (noEntryDeps[0]) external_logger_cjs_namespaceObject.logger.warn(`Could not find entry for "${external_colors_cjs_default().bold(noEntryDeps.join(', '))}"`);
+    const bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>bundleDep(depInfo)));
+    if (failedDeps[0]) external_logger_cjs_namespaceObject.logger.warn(`Something went wrong while optimizing "${external_colors_cjs_default().bold(failedDeps.join(', '))}"`);
+    const cachePath = external_node_path_default().resolve(root, external_constants_cjs_namespaceObject.TEMP_DIR, CACHE_DIR);
+    const app = external_express_default()();
+    app.use(external_cors_default()());
+    app.use(`/${CACHE_DIR}`, external_express_default().static(cachePath));
+    const port = await (0, external_utils_cjs_namespaceObject.getPort)(3200);
+    const staticServer = app.listen(port, ()=>{});
+    external_global_cjs_namespaceObject.restartCleaners.push(()=>new Promise((resolve)=>staticServer.close(()=>resolve())));
+    const externals = {};
+    const jsAssets = [];
+    const cssAssets = [];
+    const preJsAssets = [];
+    const ipv4Interfaces = (0, external_utils_cjs_namespaceObject.getIpv4Interfaces)();
+    bundledDeps.filter(Boolean).forEach((dep)=>{
+        externals[dep.name] = getExternalValue(dep.name);
+        dep.assets.forEach((absPath)=>{
+            const relativePath = external_node_path_default().relative(cachePath, absPath);
+            const preDeps = [
+                'react',
+                'react-dom',
+                'react-router',
+                'react-router-dom'
+            ];
+            const serverPath = `//${ipv4Interfaces[1].address}:${port}/${CACHE_DIR}/${relativePath}`;
+            switch(external_node_path_default().extname(relativePath)){
+                case '.js':
+                    if (preDeps.includes(dep.name)) preJsAssets.push({
+                        path: serverPath,
+                        order: preDeps.indexOf(dep.name)
+                    });
+                    else jsAssets.push(serverPath);
+                    break;
+                case '.css':
+                    cssAssets.push(serverPath);
+                    break;
+                default:
+                    break;
+            }
+        });
     });
-  });
-  unpackConfig.externals = Array.isArray(unpackConfig.externals) ? [externals, ...unpackConfig.externals] : { ...externals, ...unpackConfig.externals };
-  const HtmlPlugin = unpackConfig.bundler === "rspack" ? import_core.rspack.HtmlRspackPlugin : import_html_webpack_plugin.default;
-  unpackConfig.plugins.push({
-    name: "unpack:prebundle",
-    bundlerConfig: (config) => {
-      const PLUGIN_NAME = "PluginInjectAssets";
-      config.plugins.push({
-        apply: (compiler) => {
-          compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-            HtmlPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(
-              PLUGIN_NAME,
-              async (args) => {
-                args.assets.js.unshift(
-                  ...[
-                    ...preJsAssets.sort((a, b) => a.order - b.order).map((item) => item.path),
-                    ...jsAssets
-                  ]
-                );
-                args.assets.css.unshift(...cssAssets);
-                return args;
-              }
-            );
-          });
+    unpackConfig.externals = Array.isArray(unpackConfig.externals) ? [
+        externals,
+        ...unpackConfig.externals
+    ] : {
+        ...externals,
+        ...unpackConfig.externals
+    };
+    const HtmlPlugin = 'rspack' === unpackConfig.bundler ? core_namespaceObject.rspack.HtmlRspackPlugin : external_html_webpack_plugin_default();
+    unpackConfig.plugins.push({
+        name: 'unpack:prebundle',
+        bundlerConfig: (config)=>{
+            const PLUGIN_NAME = 'PluginInjectAssets';
+            config.plugins.push({
+                apply: (compiler)=>{
+                    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+                        HtmlPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(PLUGIN_NAME, async (args)=>{
+                            args.assets.js.unshift(...preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path), ...jsAssets);
+                            args.assets.css.unshift(...cssAssets);
+                            return args;
+                        });
+                    });
+                }
+            });
+            return config;
         }
-      });
-      return config;
-    }
-  });
-  return unpackConfig;
+    });
+    return unpackConfig;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  prebundleDeps
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });