@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/cjs/common/graph/assets.js

@@ -0,0 +1,322 @@
+"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 assets_exports = {};
+__export(assets_exports, {
+  diffAssetsByExtensions: () => diffAssetsByExtensions,
+  diffSize: () => diffSize,
+  filterAssets: () => filterAssets,
+  filterAssetsByExtensions: () => filterAssetsByExtensions,
+  formatAssetName: () => formatAssetName,
+  getAssetDetails: () => getAssetDetails,
+  getAssetsDiffResult: () => getAssetsDiffResult,
+  getAssetsSizeInfo: () => getAssetsSizeInfo,
+  getAssetsSummary: () => getAssetsSummary,
+  getInitialAssetsSizeInfo: () => getInitialAssetsSizeInfo,
+  isAssetMatchExtension: () => isAssetMatchExtension,
+  isAssetMatchExtensions: () => isAssetMatchExtensions,
+  isInitialAsset: () => isInitialAsset
+});
+module.exports = __toCommonJS(assets_exports);
+var import_types = require("@rsdoctor/types");
+var import_chunk = require("./chunk");
+var import_modules = require("./modules");
+const EXT = "js|css|html";
+const hashPattern = /[a-z|A-Z|0-9]{4,32}/;
+const hashSeparatorPattern = /[-|.]/;
+const fileExtensionPattern = /(?:\.[a-z｜A-Z|0-9]{2,}){1,}/;
+const filenamePattern = new RegExp(
+  `(.*)${hashSeparatorPattern.source}${hashPattern.source}(${fileExtensionPattern.source})$`
+);
+function formatAssetName(assetName, fileConfig) {
+  const splitFilesList = fileConfig?.split(".");
+  let outputFileTailName = "";
+  let unHashedFileName = assetName;
+  if (splitFilesList?.length && splitFilesList.length >= 3 && splitFilesList[splitFilesList.length - 2]?.indexOf("[") < 0 && EXT.indexOf(splitFilesList[splitFilesList.length - 1]) > -1) {
+    outputFileTailName = splitFilesList[splitFilesList.length - 2];
+    const _regPattern = /(.*)(\.[a-f0-9]{4,32})([^.]*.[^.]+){2,}/g;
+    unHashedFileName = assetName.replace(_regPattern, "$1");
+    return `${unHashedFileName}.${outputFileTailName}.${assetName.substring(
+      assetName.lastIndexOf(".") + 1
+    )}`;
+  }
+  return assetName.replace(filenamePattern, "$1$2");
+}
+function isAssetMatchExtension(asset, ext) {
+  return asset.path.slice(-ext.length) === ext;
+}
+function isAssetMatchExtensions(asset, exts) {
+  if (!exts.length)
+    return false;
+  return exts.some((ext) => isAssetMatchExtension(asset, ext));
+}
+function filterAssetsByExtensions(assets, exts) {
+  if (typeof exts === "string")
+    return assets.filter((e) => isAssetMatchExtension(e, exts));
+  if (Array.isArray(exts)) {
+    return assets.filter((e) => isAssetMatchExtensions(e, exts));
+  }
+  return [];
+}
+function filterAssets(assets, filterOrExtensions) {
+  if (filterOrExtensions) {
+    if (typeof filterOrExtensions === "function") {
+      assets = assets.filter(filterOrExtensions);
+    } else {
+      assets = filterAssetsByExtensions(assets, filterOrExtensions);
+    }
+  }
+  return assets;
+}
+function getAssetsSizeInfo(assets, chunks, options = {}) {
+  const { withFileContent = true, filterOrExtensions } = options;
+  assets = assets.filter(
+    (e) => !isAssetMatchExtensions(e, import_types.Constants.MapExtensions)
+  );
+  if (filterOrExtensions) {
+    assets = filterAssets(assets, filterOrExtensions);
+  }
+  if (assets.length) {
+    return {
+      count: assets.length,
+      size: assets.reduce((t, c) => t + c.size, 0),
+      files: assets.map((e) => ({
+        path: e.path,
+        size: e.size,
+        initial: isInitialAsset(e, chunks),
+        content: withFileContent ? e.content : void 0
+      }))
+    };
+  }
+  return {
+    count: 0,
+    size: 0,
+    files: []
+  };
+}
+function isInitialAsset(asset, chunks) {
+  const cks = (0, import_chunk.getChunksByAsset)(asset, chunks);
+  return cks.some((e) => Boolean(e.initial));
+}
+function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
+  if (options.filterOrExtensions) {
+    assets = filterAssets(assets, options.filterOrExtensions);
+  }
+  return getAssetsSizeInfo(assets, chunks, {
+    ...options,
+    filterOrExtensions: (asset) => isInitialAsset(asset, chunks)
+  });
+}
+function getAssetsDiffResult(baseline, current) {
+  return {
+    all: {
+      total: diffAssetsByExtensions(baseline, current)
+    },
+    js: {
+      total: diffAssetsByExtensions(baseline, current, import_types.Constants.JSExtension),
+      initial: diffAssetsByExtensions(
+        baseline,
+        current,
+        import_types.Constants.JSExtension,
+        true
+      )
+    },
+    css: {
+      total: diffAssetsByExtensions(baseline, current, import_types.Constants.CSSExtension),
+      initial: diffAssetsByExtensions(
+        baseline,
+        current,
+        import_types.Constants.CSSExtension,
+        true
+      )
+    },
+    imgs: {
+      total: diffAssetsByExtensions(baseline, current, import_types.Constants.ImgExtensions)
+    },
+    html: {
+      total: diffAssetsByExtensions(baseline, current, import_types.Constants.HtmlExtension)
+    },
+    media: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        import_types.Constants.MediaExtensions
+      )
+    },
+    fonts: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        import_types.Constants.FontExtensions
+      )
+    },
+    others: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        (asset) => !isAssetMatchExtensions(
+          asset,
+          [
+            import_types.Constants.JSExtension,
+            import_types.Constants.CSSExtension,
+            import_types.Constants.HtmlExtension
+          ].concat(
+            import_types.Constants.ImgExtensions,
+            import_types.Constants.MediaExtensions,
+            import_types.Constants.FontExtensions,
+            import_types.Constants.MapExtensions
+          )
+        )
+      )
+    }
+  };
+}
+function diffSize(bSize, cSize) {
+  const isEqual = bSize === cSize;
+  const percent = isEqual ? 0 : bSize === 0 ? 100 : Math.abs(cSize - bSize) / bSize * 100;
+  const state = isEqual ? import_types.Client.RsdoctorClientDiffState.Equal : bSize > cSize ? import_types.Client.RsdoctorClientDiffState.Down : import_types.Client.RsdoctorClientDiffState.Up;
+  return { percent, state };
+}
+function diffAssetsByExtensions(baseline, current, filterOrExtensions, isInitial = false) {
+  const { size: bSize, count: bCount } = isInitial ? getInitialAssetsSizeInfo(baseline.assets, baseline.chunks, {
+    filterOrExtensions
+  }) : getAssetsSizeInfo(baseline.assets, baseline.chunks, {
+    filterOrExtensions
+  });
+  let cSize;
+  let cCount;
+  if (baseline === current) {
+    cSize = bSize;
+    cCount = bCount;
+  } else {
+    const { size, count } = isInitial ? getInitialAssetsSizeInfo(current.assets, current.chunks, {
+      filterOrExtensions
+    }) : getAssetsSizeInfo(current.assets, current.chunks, {
+      filterOrExtensions
+    });
+    cSize = size;
+    cCount = count;
+  }
+  const { percent, state } = diffSize(bSize, cSize);
+  return {
+    size: {
+      baseline: bSize,
+      current: cSize
+    },
+    count: {
+      baseline: bCount,
+      current: cCount
+    },
+    percent,
+    state
+  };
+}
+function getAssetsSummary(assets, chunks, options = {}) {
+  const jsOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.JSExtension
+  };
+  const cssOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.CSSExtension
+  };
+  const imgOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.ImgExtensions
+  };
+  const htmlOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.HtmlExtension
+  };
+  const mediaOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.MediaExtensions
+  };
+  const fontOpt = {
+    ...options,
+    filterOrExtensions: import_types.Constants.FontExtensions
+  };
+  const otherOpt = {
+    ...options,
+    filterOrExtensions: (asset) => !isAssetMatchExtensions(
+      asset,
+      [
+        import_types.Constants.JSExtension,
+        import_types.Constants.CSSExtension,
+        import_types.Constants.HtmlExtension
+      ].concat(
+        import_types.Constants.ImgExtensions,
+        import_types.Constants.MediaExtensions,
+        import_types.Constants.FontExtensions,
+        import_types.Constants.MapExtensions
+      )
+    )
+  };
+  return {
+    all: {
+      total: getAssetsSizeInfo(assets, chunks, options)
+    },
+    js: {
+      total: getAssetsSizeInfo(assets, chunks, jsOpt),
+      initial: getInitialAssetsSizeInfo(assets, chunks, jsOpt)
+    },
+    css: {
+      total: getAssetsSizeInfo(assets, chunks, cssOpt),
+      initial: getInitialAssetsSizeInfo(assets, chunks, cssOpt)
+    },
+    imgs: {
+      total: getAssetsSizeInfo(assets, chunks, imgOpt)
+    },
+    html: {
+      total: getAssetsSizeInfo(assets, chunks, htmlOpt)
+    },
+    media: {
+      total: getAssetsSizeInfo(assets, chunks, mediaOpt)
+    },
+    fonts: {
+      total: getAssetsSizeInfo(assets, chunks, fontOpt)
+    },
+    others: {
+      total: getAssetsSizeInfo(assets, chunks, otherOpt)
+    }
+  };
+}
+function getAssetDetails(assetPath, assets, chunks, modules) {
+  const asset = assets.find((e) => e.path === assetPath);
+  return {
+    asset,
+    chunks: (0, import_chunk.getChunksByAsset)(asset, chunks),
+    modules: (0, import_modules.getModulesByAsset)(asset, chunks, modules)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffAssetsByExtensions,
+  diffSize,
+  filterAssets,
+  filterAssetsByExtensions,
+  formatAssetName,
+  getAssetDetails,
+  getAssetsDiffResult,
+  getAssetsSizeInfo,
+  getAssetsSummary,
+  getInitialAssetsSizeInfo,
+  isAssetMatchExtension,
+  isAssetMatchExtensions,
+  isInitialAsset
+});

package/dist/cjs/common/graph/chunk.js

@@ -0,0 +1,67 @@
+"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 chunk_exports = {};
+__export(chunk_exports, {
+  getChunkByChunkId: () => getChunkByChunkId,
+  getChunkIdsByAsset: () => getChunkIdsByAsset,
+  getChunksByAsset: () => getChunksByAsset,
+  getChunksByChunkIds: () => getChunksByChunkIds,
+  getChunksByModule: () => getChunksByModule,
+  getChunksByModuleId: () => getChunksByModuleId
+});
+module.exports = __toCommonJS(chunk_exports);
+function getChunkIdsByAsset(asset) {
+  if (asset.chunks) {
+    return asset.chunks;
+  }
+  return [];
+}
+function getChunksByModule(module2, chunks) {
+  if (module2.chunks.length) {
+    return getChunksByChunkIds(module2.chunks, chunks);
+  }
+  return [];
+}
+function getChunkByChunkId(chunkId, chunks) {
+  return chunks.find((e) => e.id === chunkId);
+}
+function getChunksByChunkIds(chunkIds, chunks) {
+  if (chunkIds.length) {
+    return chunkIds.map((id) => getChunkByChunkId(id, chunks)).filter(Boolean);
+  }
+  return [];
+}
+function getChunksByAsset(asset, chunks) {
+  return getChunksByChunkIds(getChunkIdsByAsset(asset), chunks);
+}
+function getChunksByModuleId(id, modules, chunks) {
+  const mod = modules.find((e) => e.id === id);
+  if (!mod)
+    return [];
+  return getChunksByModule(mod, chunks);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChunkByChunkId,
+  getChunkIdsByAsset,
+  getChunksByAsset,
+  getChunksByChunkIds,
+  getChunksByModule,
+  getChunksByModuleId
+});

package/dist/cjs/common/graph/dependency.js

@@ -0,0 +1,40 @@
+"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 dependency_exports = {};
+__export(dependency_exports, {
+  getDependenciesByModule: () => getDependenciesByModule,
+  getDependencyByPackageData: () => getDependencyByPackageData,
+  getDependencyByResolvedRequest: () => getDependencyByResolvedRequest
+});
+module.exports = __toCommonJS(dependency_exports);
+function getDependencyByPackageData(dep, dependencies) {
+  return dependencies.find((item) => item.id === dep.dependencyId);
+}
+function getDependenciesByModule(module2, dependencies) {
+  return module2.dependencies.map((id) => dependencies.find((dep) => dep.id === id)).filter(Boolean);
+}
+function getDependencyByResolvedRequest(resolvedRequest, dependencies) {
+  return dependencies.find((e) => e.resolvedRequest === resolvedRequest);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDependenciesByModule,
+  getDependencyByPackageData,
+  getDependencyByResolvedRequest
+});

package/dist/cjs/common/graph/entrypoints.js

@@ -0,0 +1,30 @@
+"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 entrypoints_exports = {};
+__export(entrypoints_exports, {
+  getEntryPoints: () => getEntryPoints
+});
+module.exports = __toCommonJS(entrypoints_exports);
+function getEntryPoints(entrypoints) {
+  return entrypoints;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntryPoints
+});

package/dist/cjs/common/graph/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_exports = {};
+module.exports = __toCommonJS(graph_exports);
+__reExport(graph_exports, require("./assets"), module.exports);
+__reExport(graph_exports, require("./chunk"), module.exports);
+__reExport(graph_exports, require("./modules"), module.exports);
+__reExport(graph_exports, require("./dependency"), module.exports);
+__reExport(graph_exports, require("./entrypoints"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./assets"),
+  ...require("./chunk"),
+  ...require("./modules"),
+  ...require("./dependency"),
+  ...require("./entrypoints")
+});

package/dist/cjs/common/graph/modules.js

@@ -0,0 +1,98 @@
+"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 modules_exports = {};
+__export(modules_exports, {
+  filterModulesAndDependenciesByPackageDeps: () => filterModulesAndDependenciesByPackageDeps,
+  getModuleByDependency: () => getModuleByDependency,
+  getModuleDetails: () => getModuleDetails,
+  getModuleIdsByChunk: () => getModuleIdsByChunk,
+  getModuleIdsByModulesIds: () => getModuleIdsByModulesIds,
+  getModulesByAsset: () => getModulesByAsset,
+  getModulesByChunk: () => getModulesByChunk,
+  getModulesByChunks: () => getModulesByChunks
+});
+module.exports = __toCommonJS(modules_exports);
+var import_chunk = require("./chunk");
+var import_dependency = require("./dependency");
+function getModulesByAsset(asset, chunks, modules) {
+  const ids = (0, import_chunk.getChunkIdsByAsset)(asset);
+  const cks = (0, import_chunk.getChunksByChunkIds)(ids, chunks);
+  const res = getModulesByChunks(cks, modules);
+  return res;
+}
+function getModuleIdsByChunk(chunk) {
+  const { modules = [] } = chunk;
+  return modules;
+}
+function getModuleIdsByModulesIds(moduleIds, modules) {
+  return moduleIds.map((id) => modules.find((m) => m.id === id)).filter(Boolean);
+}
+function getModulesByChunk(chunk, modules) {
+  const ids = getModuleIdsByChunk(chunk);
+  return ids.map((id) => modules.find((e) => e.id === id)).filter(Boolean);
+}
+function getModulesByChunks(chunks, modules) {
+  const res = [];
+  chunks.forEach((chunk) => {
+    getModulesByChunk(chunk, modules).forEach((md) => {
+      if (!res.filter((_m) => _m.id === md.id).length)
+        res.push(md);
+    });
+  });
+  return res;
+}
+function getModuleByDependency(dep, modules) {
+  return modules.find((item) => item.id === dep.module);
+}
+function filterModulesAndDependenciesByPackageDeps(deps, dependencies, modules) {
+  const _dependencies = [];
+  const _modules = [];
+  for (let i = 0; i < deps.length; i++) {
+    const dep = (0, import_dependency.getDependencyByPackageData)(deps[i], dependencies);
+    if (dep) {
+      _dependencies.push(dep);
+      const module2 = getModuleByDependency(dep, modules);
+      if (module2) {
+        _modules.push(module2);
+      }
+    }
+  }
+  return {
+    dependencies: _dependencies,
+    modules: _modules
+  };
+}
+function getModuleDetails(moduleId, modules, dependencies) {
+  const module2 = modules.find((e) => e.id === moduleId);
+  return {
+    module: module2,
+    dependencies: (0, import_dependency.getDependenciesByModule)(module2, dependencies)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterModulesAndDependenciesByPackageDeps,
+  getModuleByDependency,
+  getModuleDetails,
+  getModuleIdsByChunk,
+  getModuleIdsByModulesIds,
+  getModulesByAsset,
+  getModulesByChunk,
+  getModulesByChunks
+});

package/dist/cjs/common/index.js

@@ -0,0 +1,80 @@
+"use strict";
+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 common_exports = {};
+__export(common_exports, {
+  Alerts: () => Alerts,
+  Algorithm: () => Algorithm,
+  Bundle: () => Bundle,
+  Crypto: () => Crypto,
+  Data: () => Data,
+  Graph: () => Graph,
+  Loader: () => Loader,
+  Manifest: () => Manifest,
+  Package: () => Package,
+  Plugin: () => Plugin,
+  Resolver: () => Resolver,
+  Rspack: () => Rspack,
+  Summary: () => Summary,
+  Time: () => Time,
+  Url: () => Url
+});
+module.exports = __toCommonJS(common_exports);
+var Summary = __toESM(require("./summary"));
+var Crypto = __toESM(require("./crypto"));
+var Manifest = __toESM(require("./manifest"));
+var Loader = __toESM(require("./loader"));
+var Time = __toESM(require("./time"));
+var Algorithm = __toESM(require("./algorithm"));
+var Resolver = __toESM(require("./resolver"));
+var Graph = __toESM(require("./graph"));
+var Bundle = __toESM(require("./bundle"));
+var Url = __toESM(require("./url"));
+var Plugin = __toESM(require("./plugin"));
+var Data = __toESM(require("./data"));
+var Alerts = __toESM(require("./alerts"));
+var Rspack = __toESM(require("./rspack"));
+var Package = __toESM(require("./package"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Alerts,
+  Algorithm,
+  Bundle,
+  Crypto,
+  Data,
+  Graph,
+  Loader,
+  Manifest,
+  Package,
+  Plugin,
+  Resolver,
+  Rspack,
+  Summary,
+  Time,
+  Url
+});