@airyrooms/catela/dist/catela.build.setup.js

exports["setup"] =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

module.exports = require("path");

/***/ }),
/* 1 */
/***/ (function(module, exports) {

module.exports = require("preconditions");

/***/ }),
/* 2 */
/***/ (function(module, exports) {

module.exports = require("webpack");

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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 _path = __webpack_require__(0);

var _path2 = _interopRequireDefault(_path);

var _preconditions = __webpack_require__(1);

var _preconditions2 = _interopRequireDefault(_preconditions);

var _webpack = __webpack_require__(2);

var _webpack2 = _interopRequireDefault(_webpack);

var _WebpackConfigurationFactory = __webpack_require__(5);

var _WebpackConfigurationFactory2 = _interopRequireDefault(_WebpackConfigurationFactory);

var _webpackDevServer = __webpack_require__(12);

var _webpackDevServer2 = _interopRequireDefault(_webpackDevServer);

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"); } }

var UniversalWebApplicationSetup = function () {
  _createClass(UniversalWebApplicationSetup, null, [{
    key: 'create',
    value: function create(options) {
      return new UniversalWebApplicationSetup(options);
    }
  }]);

  function UniversalWebApplicationSetup(options) {
    _classCallCheck(this, UniversalWebApplicationSetup);

    var pc = _preconditions2.default.instance(options);
    pc.shouldBeDefined('name', 'Please provide the name of the application.');
    pc.shouldBeDefined('host', 'Please provide the host of the application.');
    pc.shouldBeDefined('port', 'Please provide the port of the application.');
    pc.shouldBeDefined('pingPort', 'Please provide the ping port of the application.');
    pc.shouldBeDefined('rootProjectPath', 'Please provide the rootProjectPath.');
    pc.shouldBeDefined('rootDeploymentPath', 'Please provide the rootDeploymentPath.');
    pc.shouldBeDefined('environment', 'Please provide the environment.');

    console.log('Application is initializing - ', options.name);

    this._options = options;

    if (this._options.modules == null || typeof this._options.modules === 'undefined') {
      this._options.modules = [];
    } else {
      if (!(this._options.modules instanceof Array)) {
        this._options.modules = [];
        console.warn('[COMPILER] Omitting modules entry. You should put the modules folder in an array.');
      }
    }

    this._applicationName = options.name;
    this._applicationHost = options.host;

    var rootProjectPath = options.rootProjectPath;
    var rootApplicationPath = _path2.default.join(options.rootProjectPath, 'applications', options.name);

    var rootDeploymentPath = options.rootDeploymentPath;
    var rootDeploymentApplicationPath = _path2.default.join(options.rootDeploymentPath, 'applications', options.name);

    console.log('==> rootProjectPath: ', rootProjectPath);
    console.log('==> rootApplicationPath: ', rootApplicationPath);
    console.log('==> rootDeploymentPath: ', rootDeploymentPath);
    console.log('==> rootDeploymentApplicationPath: ', rootDeploymentApplicationPath);
    console.log('==> supportedLocales: ', options.locales);
    console.log('==> modules: ', options.modules);

    this._rootProjectPath = rootProjectPath;
    this._rootApplicationPath = rootApplicationPath;
    this._rootDeploymentPath = rootDeploymentPath;
    this._rootDeploymentApplicationPath = rootDeploymentApplicationPath;

    var projectConfigurationOptions = {
      applicationName: options.name,
      applicationHost: options.host,
      rootProjectPath: rootProjectPath,
      rootApplicationPath: rootApplicationPath,
      rootDeploymentPath: rootDeploymentPath,
      rootDeploymentApplicationPath: rootDeploymentApplicationPath,
      environment: options.environment,
      locales: options.locales,
      port: options.port,
      pingPort: options.pingPort,
      modules: options.modules
    };

    var webpackConfigurationOptions = _extends({
      devPort: options.devPort
    }, projectConfigurationOptions);
    console.log('Building webpack configurations, we will put on some commonly used plugin & configuration.');
    this._webpackConfigurationFactory = new _WebpackConfigurationFactory2.default(webpackConfigurationOptions);
    this._webpackConfiguration = this._webpackConfigurationFactory.createWebpackConfiguration(webpackConfigurationOptions);
    this._compiler = this._createWebpackCompiler(this._webpackConfiguration);
  }

  _createClass(UniversalWebApplicationSetup, [{
    key: 'run',
    value: function run() {
      var _this = this;

      if (this._options.environment === 'development') {
        console.log('[COMPILER] Initiating server compilation');
        var serverConfiguration = this._webpackConfiguration[0];
        var serverCompiler = this._createWebpackCompiler(serverConfiguration);
        serverCompiler.watch({
          aggregateTimeout: 300,
          poll: true
        }, function (err, stats) {
          if (err) console.error(err);
          // console.log(stats.toString({ colors: true }))
          console.log(stats.compilation.errors.toString({ colors: true }));
          console.log(stats.compilation.warnings.toString({ colors: true }));
          console.log('[COMPILER] Server compilation finished. Watching for server file changes.');
        });

        console.log('[COMPILER] Initiating client compilation using webpack-dev-server');
        var clientConfiguration = this._webpackConfiguration[1];
        var clientCompiler = this._createWebpackCompiler(clientConfiguration);
        var clientDevServer = new _webpackDevServer2.default(clientCompiler, {
          contentBase: _path2.default.join(this._rootApplicationPath, 'build'),
          hot: true,
          filename: 'main.js',
          proxy: {
            '**': 'http://localhost:' + this._options.port
          },
          watchOptions: {
            aggregateTimeout: 300,
            poll: 1000
          },
          stats: {
            color: true
          },
          publicPath: '/assets',
          disableHostCheck: true
        });
        clientDevServer.listen(this._options.devPort, function (err) {
          if (err) {
            console.err('[ERROR]: ', err, err.stack);
          } else {
            console.log('\n[COMPILER] webpack-dev-server is listening at port ' + _this._options.devPort);
            console.log('[COMPILER] Client compilation finished. Watching for client file changes.');
          }
        });
      } else {
        console.log('[COMPILER] Initiating compilation.');
        this._compiler = this._createWebpackCompiler(this._webpackConfiguration);
        this._compiler.run(function (err, stats) {
          if (err) console.error(err);
          console.log(stats.toString({ colors: true }));
          console.log('[COMPILER] Compilation finished.');
        });
      }
    }
  }, {
    key: '_createWebpackCompiler',
    value: function _createWebpackCompiler(configuration) {
      var compiler = (0, _webpack2.default)(configuration);
      return compiler;
    }
  }]);

  return UniversalWebApplicationSetup;
}();

exports.default = UniversalWebApplicationSetup;
module.exports = exports['default'];

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var _UniversalWebApplicationSetup = __webpack_require__(3);

var _UniversalWebApplicationSetup2 = _interopRequireDefault(_UniversalWebApplicationSetup);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  CatelaApplicationSetup: _UniversalWebApplicationSetup2.default
};
module.exports = exports['default'];

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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; }; }();
// import NyanProgressPlugin from 'nyan-progress-webpack-plugin'


var _assetsWebpackPlugin = __webpack_require__(6);

var _assetsWebpackPlugin2 = _interopRequireDefault(_assetsWebpackPlugin);

var _chalk = __webpack_require__(7);

var _chalk2 = _interopRequireDefault(_chalk);

var _extractTextWebpackPlugin = __webpack_require__(8);

var _extractTextWebpackPlugin2 = _interopRequireDefault(_extractTextWebpackPlugin);

var _fs = __webpack_require__(9);

var _fs2 = _interopRequireDefault(_fs);

var _path = __webpack_require__(0);

var _path2 = _interopRequireDefault(_path);

var _preconditions = __webpack_require__(1);

var _preconditions2 = _interopRequireDefault(_preconditions);

var _progressBarWebpackPlugin = __webpack_require__(10);

var _progressBarWebpackPlugin2 = _interopRequireDefault(_progressBarWebpackPlugin);

var _statsWebpackPlugin = __webpack_require__(11);

var _statsWebpackPlugin2 = _interopRequireDefault(_statsWebpackPlugin);

var _webpack = __webpack_require__(2);

var _webpack2 = _interopRequireDefault(_webpack);

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"); } }

// let nyanProgressPlugin = new NyanProgressPlugin()
var progressBarPlugin = new _progressBarWebpackPlugin2.default({
  format: '  build [:bar] ' + _chalk2.default.green.bold(':percent') + ' (:elapsed seconds)',
  clear: false
});

var WebpackConfigurationFactory = function () {
  function WebpackConfigurationFactory(options) {
    _classCallCheck(this, WebpackConfigurationFactory);

    var pc = _preconditions2.default.instance(options);
    pc.shouldBeDefined('applicationName', 'applicationName is required.');
    pc.shouldBeDefined('applicationHost', 'applicationHost is required.');
    pc.shouldBeDefined('rootProjectPath', 'rootProjectPath is required.');
    pc.shouldBeDefined('rootApplicationPath', 'rootApplicationPath is required.');
    pc.shouldBeDefined('rootDeploymentPath', 'rootDeploymentPath is required.');
    pc.shouldBeDefined('rootDeploymentApplicationPath', 'rootDeploymentApplicationPath is required.');
    pc.shouldBeDefined('environment', 'environment is required.');
    pc.shouldBeDefined('locales', 'locales is required.');
    pc.shouldBeDefined('modules', 'modules is required');

    this._options = options;
    this._applicationHost = options.applicationHost;
    this._applicationName = options.applicationName;
    this._rootProjectPath = options.rootProjectPath;
    this._rootApplicationPath = options.rootApplicationPath;
    this._rootDeploymentPath = options.rootDeploymentPath;
    this._rootDeploymentApplicationPath = options.rootDeploymentApplicationPath;
    this._environment = options.environment;
  }

  _createClass(WebpackConfigurationFactory, [{
    key: 'createWebpackConfiguration',
    value: function createWebpackConfiguration() {
      var client = this._createClientWebpackConfiguration();
      var server = this._createServerWebpackConfiguration();
      var config = [server, client];
      return config;
    }
  }, {
    key: '_createServerWebpackConfiguration',
    value: function _createServerWebpackConfiguration() {
      var options = this._options;
      var entry = this._buildServerEntry(options);
      var output = this._buildServerOutput(options);
      var plugins = this._buildServerPlugins(options);
      var common = this._buildCommon();

      var externalNodeModules = {};
      var nodeModulePath = _path2.default.join(this._rootProjectPath, 'node_modules');
      _fs2.default.readdirSync(nodeModulePath).filter(function (x) {
        return ['.bin'].indexOf(x) === -1;
      }).forEach(function (mod) {
        if (mod !== 'react-toolbox') {
          externalNodeModules[mod] = 'commonjs ' + mod;
        }
      });

      return _extends({
        name: 'server'
      }, common, {
        entry: entry,
        output: output,
        plugins: plugins,
        target: 'node',
        devtool: 'sourcemap',
        externals: externalNodeModules
      });
    }
  }, {
    key: '_createClientWebpackConfiguration',
    value: function _createClientWebpackConfiguration() {
      var options = this._options;
      var entry = this._buildClientEntry(options);
      var output = this._buildClientOutput(options);
      var plugins = this._buildClientPlugins(options);
      var common = this._buildCommon();

      return _extends({
        name: 'client'
      }, common, {
        entry: entry,
        output: output,
        plugins: plugins,
        devtool: 'sourcemap'
      });
    }
  }, {
    key: '_buildCommon',
    value: function _buildCommon() {
      var _this = this;

      var options = this._options;
      var loaders = this._buildLoaders(options);
      var applicationNamespace = _path2.default.join(this._rootProjectPath, 'applications', options.applicationName);
      var modulesDirectories = ['node_modules', applicationNamespace];
      this._options.modules.forEach(function (m) {
        var moduleNamespace = _path2.default.join(_this._rootProjectPath, m);
        modulesDirectories.push(moduleNamespace);
      });
      var config = {
        resolve: {
          modules: modulesDirectories,
          extensions: ['*', '.js', '.jsx', '.scss', '.css', '.ts', '.tsx']
        },
        module: _extends({}, loaders)
      };
      return config;
    }
  }, {
    key: '_buildServerEntry',
    value: function _buildServerEntry(options) {
      var entry = {
        server: _path2.default.join(this._rootApplicationPath, 'server.jsx')
      };
      return entry;
    }
  }, {
    key: '_buildClientEntry',
    value: function _buildClientEntry(options) {
      var environment = this._options.environment;
      var clientEntry = [];
      if (environment === 'development') {
        clientEntry.push('react-hot-loader/patch');
        clientEntry.push('webpack-dev-server/client?http://localhost:' + this._options.devPort + '/');
      }
      clientEntry.push(_path2.default.join(this._rootApplicationPath, 'client.jsx'));
      var entry = {
        libs: ['react', 'react-dom', 'react-router'],
        client: clientEntry
      };
      return entry;
    }
  }, {
    key: '_buildClientOutput',
    value: function _buildClientOutput(options) {
      /*
       * You can use [hash] like: path.join(this._rootApplicationPath, 'build', '[hash]')
       * For now we will not use hash first, later on we will bring this to use when all is figured out
       */
      var output = {
        path: _path2.default.join(this._rootApplicationPath, 'build', this._environment, 'client'),
        publicPath: this._applicationHost + '/assets/',
        filename: 'main.js',
        chunkFilename: '[id].[name].js',
        sourceMapFilename: '[file].map'
      };

      return output;
    }
  }, {
    key: '_buildServerOutput',
    value: function _buildServerOutput(options) {
      /*
       * You can use [hash] like: path.join(this._rootApplicationPath, 'build', '[hash]')
       * For now we will not use hash first, later on we will bring this to use when all is figured out
       */
      var output = {
        path: _path2.default.join(this._rootApplicationPath, 'build', this._environment, 'server'),
        publicPath: this._applicationHost + '/assets/',
        filename: 'main.js',
        chunkFilename: '[id].[name].js',
        sourceMapFilename: '__dev/assets/server/debugging/[file].map'
      };

      return output;
    }
  }, {
    key: '_buildLoaders',
    value: function _buildLoaders(options) {
      var loaders = {
        'jsx': this._environment === 'development' // Disable react-hot-loader for now (it is causing bug in webpack-dev-server)
        ? ['react-hot-loader/webpack', 'babel-loader?compact=false'] : ['babel-loader?compact=false'],
        'js': 'babel-loader?compact=false',
        'tsx': 'ts-loader',
        'ts': 'ts-loader',
        'json': 'json-loader',
        'json5': 'json5-loader',
        'txt': 'raw-loader',
        'png|jpg|jpeg|gif|svg': 'url-loader?limit=10000',
        'otf|woff|woff2': 'url-loader?limit=100000',
        'ttf|eot': 'file-loader',
        'wav|mp3': 'file-loader',
        'html': 'html-loader',
        'md|markdown': ['html-loader', 'markdown-loader']
      };

      var cssLoader = 'css-loader?module&localIdentName=[name]-[local]-[hash:base64:5]';

      var stylesheetLoaders = {
        'css': cssLoader,
        'less': [cssLoader, 'less-loader'],
        'styl': [cssLoader, 'stylus-loader'],
        'scss|sass': [cssLoader, 'sass-loader']
      };

      Object.keys(stylesheetLoaders).forEach(function (ext) {
        var stylesheetLoader = stylesheetLoaders[ext];
        if (Array.isArray(stylesheetLoader)) {
          stylesheetLoader = stylesheetLoader.join('!');
        }
        stylesheetLoaders[ext] = _extractTextWebpackPlugin2.default.extract({
          fallback: 'style-loader',
          use: stylesheetLoader
        });
      });

      var resultLoaders = [].concat(this._loadersByExtension(loaders)).concat(this._loadersByExtension(stylesheetLoaders));

      return {
        loaders: resultLoaders
      };
    }
  }, {
    key: '_buildServerPlugins',
    value: function _buildServerPlugins(options) {
      var plugins = [];
      // plugins.push(nyanProgressPlugin)

      plugins.push(progressBarPlugin);
      plugins.push(new _statsWebpackPlugin2.default('stats.json', {
        chunkModules: true
      }));
      plugins.push(new _webpack2.default.DefinePlugin({
        '__PROJECT__': JSON.stringify(this._options),
        '__SERVER__': true,
        '__CLIENT__': false
      }));
      plugins.push(new _extractTextWebpackPlugin2.default('styles.css'));
      plugins.push(new _assetsWebpackPlugin2.default({
        prettyPrint: true,
        path: _path2.default.join(this._rootApplicationPath, 'build', this._environment, 'server'),
        update: true
      }));
      plugins.push(new _webpack2.default.WatchIgnorePlugin([/\.d\.ts$/]));
      return plugins;
    }
  }, {
    key: '_buildClientPlugins',
    value: function _buildClientPlugins(options) {
      var project = {
        applicationName: this._options.applicationName,
        applicationHost: this._options.applicationHost,
        environment: this._options.environment,
        locales: this._options.locales
      };
      var plugins = [];
      // plugins.push(nyanProgressPlugin)
      plugins.push(progressBarPlugin);

      if (this._options.environment === 'development') {
        plugins.push(new _webpack2.default.PrefetchPlugin('react'));
        plugins.push(new _webpack2.default.PrefetchPlugin('react-router'));
        plugins.push(new _webpack2.default.PrefetchPlugin('react-dom/lib/ReactComponentBrowserEnvironment'));
        plugins.push(new _webpack2.default.HotModuleReplacementPlugin());
      }

      plugins.push(new _statsWebpackPlugin2.default('stats.json', {
        chunkModules: true
      }));

      plugins.push(new _webpack2.default.optimize.CommonsChunkPlugin({
        name: 'libs',
        filename: 'commons.js',
        minChunks: 0
      }));

      if (this._options.environment !== 'development') {
        plugins.push(new _webpack2.default.optimize.UglifyJsPlugin({ compressor: { warnings: false } }));
      }

      plugins.push(new _webpack2.default.DefinePlugin({
        'process.env': {
          'NODE_ENV': JSON.stringify(this._environment)
        },
        '__SERVER__': false,
        '__CLIENT__': true,
        '__PROJECT__': JSON.stringify(project)
      }));
      plugins.push(new _webpack2.default.NoEmitOnErrorsPlugin());
      plugins.push(new _extractTextWebpackPlugin2.default('styles.css'));
      plugins.push(new _assetsWebpackPlugin2.default({
        prettyPrint: true,
        path: _path2.default.join(this._rootApplicationPath, 'build', this._environment, 'client'),
        update: true
      }));
      plugins.push(new _webpack2.default.WatchIgnorePlugin([/\.d\.ts$/]));
      return plugins;
    }
  }, {
    key: '_extsToRegExp',
    value: function _extsToRegExp(exts) {
      return new RegExp('\\.(' + exts.map(function (ext) {
        return ext.replace(/\./g, '\\.');
      }).join('|') + ')(\\?.*)?$');
    }
  }, {
    key: '_loadersByExtension',
    value: function _loadersByExtension(obj) {
      var self = this;
      var loaders = [];
      Object.keys(obj).forEach(function (key) {
        var exts = key.split('|');
        var value = obj[key];
        var entry;
        if (exts.indexOf('js') >= 0) {
          entry = {
            exclude: [/node_modules/],
            options: {
              ignore: [/node_modules/]
            },
            test: self._extsToRegExp(exts)
          };
        } else {
          entry = {
            test: self._extsToRegExp(exts)
          };
        }

        if (Array.isArray(value)) {
          entry.loaders = value;
        } else if (typeof value === 'string') {
          entry.loader = value;
        } else {
          Object.keys(value).forEach(function (valueKey) {
            entry[valueKey] = value[valueKey];
          });
        }
        loaders.push(entry);
      });
      return loaders;
    }
  }]);

  return WebpackConfigurationFactory;
}();

exports.default = WebpackConfigurationFactory;
module.exports = exports['default'];

/***/ }),
/* 6 */
/***/ (function(module, exports) {

module.exports = require("assets-webpack-plugin");

/***/ }),
/* 7 */
/***/ (function(module, exports) {

module.exports = require("chalk");

/***/ }),
/* 8 */
/***/ (function(module, exports) {

module.exports = require("extract-text-webpack-plugin");

/***/ }),
/* 9 */
/***/ (function(module, exports) {

module.exports = require("fs");

/***/ }),
/* 10 */
/***/ (function(module, exports) {

module.exports = require("progress-bar-webpack-plugin");

/***/ }),
/* 11 */
/***/ (function(module, exports) {

module.exports = require("stats-webpack-plugin");

/***/ }),
/* 12 */
/***/ (function(module, exports) {

module.exports = require("webpack-dev-server");

/***/ })
/******/ ]);
//# sourceMappingURL=catela.build.setup.js.map