webpack-bundle-analyzer 2.11.2 → 2.13.1

package/CHANGELOG.md

@@ -14,6 +14,34 @@ _Note: Gaps between patch versions are faulty, broken or test releases._
 
 <!-- Add changelog entries for new changes under this section -->
 
+## 2.13.1
+
+ * **Improvement**
+   * Pretty-format the generated stats.json ([#180](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/180)) [@edmorley](https://github.com/edmorley))
+   
+ * **Bug Fix**
+   * Properly parse Webpack 4 async chunk with `Array.concat` optimization ([#184](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/184), fixes [#183](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/183))
+  
+ * **Internal**
+   * Refactor bundle parsing logic ([#184](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/184))
+
+## 2.13.0
+
+ * **Improvement**
+   * Loosen bundle parsing logic ([#181](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/181)). Now analyzer will still show parsed sizes even if:
+     * It can't parse some bundle chunks. Those chunks just won't have content in the report. Fixes issues like [#160](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/160).
+     * Some bundle chunks are missing (it couldn't find files to parse). Those chunks just won't be visible in the report for parsed/gzipped sizes.
+
+## 2.12.0
+
+ * **New Feature**
+   * Add option that allows to exclude assets from the report ([#178](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/178))
+
+## 2.11.3
+
+ * **Bug Fix**
+   * Filter out modules that weren't found during bundles parsing ([#177](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/177))
+
 ## 2.11.2
 
  * **Bug Fix**

package/README.md

@@ -62,6 +62,7 @@ new BundleAnalyzerPlugin(options?: object)
 |**`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`. Relative to bundle output directory.|
 |**`statsOptions`**|`null` or `{Object}`|Default: `null`. Options for `stats.toJson()` method. For example you can exclude sources of your modules from stats file with `source: false` option. [See more options here](https://github.com/webpack/webpack/blob/webpack-1/lib/Stats.js#L21). |
+|**`excludeAssets`**|`{null\|pattern\|pattern[]}` where `pattern` equals to `{String\|RegExp\|function}`|Default: `null`. Patterns that will be used to match against asset names to exclude them from the report. If pattern is a string it will be converted to RegExp via `new RegExp(str)`. If pattern is a function it should have the following signature `(assetName: string) => boolean` and should return `true` to *exclude* matching asset. If multiple patterns are provided asset should match at least one of them to be excluded. |
 |**`logLevel`**|One of: `info`, `warn`, `error`, `silent`|Default: `info`. Used to control how much details the plugin outputs.|
 
 <h2 align="center">Usage (as a CLI utility)</h2>
@@ -106,22 +107,21 @@ Directory containing all generated bundles.
 ### `options`
 
 ```
-  -h, --help                  output usage information
   -V, --version               output the version number
   -m, --mode <mode>           Analyzer mode. Should be `server` or `static`.
                               In `server` mode analyzer will start HTTP server to show bundle report.
-                              In `static` mode single HTML file with bundle report will be generated.
-                              Default is `server`.
-  -h, --host <host>           Host that will be used in `server` mode to start HTTP server.
-                              Default is `127.0.0.1`.
-  -p, --port <n>              Port that will be used in `server` mode to start HTTP server.
-                              Default is 8888.
-  -r, --report <file>         Path to bundle report file that will be generated in `static` mode.
-                              Default is `report.html`.
+                              In `static` mode single HTML 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. (default: 8888)
+  -r, --report <file>         Path to bundle report file that will be generated in `static` mode. (default: report.html)
   -s, --default-sizes <type>  Module sizes to show in treemap by default.
-                              Possible values: stat, parsed, gzip
-                              Default is `parsed`.
+                              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
 ```
 
 <h2 align="center" id="size-definitions">Size definitions</h2>

package/lib/BundleAnalyzerPlugin.js

@@ -30,6 +30,7 @@ var BundleAnalyzerPlugin = function () {
       generateStatsFile: false,
       statsFilename: 'stats.json',
       statsOptions: null,
+      excludeAssets: null,
       logLevel: 'info',
       // deprecated
       startAnalyzer: true
@@ -97,6 +98,7 @@ var BundleAnalyzerPlugin = function () {
 
         try {
           yield bfj.write(statsFilepath, stats, {
+            space: 2,
             promises: 'ignore',
             buffers: 'ignore',
             maps: 'ignore',
@@ -129,7 +131,8 @@ var BundleAnalyzerPlugin = function () {
             port: this.opts.analyzerPort,
             bundleDir: this.getBundleDirFromCompiler(),
             logger: this.logger,
-            defaultSizes: this.opts.defaultSizes
+            defaultSizes: this.opts.defaultSizes,
+            excludeAssets: this.opts.excludeAssets
           });
         }
       });
@@ -148,7 +151,8 @@ var BundleAnalyzerPlugin = function () {
         reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename),
         bundleDir: this.getBundleDirFromCompiler(),
         logger: this.logger,
-        defaultSizes: this.opts.defaultSizes
+        defaultSizes: this.opts.defaultSizes,
+        excludeAssets: this.opts.excludeAssets
       });
     }
   }, {

package/lib/analyzer.js

@@ -12,6 +12,9 @@ var Folder = require('./tree/Folder').default;
 var _require = require('./parseUtils'),
     parseBundle = _require.parseBundle;
 
+var _require2 = require('./utils'),
+    createAssetsFilter = _require2.createAssetsFilter;
+
 var FILENAME_QUERY_REGEXP = /\?.*$/;
 
 module.exports = {
@@ -22,11 +25,13 @@ module.exports = {
 function getViewerData(bundleStats, bundleDir, opts) {
   var _ref = opts || {},
       _ref$logger = _ref.logger,
-      logger = _ref$logger === undefined ? new Logger() : _ref$logger;
-
-  // Sometimes all the information is located in `children` array (e.g. problem in #10)
+      logger = _ref$logger === undefined ? new Logger() : _ref$logger,
+      _ref$excludeAssets = _ref.excludeAssets,
+      excludeAssets = _ref$excludeAssets === undefined ? null : _ref$excludeAssets;
 
+  var isAssetIncluded = createAssetsFilter(excludeAssets);
 
+  // Sometimes all the information is located in `children` array (e.g. problem in #10)
   if (_.isEmpty(bundleStats.assets) && !_.isEmpty(bundleStats.children)) {
     bundleStats = bundleStats.children[0];
   }
@@ -37,7 +42,7 @@ function getViewerData(bundleStats, bundleDir, opts) {
     // See #22
     asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '');
 
-    return _.endsWith(asset.name, '.js') && !_.isEmpty(asset.chunks);
+    return _.endsWith(asset.name, '.js') && !_.isEmpty(asset.chunks) && isAssetIncluded(asset.name);
   });
 
   // Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
@@ -62,14 +67,9 @@ function getViewerData(bundleStats, bundleDir, opts) {
         try {
           bundleInfo = parseBundle(assetFile);
         } catch (err) {
-          bundleInfo = null;
-        }
-
-        if (!bundleInfo) {
-          logger.warn(`\nCouldn't parse bundle asset "${assetFile}".\n` + 'Analyzer will use module sizes from stats file.\n');
-          parsedModules = null;
-          bundlesSources = null;
-          break;
+          var msg = err.code === 'ENOENT' ? 'no such file' : err.message;
+          logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+          continue;
         }
 
         bundlesSources[statAsset.name] = bundleInfo.src;
@@ -89,13 +89,19 @@ function getViewerData(bundleStats, bundleDir, opts) {
         }
       }
     }
+
+    if (_.isEmpty(bundlesSources)) {
+      bundlesSources = null;
+      parsedModules = null;
+      logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n');
+    }
   }
 
   var modules = getBundleModules(bundleStats);
   var assets = _.transform(bundleStats.assets, function (result, statAsset) {
     var asset = result[statAsset.name] = _.pick(statAsset, 'size');
 
-    if (bundlesSources) {
+    if (bundlesSources && _.has(bundlesSources, statAsset.name)) {
       asset.parsedSize = bundlesSources[statAsset.name].length;
       asset.gzipSize = gzipSize.sync(bundlesSources[statAsset.name]);
     }
@@ -118,7 +124,8 @@ function getViewerData(bundleStats, bundleDir, opts) {
       // 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.
-      statSize: asset.tree.size,
+      // 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')
@@ -135,6 +142,7 @@ function getBundleModules(bundleStats) {
 }
 
 function assetHasModule(statAsset, statModule) {
+  // Checking if this module is the part of asset chunks
   return _.some(statModule.chunks, function (moduleChunk) {
     return _.includes(statAsset.chunks, moduleChunk);
   });

package/lib/bin/analyzer.js

@@ -28,7 +28,7 @@ var program = commander.version(require('../../package.json').version).usage(`<b
     bundleStatsFile  Path to Webpack Stats JSON file.
     bundleDir        Directory containing all generated bundles.
                      You should provided it if you want analyzer to show you the real parsed module sizes.
-                     By default a directory of stats file is used.`).option('-m, --mode <mode>', 'Analyzer mode. Should be `server` or `static`.' + br('In `server` mode analyzer will start HTTP server to show bundle report.') + br('In `static` mode single HTML file with bundle report will be generated.'), 'server').option('-h, --host <host>', 'Host that will be used in `server` mode to start HTTP server.', '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.', Number, 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.', 'report.html').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[].concat(_toConsumableArray(SIZES)).join(', ')}`), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").option('-l, --log-level <level>', 'Log level.' + br(`Possible values: ${[].concat(_toConsumableArray(Logger.levels)).join(', ')}`), Logger.defaultLevel).parse(process.argv);
+                     By default a directory of stats file is used.`).option('-m, --mode <mode>', 'Analyzer mode. Should be `server` or `static`.' + br('In `server` mode analyzer will start HTTP server to show bundle report.') + br('In `static` mode single HTML file with bundle report will be generated.'), 'server').option('-h, --host <host>', 'Host that will be used in `server` mode to start HTTP server.', '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.', Number, 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.', 'report.html').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[].concat(_toConsumableArray(SIZES)).join(', ')}`), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").option('-e, --exclude <regexp>', 'Assets that should be excluded from the report.' + br('Can be specified multiple times.'), array()).option('-l, --log-level <level>', 'Log level.' + br(`Possible values: ${[].concat(_toConsumableArray(Logger.levels)).join(', ')}`), Logger.defaultLevel).parse(process.argv);
 
 var mode = program.mode,
     host = program.host,
@@ -37,6 +37,7 @@ var mode = program.mode,
     defaultSizes = program.defaultSizes,
     logLevel = program.logLevel,
     openBrowser = program.open,
+    excludeAssets = program.exclude,
     _program$args = _slicedToArray(program.args, 2),
     bundleStatsFile = _program$args[0],
     bundleDir = _program$args[1];
@@ -69,6 +70,7 @@ if (mode === 'server') {
     host,
     defaultSizes,
     bundleDir,
+    excludeAssets,
     logger: new Logger(logLevel)
   });
 } else {
@@ -77,6 +79,7 @@ if (mode === 'server') {
     reportFilename: resolve(reportFilename),
     defaultSizes,
     bundleDir,
+    excludeAssets,
     logger: new Logger(logLevel)
   });
 }
@@ -89,4 +92,12 @@ function showHelp(error) {
 
 function br(str) {
   return `\n${_.repeat(' ', 28)}${str}`;
+}
+
+function array() {
+  var arr = [];
+  return function (val) {
+    arr.push(val);
+    return arr;
+  };
 }

package/lib/parseUtils.js

@@ -25,40 +25,31 @@ function parseBundle(bundlePath) {
 
   walk.recursive(ast, walkState, {
     CallExpression(node, state, c) {
-      if (state.sizes) return;
+      if (state.locations) return;
 
       var args = node.arguments;
 
-      // Additional bundle without webpack loader.
-      // Modules are stored in second argument, after chunk ids:
-      // 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' && args.length >= 2 && isArgumentContainsChunkIds(args[0]) && isArgumentContainsModulesList(args[1])) {
-        state.locations = getModulesLocationFromFunctionArgument(args[1]);
+      // 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])) {
+        state.locations = getModulesLocations(args[0]);
         return;
       }
 
-      // Additional bundle without webpack loader, with module IDs optimized.
-      // Modules are stored in second arguments Array(n).concat() call
-      // webpackJsonp([<chunks>], Array([minimum ID]).concat([<module>, <module>, ...]))
+      // 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' && (args.length === 2 || args.length === 3) && isArgumentContainsChunkIds(args[0]) && isArgumentArrayConcatContainingChunks(args[1])) {
-        state.locations = getModulesLocationFromArrayConcat(args[1]);
+      if (node.callee.type === 'Identifier' && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
+        state.locations = getModulesLocations(args[1]);
         return;
       }
 
-      // Main bundle with webpack loader
-      // Modules are stored in first argument:
-      // (function (...) {...})(<modules>)
-      if (node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1 && isArgumentContainsModulesList(args[0])) {
-        state.locations = getModulesLocationFromFunctionArgument(args[0]);
-        return;
-      }
-
-      // Additional bundles with webpack 4 are loaded with:
-      // (window.webpackJsonp=window.webpackJsonp||[]).push([[chunkId], [<module>, <module>], [[optional_entries]]]);
-      if (isAsyncChunkPushExpression(node) && args.length === 1 && isArgumentContainingChunkIdsAndModulesList(args[0])) {
-        state.locations = getModulesLocationFromFunctionArgument(args[0].elements[1]);
+      // 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)) {
+        state.locations = getModulesLocations(args[0].elements[1]);
         return;
       }
 
@@ -70,72 +61,61 @@ function parseBundle(bundlePath) {
     }
   });
 
-  if (!walkState.locations) {
-    return null;
+  var modules = void 0;
+
+  if (walkState.locations) {
+    modules = _.mapValues(walkState.locations, function (loc) {
+      return content.slice(loc.start, loc.end);
+    });
+  } else {
+    modules = {};
   }
 
   return {
     src: content,
-    modules: _.mapValues(walkState.locations, function (loc) {
-      return content.slice(loc.start, loc.end);
-    })
+    modules
   };
 }
 
-function isArgumentContainsChunkIds(arg) {
-  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
-  return arg.type === 'ArrayExpression' && _.every(arg.elements, isModuleId);
+function isModulesList(node) {
+  return isSimpleModulesList(node) ||
+  // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+  isOptimizedModulesArray(node);
 }
 
-function isArgumentContainsModulesList(arg) {
-  if (arg.type === 'ObjectExpression') {
-    return _(arg.properties).map('value').every(isModuleWrapper);
-  }
-
-  if (arg.type === 'ArrayExpression') {
-    // Modules are contained in array.
-    // Array indexes are module ids
-    return _.every(arg.elements, function (elem) {
-      return (
-        // Some of array items may be skipped because there is no module with such id
-        !elem || isModuleWrapper(elem)
-      );
-    });
-  }
+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)
+  );
+}
 
-  return false;
+function isModulesHash(node) {
+  return node.type === 'ObjectExpression' && _(node.properties).map('value').every(isModuleWrapper);
 }
 
-function isArgumentContainingChunkIdsAndModulesList(arg) {
-  if (arg.type === 'ArrayExpression' && arg.elements.length >= 2 && isArgumentContainsChunkIds(arg.elements[0]) && isArgumentContainsModulesList(arg.elements[1])) {
-    return true;
-  }
-  return false;
+function isModulesArray(node) {
+  return node.type === 'ArrayExpression' && _.every(node.elements, function (elem) {
+    return (
+      // Some of array items may be skipped because there is no module with such id
+      !elem || isModuleWrapper(elem)
+    );
+  });
 }
 
-function isArgumentArrayConcatContainingChunks(arg) {
-  if (arg.type === 'CallExpression' && arg.callee.type === 'MemberExpression' &&
+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>)`
-  arg.callee.object.type === 'CallExpression' && arg.callee.object.callee.type === 'Identifier' && arg.callee.object.callee.name === 'Array' && arg.callee.object.arguments.length === 1 && isNumericId(arg.callee.object.arguments[0]) &&
+  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`
-  arg.callee.property.type === 'Identifier' && arg.callee.property.name === 'concat' &&
+  node.callee.property.type === 'Identifier' && node.callee.property.name === 'concat' &&
   // Make sure exactly one array is passed in to `concat`
-  arg.arguments.length === 1 && arg.arguments[0].type === 'ArrayExpression') {
-    // Modules are contained in `Array(<minimum ID>).concat(` array:
-    // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
-    // The `<minimum ID>` + array indexes are module ids
-    return true;
-  }
-
-  return false;
-}
-
-function isAsyncChunkPushExpression(node) {
-  var callee = node.callee;
-
-  return callee.type === 'MemberExpression' && callee.property.name === 'push' && callee.object.type === 'AssignmentExpression' && (callee.object.left.object.name === 'window' ||
-  // Webpack 4 uses `this` instead of `window`
-  callee.object.left.object.type === 'ThisExpression');
+  node.arguments.length === 1 && isModulesArray(node.arguments[0]);
 }
 
 function isModuleWrapper(node) {
@@ -157,9 +137,29 @@ function isNumericId(node) {
   return node.type === 'Literal' && Number.isInteger(node.value) && node.value >= 0;
 }
 
-function getModulesLocationFromFunctionArgument(arg) {
-  if (arg.type === 'ObjectExpression') {
-    var modulesNodes = arg.properties;
+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);
+}
+
+function isAsyncChunkPushExpression(node) {
+  var callee = node.callee,
+      args = node.arguments;
+
+
+  return callee.type === 'MemberExpression' && callee.property.name === 'push' && callee.object.type === 'AssignmentExpression' && callee.object.left.object && (callee.object.left.object.name === 'window' ||
+  // Webpack 4 uses `this` instead of `window`
+  callee.object.left.object.type === 'ThisExpression') && 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 getModulesLocations(node) {
+  if (node.type === 'ObjectExpression') {
+    // Modules hash
+    var modulesNodes = node.properties;
 
     return _.transform(modulesNodes, function (result, moduleNode) {
       var moduleId = moduleNode.key.name || moduleNode.key.value;
@@ -168,35 +168,31 @@ function getModulesLocationFromFunctionArgument(arg) {
     }, {});
   }
 
-  if (arg.type === 'ArrayExpression') {
-    var _modulesNodes = arg.elements;
+  var isOptimizedArray = node.type === 'CallExpression';
+
+  if (node.type === 'ArrayExpression' || isOptimizedArray) {
+    // Modules array or optimized array
+    var 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;
+    var _modulesNodes = isOptimizedArray ?
+    // The modules reside in the `concat()` function call arguments
+    node.arguments[0].elements : node.elements;
 
     return _.transform(_modulesNodes, function (result, moduleNode, i) {
       if (!moduleNode) return;
-
-      result[i] = getModuleLocation(moduleNode);
+      result[i + minId] = getModuleLocation(moduleNode);
     }, {});
   }
 
   return {};
 }
 
-function getModulesLocationFromArrayConcat(arg) {
-  // arg(CallExpression) =
-  //   Array([minId]).concat([<minId module>, <minId+1 module>, ...])
-  //
-  // Get the [minId] value from the Array() call first argument literal value
-  var minId = arg.callee.object.arguments[0].value;
-  // The modules reside in the `concat()` function call arguments
-  var modulesNodes = arg.arguments[0].elements;
-
-  return _.transform(modulesNodes, function (result, moduleNode, i) {
-    if (!moduleNode) return;
-
-    result[i + minId] = getModuleLocation(moduleNode);
-  }, {});
-}
-
 function getModuleLocation(node) {
-  return _.pick(node, 'start', 'end');
+  return {
+    start: node.start,
+    end: node.end
+  };
 }

package/lib/tree/BaseFolder.js

@@ -111,9 +111,8 @@ var BaseFolder = function (_Node) {
     key: 'src',
     get: function get() {
       if (!_lodash2.default.has(this, '_src')) {
-        this._src = this.walk(function (node, src, stop) {
-          if (node.src === undefined) return stop(undefined);
-          return src += node.src;
+        this._src = this.walk(function (node, src) {
+          return src += node.src || '';
         }, '', false);
       }
 

package/lib/tree/Folder.js

@@ -94,13 +94,13 @@ var Folder = function (_BaseFolder) {
   }, {
     key: 'parsedSize',
     get: function get() {
-      return this.src ? this.src.length : undefined;
+      return this.src ? this.src.length : 0;
     }
   }, {
     key: 'gzipSize',
     get: function get() {
       if (!_lodash2.default.has(this, '_gzipSize')) {
-        this._gzipSize = this.src ? _gzipSize2.default.sync(this.src) : undefined;
+        this._gzipSize = this.src ? _gzipSize2.default.sync(this.src) : 0;
       }
 
       return this._gzipSize;

package/lib/utils.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var _require = require('util'),
+    inspect = _require.inspect;
+
+var _ = require('lodash');
+
+exports.createAssetsFilter = createAssetsFilter;
+
+function createAssetsFilter(excludePatterns) {
+  var excludeFunctions = _(excludePatterns).castArray().compact().map(function (pattern) {
+    if (typeof pattern === 'string') {
+      pattern = new RegExp(pattern);
+    }
+
+    if (_.isRegExp(pattern)) {
+      return function (asset) {
+        return pattern.test(asset);
+      };
+    }
+
+    if (!_.isFunction(pattern)) {
+      throw new TypeError(`Pattern should be either string, RegExp or a function, but "${inspect(pattern, { depth: 0 })}" got.`);
+    }
+
+    return pattern;
+  }).value();
+
+  if (excludeFunctions.length) {
+    return function (asset) {
+      return _.every(excludeFunctions, function (fn) {
+        return fn(asset) !== true;
+      });
+    };
+  } else {
+    return function () {
+      return true;
+    };
+  }
+}

package/lib/viewer.js

@@ -14,9 +14,13 @@ var startServer = function () {
         _ref2$logger = _ref2.logger,
         logger = _ref2$logger === undefined ? new Logger() : _ref2$logger,
         _ref2$defaultSizes = _ref2.defaultSizes,
-        defaultSizes = _ref2$defaultSizes === undefined ? 'parsed' : _ref2$defaultSizes;
+        defaultSizes = _ref2$defaultSizes === undefined ? 'parsed' : _ref2$defaultSizes,
+        _ref2$excludeAssets = _ref2.excludeAssets,
+        excludeAssets = _ref2$excludeAssets === undefined ? null : _ref2$excludeAssets;
 
-    var chartData = getChartData(logger, bundleStats, bundleDir);
+    var analyzerOpts = { logger, excludeAssets };
+
+    var chartData = getChartData(analyzerOpts, bundleStats, bundleDir);
 
     if (!chartData) return;
 
@@ -73,7 +77,7 @@ var startServer = function () {
     };
 
     function updateChartData(bundleStats) {
-      var newChartData = getChartData(logger, bundleStats, bundleDir);
+      var newChartData = getChartData(analyzerOpts, bundleStats, bundleDir);
 
       if (!newChartData) return;
 
@@ -134,9 +138,11 @@ function generateReport(bundleStats, opts) {
       _ref3$logger = _ref3.logger,
       logger = _ref3$logger === undefined ? new Logger() : _ref3$logger,
       _ref3$defaultSizes = _ref3.defaultSizes,
-      defaultSizes = _ref3$defaultSizes === undefined ? 'parsed' : _ref3$defaultSizes;
+      defaultSizes = _ref3$defaultSizes === undefined ? 'parsed' : _ref3$defaultSizes,
+      _ref3$excludeAssets = _ref3.excludeAssets,
+      excludeAssets = _ref3$excludeAssets === undefined ? null : _ref3$excludeAssets;
 
-  var chartData = getChartData(logger, bundleStats, bundleDir);
+  var chartData = getChartData({ logger, excludeAssets }, bundleStats, bundleDir);
 
   if (!chartData) return;
 
@@ -165,22 +171,24 @@ function getAssetContent(filename) {
   return fs.readFileSync(`${projectRoot}/public/${filename}`, 'utf8');
 }
 
-function getChartData(logger) {
+function getChartData(analyzerOpts) {
   var chartData = void 0;
+  var logger = analyzerOpts.logger;
+
 
   try {
     for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       args[_key - 1] = arguments[_key];
     }
 
-    chartData = analyzer.getViewerData.apply(analyzer, args.concat([{ logger }]));
+    chartData = analyzer.getViewerData.apply(analyzer, args.concat([analyzerOpts]));
   } catch (err) {
     logger.error(`Could't analyze webpack bundle:\n${err}`);
     logger.debug(err.stack);
     chartData = null;
   }
 
-  if (_.isEmpty(chartData)) {
+  if (_.isPlainObject(chartData) && _.isEmpty(chartData)) {
     logger.error("Could't find any javascript bundles in provided stats file");
     chartData = null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack-bundle-analyzer",
-  "version": "2.11.2",
+  "version": "2.13.1",
   "description": "Webpack plugin and CLI utility that represents bundle content as convenient interactive zoomable treemap",
   "author": "Yury Grunin <grunin.ya@ya.ru>",
   "license": "MIT",