webpack-bundle-analyzer 5.1.1 → 5.3.0

package/lib/parseUtils.js

@@ -1,42 +1,281 @@
 "use strict";
 
-const fs = require('fs');
-const acorn = require('acorn');
-const walk = require('acorn-walk');
-module.exports = {
-  parseBundle
-};
-function parseBundle(bundlePath, opts) {
+/** @typedef {import("acorn").Node} Node */
+/** @typedef {import("acorn").CallExpression} CallExpression */
+/** @typedef {import("acorn").ExpressionStatement} ExpressionStatement */
+/** @typedef {import("acorn").Expression} Expression */
+/** @typedef {import("acorn").SpreadElement} SpreadElement */
+
+const fs = require("node:fs");
+const acorn = require("acorn");
+const walk = require("acorn-walk");
+
+/**
+ * @param {Expression} node node
+ * @returns {boolean} true when id is numeric, otherwise false
+ */
+function isNumericId(node) {
+  return node.type === "Literal" && node.value !== null && node.value !== undefined && Number.isInteger(node.value) && /** @type {number} */node.value >= 0;
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module id, otherwise false
+ */
+function isModuleId(node) {
+  return node !== null && node.type === "Literal" && (isNumericId(node) || typeof node.value === "string");
+}
+
+/**
+ * @param {Expression | SpreadElement} node node
+ * @returns {boolean} true when module wrapper, otherwise false
+ */
+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])
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module hash, otherwise false
+ */
+function isModulesHash(node) {
+  return node !== null && node.type === "ObjectExpression" && node.properties.filter(property => property.type !== "SpreadElement").map(node => node.value).every(isModuleWrapper);
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when module array, otherwise false
+ */
+function isModulesArray(node) {
+  return node !== null && 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));
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when simple modules list, otherwise false
+ */
+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)
+  );
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when optimized modules array, otherwise false
+ */
+function isOptimizedModulesArray(node) {
+  // Checking whether modules are contained in `Array(<minimum ID>).concat(...modules)` array:
+  // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
+  // The `<minimum ID>` + array indexes are module ids
+  return node !== null && 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 && node.callee.object.arguments[0].type !== "SpreadElement" && 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]);
+}
+
+/**
+ * @param {Expression | SpreadElement | null} node node
+ * @returns {boolean} true when modules list, otherwise false
+ */
+function isModulesList(node) {
+  return isSimpleModulesList(node) ||
+  // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+  isOptimizedModulesArray(node);
+}
+
+/** @typedef {{ start: number, end: number }} Location */
+
+/**
+ * @param {Node} node node
+ * @returns {Location} location
+ */
+function getModuleLocation(node) {
+  return {
+    start: node.start,
+    end: node.end
+  };
+}
+
+/** @typedef {Record<number, Location>} ModulesLocations */
+
+/**
+ * @param {Expression | SpreadElement} node node
+ * @returns {ModulesLocations} modules locations
+ */
+function getModulesLocations(node) {
+  if (node.type === "ObjectExpression") {
+    // Modules hash
+    const modulesNodes = node.properties;
+    return modulesNodes.reduce((result, moduleNode) => {
+      if (moduleNode.type !== "Property") {
+        return result;
+      }
+      const moduleId = moduleNode.key.type === "Identifier" ? moduleNode.key.name :
+      // @ts-expect-error need verify why we need it, tests not cover it case
+      moduleNode.key.value;
+      if (moduleId === "undefined") {
+        return result;
+      }
+      result[moduleId] = getModuleLocation(moduleNode.value);
+      return result;
+    }, /** @type {ModulesLocations} */{});
+  }
+  const isOptimizedArray = node.type === "CallExpression";
+  if (node.type === "ArrayExpression" || isOptimizedArray) {
+    // Modules array or optimized array
+    const minId = isOptimizedArray && node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression" && node.callee.object.arguments[0].type === "Literal" ?
+    // Get the [minId] value from the Array() call first argument literal value
+    /** @type {number} */
+    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].type === "ArrayExpression" ? node.arguments[0].elements : [] : node.elements;
+    return modulesNodes.reduce((result, moduleNode, i) => {
+      if (moduleNode) {
+        result[i + minId] = getModuleLocation(moduleNode);
+      }
+      return result;
+    }, /** @type {ModulesLocations} */{});
+  }
+  return {};
+}
+
+/**
+ * @param {ExpressionStatement} node node
+ * @returns {boolean} true when IIFE, otherwise false
+ */
+function isIIFE(node) {
+  return node.type === "ExpressionStatement" && (node.expression.type === "CallExpression" || node.expression.type === "UnaryExpression" && node.expression.argument.type === "CallExpression");
+}
+
+/**
+ * @param {ExpressionStatement} node node
+ * @returns {Expression} IIFE call expression
+ */
+function getIIFECallExpression(node) {
+  if (node.expression.type === "UnaryExpression") {
+    return node.expression.argument;
+  }
+  return node.expression;
+}
+
+/**
+ * @param {Expression} node node
+ * @returns {boolean} true when chunks ids, otherwose false
+ */
+function isChunkIds(node) {
+  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
+  return node.type === "ArrayExpression" && node.elements.every(isModuleId);
+}
+
+/**
+ * @param {(Expression | SpreadElement | null)[]} args arguments
+ * @returns {boolean} true when async chunk arguments, otherwise false
+ */
+function mayBeAsyncChunkArguments(args) {
+  return args.length >= 2 && args[0] !== null && args[0].type !== "SpreadElement" && isChunkIds(args[0]);
+}
+
+/**
+ * Returns bundle source except modules
+ * @param {string} content content
+ * @param {ModulesLocations | null} modulesLocations modules locations
+ * @returns {string} runtime code
+ */
+function getBundleRuntime(content, modulesLocations) {
+  const sortedLocations = Object.values(modulesLocations || {}).toSorted((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);
+}
+
+/**
+ * @param {CallExpression} node node
+ * @returns {boolean} true when is async chunk push expression, otheriwse false
+ */
+function isAsyncChunkPushExpression(node) {
+  const {
+    callee,
+    arguments: args
+  } = node;
+  return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "push" && callee.object.type === "AssignmentExpression" && args.length === 1 && args[0].type === "ArrayExpression" && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
+}
+
+/**
+ * @param {CallExpression} node node
+ * @returns {boolean} true when is async web worker, otherwise false
+ */
+function isAsyncWebWorkerChunkExpression(node) {
+  const {
+    callee,
+    type,
+    arguments: args
+  } = node;
+  return type === "CallExpression" && callee.type === "MemberExpression" && args.length === 2 && args[0].type !== "SpreadElement" && isChunkIds(args[0]) && isModulesList(args[1]);
+}
+
+/** @typedef {Record<string, string>} Modules */
+
+/**
+ * @param {string} bundlePath bundle path
+ * @param {{ sourceType: "script" | "module" }} opts options
+ * @returns {{ modules: Modules, src: string, runtimeSrc: string }} parsed result
+ */
+module.exports.parseBundle = function parseBundle(bundlePath, opts) {
   const {
-    sourceType = 'script'
+    sourceType = "script"
   } = opts || {};
-  const content = fs.readFileSync(bundlePath, 'utf8');
+  const content = fs.readFileSync(bundlePath, "utf8");
   const ast = acorn.parse(content, {
     sourceType,
-    // I believe in a bright future of ECMAScript!
-    // Actually, it's set to `2050` to support the latest ECMAScript version that currently exists.
-    // Seems like `acorn` supports such weird option value.
-    ecmaVersion: 2050
+    ecmaVersion: "latest"
   });
+
+  /** @type {{ locations: ModulesLocations | null, expressionStatementDepth: number }} */
   const walkState = {
     locations: null,
     expressionStatementDepth: 0
   };
   walk.recursive(ast, walkState, {
-    ExpressionStatement(node, state, c) {
+    ExpressionStatement(node, state, callback) {
       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 (
+        if (fn.type === "CallExpression" &&
         // It should not contain neither arguments
-        fn.arguments.length === 0 &&
+        fn.arguments.length === 0 && (fn.callee.type === "FunctionExpression" || fn.callee.type === "ArrowFunctionExpression") &&
         // ...nor parameters
-        fn.callee.params.length === 0) {
+        fn.callee.params.length === 0 && fn.callee.body.type === "BlockStatement") {
           // Modules are stored in the very first variable declaration as hash
-          const firstVariableDeclaration = fn.callee.body.body.find(node => node.type === 'VariableDeclaration');
+          const firstVariableDeclaration = fn.callee.body.body.find(node => node.type === "VariableDeclaration");
           if (firstVariableDeclaration) {
             for (const declaration of firstVariableDeclaration.declarations) {
               if (declaration.init && isModulesList(declaration.init)) {
@@ -50,7 +289,7 @@ function parseBundle(bundlePath, opts) {
         }
       }
       if (!state.locations) {
-        c(node.expression, state);
+        callback(node.expression, state);
       }
       state.expressionStatementDepth--;
     },
@@ -63,18 +302,18 @@ function parseBundle(bundlePath, opts) {
         left,
         right
       } = node;
-      if (left && left.object && left.object.name === 'exports' && left.property && left.property.name === 'modules' && isModulesHash(right)) {
+      if (left && left.type === "MemberExpression" && left.object && left.object.type === "Identifier" && left.object.name === "exports" && left.property && left.property.type === "Identifier" && left.property.name === "modules" && isModulesHash(right)) {
         state.locations = getModulesLocations(right);
       }
     },
-    CallExpression(node, state, c) {
+    CallExpression(node, state, callback) {
       if (state.locations) return;
       const args = node.arguments;
 
       // Main chunk with webpack loader.
       // Modules are stored in first argument:
       // (function (...) {...})(<modules>)
-      if (node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
+      if (node.callee.type === "FunctionExpression" && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
         state.locations = getModulesLocations(args[0]);
         return;
       }
@@ -82,7 +321,7 @@ function parseBundle(bundlePath, opts) {
       // Async Webpack < v4 chunk without webpack loader.
       // webpackJsonp([<chunks>], <modules>, ...)
       // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
-      if (node.callee.type === 'Identifier' && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
+      if (node.callee.type === "Identifier" && mayBeAsyncChunkArguments(args) && args[1].type !== "SpreadElement" && isModulesList(args[1])) {
         state.locations = getModulesLocations(args[1]);
         return;
       }
@@ -90,7 +329,7 @@ function parseBundle(bundlePath, opts) {
       // Async Webpack v4 chunk without webpack loader.
       // (window.webpackJsonp=window.webpackJsonp||[]).push([[<chunks>], <modules>, ...]);
       // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
-      if (isAsyncChunkPushExpression(node)) {
+      if (isAsyncChunkPushExpression(node) && args[0].type === "ArrayExpression" && args[0].elements[1]) {
         state.locations = getModulesLocations(args[0].elements[1]);
         return;
       }
@@ -105,152 +344,22 @@ function parseBundle(bundlePath, opts) {
 
       // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
       // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
-      args.forEach(arg => c(arg, state));
+      for (const arg of args) {
+        callback(arg, state);
+      }
     }
   });
+
+  /** @type {Modules} */
   const modules = {};
   if (walkState.locations) {
-    Object.entries(walkState.locations).forEach(([id, loc]) => {
+    for (const [id, loc] of Object.entries(walkState.locations)) {
       modules[id] = content.slice(loc.start, loc.end);
-    });
+    }
   }
   return {
     modules,
     src: content,
     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>, ...])`
-  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(node => node.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) {
-  // Checking whether modules are contained in `Array(<minimum ID>).concat(...modules)` array:
-  // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
-  // The `<minimum ID>` + array indexes are module ids
-  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) {
-  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
-  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') {
-    // Modules hash
-    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) {
-    // Modules array or optimized array
-    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
-  };
-}
+};

package/lib/sizeUtils.js

@@ -4,11 +4,30 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getCompressedSize = getCompressedSize;
-const zlib = require('zlib');
-function getCompressedSize(compressionAlgorithm, input) {
-  if (compressionAlgorithm === 'gzip') return zlib.gzipSync(input, {
-    level: 9
-  }).length;
-  if (compressionAlgorithm === 'brotli') return zlib.brotliCompressSync(input).length;
-  throw new Error(`Unsupported compression algorithm: ${compressionAlgorithm}.`);
+exports.isZstdSupported = void 0;
+var _nodeZlib = _interopRequireDefault(require("node:zlib"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const isZstdSupported = exports.isZstdSupported = "createZstdCompress" in _nodeZlib.default;
+
+/** @typedef {"gzip" | "brotli" | "zstd"} Algorithm */
+
+/**
+ * @param {Algorithm} algorithm compression algorithm
+ * @param {string} input input
+ * @returns {number} compressed size
+ */
+function getCompressedSize(algorithm, input) {
+  if (algorithm === "gzip") {
+    return _nodeZlib.default.gzipSync(input, {
+      level: 9
+    }).length;
+  }
+  if (algorithm === "brotli") {
+    return _nodeZlib.default.brotliCompressSync(input).length;
+  }
+  if (algorithm === "zstd" && isZstdSupported) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    return _nodeZlib.default.zstdCompressSync(input).length;
+  }
+  throw new Error(`Unsupported compression algorithm: ${algorithm}.`);
 }

package/lib/statsUtils.js

@@ -2,18 +2,28 @@
 
 const {
   createWriteStream
-} = require('fs');
+} = require("node:fs");
 const {
   Readable
-} = require('stream');
+} = require("node:stream");
+const {
+  pipeline
+} = require("node:stream/promises");
+
+/** @typedef {import("./BundleAnalyzerPlugin").EXPECTED_ANY} EXPECTED_ANY */
+/** @typedef {import("webpack").StatsCompilation} StatsCompilation */
+
 class StatsSerializeStream extends Readable {
+  /**
+   * @param {StatsCompilation} stats stats
+   */
   constructor(stats) {
     super();
     this._indentLevel = 0;
     this._stringifier = this._stringify(stats);
   }
   get _indent() {
-    return '  '.repeat(this._indentLevel);
+    return "  ".repeat(this._indentLevel);
   }
   _read() {
     let readMore = true;
@@ -30,25 +40,31 @@ class StatsSerializeStream extends Readable {
       }
     }
   }
+
+  /**
+   * @param {EXPECTED_ANY} obj obj
+   * @returns {Generator<string, undefined, unknown>} stringified result
+   * @private
+   */
   *_stringify(obj) {
-    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
+    if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null) {
       yield JSON.stringify(obj);
     } else if (Array.isArray(obj)) {
-      yield '[';
+      yield "[";
       this._indentLevel++;
       let isFirst = true;
       for (let item of obj) {
         if (item === undefined) {
           item = null;
         }
-        yield `${isFirst ? '' : ','}\n${this._indent}`;
+        yield `${isFirst ? "" : ","}\n${this._indent}`;
         yield* this._stringify(item);
         isFirst = false;
       }
       this._indentLevel--;
-      yield obj.length ? `\n${this._indent}]` : ']';
+      yield obj.length ? `\n${this._indent}]` : "]";
     } else {
-      yield '{';
+      yield "{";
       this._indentLevel++;
       let isFirst = true;
       const entries = Object.entries(obj);
@@ -56,19 +72,25 @@ class StatsSerializeStream extends Readable {
         if (itemValue === undefined) {
           continue;
         }
-        yield `${isFirst ? '' : ','}\n${this._indent}${JSON.stringify(itemKey)}: `;
+        yield `${isFirst ? "" : ","}\n${this._indent}${JSON.stringify(itemKey)}: `;
         yield* this._stringify(itemValue);
         isFirst = false;
       }
       this._indentLevel--;
-      yield entries.length ? `\n${this._indent}}` : '}';
+      yield entries.length ? `\n${this._indent}}` : "}";
     }
   }
 }
-exports.StatsSerializeStream = StatsSerializeStream;
-exports.writeStats = writeStats;
+
+/**
+ * @param {StatsCompilation} stats stats
+ * @param {string} filepath filepath file path
+ * @returns {Promise<void>}
+ */
 async function writeStats(stats, filepath) {
-  return new Promise((resolve, reject) => {
-    new StatsSerializeStream(stats).on('end', resolve).on('error', reject).pipe(createWriteStream(filepath));
-  });
-}
+  await pipeline(new StatsSerializeStream(stats), createWriteStream(filepath));
+}
+module.exports = {
+  StatsSerializeStream,
+  writeStats
+};