first commit

node_modules/webpack-bundle-analyzer/lib/BundleAnalyzerPlugin.js

@@ -0,0 +1,190 @@
+"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 path = require('path');
+
+const mkdir = require('mkdirp');
+
+const {
+  bold
+} = require('chalk');
+
+const Logger = require('./Logger');
+
+const viewer = require('./viewer');
+
+const utils = require('./utils');
+
+class BundleAnalyzerPlugin {
+  constructor(opts = {}) {
+    this.opts = _objectSpread({
+      analyzerMode: 'server',
+      analyzerHost: '127.0.0.1',
+      reportFilename: null,
+      reportTitle: utils.defaultTitle,
+      defaultSizes: 'parsed',
+      openAnalyzer: true,
+      generateStatsFile: false,
+      statsFilename: 'stats.json',
+      statsOptions: null,
+      excludeAssets: null,
+      logLevel: 'info',
+      // deprecated
+      startAnalyzer: true
+    }, opts, {
+      analyzerPort: 'analyzerPort' in opts ? opts.analyzerPort === 'auto' ? 0 : opts.analyzerPort : 8888
+    });
+    this.server = null;
+    this.logger = new Logger(this.opts.logLevel);
+  }
+
+  apply(compiler) {
+    this.compiler = compiler;
+
+    const done = (stats, callback) => {
+      callback = callback || (() => {});
+
+      const actions = [];
+
+      if (this.opts.generateStatsFile) {
+        actions.push(() => this.generateStatsFile(stats.toJson(this.opts.statsOptions)));
+      } // Handling deprecated `startAnalyzer` flag
+
+
+      if (this.opts.analyzerMode === 'server' && !this.opts.startAnalyzer) {
+        this.opts.analyzerMode = 'disabled';
+      }
+
+      if (this.opts.analyzerMode === 'server') {
+        actions.push(() => this.startAnalyzerServer(stats.toJson()));
+      } else if (this.opts.analyzerMode === 'static') {
+        actions.push(() => this.generateStaticReport(stats.toJson()));
+      } else if (this.opts.analyzerMode === 'json') {
+        actions.push(() => this.generateJSONReport(stats.toJson()));
+      }
+
+      if (actions.length) {
+        // Making analyzer logs to be after all webpack logs in the console
+        setImmediate( /*#__PURE__*/_asyncToGenerator(function* () {
+          try {
+            yield Promise.all(actions.map(action => action()));
+            callback();
+          } catch (e) {
+            callback(e);
+          }
+        }));
+      } else {
+        callback();
+      }
+    };
+
+    if (compiler.hooks) {
+      compiler.hooks.done.tapAsync('webpack-bundle-analyzer', done);
+    } else {
+      compiler.plugin('done', done);
+    }
+  }
+
+  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'
+        });
+
+        _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
+        });
+      }
+    })();
+  }
+
+  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
+      });
+    })();
+  }
+
+  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
+      });
+    })();
+  }
+
+  getBundleDirFromCompiler() {
+    switch (this.compiler.outputFileSystem.constructor.name) {
+      case 'MemoryFileSystem':
+        return null;
+      // Detect AsyncMFS used by Nuxt 2.5 that replaces webpack's MFS during development
+      // Related: #274
+
+      case 'AsyncMFS':
+        return null;
+
+      default:
+        return this.compiler.outputPath;
+    }
+  }
+
+}
+
+module.exports = BundleAnalyzerPlugin;

node_modules/webpack-bundle-analyzer/lib/Logger.js

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

node_modules/webpack-bundle-analyzer/lib/analyzer.js

@@ -0,0 +1,160 @@
+"use strict";
+
+const fs = require('fs');
+
+const path = require('path');
+
+const _ = require('lodash');
+
+const gzipSize = require('gzip-size');
+
+const Logger = require('./Logger');
+
+const Folder = require('./tree/Folder').default;
+
+const {
+  parseBundle
+} = require('./parseUtils');
+
+const {
+  createAssetsFilter
+} = require('./utils');
+
+const FILENAME_QUERY_REGEXP = /\?.*$/u;
+const FILENAME_EXTENSIONS = /\.(js|mjs)$/iu;
+module.exports = {
+  getViewerData,
+  readStatsFromFile
+};
+
+function getViewerData(bundleStats, bundleDir, opts) {
+  const {
+    logger = new Logger(),
+    excludeAssets = null
+  } = opts || {};
+  const isAssetIncluded = createAssetsFilter(excludeAssets); // Sometimes all the information is located in `children` array (e.g. problem in #10)
+
+  if (_.isEmpty(bundleStats.assets) && !_.isEmpty(bundleStats.children)) {
+    const {
+      children
+    } = bundleStats;
+    bundleStats = bundleStats.children[0]; // Sometimes if there are additional child chunks produced add them as child assets,
+    // leave the 1st one as that is considered the 'root' asset.
+
+    for (let i = 1; i < children.length; i++) {
+      bundleStats.children[i].assets.forEach(asset => {
+        asset.isChild = true;
+        bundleStats.assets.push(asset);
+      });
+    }
+  } else if (!_.isEmpty(bundleStats.children)) {
+    // Sometimes if there are additional child chunks produced add them as child assets
+    bundleStats.children.forEach(child => {
+      child.assets.forEach(asset => {
+        asset.isChild = true;
+        bundleStats.assets.push(asset);
+      });
+    });
+  } // 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)
+    // 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
+
+  let bundlesSources = null;
+  let parsedModules = null;
+
+  if (bundleDir) {
+    bundlesSources = {};
+    parsedModules = {};
+
+    for (const statAsset of bundleStats.assets) {
+      const assetFile = path.join(bundleDir, statAsset.name);
+      let bundleInfo;
+
+      try {
+        bundleInfo = parseBundle(assetFile);
+      } catch (err) {
+        const msg = err.code === 'ENOENT' ? 'no such file' : err.message;
+        logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+        continue;
+      }
+
+      bundlesSources[statAsset.name] = bundleInfo.src;
+
+      _.assign(parsedModules, bundleInfo.modules);
+    }
+
+    if (_.isEmpty(bundlesSources)) {
+      bundlesSources = null;
+      parsedModules = null;
+      logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n');
+    }
+  }
+
+  const assets = _.transform(bundleStats.assets, (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]);
+    } // Picking modules from current bundle script
+
+
+    asset.modules = _(modules).filter(statModule => assetHasModule(statAsset, statModule)).each(statModule => {
+      if (parsedModules) {
+        statModule.parsedSrc = parsedModules[statModule.id];
+      }
+    });
+    asset.tree = createModulesTree(asset.modules);
+  }, {});
+
+  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')
+    });
+  }, []);
+}
+
+function readStatsFromFile(filename) {
+  return JSON.parse(fs.readFileSync(filename, 'utf8'));
+}
+
+function getChildAssetBundles(bundleStats, assetName) {
+  return _.find(bundleStats.children, c => _(c.assetsByChunkName).values().flatten().includes(assetName));
+}
+
+function getBundleModules(bundleStats) {
+  return _(bundleStats.chunks).map('modules').concat(bundleStats.modules).compact().flatten().uniqBy('id').value();
+}
+
+function assetHasModule(statAsset, statModule) {
+  // Checking if this module is the part of asset chunks
+  return _.some(statModule.chunks, moduleChunk => _.includes(statAsset.chunks, moduleChunk));
+}
+
+function createModulesTree(modules) {
+  const root = new Folder('.');
+
+  _.each(modules, module => root.addModule(module));
+
+  root.mergeNestedFolders();
+  return root;
+}

node_modules/webpack-bundle-analyzer/lib/bin/analyzer.js

@@ -0,0 +1,125 @@
+#! /usr/bin/env node
+"use strict";
+
+const {
+  resolve,
+  dirname
+} = require('path');
+
+const _ = require('lodash');
+
+const commander = require('commander');
+
+const {
+  magenta
+} = require('chalk');
+
+const analyzer = require('../analyzer');
+
+const viewer = require('../viewer');
+
+const Logger = require('../Logger');
+
+const utils = require('../utils');
+
+const SIZES = new Set(['stat', 'parsed', 'gzip']);
+const program = commander.version(require('../../package.json').version).usage(`<bundleStatsFile> [bundleDir] [options]
+
+  Arguments:
+  
+    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`,`static` or `json`.' + 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('In `json` mode single JSON file with bundle report will be generated.'), 'server').option( // Had to make `host` parameter optional in order to let `-h` flag output help message
+// Fixes https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/239
+'-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.', 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.').option('-t, --title <title>', 'String to use in title element of html report.').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[...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: ${[...Logger.levels].join(', ')}`), Logger.defaultLevel).parse(process.argv);
+let {
+  mode,
+  host,
+  port,
+  report: reportFilename,
+  title: reportTitle,
+  defaultSizes,
+  logLevel,
+  open: openBrowser,
+  exclude: excludeAssets,
+  args: [bundleStatsFile, bundleDir]
+} = program;
+const logger = new Logger(logLevel);
+
+if (typeof reportTitle === 'undefined') {
+  reportTitle = utils.defaultTitle;
+}
+
+if (!bundleStatsFile) showHelp('Provide path to Webpack Stats file as first argument');
+
+if (mode !== 'server' && mode !== 'static' && mode !== 'json') {
+  showHelp('Invalid mode. Should be either `server`, `static` or `json`.');
+}
+
+if (mode === 'server') {
+  if (!host) showHelp('Invalid host name');
+  port = port === 'auto' ? 0 : Number(port);
+  if (isNaN(port)) showHelp('Invalid port. Should be a number or `auto`');
+}
+
+if (!SIZES.has(defaultSizes)) showHelp(`Invalid default sizes option. Possible values are: ${[...SIZES].join(', ')}`);
+bundleStatsFile = resolve(bundleStatsFile);
+if (!bundleDir) bundleDir = dirname(bundleStatsFile);
+let bundleStats;
+
+try {
+  bundleStats = analyzer.readStatsFromFile(bundleStatsFile);
+} catch (err) {
+  logger.error(`Couldn't read webpack bundle stats from "${bundleStatsFile}":\n${err}`);
+  logger.debug(err.stack);
+  process.exit(1);
+}
+
+if (mode === 'server') {
+  viewer.startServer(bundleStats, {
+    openBrowser,
+    port,
+    host,
+    defaultSizes,
+    reportTitle,
+    bundleDir,
+    excludeAssets,
+    logger: new Logger(logLevel)
+  });
+} else if (mode === 'static') {
+  viewer.generateReport(bundleStats, {
+    openBrowser,
+    reportFilename: resolve(reportFilename || 'report.html'),
+    reportTitle,
+    defaultSizes,
+    bundleDir,
+    excludeAssets,
+    logger: new Logger(logLevel)
+  });
+} else if (mode === 'json') {
+  viewer.generateJSONReport(bundleStats, {
+    reportFilename: resolve(reportFilename || 'report.json'),
+    bundleDir,
+    excludeAssets,
+    logger: new Logger(logLevel)
+  });
+}
+
+function showHelp(error) {
+  if (error) console.log(`\n  ${magenta(error)}\n`);
+  program.outputHelp();
+  process.exit(1);
+}
+
+function br(str) {
+  return `\n${_.repeat(' ', 28)}${str}`;
+}
+
+function array() {
+  const arr = [];
+  return val => {
+    arr.push(val);
+    return arr;
+  };
+}

node_modules/webpack-bundle-analyzer/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const {
+  start
+} = require('./viewer');
+
+module.exports = {
+  start,
+  BundleAnalyzerPlugin: require('./BundleAnalyzerPlugin')
+};

node_modules/webpack-bundle-analyzer/lib/parseUtils.js

@@ -0,0 +1,203 @@
+"use strict";
+
+const fs = require('fs');
+
+const _ = require('lodash');
+
+const acorn = require('acorn');
+
+const walk = require('acorn-walk');
+
+module.exports = {
+  parseBundle
+};
+
+function parseBundle(bundlePath) {
+  const content = fs.readFileSync(bundlePath, 'utf8');
+  const ast = acorn.parse(content, {
+    sourceType: 'script',
+    // 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
+  });
+  const walkState = {
+    locations: null
+  };
+  walk.recursive(ast, walkState, {
+    AssignmentExpression(node, state) {
+      if (state.locations) return; // Modules are stored in exports.modules:
+      // exports.modules = {};
+
+      const {
+        left,
+        right
+      } = node;
+
+      if (left && left.object && left.object.name === 'exports' && left.property && left.property.name === 'modules' && isModulesHash(right)) {
+        state.locations = getModulesLocations(right);
+      }
+    },
+
+    CallExpression(node, state, c) {
+      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])) {
+        state.locations = getModulesLocations(args[0]);
+        return;
+      } // 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])) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      } // 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;
+      } // Webpack v4 WebWorkerChunkTemplatePlugin
+      // globalObject.chunkCallbackName([<chunks>],<modules>, ...);
+      // Both globalObject and chunkCallbackName can be changed through the config, so we can't check them.
+
+
+      if (isAsyncWebWorkerChunkExpression(node)) {
+        state.locations = getModulesLocations(args[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, arg => c(arg, state));
+    }
+
+  });
+  let modules;
+
+  if (walkState.locations) {
+    modules = _.mapValues(walkState.locations, loc => content.slice(loc.start, loc.end));
+  } else {
+    modules = {};
+  }
+
+  return {
+    src: content,
+    modules
+  };
+}
+
+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('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
+  !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' && _.every(node.elements, 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 _.transform(modulesNodes, (result, moduleNode) => {
+      const moduleId = moduleNode.key.name || moduleNode.key.value;
+      result[moduleId] = getModuleLocation(moduleNode.value);
+    }, {});
+  }
+
+  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 _.transform(modulesNodes, (result, moduleNode, i) => {
+      if (!moduleNode) return;
+      result[i + minId] = getModuleLocation(moduleNode);
+    }, {});
+  }
+
+  return {};
+}
+
+function getModuleLocation(node) {
+  return {
+    start: node.start,
+    end: node.end
+  };
+}

node_modules/webpack-bundle-analyzer/lib/tree/BaseFolder.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _Node = _interopRequireDefault(require("./Node"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class BaseFolder extends _Node.default {
+  constructor(name, parent) {
+    super(name, parent);
+    this.children = Object.create(null);
+  }
+
+  get src() {
+    if (!_lodash.default.has(this, '_src')) {
+      this._src = this.walk((node, src) => src += node.src || '', '', false);
+    }
+
+    return this._src;
+  }
+
+  get size() {
+    if (!_lodash.default.has(this, '_size')) {
+      this._size = this.walk((node, size) => size + node.size, 0, false);
+    }
+
+    return this._size;
+  }
+
+  getChild(name) {
+    return this.children[name];
+  }
+
+  addChildModule(module) {
+    const {
+      name
+    } = module;
+    const 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;
+  }
+
+  addChildFolder(folder) {
+    folder.parent = this;
+    this.children[folder.name] = folder;
+    delete this._size;
+    delete this._src;
+    return folder;
+  }
+
+  walk(walker, state = {}, deep = true) {
+    let stopped = false;
+
+    _lodash.default.each(this.children, 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;
+    }
+  }
+
+  mergeNestedFolders() {
+    if (!this.isRoot) {
+      let childNames;
+
+      while ((childNames = Object.keys(this.children)).length === 1) {
+        const childName = childNames[0];
+        const onlyChild = this.children[childName];
+
+        if (onlyChild instanceof this.constructor) {
+          this.name += `/${onlyChild.name}`;
+          this.children = onlyChild.children;
+        } else {
+          break;
+        }
+      }
+    }
+
+    this.walk(child => {
+      child.parent = this;
+
+      if (child.mergeNestedFolders) {
+        child.mergeNestedFolders();
+      }
+    }, null, false);
+  }
+
+  toChartData() {
+    return {
+      label: this.name,
+      path: this.path,
+      statSize: this.size,
+      groups: _lodash.default.invokeMap(this.children, 'toChartData')
+    };
+  }
+
+}
+
+exports.default = BaseFolder;
+;

node_modules/webpack-bundle-analyzer/lib/tree/ConcatenatedModule.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _Module = _interopRequireDefault(require("./Module"));
+
+var _ContentModule = _interopRequireDefault(require("./ContentModule"));
+
+var _ContentFolder = _interopRequireDefault(require("./ContentFolder"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class ConcatenatedModule extends _Module.default {
+  constructor(name, data, parent) {
+    super(name, data, parent);
+    this.name += ' (concatenated)';
+    this.children = Object.create(null);
+    this.fillContentModules();
+  }
+
+  fillContentModules() {
+    _lodash.default.each(this.data.modules, moduleData => this.addContentModule(moduleData));
+  }
+
+  addContentModule(moduleData) {
+    const pathParts = (0, _utils.getModulePathParts)(moduleData);
+
+    if (!pathParts) {
+      return;
+    }
+
+    const [folders, fileName] = [pathParts.slice(0, -1), _lodash.default.last(pathParts)];
+    let currentFolder = this;
+
+    _lodash.default.each(folders, folderName => {
+      let childFolder = currentFolder.getChild(folderName);
+
+      if (!childFolder) {
+        childFolder = currentFolder.addChildFolder(new _ContentFolder.default(folderName, this));
+      }
+
+      currentFolder = childFolder;
+    });
+
+    const module = new _ContentModule.default(fileName, moduleData, this);
+    currentFolder.addChildModule(module);
+  }
+
+  getChild(name) {
+    return this.children[name];
+  }
+
+  addChildModule(module) {
+    module.parent = this;
+    this.children[module.name] = module;
+  }
+
+  addChildFolder(folder) {
+    folder.parent = this;
+    this.children[folder.name] = folder;
+    return folder;
+  }
+
+  mergeNestedFolders() {
+    _lodash.default.invokeMap(this.children, 'mergeNestedFolders');
+  }
+
+  toChartData() {
+    return _objectSpread({}, super.toChartData(), {
+      concatenated: true,
+      groups: _lodash.default.invokeMap(this.children, 'toChartData')
+    });
+  }
+
+}
+
+exports.default = ConcatenatedModule;
+;

node_modules/webpack-bundle-analyzer/lib/tree/ContentFolder.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _BaseFolder = _interopRequireDefault(require("./BaseFolder"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class ContentFolder extends _BaseFolder.default {
+  constructor(name, ownerModule, parent) {
+    super(name, parent);
+    this.ownerModule = ownerModule;
+  }
+
+  get parsedSize() {
+    return this.getSize('parsedSize');
+  }
+
+  get gzipSize() {
+    return this.getSize('gzipSize');
+  }
+
+  getSize(sizeType) {
+    const ownerModuleSize = this.ownerModule[sizeType];
+
+    if (ownerModuleSize !== undefined) {
+      return Math.floor(this.size / this.ownerModule.size * ownerModuleSize);
+    }
+  }
+
+  toChartData() {
+    return _objectSpread({}, super.toChartData(), {
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize,
+      inaccurateSizes: true
+    });
+  }
+
+}
+
+exports.default = ContentFolder;
+;

node_modules/webpack-bundle-analyzer/lib/tree/ContentModule.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Module = _interopRequireDefault(require("./Module"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class ContentModule extends _Module.default {
+  constructor(name, data, ownerModule, parent) {
+    super(name, data, parent);
+    this.ownerModule = ownerModule;
+  }
+
+  get parsedSize() {
+    return this.getSize('parsedSize');
+  }
+
+  get gzipSize() {
+    return this.getSize('gzipSize');
+  }
+
+  getSize(sizeType) {
+    const ownerModuleSize = this.ownerModule[sizeType];
+
+    if (ownerModuleSize !== undefined) {
+      return Math.floor(this.size / this.ownerModule.size * ownerModuleSize);
+    }
+  }
+
+  toChartData() {
+    return _objectSpread({}, super.toChartData(), {
+      inaccurateSizes: true
+    });
+  }
+
+}
+
+exports.default = ContentModule;
+;

node_modules/webpack-bundle-analyzer/lib/tree/Folder.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _gzipSize = _interopRequireDefault(require("gzip-size"));
+
+var _Module = _interopRequireDefault(require("./Module"));
+
+var _BaseFolder = _interopRequireDefault(require("./BaseFolder"));
+
+var _ConcatenatedModule = _interopRequireDefault(require("./ConcatenatedModule"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class Folder extends _BaseFolder.default {
+  get parsedSize() {
+    return this.src ? this.src.length : 0;
+  }
+
+  get gzipSize() {
+    if (!_lodash.default.has(this, '_gzipSize')) {
+      this._gzipSize = this.src ? _gzipSize.default.sync(this.src) : 0;
+    }
+
+    return this._gzipSize;
+  }
+
+  addModule(moduleData) {
+    const pathParts = (0, _utils.getModulePathParts)(moduleData);
+
+    if (!pathParts) {
+      return;
+    }
+
+    const [folders, fileName] = [pathParts.slice(0, -1), _lodash.default.last(pathParts)];
+    let currentFolder = this;
+
+    _lodash.default.each(folders, folderName => {
+      let childNode = currentFolder.getChild(folderName);
+
+      if ( // Folder is not created yet
+      !childNode || // In some situations (invalid usage of dynamic `require()`) webpack generates a module with empty require
+      // context, but it's moduleId points to a directory in filesystem.
+      // In this case we replace this `File` node with `Folder`.
+      // See `test/stats/with-invalid-dynamic-require.json` as an example.
+      !(childNode instanceof Folder)) {
+        childNode = currentFolder.addChildFolder(new Folder(folderName));
+      }
+
+      currentFolder = childNode;
+    });
+
+    const ModuleConstructor = moduleData.modules ? _ConcatenatedModule.default : _Module.default;
+    const module = new ModuleConstructor(fileName, moduleData, this);
+    currentFolder.addChildModule(module);
+  }
+
+  toChartData() {
+    return _objectSpread({}, super.toChartData(), {
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize
+    });
+  }
+
+}
+
+exports.default = Folder;
+;

node_modules/webpack-bundle-analyzer/lib/tree/Module.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _gzipSize = _interopRequireDefault(require("gzip-size"));
+
+var _Node = _interopRequireDefault(require("./Node"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Module extends _Node.default {
+  constructor(name, data, parent) {
+    super(name, parent);
+    this.data = data;
+  }
+
+  get src() {
+    return this.data.parsedSrc;
+  }
+
+  set src(value) {
+    this.data.parsedSrc = value;
+    delete this._gzipSize;
+  }
+
+  get size() {
+    return this.data.size;
+  }
+
+  set size(value) {
+    this.data.size = value;
+  }
+
+  get parsedSize() {
+    return this.src ? this.src.length : undefined;
+  }
+
+  get gzipSize() {
+    if (!_lodash.default.has(this, '_gzipSize')) {
+      this._gzipSize = this.src ? _gzipSize.default.sync(this.src) : undefined;
+    }
+
+    return this._gzipSize;
+  }
+
+  mergeData(data) {
+    if (data.size) {
+      this.size += data.size;
+    }
+
+    if (data.parsedSrc) {
+      this.src = (this.src || '') + data.parsedSrc;
+    }
+  }
+
+  toChartData() {
+    return {
+      id: this.data.id,
+      label: this.name,
+      path: this.path,
+      statSize: this.size,
+      parsedSize: this.parsedSize,
+      gzipSize: this.gzipSize
+    };
+  }
+
+}
+
+exports.default = Module;
+;

node_modules/webpack-bundle-analyzer/lib/tree/Node.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Node {
+  constructor(name, parent) {
+    this.name = name;
+    this.parent = parent;
+  }
+
+  get path() {
+    const path = [];
+    let node = this;
+
+    while (node) {
+      path.push(node.name);
+      node = node.parent;
+    }
+
+    return path.reverse().join('/');
+  }
+
+  get isRoot() {
+    return !this.parent;
+  }
+
+}
+
+exports.default = Node;
+;

node_modules/webpack-bundle-analyzer/lib/tree/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getModulePathParts = getModulePathParts;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const MULTI_MODULE_REGEXP = /^multi /u;
+
+function getModulePathParts(moduleData) {
+  if (MULTI_MODULE_REGEXP.test(moduleData.identifier)) {
+    return [moduleData.identifier];
+  }
+
+  const parsedPath = _lodash.default // Removing loaders from module path: they're joined by `!` and the last part is a raw module path
+  .last(moduleData.name.split('!')) // Splitting module path into parts
+  .split('/') // Removing first `.`
+  .slice(1) // Replacing `~` with `node_modules`
+  .map(part => part === '~' ? 'node_modules' : part);
+
+  return parsedPath.length ? parsedPath : null;
+}

node_modules/webpack-bundle-analyzer/lib/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const {
+  inspect
+} = require('util');
+
+const _ = require('lodash');
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+exports.createAssetsFilter = createAssetsFilter;
+
+function createAssetsFilter(excludePatterns) {
+  const excludeFunctions = _(excludePatterns).castArray().compact().map(pattern => {
+    if (typeof pattern === 'string') {
+      pattern = new RegExp(pattern, 'u');
+    }
+
+    if (_.isRegExp(pattern)) {
+      return asset => 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 asset => _.every(excludeFunctions, fn => fn(asset) !== true);
+  } else {
+    return () => true;
+  }
+}
+/**
+ * @desc get string of current time
+ * format: dd/MMM HH:mm
+ * */
+
+
+exports.defaultTitle = function () {
+  const time = new Date();
+  const year = time.getFullYear();
+  const month = MONTHS[time.getMonth()];
+  const day = time.getDate();
+  const hour = `0${time.getHours()}`.slice(-2);
+  const minute = `0${time.getMinutes()}`.slice(-2);
+  const currentTime = `${day} ${month} ${year} at ${hour}:${minute}`;
+  return `${process.env.npm_package_name || 'Webpack Bundle Analyzer'} [${currentTime}]`;
+};

node_modules/webpack-bundle-analyzer/lib/viewer.js

@@ -0,0 +1,260 @@
+"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); }); }; }
+
+const path = require('path');
+
+const fs = require('fs');
+
+const http = require('http');
+
+const WebSocket = require('ws');
+
+const _ = require('lodash');
+
+const express = require('express');
+
+const ejs = require('ejs');
+
+const opener = require('opener');
+
+const mkdir = require('mkdirp');
+
+const {
+  bold
+} = require('chalk');
+
+const Logger = require('./Logger');
+
+const analyzer = require('./analyzer');
+
+const projectRoot = path.resolve(__dirname, '..');
+const assetsRoot = path.join(projectRoot, 'public');
+
+function resolveTitle(reportTitle) {
+  if (typeof reportTitle === 'function') {
+    return reportTitle();
+  } else {
+    return reportTitle;
+  }
+}
+
+module.exports = {
+  startServer,
+  generateReport,
+  generateJSONReport,
+  // deprecated
+  start: startServer
+};
+
+function startServer(_x, _x2) {
+  return _startServer.apply(this, arguments);
+}
+
+function _startServer() {
+  _startServer = _asyncToGenerator(function* (bundleStats, opts) {
+    const {
+      port = 8888,
+      host = '127.0.0.1',
+      openBrowser = true,
+      bundleDir = null,
+      logger = new Logger(),
+      defaultSizes = 'parsed',
+      excludeAssets = null,
+      reportTitle
+    } = opts || {};
+    const analyzerOpts = {
+      logger,
+      excludeAssets
+    };
+    let chartData = getChartData(analyzerOpts, bundleStats, bundleDir);
+    if (!chartData) return;
+    const app = express(); // Explicitly using our `ejs` dependency to render templates
+    // Fixes #17
+
+    app.engine('ejs', require('ejs').renderFile);
+    app.set('view engine', 'ejs');
+    app.set('views', `${projectRoot}/views`);
+    app.use(express.static(`${projectRoot}/public`));
+    app.use('/', (req, res) => {
+      res.render('viewer', {
+        mode: 'server',
+        title: resolveTitle(reportTitle),
+
+        get chartData() {
+          return chartData;
+        },
+
+        defaultSizes,
+        enableWebSocket: true,
+        // Helpers
+        escapeJson
+      });
+    });
+    const server = http.createServer(app);
+    yield new Promise(resolve => {
+      server.listen(port, host, () => {
+        resolve();
+        const url = `http://${host}:${server.address().port}`;
+        logger.info(`${bold('Webpack Bundle Analyzer')} is started at ${bold(url)}\n` + `Use ${bold('Ctrl+C')} to close it`);
+
+        if (openBrowser) {
+          opener(url);
+        }
+      });
+    });
+    const wss = new WebSocket.Server({
+      server
+    });
+    wss.on('connection', ws => {
+      ws.on('error', err => {
+        // Ignore network errors like `ECONNRESET`, `EPIPE`, etc.
+        if (err.errno) return;
+        logger.info(err.message);
+      });
+    });
+    return {
+      ws: wss,
+      http: server,
+      updateChartData
+    };
+
+    function updateChartData(bundleStats) {
+      const newChartData = getChartData(analyzerOpts, bundleStats, bundleDir);
+      if (!newChartData) return;
+      chartData = newChartData;
+      wss.clients.forEach(client => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(JSON.stringify({
+            event: 'chartDataUpdated',
+            data: newChartData
+          }));
+        }
+      });
+    }
+  });
+  return _startServer.apply(this, arguments);
+}
+
+function generateReport(_x3, _x4) {
+  return _generateReport.apply(this, arguments);
+}
+
+function _generateReport() {
+  _generateReport = _asyncToGenerator(function* (bundleStats, opts) {
+    const {
+      openBrowser = true,
+      reportFilename,
+      reportTitle,
+      bundleDir = null,
+      logger = new Logger(),
+      defaultSizes = 'parsed',
+      excludeAssets = null
+    } = opts || {};
+    const chartData = getChartData({
+      logger,
+      excludeAssets
+    }, bundleStats, bundleDir);
+    if (!chartData) return;
+    yield new Promise((resolve, reject) => {
+      ejs.renderFile(`${projectRoot}/views/viewer.ejs`, {
+        mode: 'static',
+        title: resolveTitle(reportTitle),
+        chartData,
+        defaultSizes,
+        enableWebSocket: false,
+        // Helpers
+        assetContent: getAssetContent,
+        escapeJson
+      }, (err, reportHtml) => {
+        try {
+          if (err) {
+            logger.error(err);
+            reject(err);
+            return;
+          }
+
+          const reportFilepath = path.resolve(bundleDir || process.cwd(), reportFilename);
+          mkdir.sync(path.dirname(reportFilepath));
+          fs.writeFileSync(reportFilepath, reportHtml);
+          logger.info(`${bold('Webpack Bundle Analyzer')} saved report to ${bold(reportFilepath)}`);
+
+          if (openBrowser) {
+            opener(`file://${reportFilepath}`);
+          }
+
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  });
+  return _generateReport.apply(this, arguments);
+}
+
+function generateJSONReport(_x5, _x6) {
+  return _generateJSONReport.apply(this, arguments);
+}
+
+function _generateJSONReport() {
+  _generateJSONReport = _asyncToGenerator(function* (bundleStats, opts) {
+    const {
+      reportFilename,
+      bundleDir = null,
+      logger = new Logger(),
+      excludeAssets = null
+    } = opts || {};
+    const chartData = getChartData({
+      logger,
+      excludeAssets
+    }, bundleStats, bundleDir);
+    if (!chartData) return;
+    mkdir.sync(path.dirname(reportFilename));
+    fs.writeFileSync(reportFilename, JSON.stringify(chartData));
+    logger.info(`${bold('Webpack Bundle Analyzer')} saved JSON report to ${bold(reportFilename)}`);
+  });
+  return _generateJSONReport.apply(this, arguments);
+}
+
+function getAssetContent(filename) {
+  const assetPath = path.join(assetsRoot, filename);
+
+  if (!assetPath.startsWith(assetsRoot)) {
+    throw new Error(`"${filename}" is outside of the assets root`);
+  }
+
+  return fs.readFileSync(assetPath, 'utf8');
+}
+/**
+ * Escapes `<` characters in JSON to safely use it in `<script>` tag.
+ */
+
+
+function escapeJson(json) {
+  return JSON.stringify(json).replace(/</gu, '\\u003c');
+}
+
+function getChartData(analyzerOpts, ...args) {
+  let chartData;
+  const {
+    logger
+  } = analyzerOpts;
+
+  try {
+    chartData = analyzer.getViewerData(...args, analyzerOpts);
+  } catch (err) {
+    logger.error(`Could't analyze webpack bundle:\n${err}`);
+    logger.debug(err.stack);
+    chartData = null;
+  }
+
+  if (_.isPlainObject(chartData) && _.isEmpty(chartData)) {
+    logger.error("Could't find any javascript bundles in provided stats file");
+    chartData = null;
+  }
+
+  return chartData;
+}