webpack-bundle-analyzer 3.9.0 → 4.2.0

package/CHANGELOG.md

@@ -14,6 +14,35 @@ _Note: Gaps between patch versions are faulty, broken or test releases._
 
 <!-- Add changelog entries for new changes under this section -->
 
+## 4.2.0
+
+ * **Improvement**
+   * A  number of improvements to reduce the number of dependencies ([#391](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/391), [#396](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/396), [#397](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/397))
+
+ * **Bug Fix**
+   * Prevent crashes for bundles generated from webpack array configs. ([#394](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/394) by [@ctavan](https://github.com/ctavan))
+   * Fix `non-asset` assets causing analyze failure. ([#385](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/385) by [@ZKHelloworld](https://github.com/ZKHelloworld))
+
+## 4.1.0
+
+ * **Improvement**
+   * Significantly speed up generation of `stats.json` file (see `generateStatsFile` option).
+
+## 4.0.0
+
+ * **Breaking change**
+   * Dropped support for Node.js 6 and 8. Minimal required version now is v10.13.0
+
+ * **Improvement**
+   * Support for Webpack 5
+ 
+ * **Bug Fix**
+   * Prevent crashes when `openAnalyzer` was set to true in environments where there's no program to handle opening. ([#382](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/382) by [@wbobeirne](https://github.com/wbobeirne))
+  
+ * **Internal**
+   * Updated dependencies
+   * Added support for multiple Webpack versions in tests
+
 ## 3.9.0
 
  * **New Feature**

package/lib/BundleAnalyzerPlugin.js

@@ -1,21 +1,9 @@
 "use strict";
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-const bfj = require('bfj');
+const fs = require('fs');
 
 const path = require('path');
 
-const mkdir = require('mkdirp');
-
 const {
   bold
 } = require('chalk');
@@ -26,9 +14,13 @@ const viewer = require('./viewer');
 
 const utils = require('./utils');
 
+const {
+  writeStats
+} = require('./statsUtils');
+
 class BundleAnalyzerPlugin {
   constructor(opts = {}) {
-    this.opts = _objectSpread({
+    this.opts = {
       analyzerMode: 'server',
       analyzerHost: '127.0.0.1',
       reportFilename: null,
@@ -41,10 +33,10 @@ class BundleAnalyzerPlugin {
       excludeAssets: null,
       logLevel: 'info',
       // deprecated
-      startAnalyzer: true
-    }, opts, {
+      startAnalyzer: true,
+      ...opts,
       analyzerPort: 'analyzerPort' in opts ? opts.analyzerPort === 'auto' ? 0 : opts.analyzerPort : 8888
-    });
+    };
     this.server = null;
     this.logger = new Logger(this.opts.logLevel);
   }
@@ -76,14 +68,14 @@ class BundleAnalyzerPlugin {
 
       if (actions.length) {
         // Making analyzer logs to be after all webpack logs in the console
-        setImmediate( /*#__PURE__*/_asyncToGenerator(function* () {
+        setImmediate(async () => {
           try {
-            yield Promise.all(actions.map(action => action()));
+            await Promise.all(actions.map(action => action()));
             callback();
           } catch (e) {
             callback(e);
           }
-        }));
+        });
       } else {
         callback();
       }
@@ -96,78 +88,56 @@ class BundleAnalyzerPlugin {
     }
   }
 
-  generateStatsFile(stats) {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      const statsFilepath = path.resolve(_this.compiler.outputPath, _this.opts.statsFilename);
-      mkdir.sync(path.dirname(statsFilepath));
-
-      try {
-        yield bfj.write(statsFilepath, stats, {
-          space: 2,
-          promises: 'ignore',
-          buffers: 'ignore',
-          maps: 'ignore',
-          iterables: 'ignore',
-          circular: 'ignore'
-        });
+  async generateStatsFile(stats) {
+    const statsFilepath = path.resolve(this.compiler.outputPath, this.opts.statsFilename);
+    await fs.promises.mkdir(path.dirname(statsFilepath), {
+      recursive: true
+    });
 
-        _this.logger.info(`${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`);
-      } catch (error) {
-        _this.logger.error(`${bold('Webpack Bundle Analyzer')} error saving stats file to ${bold(statsFilepath)}: ${error}`);
-      }
-    })();
+    try {
+      await writeStats(stats, statsFilepath);
+      this.logger.info(`${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`);
+    } catch (error) {
+      this.logger.error(`${bold('Webpack Bundle Analyzer')} error saving stats file to ${bold(statsFilepath)}: ${error}`);
+    }
   }
 
-  startAnalyzerServer(stats) {
-    var _this2 = this;
-
-    return _asyncToGenerator(function* () {
-      if (_this2.server) {
-        (yield _this2.server).updateChartData(stats);
-      } else {
-        _this2.server = viewer.startServer(stats, {
-          openBrowser: _this2.opts.openAnalyzer,
-          host: _this2.opts.analyzerHost,
-          port: _this2.opts.analyzerPort,
-          reportTitle: _this2.opts.reportTitle,
-          bundleDir: _this2.getBundleDirFromCompiler(),
-          logger: _this2.logger,
-          defaultSizes: _this2.opts.defaultSizes,
-          excludeAssets: _this2.opts.excludeAssets
-        });
-      }
-    })();
+  async startAnalyzerServer(stats) {
+    if (this.server) {
+      (await this.server).updateChartData(stats);
+    } else {
+      this.server = viewer.startServer(stats, {
+        openBrowser: this.opts.openAnalyzer,
+        host: this.opts.analyzerHost,
+        port: this.opts.analyzerPort,
+        reportTitle: this.opts.reportTitle,
+        bundleDir: this.getBundleDirFromCompiler(),
+        logger: this.logger,
+        defaultSizes: this.opts.defaultSizes,
+        excludeAssets: this.opts.excludeAssets
+      });
+    }
   }
 
-  generateJSONReport(stats) {
-    var _this3 = this;
-
-    return _asyncToGenerator(function* () {
-      yield viewer.generateJSONReport(stats, {
-        reportFilename: path.resolve(_this3.compiler.outputPath, _this3.opts.reportFilename || 'report.json'),
-        bundleDir: _this3.getBundleDirFromCompiler(),
-        logger: _this3.logger,
-        excludeAssets: _this3.opts.excludeAssets
-      });
-    })();
+  async generateJSONReport(stats) {
+    await viewer.generateJSONReport(stats, {
+      reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename || 'report.json'),
+      bundleDir: this.getBundleDirFromCompiler(),
+      logger: this.logger,
+      excludeAssets: this.opts.excludeAssets
+    });
   }
 
-  generateStaticReport(stats) {
-    var _this4 = this;
-
-    return _asyncToGenerator(function* () {
-      yield viewer.generateReport(stats, {
-        openBrowser: _this4.opts.openAnalyzer,
-        reportFilename: path.resolve(_this4.compiler.outputPath, _this4.opts.reportFilename || 'report.html'),
-        reportTitle: _this4.opts.reportTitle,
-        bundleDir: _this4.getBundleDirFromCompiler(),
-        logger: _this4.logger,
-        defaultSizes: _this4.opts.defaultSizes,
-        excludeAssets: _this4.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,
+      bundleDir: this.getBundleDirFromCompiler(),
+      logger: this.logger,
+      defaultSizes: this.opts.defaultSizes,
+      excludeAssets: this.opts.excludeAssets
+    });
   }
 
   getBundleDirFromCompiler() {

package/lib/analyzer.js

@@ -42,7 +42,7 @@ function getViewerData(bundleStats, bundleDir, opts) {
     // leave the 1st one as that is considered the 'root' asset.
 
     for (let i = 1; i < children.length; i++) {
-      bundleStats.children[i].assets.forEach(asset => {
+      children[i].assets.forEach(asset => {
         asset.isChild = true;
         bundleStats.assets.push(asset);
       });
@@ -58,9 +58,14 @@ function getViewerData(bundleStats, bundleDir, opts) {
   } // Picking only `*.js or *.mjs` assets from bundle that has non-empty `chunks` array
 
 
-  bundleStats.assets = _.filter(bundleStats.assets, asset => {
-    // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
+  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
+
+
     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
@@ -84,9 +89,8 @@ function getViewerData(bundleStats, bundleDir, opts) {
         continue;
       }
 
-      bundlesSources[statAsset.name] = bundleInfo.src;
-
-      _.assign(parsedModules, bundleInfo.modules);
+      bundlesSources[statAsset.name] = _.pick(bundleInfo, 'src', 'runtimeSrc');
+      Object.assign(parsedModules, bundleInfo.modules);
     }
 
     if (_.isEmpty(bundlesSources)) {
@@ -96,41 +100,73 @@ function getViewerData(bundleStats, bundleDir, opts) {
     }
   }
 
-  const assets = _.transform(bundleStats.assets, (result, statAsset) => {
+  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');
 
-    if (bundlesSources && _.has(bundlesSources, statAsset.name)) {
-      asset.parsedSize = Buffer.byteLength(bundlesSources[statAsset.name]);
-      asset.gzipSize = gzipSize.sync(bundlesSources[statAsset.name]);
+    const assetSources = bundlesSources && _.has(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
 
 
-    asset.modules = _(modules).filter(statModule => assetHasModule(statAsset, statModule)).each(statModule => {
-      if (parsedModules) {
-        statModule.parsedSrc = parsedModules[statModule.id];
+    const 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.
+      // 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
+          // from parsed modules.
+          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.unshift({
+            identifier: './entry modules',
+            name: './entry modules',
+            modules: unparsedEntryModules,
+            size: unparsedEntryModules.reduce((totalSize, module) => totalSize + module.size, 0),
+            parsedSrc: assetSources.runtimeSrc
+          });
+        }
       }
-    });
+    }
+
+    asset.modules = assetModules;
     asset.tree = createModulesTree(asset.modules);
+    return result;
   }, {});
-
-  return _.transform(assets, (result, asset, filename) => {
-    result.push({
-      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')
-    });
-  }, []);
+  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,
+    groups: _.invokeMap(asset.tree.children, 'toChartData')
+  }));
 }
 
 function readStatsFromFile(filename) {
@@ -138,23 +174,30 @@ function readStatsFromFile(filename) {
 }
 
 function getChildAssetBundles(bundleStats, assetName) {
-  return _.find(bundleStats.children, c => _(c.assetsByChunkName).values().flatten().includes(assetName));
+  return (bundleStats.children || []).find(c => _(c.assetsByChunkName).values().flatten().includes(assetName));
 }
 
 function getBundleModules(bundleStats) {
-  return _(bundleStats.chunks).map('modules').concat(bundleStats.modules).compact().flatten().uniqBy('id').value();
+  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();
 }
 
 function assetHasModule(statAsset, statModule) {
   // Checking if this module is the part of asset chunks
-  return _.some(statModule.chunks, moduleChunk => _.includes(statAsset.chunks, moduleChunk));
+  return statModule.chunks.some(moduleChunk => statAsset.chunks.includes(moduleChunk));
 }
 
-function createModulesTree(modules) {
-  const root = new Folder('.');
+function isEntryModule(statModule) {
+  return statModule.depth === 0;
+}
 
-  _.each(modules, module => root.addModule(module));
+function isRuntimeModule(statModule) {
+  return statModule.moduleType === 'runtime';
+}
 
+function createModulesTree(modules) {
+  const root = new Folder('.');
+  modules.forEach(module => root.addModule(module));
   root.mergeNestedFolders();
   return root;
 }

package/lib/bin/analyzer.js

@@ -6,8 +6,6 @@ const {
   dirname
 } = require('path');
 
-const _ = require('lodash');
-
 const commander = require('commander');
 
 const {
@@ -113,7 +111,7 @@ function showHelp(error) {
 }
 
 function br(str) {
-  return `\n${_.repeat(' ', 28)}${str}`;
+  return `\n${' '.repeat(28)}${str}`;
 }
 
 function array() {

package/lib/parseUtils.js

@@ -22,9 +22,45 @@ function parseBundle(bundlePath) {
     ecmaVersion: 2050
   });
   const walkState = {
-    locations: null
+    locations: null,
+    expressionStatementDepth: 0
   };
   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.body.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) {
+          // Modules are stored in the very first variable declaration as hash
+          const firstVariableDeclaration = fn.callee.body.body.find(node => node.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; // Modules are stored in exports.modules:
       // exports.modules = {};
@@ -76,7 +112,7 @@ function parseBundle(bundlePath) {
       // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
 
 
-      _.each(args, arg => c(arg, state));
+      args.forEach(arg => c(arg, state));
     }
 
   });
@@ -89,10 +125,43 @@ function parseBundle(bundlePath) {
   }
 
   return {
+    modules,
     src: content,
-    modules
+    runtimeSrc: getBundleRuntime(content, walkState.locations)
   };
 }
+/**
+ * Returns bundle source except modules
+ */
+
+
+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;
+  } else {
+    return node.expression;
+  }
+}
 
 function isModulesList(node) {
   return isSimpleModulesList(node) || // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
@@ -107,11 +176,11 @@ function isSimpleModulesList(node) {
 }
 
 function isModulesHash(node) {
-  return node.type === 'ObjectExpression' && _(node.properties).map('value').every(isModuleWrapper);
+  return node.type === 'ObjectExpression' && node.properties.map(node => node.value).every(isModuleWrapper);
 }
 
 function isModulesArray(node) {
-  return node.type === 'ArrayExpression' && _.every(node.elements, elem => // Some of array items may be skipped because there is no module with such id
+  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));
 }
 
@@ -143,7 +212,7 @@ function isNumericId(node) {
 
 function isChunkIds(node) {
   // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
-  return node.type === 'ArrayExpression' && _.every(node.elements, isModuleId);
+  return node.type === 'ArrayExpression' && node.elements.every(isModuleId);
 }
 
 function isAsyncChunkPushExpression(node) {
@@ -171,9 +240,10 @@ function getModulesLocations(node) {
   if (node.type === 'ObjectExpression') {
     // Modules hash
     const modulesNodes = node.properties;
-    return _.transform(modulesNodes, (result, moduleNode) => {
+    return modulesNodes.reduce((result, moduleNode) => {
       const moduleId = moduleNode.key.name || moduleNode.key.value;
       result[moduleId] = getModuleLocation(moduleNode.value);
+      return result;
     }, {});
   }
 
@@ -186,9 +256,12 @@ function getModulesLocations(node) {
     0;
     const modulesNodes = isOptimizedArray ? // The modules reside in the `concat()` function call arguments
     node.arguments[0].elements : node.elements;
-    return _.transform(modulesNodes, (result, moduleNode, i) => {
-      if (!moduleNode) return;
-      result[i + minId] = getModuleLocation(moduleNode);
+    return modulesNodes.reduce((result, moduleNode, i) => {
+      if (moduleNode) {
+        result[i + minId] = getModuleLocation(moduleNode);
+      }
+
+      return result;
     }, {});
   }
 

package/lib/statsUtils.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const {
+  createWriteStream
+} = require('fs');
+
+const {
+  Readable
+} = require('stream');
+
+class StatsSerializeStream extends Readable {
+  constructor(stats) {
+    super();
+    this._indentLevel = 0;
+    this._stringifier = this._stringify(stats);
+  }
+
+  get _indent() {
+    return '  '.repeat(this._indentLevel);
+  }
+
+  _read() {
+    let readMore = true;
+
+    while (readMore) {
+      const {
+        value,
+        done
+      } = this._stringifier.next();
+
+      if (done) {
+        this.push(null);
+        readMore = false;
+      } else {
+        readMore = this.push(value);
+      }
+    }
+  }
+
+  *_stringify(obj) {
+    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
+      yield JSON.stringify(obj);
+    } else if (Array.isArray(obj)) {
+      yield '[';
+      this._indentLevel++;
+      let isFirst = true;
+
+      for (let item of obj) {
+        if (item === undefined) {
+          item = null;
+        }
+
+        yield `${isFirst ? '' : ','}\n${this._indent}`;
+        yield* this._stringify(item);
+        isFirst = false;
+      }
+
+      this._indentLevel--;
+      yield obj.length ? `\n${this._indent}]` : ']';
+    } else {
+      yield '{';
+      this._indentLevel++;
+      let isFirst = true;
+      const entries = Object.entries(obj);
+
+      for (const [itemKey, itemValue] of entries) {
+        if (itemValue === undefined) {
+          continue;
+        }
+
+        yield `${isFirst ? '' : ','}\n${this._indent}${JSON.stringify(itemKey)}: `;
+        yield* this._stringify(itemValue);
+        isFirst = false;
+      }
+
+      this._indentLevel--;
+      yield entries.length ? `\n${this._indent}}` : '}';
+    }
+  }
+
+}
+
+exports.StatsSerializeStream = StatsSerializeStream;
+exports.writeStats = writeStats;
+
+async function writeStats(stats, filepath) {
+  return new Promise((resolve, reject) => {
+    new StatsSerializeStream(stats).on('end', resolve).on('error', reject).pipe(createWriteStream(filepath));
+  });
+}