webpack-bundle-analyzer 2.9.2 → 2.11.1

package/CHANGELOG.md

@@ -14,6 +14,31 @@ _Note: Gaps between patch versions are faulty, broken or test releases._
 
 <!-- Add changelog entries for new changes under this section -->
 
+## 2.11.1
+
+ * **Improvement**
+   * Add support for parsing Webpack 4's chunked modules ([#159](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/159), [@jdelStrother](https://github.com/jdelStrother))
+
+## 2.11.0
+
+ * **Improvement**
+   * Show contents of concatenated module (requires Webpack 4) ([#158](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/158), closes [#157](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/157))
+
+## 2.10.1
+
+ * **Improvement**
+   * Support webpack 4 without deprecation warnings. @ai in [#156](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/156), fixes [#154](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/154)
+
+## 2.10.0
+
+ * **Bug Fix**
+   * Fix "out of memory" crash when dealing with huge stats objects ([#129](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/129), [@ryan953](https://github.com/ryan953))
+
+ * **Internal**
+   * Update dependencies ([#146](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/146))
+   * Update gulp to v4 and simplify gulpfile ([#146](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/146), [#149](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/149))
+   * Simplify ESLint configs ([#148](https://github.com/webpack-contrib/webpack-bundle-analyzer/pull/148))
+
 ## 2.9.2
 
  * **Bug Fix**

package/README.md

@@ -149,9 +149,11 @@ This is the size of running the parsed bundles/modules through gzip compression.
 
 ### I can't see all the dependencies in a chunk
 
-This is a known caveat when `webpack.optimize.ModuleConcatenationPlugin` is used. The way `ModuleConcatenationPlugin` works is that it merges multiple modules into a single one, and so that resulting module doesn't have edges anymore.
+This is a known caveat when `webpack.optimize.ModuleConcatenationPlugin` is used with `Webpack 3` or `webpack-bundle-analyzer < 2.11.0`.
+The way `ModuleConcatenationPlugin` works is that it merges multiple modules into a single one, and so that resulting module doesn't have edges anymore.
+`Webpack 3` didn't provide any information about concatenated modules, but `Webpack 4` started including it into a `stats` files and `webpack-bundle-analyzer 2.11.0` learned to show it.
 
-If you are interested to drill down to exact dependencies, try analyzing your bundle without `ModuleConcatenationPlugin`. See [issue #115](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/115) for more discussion.
+If for some reason you can't update to the latest versions try analyzing your bundle without `ModuleConcatenationPlugin`. See [issue #115](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/115) for more discussion.
 
 <h2 align="center">Maintainers</h2>
 

package/lib/BundleAnalyzerPlugin.js

@@ -6,7 +6,7 @@ function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, a
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var fs = require('fs');
+var bfj = require('bfj-node4');
 var path = require('path');
 var mkdir = require('mkdirp');
 
@@ -46,7 +46,7 @@ var BundleAnalyzerPlugin = function () {
 
       this.compiler = compiler;
 
-      compiler.plugin('done', function (stats) {
+      var done = function done(stats) {
         stats = stats.toJson(_this.opts.statsOptions);
 
         var actions = [];
@@ -80,23 +80,46 @@ var BundleAnalyzerPlugin = function () {
             });
           });
         }
-      });
+      };
+
+      if (compiler.hooks) {
+        compiler.hooks.done.tap('webpack-bundle-analyzer', done);
+      } else {
+        compiler.plugin('done', done);
+      }
     }
   }, {
     key: 'generateStatsFile',
-    value: function generateStatsFile(stats) {
-      var statsFilepath = path.resolve(this.compiler.outputPath, this.opts.statsFilename);
+    value: function () {
+      var _ref = _asyncToGenerator(function* (stats) {
+        var statsFilepath = path.resolve(this.compiler.outputPath, this.opts.statsFilename);
+        mkdir.sync(path.dirname(statsFilepath));
+
+        try {
+          yield bfj.write(statsFilepath, stats, {
+            promises: 'ignore',
+            buffers: 'ignore',
+            maps: 'ignore',
+            iterables: 'ignore',
+            circular: 'ignore'
+          });
 
-      mkdir.sync(path.dirname(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}`);
+        }
+      });
 
-      fs.writeFileSync(statsFilepath, JSON.stringify(stats, null, 2));
+      function generateStatsFile(_x) {
+        return _ref.apply(this, arguments);
+      }
 
-      this.logger.info(`${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`);
-    }
+      return generateStatsFile;
+    }()
   }, {
     key: 'startAnalyzerServer',
     value: function () {
-      var _ref = _asyncToGenerator(function* (stats) {
+      var _ref2 = _asyncToGenerator(function* (stats) {
         if (this.server) {
           (yield this.server).updateChartData(stats);
         } else {
@@ -111,8 +134,8 @@ var BundleAnalyzerPlugin = function () {
         }
       });
 
-      function startAnalyzerServer(_x) {
-        return _ref.apply(this, arguments);
+      function startAnalyzerServer(_x2) {
+        return _ref2.apply(this, arguments);
       }
 
       return startAnalyzerServer;

package/lib/Logger.js

@@ -6,13 +6,13 @@ var _createClass = function () { function defineProperties(target, props) { for
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var LEVELS = ['info', 'warn', 'error', 'silent'];
+var LEVELS = ['debug', 'info', 'warn', 'error', 'silent'];
 
-var LEVEL_TO_CONSOLE_METHOD = new Map([['info', 'log'], ['warn', 'log']]);
+var LEVEL_TO_CONSOLE_METHOD = new Map([['debug', 'log'], ['info', 'log'], ['warn', 'log']]);
 
 var Logger = function () {
   function Logger() {
-    var level = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'info';
+    var level = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Logger.defaultLevel;
 
     _classCallCheck(this, Logger);
 
@@ -76,6 +76,7 @@ var Logger = function () {
 }();
 
 Logger.levels = LEVELS;
+Logger.defaultLevel = 'info';
 ;
 
 LEVELS.forEach(function (level) {

package/lib/analyzer.js

@@ -7,15 +7,12 @@ var _ = require('lodash');
 var gzipSize = require('gzip-size');
 
 var Logger = require('./Logger');
+var Folder = require('./tree/Folder').default;
 
-var _require = require('../lib/tree'),
-    Folder = _require.Folder;
-
-var _require2 = require('../lib/parseUtils'),
-    parseBundle = _require2.parseBundle;
+var _require = require('./parseUtils'),
+    parseBundle = _require.parseBundle;
 
 var FILENAME_QUERY_REGEXP = /\?.*$/;
-var MULTI_MODULE_REGEXP = /^multi /;
 
 module.exports = {
   getViewerData,
@@ -142,32 +139,8 @@ function createModulesTree(modules) {
   var root = new Folder('.');
 
   _.each(modules, function (module) {
-    var path = getModulePath(module);
-
-    if (path) {
-      root.addModuleByPath(path, module);
-    }
+    return root.addModule(module);
   });
 
   return root;
-}
-
-function getModulePath(module) {
-  if (MULTI_MODULE_REGEXP.test(module.identifier)) {
-    return [module.identifier];
-  }
-
-  var parsedPath = _
-  // Removing loaders from module path: they're joined by `!` and the last part is a raw module path
-  .last(module.name.split('!'))
-  // Splitting module path into parts
-  .split('/')
-  // Removing first `.`
-  .slice(1)
-  // Replacing `~` with `node_modules`
-  .map(function (part) {
-    return part === '~' ? 'node_modules' : part;
-  });
-
-  return parsedPath.length ? parsedPath : null;
 }

package/lib/bin/analyzer.js

@@ -17,6 +17,7 @@ var _require2 = require('chalk'),
 
 var analyzer = require('../analyzer');
 var viewer = require('../viewer');
+var Logger = require('../Logger');
 
 var SIZES = new Set(['stat', 'parsed', 'gzip']);
 
@@ -27,18 +28,21 @@ 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.') + br('Default is `server`.'), 'server').option('-h, --host <host>', 'Host that will be used in `server` mode to start HTTP server.' + br('Default is `127.0.0.1`.'), '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.' + br('Default is 8888.'), Number, 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.' + br('Default is `report.html`.'), 'report.html').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[].concat(_toConsumableArray(SIZES)).join(', ')}`) + br('Default is `parsed`.'), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").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('-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,
     port = program.port,
     reportFilename = program.report,
     defaultSizes = program.defaultSizes,
+    logLevel = program.logLevel,
     openBrowser = program.open,
     _program$args = _slicedToArray(program.args, 2),
     bundleStatsFile = _program$args[0],
     bundleDir = _program$args[1];
 
+var logger = new Logger(logLevel);
+
 if (!bundleStatsFile) showHelp('Provide path to Webpack Stats file as first argument');
 if (mode !== 'server' && mode !== 'static') showHelp('Invalid mode. Should be either `server` or `static`.');
 if (mode === 'server' && !host) showHelp('Invalid host name');
@@ -53,7 +57,8 @@ var bundleStats = void 0;
 try {
   bundleStats = analyzer.readStatsFromFile(bundleStatsFile);
 } catch (err) {
-  console.error(`Could't read webpack bundle stats from "${bundleStatsFile}":\n${err}`);
+  logger.error(`Could't read webpack bundle stats from "${bundleStatsFile}":\n${err}`);
+  logger.debug(err.stack);
   process.exit(1);
 }
 
@@ -63,14 +68,16 @@ if (mode === 'server') {
     port,
     host,
     defaultSizes,
-    bundleDir
+    bundleDir,
+    logger: new Logger(logLevel)
   });
 } else {
   viewer.generateReport(bundleStats, {
     openBrowser,
     reportFilename: resolve(reportFilename),
     defaultSizes,
-    bundleDir
+    bundleDir,
+    logger: new Logger(logLevel)
   });
 }
 

package/lib/parseUtils.js

@@ -55,6 +55,13 @@ function parseBundle(bundlePath) {
         return;
       }
 
+      // Additional bundles with webpack 4 are loaded with:
+      // (window.webpackJsonp=window.webpackJsonp||[]).push([[chunkId], [<module>, <module>], [[optional_entries]]]);
+      if (isWindowPropertyPushExpression(node) && args.length === 1 && isArgumentContainingChunkIdsAndModulesList(args[0])) {
+        state.locations = getModulesLocationFromFunctionArgument(args[0].elements[1]);
+        return;
+      }
+
       // 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.
       _.each(args, function (arg) {
@@ -99,6 +106,13 @@ function isArgumentContainsModulesList(arg) {
   return false;
 }
 
+function isArgumentContainingChunkIdsAndModulesList(arg) {
+  if (arg.type === 'ArrayExpression' && arg.elements.length >= 2 && isArgumentContainsChunkIds(arg.elements[0]) && isArgumentContainsModulesList(arg.elements[1])) {
+    return true;
+  }
+  return false;
+}
+
 function isArgumentArrayConcatContainingChunks(arg) {
   if (arg.type === 'CallExpression' && arg.callee.type === 'MemberExpression' &&
   // Make sure the object called is `Array(<some number>)`
@@ -116,6 +130,10 @@ function isArgumentArrayConcatContainingChunks(arg) {
   return false;
 }
 
+function isWindowPropertyPushExpression(node) {
+  return node.callee.type === 'MemberExpression' && node.callee.property.name === 'push' && node.callee.object.type === 'AssignmentExpression' && node.callee.object.left.object.name === 'window';
+}
+
 function isModuleWrapper(node) {
   return (
     // It's an anonymous function expression that wraps module

package/lib/tree/BaseFolder.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _Node2 = require('./Node');
+
+var _Node3 = _interopRequireDefault(_Node2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var BaseFolder = function (_Node) {
+  _inherits(BaseFolder, _Node);
+
+  function BaseFolder(name, parent) {
+    _classCallCheck(this, BaseFolder);
+
+    var _this = _possibleConstructorReturn(this, (BaseFolder.__proto__ || Object.getPrototypeOf(BaseFolder)).call(this, name, parent));
+
+    _this.children = Object.create(null);
+    return _this;
+  }
+
+  _createClass(BaseFolder, [{
+    key: 'getChild',
+    value: function getChild(name) {
+      return this.children[name];
+    }
+  }, {
+    key: 'addChildModule',
+    value: function addChildModule(module) {
+      var name = module.name;
+
+      var currentChild = this.children[name];
+
+      // For some reason we already have this node in children and it's a folder.
+      if (currentChild && currentChild instanceof BaseFolder) return;
+
+      if (currentChild) {
+        // We already have this node in children and it's a module.
+        // Merging it's data.
+        currentChild.mergeData(module.data);
+      } else {
+        // Pushing new module
+        module.parent = this;
+        this.children[name] = module;
+      }
+
+      delete this._size;
+      delete this._src;
+    }
+  }, {
+    key: 'addChildFolder',
+    value: function addChildFolder(folder) {
+      folder.parent = this;
+      this.children[folder.name] = folder;
+      delete this._size;
+      delete this._src;
+
+      return folder;
+    }
+  }, {
+    key: 'walk',
+    value: function walk(walker) {
+      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+      var stopped = false;
+
+      _lodash2.default.each(this.children, function (child) {
+        if (deep && child.walk) {
+          state = child.walk(walker, state, stop);
+        } else {
+          state = walker(child, state, stop);
+        }
+
+        if (stopped) return false;
+      });
+
+      return state;
+
+      function stop(finalState) {
+        stopped = true;
+        return finalState;
+      }
+    }
+  }, {
+    key: 'toChartData',
+    value: function toChartData() {
+      return {
+        label: this.name,
+        path: this.path,
+        statSize: this.size,
+        groups: _lodash2.default.invokeMap(this.children, 'toChartData')
+      };
+    }
+  }, {
+    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;
+        }, '', false);
+      }
+
+      return this._src;
+    }
+  }, {
+    key: 'size',
+    get: function get() {
+      if (!_lodash2.default.has(this, '_size')) {
+        this._size = this.walk(function (node, size) {
+          return size + node.size;
+        }, 0, false);
+      }
+
+      return this._size;
+    }
+  }]);
+
+  return BaseFolder;
+}(_Node3.default);
+
+exports.default = BaseFolder;
+;

package/lib/tree/ConcatenatedModule.js

@@ -0,0 +1,122 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _Module2 = require('./Module');
+
+var _Module3 = _interopRequireDefault(_Module2);
+
+var _ContentModule = require('./ContentModule');
+
+var _ContentModule2 = _interopRequireDefault(_ContentModule);
+
+var _ContentFolder = require('./ContentFolder');
+
+var _ContentFolder2 = _interopRequireDefault(_ContentFolder);
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ConcatenatedModule = function (_Module) {
+  _inherits(ConcatenatedModule, _Module);
+
+  function ConcatenatedModule(name, data, parent) {
+    _classCallCheck(this, ConcatenatedModule);
+
+    var _this = _possibleConstructorReturn(this, (ConcatenatedModule.__proto__ || Object.getPrototypeOf(ConcatenatedModule)).call(this, name, data, parent));
+
+    _this.name += ' (concatenated)';
+    _this.children = Object.create(null);
+    _this.fillContentModules();
+    return _this;
+  }
+
+  _createClass(ConcatenatedModule, [{
+    key: 'fillContentModules',
+    value: function fillContentModules() {
+      var _this2 = this;
+
+      _lodash2.default.each(this.data.modules, function (moduleData) {
+        return _this2.addContentModule(moduleData);
+      });
+    }
+  }, {
+    key: 'addContentModule',
+    value: function addContentModule(moduleData) {
+      var _this3 = this;
+
+      var pathParts = (0, _utils.getModulePathParts)(moduleData);
+
+      if (!pathParts) {
+        return;
+      }
+
+      var _ref = [pathParts.slice(0, -1), _lodash2.default.last(pathParts)],
+          folders = _ref[0],
+          fileName = _ref[1];
+
+      var currentFolder = this;
+
+      _lodash2.default.each(folders, function (folderName) {
+        var childFolder = currentFolder.getChild(folderName);
+
+        if (!childFolder) {
+          childFolder = currentFolder.addChildFolder(new _ContentFolder2.default(folderName, _this3));
+        }
+
+        currentFolder = childFolder;
+      });
+
+      var module = new _ContentModule2.default(fileName, moduleData, this);
+      currentFolder.addChildModule(module);
+    }
+  }, {
+    key: 'getChild',
+    value: function getChild(name) {
+      return this.children[name];
+    }
+  }, {
+    key: 'addChildModule',
+    value: function addChildModule(module) {
+      module.parent = this;
+      this.children[module.name] = module;
+    }
+  }, {
+    key: 'addChildFolder',
+    value: function addChildFolder(folder) {
+      folder.parent = this;
+      this.children[folder.name] = folder;
+      return folder;
+    }
+  }, {
+    key: 'toChartData',
+    value: function toChartData() {
+      return Object.assign({}, _get(ConcatenatedModule.prototype.__proto__ || Object.getPrototypeOf(ConcatenatedModule.prototype), 'toChartData', this).call(this), {
+        concatenated: true,
+        groups: _lodash2.default.invokeMap(this.children, 'toChartData')
+      });
+    }
+  }]);
+
+  return ConcatenatedModule;
+}(_Module3.default);
+
+exports.default = ConcatenatedModule;
+;

package/lib/tree/ContentFolder.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+var _BaseFolder2 = require('./BaseFolder');
+
+var _BaseFolder3 = _interopRequireDefault(_BaseFolder2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ContentFolder = function (_BaseFolder) {
+  _inherits(ContentFolder, _BaseFolder);
+
+  function ContentFolder(name, ownerModule, parent) {
+    _classCallCheck(this, ContentFolder);
+
+    var _this = _possibleConstructorReturn(this, (ContentFolder.__proto__ || Object.getPrototypeOf(ContentFolder)).call(this, name, parent));
+
+    _this.ownerModule = ownerModule;
+    return _this;
+  }
+
+  _createClass(ContentFolder, [{
+    key: 'getSize',
+    value: function getSize(sizeType) {
+      var ownerModuleSize = this.ownerModule[sizeType];
+
+      if (ownerModuleSize !== undefined) {
+        return Math.floor(this.size / this.ownerModule.size * ownerModuleSize);
+      }
+    }
+  }, {
+    key: 'toChartData',
+    value: function toChartData() {
+      return Object.assign({}, _get(ContentFolder.prototype.__proto__ || Object.getPrototypeOf(ContentFolder.prototype), 'toChartData', this).call(this), {
+        parsedSize: this.parsedSize,
+        gzipSize: this.gzipSize,
+        inaccurateSizes: true
+      });
+    }
+  }, {
+    key: 'parsedSize',
+    get: function get() {
+      return this.getSize('parsedSize');
+    }
+  }, {
+    key: 'gzipSize',
+    get: function get() {
+      return this.getSize('gzipSize');
+    }
+  }]);
+
+  return ContentFolder;
+}(_BaseFolder3.default);
+
+exports.default = ContentFolder;
+;