@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/cjs/common/loader.js

@@ -0,0 +1,261 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  LoaderInternalPropertyName: () => LoaderInternalPropertyName,
+  findLoaderTotalTiming: () => findLoaderTotalTiming,
+  getLoaderChartData: () => getLoaderChartData,
+  getLoaderCosts: () => getLoaderCosts,
+  getLoaderFileDetails: () => getLoaderFileDetails,
+  getLoaderFileFirstInput: () => getLoaderFileFirstInput,
+  getLoaderFileInputAndOutput: () => getLoaderFileInputAndOutput,
+  getLoaderFileTree: () => getLoaderFileTree,
+  getLoaderFolderStatistics: () => getLoaderFolderStatistics,
+  getLoaderNames: () => getLoaderNames,
+  getLoadersCosts: () => getLoadersCosts,
+  getLoadersTransformData: () => getLoadersTransformData,
+  isVue: () => isVue
+});
+module.exports = __toCommonJS(loader_exports);
+var import_algorithm = require("./algorithm");
+function findLoaderTotalTiming(loaders) {
+  let start = Infinity;
+  let end = -Infinity;
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    if (loader.startAt <= start) {
+      start = loader.startAt;
+    }
+    if (loader.endAt >= end) {
+      end = loader.endAt;
+    }
+  }
+  return {
+    start,
+    end
+  };
+}
+function getLoadersCosts(filter, loaders) {
+  const match = {};
+  const others = {};
+  loaders.forEach((e) => {
+    if (filter(e)) {
+      if (!match[e.pid])
+        match[e.pid] = [];
+      match[e.pid].push([e.startAt, e.endAt]);
+    } else {
+      if (!others[e.pid])
+        others[e.pid] = [];
+      others[e.pid].push([e.startAt, e.endAt]);
+    }
+  });
+  let costs = 0;
+  const pids = Object.keys(match);
+  for (let i = 0; i < pids.length; i++) {
+    const pid = pids[i];
+    const _match = (0, import_algorithm.mergeIntervals)(match[pid]);
+    const _others = (0, import_algorithm.mergeIntervals)(others[pid] || []).filter(
+      ([s, e]) => _match.some((el) => s >= el[0] && e <= el[1])
+    );
+    const matchSum = _match.length ? _match.reduce((t, c) => t += c[1] - c[0], 0) : 0;
+    const othersSum = _others.length ? _others.reduce((t, c) => t += c[1] - c[0], 0) : 0;
+    costs += matchSum - othersSum;
+  }
+  return costs;
+}
+function getLoaderCosts(loader, loaders) {
+  const blocked = loaders.filter((e) => {
+    if (e !== loader && e.pid === loader.pid) {
+      if (e.startAt >= loader.startAt) {
+        if (e.endAt <= loader.endAt)
+          return true;
+      }
+    }
+    return false;
+  });
+  let costs = loader.endAt - loader.startAt;
+  if (blocked.length) {
+    const intervals = blocked.map((e) => [
+      Math.max(e.startAt, loader.startAt),
+      Math.min(e.endAt, loader.endAt)
+    ]);
+    (0, import_algorithm.mergeIntervals)(intervals).forEach((e) => {
+      const sub = e[1] - e[0];
+      costs -= sub;
+    });
+  }
+  return costs;
+}
+function getLoaderNames(loaders) {
+  const names = /* @__PURE__ */ new Set();
+  loaders.forEach((e) => e.loaders.forEach((l) => names.add(l.loader)));
+  return [...names];
+}
+function getLoadersTransformData(loaders) {
+  const res = [];
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    for (let j = 0; j < item.loaders.length; j++) {
+      const loader = item.loaders[j];
+      res.push(loader);
+    }
+  }
+  return res;
+}
+function getLoaderChartData(loaders) {
+  const res = [];
+  const list = getLoadersTransformData(loaders);
+  loaders.forEach((item) => {
+    item.loaders.forEach((el) => {
+      res.push({
+        loader: el.loader,
+        isPitch: el.isPitch,
+        startAt: el.startAt,
+        endAt: el.endAt,
+        pid: el.pid,
+        sync: el.sync,
+        resource: item.resource.path,
+        costs: getLoaderCosts(el, list)
+      });
+    });
+  });
+  return res;
+}
+function getLoaderFileTree(loaders) {
+  const list = getLoadersTransformData(loaders);
+  return loaders.map((data) => {
+    const { loaders: arr, resource } = data;
+    return {
+      path: resource.path,
+      loaders: arr.map((l) => {
+        return {
+          loader: l.loader,
+          path: l.path,
+          errors: l.errors,
+          costs: getLoaderCosts(l, list)
+        };
+      })
+    };
+  });
+}
+function getLoaderFileDetails(path, loaders) {
+  const data = loaders.find((e) => e.resource.path === path);
+  if (!data) {
+    throw new Error(`"${path}" not match any loader data`);
+  }
+  const list = getLoadersTransformData(loaders);
+  return {
+    ...data,
+    loaders: data.loaders.map((el) => {
+      return {
+        ...el,
+        costs: getLoaderCosts(el, list)
+      };
+    })
+  };
+}
+function getLoaderFolderStatistics(folder, loaders) {
+  const datas = loaders.filter((data) => {
+    const { path } = data.resource;
+    return path.startsWith(folder);
+  });
+  const list = getLoadersTransformData(loaders);
+  return datas.reduce((t, data) => {
+    const { loaders: loaders2 } = data;
+    loaders2.forEach((l) => {
+      const match = t.find((el) => el.loader === l.loader);
+      const costs = getLoaderCosts(l, list);
+      if (match) {
+        match.files++;
+        match.costs += costs;
+      } else {
+        t.push({
+          loader: l.loader,
+          path: l.path,
+          files: 1,
+          costs
+        });
+      }
+    });
+    return t;
+  }, []);
+}
+function getLoaderFileFirstInput(file, loaders) {
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    if (item.resource.path === file) {
+      const nonPitchLoaders = item.loaders.filter((e) => !e.isPitch);
+      if (!nonPitchLoaders.length)
+        return "";
+      return nonPitchLoaders[0].input || "";
+    }
+  }
+  return "";
+}
+function getLoaderFileInputAndOutput(file, loader, loaderIndex, loaders) {
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    if (item.resource.path === file) {
+      for (let j = 0; j < item.loaders.length; j++) {
+        const l = item.loaders[j];
+        if (l.loader === loader && l.loaderIndex === loaderIndex) {
+          return {
+            input: l.input || "",
+            output: l.result || ""
+          };
+        }
+        return {
+          input: "",
+          output: ""
+        };
+      }
+    }
+  }
+  return {
+    input: "",
+    output: ""
+  };
+}
+const LoaderInternalPropertyName = "__l__";
+const isVue = (compiler) => {
+  const rules = compiler.options.module.rules;
+  const hasVueRule = rules.some((rule) => {
+    if (rule && typeof rule === "object" && rule.test instanceof RegExp && rule.test?.test(".vue")) {
+      return true;
+    }
+    return false;
+  });
+  return hasVueRule;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoaderInternalPropertyName,
+  findLoaderTotalTiming,
+  getLoaderChartData,
+  getLoaderCosts,
+  getLoaderFileDetails,
+  getLoaderFileFirstInput,
+  getLoaderFileInputAndOutput,
+  getLoaderFileTree,
+  getLoaderFolderStatistics,
+  getLoaderNames,
+  getLoadersCosts,
+  getLoadersTransformData,
+  isVue
+});

package/dist/cjs/common/manifest.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var manifest_exports = {};
+__export(manifest_exports, {
+  fetchShardingData: () => fetchShardingData,
+  fetchShardingFiles: () => fetchShardingFiles,
+  isShardingData: () => isShardingData
+});
+module.exports = __toCommonJS(manifest_exports);
+var import_algorithm = require("./algorithm");
+var import_url = require("./url");
+function isShardingData(data) {
+  if (Array.isArray(data) && data.length > 0) {
+    if (data.every((e) => (0, import_url.isRemoteUrl)(e))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fetchShardingData(shardingFiles, fetchImplement) {
+  const res = await Promise.all(
+    shardingFiles.map((url) => fetchImplement(url))
+  );
+  const strings = res.length === 0 ? [] : res.reduce((t, e) => t + e);
+  return typeof strings === "object" ? strings : JSON.parse((0, import_algorithm.decompressText)(strings));
+}
+async function fetchShardingFiles(data, fetchImplement, filterKeys) {
+  const datas = await Promise.all(
+    Object.keys(data).map(async (_key) => {
+      const key = _key;
+      const val = data[key];
+      if (filterKeys?.length && filterKeys.indexOf(key) < 0) {
+        return {
+          [key]: []
+        };
+      }
+      if (isShardingData(val)) {
+        return {
+          [key]: await fetchShardingData(val, fetchImplement)
+        };
+      }
+      return {
+        [key]: val
+      };
+    })
+  );
+  return datas.reduce(
+    (t, c) => Object.assign(t, c)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchShardingData,
+  fetchShardingFiles,
+  isShardingData
+});

package/dist/cjs/common/package.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var package_exports = {};
+__export(package_exports, {
+  MODULE_PATH_PACKAGES: () => MODULE_PATH_PACKAGES,
+  PACKAGE_PATH_NAME: () => PACKAGE_PATH_NAME,
+  getPackageMetaFromModulePath: () => getPackageMetaFromModulePath
+});
+module.exports = __toCommonJS(package_exports);
+var import_lodash = require("lodash");
+const PACKAGE_PREFIX = /(?:node_modules|~)(?:\/\.pnpm)?/;
+const PACKAGE_SLUG = /[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*/;
+const VERSION = /@[\w|\-|_|.]+/;
+const VERSION_NUMBER = "@([\\d.]+)";
+const MODULE_PATH_PACKAGES = new RegExp(
+  [
+    // match dependency directory (eg: `node_modules/`, `node_modules/.pnpm/`)
+    `(?:${PACKAGE_PREFIX.source}/)`,
+    // match package name
+    "(?:",
+    // match `@organization/` or `@organization+`(pnpm)
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    // match github.com+organization+
+    `(?:${PACKAGE_SLUG.source}\\+)*`,
+    // match package name
+    `(?:${PACKAGE_SLUG.source})`,
+    // match version
+    `(?:${VERSION.source})?`,
+    ")",
+    // Match pnpm peer dependencies (eg: package-a@version_package-b@version)
+    "(?:_",
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    `(?:${PACKAGE_SLUG.source})`,
+    `(?:@${PACKAGE_SLUG.source})?`,
+    ")*",
+    "/"
+  ].join(""),
+  "g"
+);
+const PACKAGE_PATH_NAME = /(?:(?:node_modules|~)(?:\/\.pnpm)?\/)(?:((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*\+)*)(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[\w|\-|_|.]+)?)(?:_((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))*\//gm;
+const uniqLast = (data) => {
+  const res = [];
+  data.forEach((item, index) => {
+    if (!data.slice(index + 1).includes(item)) {
+      res.push(item);
+    }
+  });
+  return res;
+};
+const getPackageMetaFromModulePath = (modulePath) => {
+  const paths = modulePath.match(MODULE_PATH_PACKAGES);
+  if (!paths) {
+    return { name: "", version: "" };
+  }
+  const names = uniqLast(
+    paths.flatMap((packagePath) => {
+      const found = packagePath.matchAll(PACKAGE_PATH_NAME);
+      if (!found) {
+        return [];
+      }
+      const paksArray = (0, import_lodash.compact)([...found].flat());
+      return paksArray.slice(1).filter(Boolean).map((name2) => name2.replace(/\+/g, "/"));
+    })
+  );
+  if ((0, import_lodash.isEmpty)(names)) {
+    return { name: "", version: "" };
+  }
+  const name = (0, import_lodash.last)(names);
+  const pattern = new RegExp(`(.*)(${(0, import_lodash.last)(paths)}).*`);
+  const path = modulePath.replace(pattern, "$1$2").replace(/\/$/, "");
+  return {
+    name,
+    version: path && name ? path.match(new RegExp(`${name}${VERSION_NUMBER}`))?.flat().slice(1)?.[0] || "" : ""
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODULE_PATH_PACKAGES,
+  PACKAGE_PATH_NAME,
+  getPackageMetaFromModulePath
+});

package/dist/cjs/common/plugin.js

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  getPluginData: () => getPluginData,
+  getPluginHooks: () => getPluginHooks,
+  getPluginSummary: () => getPluginSummary,
+  getPluginTapNames: () => getPluginTapNames
+});
+module.exports = __toCommonJS(plugin_exports);
+function getPluginHooks(plugin) {
+  return Object.keys(plugin);
+}
+function getPluginTapNames(plugin) {
+  const hooks = getPluginHooks(plugin);
+  const tapNames = /* @__PURE__ */ new Set();
+  hooks.forEach((hook) => {
+    plugin[hook].forEach((data) => {
+      tapNames.add(data.tapName);
+    });
+  });
+  return [...tapNames];
+}
+function getPluginSummary(plugin) {
+  return {
+    hooks: getPluginHooks(plugin),
+    tapNames: getPluginTapNames(plugin)
+  };
+}
+function getPluginData(plugin, selectedHooks = [], selectedTapNames = []) {
+  const hooks = getPluginHooks(plugin).filter((hook) => {
+    if (selectedHooks.length && selectedHooks.indexOf(hook) === -1) {
+      return false;
+    }
+    return true;
+  });
+  if (!hooks.length)
+    return [];
+  const tapNames = getPluginTapNames(plugin);
+  return tapNames.reduce((total, tapName) => {
+    if (selectedTapNames.length && selectedTapNames.indexOf(tapName) === -1) {
+      return total;
+    }
+    hooks.forEach((hook) => {
+      const hookData = plugin[hook].filter((e) => e.tapName === tapName);
+      if (hookData.length === 0)
+        return;
+      total.push({
+        tapName,
+        hook,
+        data: hookData.map((e) => {
+          return {
+            startAt: e.startAt,
+            endAt: e.endAt,
+            costs: e.costs,
+            type: e.type
+          };
+        })
+      });
+    });
+    return total;
+  }, []);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPluginData,
+  getPluginHooks,
+  getPluginSummary,
+  getPluginTapNames
+});

package/dist/cjs/common/resolver.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolver_exports = {};
+__export(resolver_exports, {
+  getResolverCosts: () => getResolverCosts,
+  getResolverFileDetails: () => getResolverFileDetails,
+  getResolverFileTree: () => getResolverFileTree,
+  isResolveFailData: () => isResolveFailData,
+  isResolveSuccessData: () => isResolveSuccessData
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_algorithm = require("./algorithm");
+function isResolveSuccessData(data) {
+  return Boolean(data.result);
+}
+function isResolveFailData(data) {
+  return Boolean(data.error);
+}
+function getResolverCosts(resolver, resolvers) {
+  const blocked = resolvers.filter(
+    (e) => e !== resolver && e.pid === resolver.pid && e.startAt >= resolver.startAt && e.endAt <= resolver.endAt
+  );
+  let costs = resolver.endAt - resolver.startAt;
+  if (blocked.length) {
+    const intervals = blocked.map((e) => [
+      Math.max(e.startAt, resolver.startAt),
+      Math.min(e.endAt, resolver.endAt)
+    ]);
+    (0, import_algorithm.mergeIntervals)(intervals).forEach((e) => {
+      const sub = e[1] - e[0];
+      costs -= sub;
+    });
+  }
+  return costs;
+}
+function getResolverFileTree(resolver) {
+  return resolver.map((e) => ({ issuerPath: e.issuerPath }));
+}
+function getResolverFileDetails(filepath, resolvers, modules, moduleCodeMap) {
+  const module2 = modules.find((item) => item.path === filepath);
+  const matchResolvers = resolvers.filter((e) => e.issuerPath === filepath);
+  const before = module2 && moduleCodeMap && moduleCodeMap[module2.id] ? moduleCodeMap[module2.id].source : "";
+  const after = matchResolvers.reduce((t, c) => {
+    if (c.request && isResolveSuccessData(c)) {
+      return t.replace(new RegExp(`["']${c.request}["']`), `"${c.result}"`);
+    }
+    return t;
+  }, before);
+  return {
+    filepath,
+    before,
+    after,
+    resolvers: matchResolvers.map((e) => ({
+      ...e,
+      costs: getResolverCosts(e, resolvers)
+    }))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getResolverCosts,
+  getResolverFileDetails,
+  getResolverFileTree,
+  isResolveFailData,
+  isResolveSuccessData
+});

package/dist/cjs/common/rspack.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rspack_exports = {};
+__export(rspack_exports, {
+  RspackLoaderInternalPropertyName: () => RspackLoaderInternalPropertyName,
+  RspackSummaryCostsDataName: () => RspackSummaryCostsDataName
+});
+module.exports = __toCommonJS(rspack_exports);
+const RspackLoaderInternalPropertyName = "__l__";
+var RspackSummaryCostsDataName = /* @__PURE__ */ ((RspackSummaryCostsDataName2) => {
+  RspackSummaryCostsDataName2["Bootstrap"] = "bootstrap->rspack:beforeCompile";
+  RspackSummaryCostsDataName2["Compile"] = "rspack:beforeCompile->afterCompile";
+  RspackSummaryCostsDataName2["Done"] = "rspack:afterCompile->done";
+  RspackSummaryCostsDataName2["Minify"] = "rspack:minify(rspack:optimizeChunkAssets)";
+  return RspackSummaryCostsDataName2;
+})(RspackSummaryCostsDataName || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RspackLoaderInternalPropertyName,
+  RspackSummaryCostsDataName
+});

package/dist/cjs/common/summary.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var summary_exports = {};
+__export(summary_exports, {
+  SummaryCostsDataName: () => SummaryCostsDataName
+});
+module.exports = __toCommonJS(summary_exports);
+var SummaryCostsDataName = /* @__PURE__ */ ((SummaryCostsDataName2) => {
+  SummaryCostsDataName2["Bootstrap"] = "bootstrap->beforeCompile";
+  SummaryCostsDataName2["Compile"] = "beforeCompile->afterCompile";
+  SummaryCostsDataName2["Done"] = "afterCompile->done";
+  SummaryCostsDataName2["Minify"] = "minify(webpack4:optimizeChunkAssets|webpack5:processAssets|rspack:processAssets)";
+  return SummaryCostsDataName2;
+})(SummaryCostsDataName || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SummaryCostsDataName
+});