webpack-bundle-analyzer 4.9.0 → 5.2.0

package/README.md

@@ -45,7 +45,7 @@ This module will help you:
 4. Optimize it!
 
 And the best thing is it supports minified bundles! It parses them to get real size of bundled modules.
-And it also shows their gzipped sizes!
+And it also shows their gzipped, Brotli, or Zstandard sizes!
 
 <h2 align="center">Options (for plugin)</h2>
 
@@ -61,7 +61,8 @@ new BundleAnalyzerPlugin(options?: object)
 |**`analyzerUrl`**|`{Function}` called with `{ listenHost: string, listenHost: string, boundAddress: server.address}`. [server.address comes from Node.js](https://nodejs.org/api/net.html#serveraddress)| Default: `http://${listenHost}:${boundAddress.port}`. The URL printed to console with server mode.|
 |**`reportFilename`**|`{String}`|Default: `report.html`. Path to bundle report file that will be generated in `static` mode. It can be either an absolute path or a path relative to a bundle output directory (which is output.path in webpack config).|
 |**`reportTitle`**|`{String\|function}`|Default: function that returns pretty printed current date and time. Content of the HTML `title` element; or a function of the form `() => string` that provides the content.|
-|**`defaultSizes`**|One of: `stat`, `parsed`, `gzip`|Default: `parsed`. Module sizes to show in report by default. [Size definitions](#size-definitions) section describes what these values mean.|
+|**`defaultSizes`**|One of: `stat`, `parsed`, `gzip`, `brotli`|Default: `parsed`. Module sizes to show in report by default. [Size definitions](#size-definitions) section describes what these values mean.|
+|**`compressionAlgorithm`**|One of: `gzip`, `brotli`, `zstd`|Default: `gzip`. Compression type used to calculate the compressed module sizes.|
 |**`openAnalyzer`**|`{Boolean}`|Default: `true`. Automatically open report in default browser.|
 |**`generateStatsFile`**|`{Boolean}`|Default: `false`. If `true`, webpack stats JSON file will be generated in bundle output directory|
 |**`statsFilename`**|`{String}`|Default: `stats.json`. Name of webpack stats JSON file that will be generated if `generateStatsFile` is `true`. It can be either an absolute path or a path relative to a bundle output directory (which is output.path in webpack config).|
@@ -80,7 +81,7 @@ command:
 webpack --profile --json > stats.json
 ```
 
-If you're on Windows and using PowerShell, you can generate the stats file with this command to [avoid BOM issues](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/47):
+If you're on Windows and using PowerShell, you can generate the stats file with this command to [avoid BOM issues](https://github.com/webpack/webpack-bundle-analyzer/issues/47):
 
 ```
 webpack --profile --json | Out-file 'stats.json' -Encoding OEM
@@ -111,23 +112,25 @@ Directory containing all generated bundles.
 ### `options`
 
 ```
-  -V, --version               output the version number
-  -m, --mode <mode>           Analyzer mode. Should be `server`, `static` or `json`.
-                              In `server` mode analyzer will start HTTP server to show bundle report.
-                              In `static` mode single HTML file with bundle report will be generated.
-                              In `json` mode single JSON file with bundle report will be generated. (default: server)
-  -h, --host <host>           Host that will be used in `server` mode to start HTTP server. (default: 127.0.0.1)
-  -p, --port <n>              Port that will be used in `server` mode to start HTTP server. Should be a number or `auto` (default: 8888)
-  -r, --report <file>         Path to bundle report file that will be generated in `static` mode. (default: report.html)
-  -t, --title <title>         String to use in title element of html report. (default: pretty printed current date)
-  -s, --default-sizes <type>  Module sizes to show in treemap by default.
-                              Possible values: stat, parsed, gzip (default: parsed)
-  -O, --no-open               Don't open report in default browser automatically.
-  -e, --exclude <regexp>      Assets that should be excluded from the report.
-                              Can be specified multiple times.
-  -l, --log-level <level>     Log level.
-                              Possible values: debug, info, warn, error, silent (default: info)
-  -h, --help                  output usage information
+  -V, --version                   output the version number
+  -m, --mode <mode>               Analyzer mode. Should be `server`, `static` or `json`.
+                                  In `server` mode analyzer will start HTTP server to show bundle report.
+                                  In `static` mode single HTML file with bundle report will be generated.
+                                  In `json` mode single JSON file with bundle report will be generated. (default: server)
+  -h, --host <host>               Host that will be used in `server` mode to start HTTP server. (default: 127.0.0.1)
+  -p, --port <n>                  Port that will be used in `server` mode to start HTTP server. Should be a number or `auto` (default: 8888)
+  -r, --report <file>             Path to bundle report file that will be generated in `static` mode. (default: report.html)
+  -t, --title <title>             String to use in title element of html report. (default: pretty printed current date)
+  -s, --default-sizes <type>      Module sizes to show in treemap by default.
+                                  Possible values: stat, parsed, gzip, brotli, zstd (default: parsed)
+  --compression-algorithm <type>  Compression algorithm that will be used to calculate the compressed module sizes.
+                                  Possible values: gzip, brotli, zstd (default: gzip)
+  -O, --no-open                   Don't open report in default browser automatically.
+  -e, --exclude <regexp>          Assets that should be excluded from the report.
+                                  Can be specified multiple times.
+  -l, --log-level <level>         Log level.
+                                  Possible values: debug, info, warn, error, silent (default: info)
+  -h, --help                      output usage information
 ```
 
 <h2 align="center" id="size-definitions">Size definitions</h2>
@@ -151,6 +154,14 @@ as Uglify, then this value will reflect the minified size of your code.
 
 This is the size of running the parsed bundles/modules through gzip compression.
 
+### `brotli`
+
+This is the size of running the parsed bundles/modules through Brotli compression.
+
+### `zstd`
+
+This is the size of running the parsed bundles/modules through Zstandard compression. (Node.js 22.15.0+ is required for this feature)
+
 <h2 align="center">Selecting Which Chunks to Display</h2>
 
 When opened, the report displays all of the Webpack chunks for your project. It's possible to filter to a more specific list of chunks by using the sidebar or the chunk context menu.
@@ -176,7 +187,7 @@ It happens when `webpack-bundle-analyzer` analyzes files that don't actually exi
 Error parsing bundle asset "your_bundle_name.bundle.js": no such file
 No bundles were parsed. Analyzer will show only original module sizes from stats file.
 ```
-To get more information about it you can read [issue #147](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/147).
+To get more information about it you can read [issue #147](https://github.com/webpack/webpack-bundle-analyzer/issues/147).
 
 <h2 align="center">Other tools</h2>
 
@@ -210,8 +221,8 @@ To get more information about it you can read [issue #147](https://github.com/we
 [node]: https://img.shields.io/node/v/webpack-bundle-analyzer.svg
 [node-url]: https://nodejs.org
 
-[tests]: http://img.shields.io/travis/webpack-contrib/webpack-bundle-analyzer.svg
-[tests-url]: https://travis-ci.org/webpack-contrib/webpack-bundle-analyzer
+[tests]: https://github.com/webpack/webpack-bundle-analyzer/actions/workflows/main.yml/badge.svg
+[tests-url]: https://github.com/webpack/webpack-bundle-analyzer/actions/workflows/main.yml
 
 [downloads]: https://img.shields.io/npm/dt/webpack-bundle-analyzer.svg
 [downloads-url]: https://npmjs.com/package/webpack-bundle-analyzer

package/lib/BundleAnalyzerPlugin.js

@@ -1,28 +1,22 @@
 "use strict";
 
 const fs = require('fs');
-
 const path = require('path');
-
 const {
   bold
-} = require('chalk');
-
+} = require('picocolors');
 const Logger = require('./Logger');
-
 const viewer = require('./viewer');
-
 const utils = require('./utils');
-
 const {
   writeStats
 } = require('./statsUtils');
-
 class BundleAnalyzerPlugin {
   constructor(opts = {}) {
     this.opts = {
       analyzerMode: 'server',
       analyzerHost: '127.0.0.1',
+      compressionAlgorithm: 'gzip',
       reportFilename: null,
       reportTitle: utils.defaultTitle,
       defaultSizes: 'parsed',
@@ -41,24 +35,19 @@ class BundleAnalyzerPlugin {
     this.server = null;
     this.logger = new Logger(this.opts.logLevel);
   }
-
   apply(compiler) {
     this.compiler = compiler;
-
     const done = (stats, callback) => {
       callback = callback || (() => {});
-
       const actions = [];
-
       if (this.opts.generateStatsFile) {
         actions.push(() => this.generateStatsFile(stats.toJson(this.opts.statsOptions)));
-      } // Handling deprecated `startAnalyzer` flag
-
+      }
 
+      // Handling deprecated `startAnalyzer` flag
       if (this.opts.analyzerMode === 'server' && !this.opts.startAnalyzer) {
         this.opts.analyzerMode = 'disabled';
       }
-
       if (this.opts.analyzerMode === 'server') {
         actions.push(() => this.startAnalyzerServer(stats.toJson()));
       } else if (this.opts.analyzerMode === 'static') {
@@ -66,7 +55,6 @@ class BundleAnalyzerPlugin {
       } else if (this.opts.analyzerMode === 'json') {
         actions.push(() => this.generateJSONReport(stats.toJson()));
       }
-
       if (actions.length) {
         // Making analyzer logs to be after all webpack logs in the console
         setImmediate(async () => {
@@ -81,20 +69,17 @@ class BundleAnalyzerPlugin {
         callback();
       }
     };
-
     if (compiler.hooks) {
       compiler.hooks.done.tapAsync('webpack-bundle-analyzer', done);
     } else {
       compiler.plugin('done', done);
     }
   }
-
   async generateStatsFile(stats) {
     const statsFilepath = path.resolve(this.compiler.outputPath, this.opts.statsFilename);
     await fs.promises.mkdir(path.dirname(statsFilepath), {
       recursive: true
     });
-
     try {
       await writeStats(stats, statsFilepath);
       this.logger.info(`${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`);
@@ -102,7 +87,6 @@ class BundleAnalyzerPlugin {
       this.logger.error(`${bold('Webpack Bundle Analyzer')} error saving stats file to ${bold(statsFilepath)}: ${error}`);
     }
   }
-
   async startAnalyzerServer(stats) {
     if (this.server) {
       (await this.server).updateChartData(stats);
@@ -112,6 +96,7 @@ class BundleAnalyzerPlugin {
         host: this.opts.analyzerHost,
         port: this.opts.analyzerPort,
         reportTitle: this.opts.reportTitle,
+        compressionAlgorithm: this.opts.compressionAlgorithm,
         bundleDir: this.getBundleDirFromCompiler(),
         logger: this.logger,
         defaultSizes: this.opts.defaultSizes,
@@ -120,47 +105,41 @@ class BundleAnalyzerPlugin {
       });
     }
   }
-
   async generateJSONReport(stats) {
     await viewer.generateJSONReport(stats, {
       reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename || 'report.json'),
+      compressionAlgorithm: this.opts.compressionAlgorithm,
       bundleDir: this.getBundleDirFromCompiler(),
       logger: this.logger,
       excludeAssets: this.opts.excludeAssets
     });
   }
-
   async generateStaticReport(stats) {
     await viewer.generateReport(stats, {
       openBrowser: this.opts.openAnalyzer,
       reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename || 'report.html'),
       reportTitle: this.opts.reportTitle,
+      compressionAlgorithm: this.opts.compressionAlgorithm,
       bundleDir: this.getBundleDirFromCompiler(),
       logger: this.logger,
       defaultSizes: this.opts.defaultSizes,
       excludeAssets: this.opts.excludeAssets
     });
   }
-
   getBundleDirFromCompiler() {
     if (typeof this.compiler.outputFileSystem.constructor === 'undefined') {
       return this.compiler.outputPath;
     }
-
     switch (this.compiler.outputFileSystem.constructor.name) {
       case 'MemoryFileSystem':
         return null;
       // Detect AsyncMFS used by Nuxt 2.5 that replaces webpack's MFS during development
       // Related: #274
-
       case 'AsyncMFS':
         return null;
-
       default:
         return this.compiler.outputPath;
     }
   }
-
 }
-
 module.exports = BundleAnalyzerPlugin;

package/lib/Logger.js

@@ -2,35 +2,28 @@
 
 const LEVELS = ['debug', 'info', 'warn', 'error', 'silent'];
 const LEVEL_TO_CONSOLE_METHOD = new Map([['debug', 'log'], ['info', 'log'], ['warn', 'log']]);
-
 class Logger {
+  static levels = LEVELS;
+  static defaultLevel = 'info';
   constructor(level = Logger.defaultLevel) {
     this.activeLevels = new Set();
     this.setLogLevel(level);
   }
-
   setLogLevel(level) {
     const levelIndex = LEVELS.indexOf(level);
     if (levelIndex === -1) throw new Error(`Invalid log level "${level}". Use one of these: ${LEVELS.join(', ')}`);
     this.activeLevels.clear();
-
     for (const [i, level] of LEVELS.entries()) {
       if (i >= levelIndex) this.activeLevels.add(level);
     }
   }
-
   _log(level, ...args) {
     console[LEVEL_TO_CONSOLE_METHOD.get(level) || level](...args);
   }
-
 }
-
-Logger.levels = LEVELS;
-Logger.defaultLevel = 'info';
 ;
 LEVELS.forEach(level => {
   if (level === 'silent') return;
-
   Logger.prototype[level] = function (...args) {
     if (this.activeLevels.has(level)) this._log(level, ...args);
   };

package/lib/analyzer.js

@@ -1,57 +1,50 @@
 "use strict";
 
 const fs = require('fs');
-
 const path = require('path');
-
-const _ = require('lodash');
-
-const gzipSize = require('gzip-size');
-
 const {
   parseChunked
 } = require('@discoveryjs/json-ext');
-
 const Logger = require('./Logger');
-
 const Folder = require('./tree/Folder').default;
-
 const {
   parseBundle
 } = require('./parseUtils');
-
 const {
   createAssetsFilter
 } = require('./utils');
-
+const {
+  getCompressedSize
+} = require('./sizeUtils');
 const FILENAME_QUERY_REGEXP = /\?.*$/u;
-const FILENAME_EXTENSIONS = /\.(js|mjs)$/iu;
+const FILENAME_EXTENSIONS = /\.(js|mjs|cjs|bundle)$/iu;
 module.exports = {
   getViewerData,
   readStatsFromFile
 };
-
 function getViewerData(bundleStats, bundleDir, opts) {
   const {
     logger = new Logger(),
+    compressionAlgorithm,
     excludeAssets = null
   } = opts || {};
-  const isAssetIncluded = createAssetsFilter(excludeAssets); // Sometimes all the information is located in `children` array (e.g. problem in #10)
+  const isAssetIncluded = createAssetsFilter(excludeAssets);
 
-  if (_.isEmpty(bundleStats.assets) && !_.isEmpty(bundleStats.children)) {
+  // Sometimes all the information is located in `children` array (e.g. problem in #10)
+  if ((bundleStats.assets == null || bundleStats.assets.length === 0) && bundleStats.children && bundleStats.children.length > 0) {
     const {
       children
     } = bundleStats;
-    bundleStats = bundleStats.children[0]; // Sometimes if there are additional child chunks produced add them as child assets,
+    bundleStats = bundleStats.children[0];
+    // Sometimes if there are additional child chunks produced add them as child assets,
     // leave the 1st one as that is considered the 'root' asset.
-
     for (let i = 1; i < children.length; i++) {
       children[i].assets.forEach(asset => {
         asset.isChild = true;
         bundleStats.assets.push(asset);
       });
     }
-  } else if (!_.isEmpty(bundleStats.children)) {
+  } else if (bundleStats.children && bundleStats.children.length > 0) {
     // Sometimes if there are additional child chunks produced add them as child assets
     bundleStats.children.forEach(child => {
       child.assets.forEach(asset => {
@@ -59,82 +52,85 @@ function getViewerData(bundleStats, bundleDir, opts) {
         bundleStats.assets.push(asset);
       });
     });
-  } // Picking only `*.js or *.mjs` assets from bundle that has non-empty `chunks` array
-
+  }
 
-  bundleStats.assets = bundleStats.assets.filter(asset => {
+  // Picking only `*.js, *.cjs or *.mjs` assets from bundle that has non-empty `chunks` array
+  bundleStats.assets = (bundleStats.assets || []).filter(asset => {
     // Filter out non 'asset' type asset if type is provided (Webpack 5 add a type to indicate asset types)
     if (asset.type && asset.type !== 'asset') {
       return false;
-    } // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
-    // See #22
-
+    }
 
+    // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
+    // See #22
     asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '');
-    return FILENAME_EXTENSIONS.test(asset.name) && !_.isEmpty(asset.chunks) && isAssetIncluded(asset.name);
-  }); // Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
+    return FILENAME_EXTENSIONS.test(asset.name) && asset.chunks.length > 0 && isAssetIncluded(asset.name);
+  });
 
+  // Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
   let bundlesSources = null;
   let parsedModules = null;
-
   if (bundleDir) {
     bundlesSources = {};
     parsedModules = {};
-
     for (const statAsset of bundleStats.assets) {
       const assetFile = path.join(bundleDir, statAsset.name);
       let bundleInfo;
-
       try {
-        bundleInfo = parseBundle(assetFile);
+        bundleInfo = parseBundle(assetFile, {
+          sourceType: statAsset.info.javascriptModule ? 'module' : 'script'
+        });
       } catch (err) {
         const msg = err.code === 'ENOENT' ? 'no such file' : err.message;
-        logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+        logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`, {
+          cause: err
+        });
         continue;
       }
-
-      bundlesSources[statAsset.name] = _.pick(bundleInfo, 'src', 'runtimeSrc');
+      bundlesSources[statAsset.name] = {
+        src: bundleInfo.src,
+        runtimeSrc: bundleInfo.runtimeSrc
+      };
       Object.assign(parsedModules, bundleInfo.modules);
     }
-
-    if (_.isEmpty(bundlesSources)) {
+    if (Object.keys(bundlesSources).length === 0) {
       bundlesSources = null;
       parsedModules = null;
       logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n');
     }
   }
-
   const assets = bundleStats.assets.reduce((result, statAsset) => {
     // If asset is a childAsset, then calculate appropriate bundle modules by looking through stats.children
     const assetBundles = statAsset.isChild ? getChildAssetBundles(bundleStats, statAsset.name) : bundleStats;
     const modules = assetBundles ? getBundleModules(assetBundles) : [];
-
-    const asset = result[statAsset.name] = _.pick(statAsset, 'size');
-
-    const assetSources = bundlesSources && _.has(bundlesSources, statAsset.name) ? bundlesSources[statAsset.name] : null;
-
+    const asset = result[statAsset.name] = {
+      size: statAsset.size
+    };
+    const assetSources = bundlesSources && Object.prototype.hasOwnProperty.call(bundlesSources, statAsset.name) ? bundlesSources[statAsset.name] : null;
     if (assetSources) {
       asset.parsedSize = Buffer.byteLength(assetSources.src);
-      asset.gzipSize = gzipSize.sync(assetSources.src);
-    } // Picking modules from current bundle script
-
+      if (compressionAlgorithm === 'gzip') asset.gzipSize = getCompressedSize('gzip', assetSources.src);
+      if (compressionAlgorithm === 'brotli') asset.brotliSize = getCompressedSize('brotli', assetSources.src);
+      if (compressionAlgorithm === 'zstd') asset.zstdSize = getCompressedSize('zstd', assetSources.src);
+    }
 
-    const assetModules = modules.filter(statModule => assetHasModule(statAsset, statModule)); // Adding parsed sources
+    // Picking modules from current bundle script
+    let assetModules = (modules || []).filter(statModule => assetHasModule(statAsset, statModule));
 
+    // Adding parsed sources
     if (parsedModules) {
       const unparsedEntryModules = [];
-
       for (const statModule of assetModules) {
         if (parsedModules[statModule.id]) {
           statModule.parsedSrc = parsedModules[statModule.id];
         } else if (isEntryModule(statModule)) {
           unparsedEntryModules.push(statModule);
         }
-      } // Webpack 5 changed bundle format and now entry modules are concatenated and located at the end of it.
+      }
+
+      // Webpack 5 changed bundle format and now entry modules are concatenated and located at the end of it.
       // Because of this they basically become a concatenated module, for which we can't even precisely determine its
       // parsed source as it's located in the same scope as all Webpack runtime helpers.
-
-
       if (unparsedEntryModules.length && assetSources) {
         if (unparsedEntryModules.length === 1) {
           // So if there is only one entry we consider its parsed source to be all the bundle code excluding code
@@ -142,8 +138,7 @@ function getViewerData(bundleStats, bundleDir, opts) {
           unparsedEntryModules[0].parsedSrc = assetSources.runtimeSrc;
         } else {
           // If there are multiple entry points we move all of them under synthetic concatenated module.
-          _.pullAll(assetModules, unparsedEntryModules);
-
+          assetModules = (assetModules || []).filter(mod => !unparsedEntryModules.includes(mod));
           assetModules.unshift({
             identifier: './entry modules',
             name: './entry modules',
@@ -154,81 +149,107 @@ function getViewerData(bundleStats, bundleDir, opts) {
         }
       }
     }
-
     asset.modules = assetModules;
-    asset.tree = createModulesTree(asset.modules);
+    asset.tree = createModulesTree(asset.modules, {
+      compressionAlgorithm
+    });
     return result;
   }, {});
   const chunkToInitialByEntrypoint = getChunkToInitialByEntrypoint(bundleStats);
-  return Object.entries(assets).map(([filename, asset]) => {
-    var _chunkToInitialByEntr;
-
-    return {
-      label: filename,
-      isAsset: true,
-      // Not using `asset.size` here provided by Webpack because it can be very confusing when `UglifyJsPlugin` is used.
-      // In this case all module sizes from stats file will represent unminified module sizes, but `asset.size` will
-      // be the size of minified bundle.
-      // Using `asset.size` only if current asset doesn't contain any modules (resulting size equals 0)
-      statSize: asset.tree.size || asset.size,
-      parsedSize: asset.parsedSize,
-      gzipSize: asset.gzipSize,
-      groups: _.invokeMap(asset.tree.children, 'toChartData'),
-      isInitialByEntrypoint: (_chunkToInitialByEntr = chunkToInitialByEntrypoint[filename]) !== null && _chunkToInitialByEntr !== void 0 ? _chunkToInitialByEntr : {}
-    };
-  });
+  return Object.entries(assets).map(([filename, asset]) => ({
+    label: filename,
+    isAsset: true,
+    // Not using `asset.size` here provided by Webpack because it can be very confusing when `UglifyJsPlugin` is used.
+    // In this case all module sizes from stats file will represent unminified module sizes, but `asset.size` will
+    // be the size of minified bundle.
+    // Using `asset.size` only if current asset doesn't contain any modules (resulting size equals 0)
+    statSize: asset.tree.size || asset.size,
+    parsedSize: asset.parsedSize,
+    gzipSize: asset.gzipSize,
+    brotliSize: asset.brotliSize,
+    zstdSize: asset.zstdSize,
+    groups: Object.values(asset.tree.children).map(i => i.toChartData()),
+    isInitialByEntrypoint: chunkToInitialByEntrypoint[filename] ?? {}
+  }));
 }
-
 function readStatsFromFile(filename) {
   return parseChunked(fs.createReadStream(filename, {
     encoding: 'utf8'
   }));
 }
-
 function getChildAssetBundles(bundleStats, assetName) {
-  return (bundleStats.children || []).find(c => _(c.assetsByChunkName).values().flatten().includes(assetName));
+  return flatten((bundleStats.children || []).find(c => Object.values(c.assetsByChunkName))).includes(assetName);
 }
-
 function getBundleModules(bundleStats) {
-  return _(bundleStats.chunks).map('modules').concat(bundleStats.modules).compact().flatten().uniqBy('id') // Filtering out Webpack's runtime modules as they don't have ids and can't be parsed (introduced in Webpack 5)
-  .reject(isRuntimeModule).value();
+  const seenIds = new Set();
+  return flatten((bundleStats.chunks?.map(chunk => chunk.modules) || []).concat(bundleStats.modules).filter(Boolean)).filter(mod => {
+    // Filtering out Webpack's runtime modules as they don't have ids and can't be parsed (introduced in Webpack 5)
+    if (isRuntimeModule(mod)) {
+      return false;
+    }
+    if (seenIds.has(mod.id)) {
+      return false;
+    }
+    seenIds.add(mod.id);
+    return true;
+  });
 }
-
 function assetHasModule(statAsset, statModule) {
   // Checking if this module is the part of asset chunks
   return (statModule.chunks || []).some(moduleChunk => statAsset.chunks.includes(moduleChunk));
 }
-
 function isEntryModule(statModule) {
   return statModule.depth === 0;
 }
-
 function isRuntimeModule(statModule) {
   return statModule.moduleType === 'runtime';
 }
-
-function createModulesTree(modules) {
-  const root = new Folder('.');
+function createModulesTree(modules, opts) {
+  const root = new Folder('.', opts);
   modules.forEach(module => root.addModule(module));
   root.mergeNestedFolders();
   return root;
 }
-
 function getChunkToInitialByEntrypoint(bundleStats) {
   if (bundleStats == null) {
     return {};
   }
-
   const chunkToEntrypointInititalMap = {};
   Object.values(bundleStats.entrypoints || {}).forEach(entrypoint => {
     for (const asset of entrypoint.assets) {
-      var _chunkToEntrypointIni;
-
-      chunkToEntrypointInititalMap[asset.name] = (_chunkToEntrypointIni = chunkToEntrypointInititalMap[asset.name]) !== null && _chunkToEntrypointIni !== void 0 ? _chunkToEntrypointIni : {};
+      chunkToEntrypointInititalMap[asset.name] = chunkToEntrypointInititalMap[asset.name] ?? {};
       chunkToEntrypointInititalMap[asset.name][entrypoint.name] = true;
     }
   });
   return chunkToEntrypointInititalMap;
 }
-
-;
+;
+
+/**
+ * arr-flatten <https://github.com/jonschlinkert/arr-flatten>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ *
+ * Modified by Sukka <https://skk.moe>
+ *
+ * Replace recursively flatten with one-level deep flatten to match lodash.flatten
+ *
+ * TODO: replace with Array.prototype.flat once Node.js 10 support is dropped
+ */
+function flatten(arr) {
+  if (!arr) return [];
+  const len = arr.length;
+  if (!len) return [];
+  let cur;
+  const res = [];
+  for (let i = 0; i < len; i++) {
+    cur = arr[i];
+    if (Array.isArray(cur)) {
+      res.push(...cur);
+    } else {
+      res.push(cur);
+    }
+  }
+  return res;
+}