@rsdoctor/core 0.0.2-beta.0

package/dist/build-utils/build/utils/parseBundle.js

@@ -0,0 +1,277 @@
+"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 parseBundle_exports = {};
+__export(parseBundle_exports, {
+  parseBundle: () => parseBundle
+});
+module.exports = __toCommonJS(parseBundle_exports);
+var import_fs = __toESM(require("fs"));
+var import_lodash = require("lodash");
+var import_bytes = __toESM(require("bytes"));
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+var import_path = require("path");
+const parseBundle = (bundlePath, modulesData) => {
+  if (bundlePath.indexOf(".worker.") > 0) {
+    return {};
+  }
+  if ((0, import_path.extname)(bundlePath) !== ".js") {
+    return {};
+  }
+  const content = import_fs.default.readFileSync(bundlePath, "utf8");
+  const ast = import_ruleUtils.parser.internal.parse(content, {
+    sourceType: "script",
+    ecmaVersion: "latest"
+  });
+  const walkState = {
+    locations: null,
+    expressionStatementDepth: 0
+  };
+  import_ruleUtils.parser.walk.recursive(ast, walkState, {
+    ExpressionStatement(node, state, c) {
+      if (state.locations)
+        return;
+      state.expressionStatementDepth++;
+      if (
+        // Webpack 5 stores modules in the the top-level IIFE
+        state.expressionStatementDepth === 1 && // ast?.range?.includes(node) &&
+        isIIFE(node)
+      ) {
+        const fn = getIIFECallExpression(node);
+        if (
+          // It should not contain neither arguments
+          fn.arguments.length === 0 && // ...nor parameters
+          fn.callee.params.length === 0
+        ) {
+          const firstVariableDeclaration = fn.callee.body.body.find(
+            (node2) => node2.type === "VariableDeclaration"
+          );
+          if (firstVariableDeclaration) {
+            for (const declaration of firstVariableDeclaration.declarations) {
+              if (declaration.init) {
+                state.locations = getModulesLocations(declaration.init);
+                if (state.locations) {
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+      if (!state.locations) {
+        c(node.expression, state);
+      }
+      state.expressionStatementDepth--;
+    },
+    AssignmentExpression(node, state) {
+      if (state.locations)
+        return;
+      const { left, right } = node;
+      if (left && left.object && left.object.name === "exports" && left.property && left.property.name === "modules" && isModulesHash(right)) {
+        state.locations = getModulesLocations(right);
+      }
+    },
+    CallExpression(node, state, c) {
+      if (state.locations)
+        return;
+      const args = node.arguments;
+      if (node.callee.type === "FunctionExpression" && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
+        state.locations = getModulesLocations(args[0]);
+        return;
+      }
+      if (node.callee.type === "Identifier" && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+      if (isAsyncChunkPushExpression(node)) {
+        state.locations = getModulesLocations(args[0].elements[1]);
+        return;
+      }
+      if (isAsyncWebWorkerChunkExpression(node)) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+      args.forEach((arg) => c(arg, state));
+    }
+  });
+  let modules;
+  if (walkState.locations) {
+    modules = (0, import_lodash.mapValues)(
+      walkState.locations,
+      (loc) => content.slice(loc.start, loc.end)
+    );
+  } else {
+    modules = {};
+  }
+  const modulesObj = {};
+  for (const module2 in modules) {
+    if (!module2) {
+      return {};
+    }
+    const moduleContent = modules[module2];
+    const size = moduleContent && Buffer.byteLength(moduleContent);
+    const _filterModules = (0, import_lodash.find)(modulesData, {
+      id: Number(module2)
+    });
+    const identifier = _filterModules?.identifier || (0, import_lodash.find)(modulesData, { id: module2 })?.identifier || "";
+    modulesObj[identifier] = {
+      size,
+      sizeConvert: (0, import_bytes.default)(size || 0),
+      content: moduleContent
+    };
+  }
+  return {
+    modules: modulesObj,
+    src: content,
+    runtimeSrc: getBundleRuntime(content, walkState.locations)
+  };
+};
+function getBundleRuntime(content, modulesLocations) {
+  const sortedLocations = Object.values(modulesLocations || {}).sort(
+    (a, b) => a.start - b.start
+  );
+  let result = "";
+  let lastIndex = 0;
+  for (const { start, end } of sortedLocations) {
+    result += content.slice(lastIndex, start);
+    lastIndex = end;
+  }
+  return result + content.slice(lastIndex, content.length);
+}
+function isIIFE(node) {
+  return node.type === "ExpressionStatement" && (node.expression.type === "CallExpression" || node.expression.type === "UnaryExpression" && node.expression.argument.type === "CallExpression");
+}
+function getIIFECallExpression(node) {
+  if (node.expression.type === "UnaryExpression") {
+    return node.expression.argument;
+  }
+  return node.expression;
+}
+function isModulesList(node) {
+  return isSimpleModulesList(node) || // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+  isOptimizedModulesArray(node);
+}
+function isSimpleModulesList(node) {
+  return (
+    // Modules are contained in hash. Keys are module ids.
+    isModulesHash(node) || // Modules are contained in array. Indexes are module ids.
+    isModulesArray(node)
+  );
+}
+function isModulesHash(node) {
+  return node.type === "ObjectExpression" && node.properties.map((node2) => node2.value).every(isModuleWrapper);
+}
+function isModulesArray(node) {
+  return node.type === "ArrayExpression" && node.elements.every(
+    (elem) => (
+      // Some of array items may be skipped because there is no module with such id
+      !elem || isModuleWrapper(elem)
+    )
+  );
+}
+function isOptimizedModulesArray(node) {
+  return node.type === "CallExpression" && node.callee.type === "MemberExpression" && // Make sure the object called is `Array(<some number>)`
+  node.callee.object.type === "CallExpression" && node.callee.object.callee.type === "Identifier" && node.callee.object.callee.name === "Array" && node.callee.object.arguments.length === 1 && isNumericId(node.callee.object.arguments[0]) && // Make sure the property X called for `Array(<some number>).X` is `concat`
+  node.callee.property.type === "Identifier" && node.callee.property.name === "concat" && // Make sure exactly one array is passed in to `concat`
+  node.arguments.length === 1 && isModulesArray(node.arguments[0]);
+}
+function isModuleWrapper(node) {
+  return (
+    // It's an anonymous function expression that wraps module
+    (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && !node.id || // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) || // or an array of shape [<module_id>, ...args]
+    node.type === "ArrayExpression" && node.elements.length > 1 && isModuleId(node.elements[0])
+  );
+}
+function isModuleId(node) {
+  return node.type === "Literal" && (isNumericId(node) || typeof node.value === "string");
+}
+function isNumericId(node) {
+  return node.type === "Literal" && Number.isInteger(node.value) && node.value >= 0;
+}
+function isChunkIds(node) {
+  return node.type === "ArrayExpression" && node.elements.every(isModuleId);
+}
+function isAsyncChunkPushExpression(node) {
+  const { callee, arguments: args } = node;
+  return callee.type === "MemberExpression" && callee.property.name === "push" && callee.object.type === "AssignmentExpression" && args.length === 1 && args[0].type === "ArrayExpression" && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
+}
+function mayBeAsyncChunkArguments(args) {
+  return args.length >= 2 && isChunkIds(args[0]);
+}
+function isAsyncWebWorkerChunkExpression(node) {
+  const { callee, type, arguments: args } = node;
+  return type === "CallExpression" && callee.type === "MemberExpression" && args.length === 2 && isChunkIds(args[0]) && isModulesList(args[1]);
+}
+function getModulesLocations(node) {
+  if (node.type === "ObjectExpression") {
+    const modulesNodes = node.properties;
+    return modulesNodes.reduce(
+      (result, moduleNode) => {
+        const moduleId = moduleNode.key.name || moduleNode.key.value;
+        result[moduleId] = getModuleLocation(moduleNode.value);
+        return result;
+      },
+      {}
+    );
+  }
+  const isOptimizedArray = node.type === "CallExpression";
+  if (node.type === "ArrayExpression" || isOptimizedArray) {
+    const minId = isOptimizedArray ? (
+      // Get the [minId] value from the Array() call first argument literal value
+      node.callee.object.arguments[0].value
+    ) : (
+      // `0` for simple array
+      0
+    );
+    const modulesNodes = isOptimizedArray ? (
+      // The modules reside in the `concat()` function call arguments
+      node.arguments[0].elements
+    ) : node.elements;
+    return modulesNodes.reduce(
+      (result, moduleNode, i) => {
+        if (moduleNode) {
+          result[i + minId] = getModuleLocation(moduleNode);
+        }
+        return result;
+      },
+      {}
+    );
+  }
+  return {};
+}
+function getModuleLocation(node) {
+  return {
+    start: node.start,
+    end: node.end
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseBundle
+});

package/dist/build-utils/build/utils/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Hook } from 'tapable';
+import { Plugin } from '@rsdoctor/types';
+export declare function shouldInterceptPluginHook<T extends Hook<any, any>>(hook: T): boolean;
+export declare function interceptCompilerHooks(compiler: Plugin.BaseCompiler, interceptor: (name: string, hook: Hook<any, any>, scope: 'compiler') => void): void;
+export declare function interceptCompilationHooks(compilation: Plugin.BaseCompilation, interceptor: (name: string, hook: Hook<any, any>, scope: 'compilation') => void): void;

package/dist/build-utils/build/utils/plugin.js

@@ -0,0 +1,63 @@
+"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, {
+  interceptCompilationHooks: () => interceptCompilationHooks,
+  interceptCompilerHooks: () => interceptCompilerHooks,
+  shouldInterceptPluginHook: () => shouldInterceptPluginHook
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_compatible = require("../../common/module-graph/compatible");
+function shouldInterceptPluginHook(hook) {
+  if (hook._fakeHook) {
+    return false;
+  }
+  if (typeof hook.isUsed === "function") {
+    return hook.isUsed();
+  }
+  if (hook._map && hook._map.size === 0) {
+    return false;
+  }
+  return true;
+}
+function interceptCompilerHooks(compiler, interceptor) {
+  Object.keys(compiler.hooks).forEach((hook) => {
+    const v = compiler.hooks[hook];
+    if (shouldInterceptPluginHook(v)) {
+      interceptor(hook, v, "compiler");
+    }
+  });
+}
+function interceptCompilationHooks(compilation, interceptor) {
+  Object.keys(compilation.hooks).forEach((hook) => {
+    if (hook === "normalModuleLoader" && (0, import_compatible.isWebpack5orRspack)(compilation)) {
+      return;
+    }
+    const v = compilation.hooks[hook];
+    if (shouldInterceptPluginHook(v)) {
+      interceptor(hook, v, "compilation");
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  interceptCompilationHooks,
+  interceptCompilerHooks,
+  shouldInterceptPluginHook
+});

package/dist/build-utils/common/chunks/assetsContent.d.ts

@@ -0,0 +1,4 @@
+import { ChunkGraph } from '@rsdoctor/graph';
+export declare function assetsContents(assetMap: Map<string, {
+  content: string;
+}>, chunkGraph: ChunkGraph): void;

package/dist/build-utils/common/chunks/assetsContent.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 assetsContent_exports = {};
+__export(assetsContent_exports, {
+  assetsContents: () => assetsContents
+});
+module.exports = __toCommonJS(assetsContent_exports);
+function assetsContents(assetMap, chunkGraph) {
+  const assets = chunkGraph.getAssets();
+  assets.forEach((asset) => {
+    const { content = "" } = assetMap.get(asset.path) || {};
+    asset.content = content;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assetsContents
+});

package/dist/build-utils/common/chunks/assetsModules.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from '@rsdoctor/types';
+import type { ModuleGraph } from '@rsdoctor/graph';
+import { ParseBundle } from "../../../types";
+export type ParsedModuleSizeData = {
+  [x: string]: {
+    size: number;
+    sizeConvert: string;
+    content: string;
+  };
+};
+/**
+ * The following code is modified based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/8a3d3f0f40010f2b41ccd28519eda5a44e13da3e/src/analyzer.js#L20
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare function getAssetsModulesData(bundleStats: Plugin.StatsCompilation, bundleDir: string, opts: {
+  parseBundle?: ParseBundle;
+}): Promise<ParsedModuleSizeData | null>;
+export declare function transformAssetsModulesData(parsedModulesData: ParsedModuleSizeData, moduleGraph: ModuleGraph): void;

package/dist/build-utils/common/chunks/assetsModules.js

@@ -0,0 +1,106 @@
+"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 assetsModules_exports = {};
+__export(assetsModules_exports, {
+  getAssetsModulesData: () => getAssetsModulesData,
+  transformAssetsModulesData: () => transformAssetsModulesData
+});
+module.exports = __toCommonJS(assetsModules_exports);
+var import_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+var import_logger = require("@rsdoctor/utils/logger");
+var import_module_graph = require("../module-graph");
+const logger = (0, import_logger.createLogger)();
+async function getAssetsModulesData(bundleStats, bundleDir, opts) {
+  const { parseBundle = () => ({}) } = opts || {};
+  if ((0, import_lodash.isEmpty)(bundleStats.assets) && !(0, import_lodash.isEmpty)(bundleStats.children)) {
+    const { children } = bundleStats;
+    const _bundleStats = children?.[0];
+    if (!children) {
+      return {};
+    }
+    for (let i = 1; i < children.length; i++) {
+      children[i]?.assets?.forEach((asset) => {
+        _bundleStats?.assets?.push(asset);
+      });
+    }
+  } else if (!(0, import_lodash.isEmpty)(bundleStats.children)) {
+    bundleStats?.children?.forEach((child) => {
+      child?.assets?.forEach((asset) => {
+        bundleStats?.assets?.push(asset);
+      });
+    });
+  }
+  let bundlesSources = null;
+  let parsedModules = null;
+  if (bundleDir && bundleStats?.assets) {
+    bundlesSources = {};
+    parsedModules = {};
+    for (const statAsset of bundleStats?.assets) {
+      const assetFile = import_path.default.join(bundleDir, statAsset.name);
+      let bundleInfo;
+      const collectedModules = [];
+      (0, import_module_graph.getModulesFromArray)(bundleStats.modules ?? [], collectedModules);
+      try {
+        bundleInfo = await parseBundle(assetFile, collectedModules);
+      } catch (err) {
+        const { code = "", message } = err;
+        const msg = code === "ENOENT" ? "no such file" : message;
+        process.env.DEVTOOLS_NODE_DEV === "1" && logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+        continue;
+      }
+      bundlesSources[statAsset.name] = (0, import_lodash.pick)(bundleInfo, "src", "runtimeSrc");
+      Object.assign(parsedModules, bundleInfo?.modules || {});
+    }
+    if ((0, import_lodash.isEmpty)(bundlesSources)) {
+      bundlesSources = null;
+      parsedModules = null;
+      process.env.DEVTOOLS_DEV && logger.warn(
+        "\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n"
+      );
+    }
+  }
+  return parsedModules;
+}
+function transformAssetsModulesData(parsedModulesData, moduleGraph) {
+  if (!moduleGraph)
+    return;
+  Object.entries(parsedModulesData).forEach(([moduleId, parsedData]) => {
+    const module2 = moduleGraph.getModuleByWebpackId(moduleId ?? "");
+    module2?.setSize({
+      parsedSize: parsedData?.size
+    });
+    module2?.setSource({ parsedSource: parsedData?.content || "" });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAssetsModulesData,
+  transformAssetsModulesData
+});

package/dist/build-utils/common/chunks/chunkTransform.d.ts

@@ -0,0 +1,5 @@
+import { ChunkGraph } from '@rsdoctor/graph';
+import { Plugin } from '@rsdoctor/types';
+export declare function chunkTransform(assetMap: Map<string, {
+  content: string;
+}>, bundleStats: Plugin.StatsCompilation): ChunkGraph;

package/dist/build-utils/common/chunks/chunkTransform.js

@@ -0,0 +1,73 @@
+"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 chunkTransform_exports = {};
+__export(chunkTransform_exports, {
+  chunkTransform: () => chunkTransform
+});
+module.exports = __toCommonJS(chunkTransform_exports);
+var import_graph = require("@rsdoctor/graph");
+var import_lodash = require("lodash");
+const FILTER_ASSETS_TYPE = "assets by status";
+function chunkTransform(assetMap, bundleStats) {
+  const chunkGraph = new import_graph.ChunkGraph();
+  (0, import_lodash.forEach)(bundleStats.chunks, (_chunk) => {
+    const parsedSize = 0;
+    const chunk = new import_graph.Chunk(
+      String(_chunk.id),
+      _chunk.names?.join("") || _chunk.files?.join("| ") || "",
+      _chunk.size,
+      _chunk.initial,
+      _chunk.entry
+    );
+    chunk.setParsedSize(parsedSize);
+    chunkGraph.addChunk(chunk);
+  });
+  (0, import_lodash.forEach)(bundleStats.assets, (_asset) => {
+    if (_asset.type === FILTER_ASSETS_TYPE) {
+      return;
+    }
+    const chunks = _asset.chunks?.map((ck) => {
+      const chunk = chunkGraph.getChunkById(String(ck));
+      return chunk;
+    }).filter((chunk) => !!chunk) || [];
+    const { content = "" } = assetMap.get(_asset.name) || {};
+    const asset = new import_graph.Asset(_asset.name, _asset.size, chunks, content);
+    chunks.forEach((chunk) => chunk?.addAsset(asset));
+    chunkGraph.addAsset(asset);
+  });
+  (0, import_lodash.forEach)(bundleStats.entrypoints, (_entrypoint, key) => {
+    const entrypoint = new import_graph.EntryPoint(_entrypoint.name || key);
+    (0, import_lodash.forEach)(_entrypoint.chunks, (chunkId) => {
+      const ck = chunkGraph.getChunkById(`${chunkId}`);
+      if (ck)
+        entrypoint.addChunk(ck);
+    });
+    (0, import_lodash.forEach)(_entrypoint.assets, (_asset) => {
+      const asset = chunkGraph.getAssetByPath(_asset.name);
+      if (asset)
+        entrypoint.addAsset(asset);
+    });
+    chunkGraph.addEntryPoint(entrypoint);
+  });
+  return chunkGraph;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunkTransform
+});

package/dist/build-utils/common/chunks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './assetsModules';
+export * from './chunkTransform';
+export * from './assetsContent';

package/dist/build-utils/common/chunks/index.js

@@ -0,0 +1,26 @@
+"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 chunks_exports = {};
+module.exports = __toCommonJS(chunks_exports);
+__reExport(chunks_exports, require("./assetsModules"), module.exports);
+__reExport(chunks_exports, require("./chunkTransform"), module.exports);
+__reExport(chunks_exports, require("./assetsContent"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./assetsModules"),
+  ...require("./chunkTransform"),
+  ...require("./assetsContent")
+});

package/dist/build-utils/common/index.d.ts

@@ -0,0 +1,5 @@
+export * as Chunks from './chunks';
+export * as Types from '../../types';
+export * as ModuleGraph from './module-graph';
+export * as TransUtils from './trans-utils';
+export * as Webpack from './webpack/compatible';